/*
* Copyright (c) 2003, 2004 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  TJ2kUtils class used to provide common public static
*                functions used by all classes in JP2KCodec.
*
*/


// INCLUDE FILES
#include "JP2KUtils.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS
const TUint32 KLog2Table[] = { 0,1,2,4,8,16,32,64,128,256,512,1024,2048,
                               4096,8192,16384,32768,65536,131072,262144,
                               524288,1048576,2097152,4194304,8388608,
                               16777216,33554432,67108864,134217728,
                               268435456,536870912,1073741824,
                               KMaxTUint32 };

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// CONSTANTS

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// TJ2kUtils::CeilL
// Get the ceiling between two integers.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt32 TJ2kUtils::CeilL( TInt32 aL, TInt32 aR )
    {
    // Check that no divided by zero calculation are done.
    if ( aR == 0 )
    	{
    	User::Leave( KErrCorrupt );
    	}

    if ( aL < 0 )
        {
        if ( aR < 0 )
            {
            aL = -aL;
            aR = -aR;
            return ( aL % aR ) ? ( aL / aR ) + 1 : aL / aR;
            }
        else
            {
            return -( ( -aL ) / aR );
            }
        }
    else if ( aR < 0 )
        {
        return -( aL / ( -aR ) );
        }
    else
        {
        return ( aL % aR ) ? ( aL / aR ) + 1 : aL / aR;
        }
    }

// -----------------------------------------------------------------------------
// TJ2kUtils::FloorL
// Get the floor between two integers.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt32 TJ2kUtils::FloorL( TInt32 aL, TInt32 aR )
    {
    // Check that no divided by zero calculation are done.
    if ( aR == 0 )
    	{
    	User::Leave( KErrCorrupt );
    	}
    
    if ( ( aL < 0 || aR < 0 ) && !( aL < 0 && aR < 0 ) )
        {
        return aL / aR - 1;
        }
    else
        {
        return aL / aR;
        }
    }

// -----------------------------------------------------------------------------
// TJ2kUtils::DivL
// Get the quotient and remainder.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TDiv TJ2kUtils::DivL( TInt aNum, TInt aDenom )
    {
    // Check that no divided by zero calculation are done.
    if ( aDenom == 0 )
    	{
    	User::Leave( KErrCorrupt );
    	}
    
    TDiv aDiv;
    aDiv.quot = aNum / aDenom;
    aDiv.rem = aNum % aDenom;

    /*
     * The ANSI standard says that |r.quot| <= |n/d|, where
     * n/d is to be computed in infinite precision.  In other
     * words, we should always truncate the quotient towards
     * 0, never -infinity.
     *
     * Machine division and remainer may work either way when
     * one or both of n or d is negative.  If only one is
     * negative and r.quot has been truncated towards -inf,
     * r.rem will have the same sign as denom and the opposite
     * sign of num; if both are negative and r.quot has been
     * truncated towards -inf, r.rem will be positive ( will
     * have the opposite sign of num ).  These are considered
     * `wrong'.
     *
     * If both are num and denom are positive, r will always
     * be positive.
     *
     * This all boils down to:
     * if num >= 0, but r.rem < 0, we got the wrong answer.
     * In that case, to get the right answer, add 1 to r.quot and
     * subtract denom from r.rem.
     */
    if ( aNum >= 0 && aDiv.rem < 0 ) 
        {
        aDiv.quot++;
        aDiv.rem -= aDenom;
        }
    return aDiv;
    }

// -----------------------------------------------------------------------------
// TJ2kUtils::Log2
// Get he log2 value of an integer.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt32 TJ2kUtils::Log2( TUint32 aI )
    {
    TInt32 index = 0;
    TInt32 count = sizeof( KLog2Table ) / sizeof( TUint32 );
    for ( index = 0; index < count; ++index )
        {
        if ( KLog2Table[index] > aI )
            {
            break;   //lint !e960    Break is OK.
            }
        }
    return index - 2;
    }

// -----------------------------------------------------------------------------
// TJ2kUtils::Alloc2DArrayL
// Allocate 2-D array.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TPrecInt** TJ2kUtils::Alloc2DArrayL( TInt aRowSize, TInt aColSize )
    {
    TPrecInt **ptr = STATIC_CAST( TPrecInt**, User::Alloc( aRowSize * sizeof( TPrecInt* ) ) );
    if ( !ptr )
        {
        User::Leave( KErrNoMemory );
        }
    CleanupStack::PushL( ptr );

    // If first allocation fail, it will not reach here
    TPrecInt *ptrRow = STATIC_CAST( TPrecInt*, User::Alloc( aRowSize * aColSize * sizeof( TPrecInt ) ) );
    if ( !ptrRow )
        {
        User::Leave( KErrNoMemory );
        }
    Mem::FillZ( ptrRow, ( aRowSize * aColSize * sizeof( TPrecInt ) ) );
    for ( TInt i = 0; i < aRowSize; ++i )
        {
        ptr[i] = ptrRow + ( i * aColSize );
        }

    CleanupStack::Pop( 1 );
    return ptr;
    }

// -----------------------------------------------------------------------------
// TJ2kUtils::Free2DArray
// Free 2-D array.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void TJ2kUtils::Free2DArray( TPrecInt **aPtr )
    {
    if ( aPtr )
        {
        if ( aPtr[0] )
            {
            User::Free( aPtr[0] );
            }
        User::Free( aPtr );
        }
    }

// -----------------------------------------------------------------------------
// TJ2kUtils::Free2DArray
// Wrapper to free 2-D array when put into TCleanupItem.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void TJ2kUtils::Free2DArray( TAny *aPtr ) //lint !e1714 Referenced from CleanupStack item.
    {
    Free2DArray( ( TPrecInt ** )aPtr );
    }