/*

* 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:  Entropy decoder functionality..

*

*/

// INCLUDE FILES

#include "JP2KCodeBlock.h"

#include "JP2KTileInfo.h"

#include "JP2KImageInfo.h"

#include "JP2KEntropyDecoder.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// Mq decoder state information, all of the 47 states contain

// the probability estimate of LPS in hexadecimal, the next

// mps state index, the next lps state index and the flag

// indicating a mps switch.

const TUint32 KMqQeStates[KNumberOriginalMQEntries] =  {0x5601,0x3401,0x1801,0x0ac1,0x0521,0x0221,0x5601,

                                                        0x5401,0x4801,0x3801,0x3001,0x2401,0x1c01,0x1601,

                                                        0x5601,0x5401,0x5101,0x4801,0x3801,0x3401,0x3001,

                                                        0x2801,0x2401,0x2201,0x1c01,0x1801,0x1601,0x1401,

                                                        0x1201,0x1101,0x0ac1,0x09c1,0x08a1,0x0521,0x0441,

                                                        0x02a1,0x0221,0x0141,0x0111,0x0085,0x0049,0x0025,

                                                        0x0015,0x0009,0x0005,0x0001,0x5601};

const TInt32 KMqMpsStates[KNumberOriginalMQEntries] =  {1,2,3,4,5,38,7,8,9,10,11,12,13,29,15,16,17,18,19,

                                                        20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,

                                                        36,37,38,39,40,41,42,43,44,45,45,46};

const TInt32 KMqLpsStates[KNumberOriginalMQEntries] =  {1,6,9,12,29,33,6,14,14,14,17,18,20,21,14,14,15,16,

                                                        17,18,19,19,20,21,22,23,24,25,26,27,28,29,30,31,

                                                        32,33,34,35,36,37,38,39,40,41,42,43,46};

const TInt32 KMqSwitchFlagStates[KNumberOriginalMQEntries] =  {1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,

                                                               0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

                                                               0,0,0,0,0,0,0};

// MQCoder initial states

const TInt32 KMqInitStates[KNumberContexts] = {46,3,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

// -----------------------------------------------------------------------------

// J2KEntropyStream::ReadByteFromStream

// Read a byte from the input stream

// ( other items were commented in a header ).

// -----------------------------------------------------------------------------

//

TUint8 J2KEntropyStream::ReadByteFromStream()

    {

    if ( iPosition < iNumBytes )

        {

        return ( TUint8 )iBuffer[iPosition++];

        }

    else

        {

        // 0xFF to represent EOF

        return ( 0xFF );   

        }

    }

// -----------------------------------------------------------------------------

// J2KEntropyStream::ReadBitFromStream

// Read a bit from the input stream

// ( other items were commented in a header ).

// -----------------------------------------------------------------------------

//

TUint8 J2KEntropyStream::ReadBitFromStream() 

    {

    if ( iTinyBufferPos == 0 )

        {

        // Input the byte buffer

        iTinyBuffer = ReadByteFromStream();

        if ( iDelayedFF )

            {

            iTinyBufferPos = 7;

            }

        else

            {

            iTinyBufferPos = 8;

            }

        if ( iTinyBuffer != 0xFF ) // No bit-stuffing needed

            {

            iDelayedFF = 0;

            }

        else  // We need to do bit stuffing on next byte

            {

            iDelayedFF = 1;

            }

        }

    return (TUint8)( ( iTinyBuffer >> ( --iTinyBufferPos ) ) & 0x01 );

    }

// -----------------------------------------------------------------------------

// J2KEntropyStream::CheckPrediction

// Check a prediction termination for raw coding

// ( other items were commented in a header ).

// -----------------------------------------------------------------------------

//

TEntropyErrorState J2KEntropyStream::CheckPrediction()

    {

    // Error resilient sequence in last byte

    TInt32 errorResSeq = 0; 

    // If tiny buffer is empty and equal to 0xFF, 

    // get the next byte for error resilience marker

    if ( iTinyBufferPos == 0 && iTinyBuffer == 0xFF ) 

        {

        iTinyBuffer = ReadByteFromStream();

        iTinyBufferPos = 7;

        }

    // Search for the error resilience marker

    if ( iTinyBufferPos > 0 ) 

        {

        // Get the error resilience sequence

        errorResSeq = iTinyBuffer & ( ( 1 << iTinyBufferPos ) - 1 );

        // Compare the read error resilience marker to the constant 01010101 byte

        if ( errorResSeq != ( KErrorResilienceTermination >> ( 8 - iTinyBufferPos ) ) ) 

            {

            return EEntropyCodingError;

            }

        }

    // If we are not at the end of this stream, 

    // next byte should be smaller than 0x80.

    if ( iPosition < iNumBytes )

        {

        if ( iTinyBuffer == 0xFF && iTinyBufferPos == 1 ) 

            {

            if ( ReadByteFromStream() >= 0x80 ) 

                {

                return EEntropyCodingError;

                }

            }

        else 

            {

            if ( ReadByteFromStream() != 0xFF ) 

                {

                return EEntropyCodingError;

                }

            }

        }

    // No error detected

    return ENoError;

    }

// -----------------------------------------------------------------------------

// J2KEntropyStream::ResetInputStream

// Reset the input stream

// ( other items were commented in a header ).

// -----------------------------------------------------------------------------

//

void J2KEntropyStream::ResetInputStream()

    {

    // Initialize the stream parameters. Note that stream->position is not reset here,

    // it is reset only when the stream is created for the first time.

    iTinyBuffer = 0;

    iTinyBufferPos = 0;

    iDelayedFF = 0;

    }

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

// Destructor

J2KMQCoder::~J2KMQCoder()

    {

    iOriginalStates.ResetAndDestroy();

    iContextList.ResetAndDestroy();

    }

// -----------------------------------------------------------------------------

// J2KMQCoder::MqByteIn

// Read a byte from the input stream

// ( other items were commented in a header ).

// -----------------------------------------------------------------------------

//

void J2KMQCoder::MqByteIn()

    {

    if ( !iMarker )

        {

        if ( iB == 0xff )

            {

            iB = iInputStream.ReadByteFromStream();

            if ( iB > 0x8f )

                {

                iMarker = 1;

                iCT = 8;

                }

            else

                {

                iC += 0xFE00 - ( iB << 9 );

                iCT = 7;

                }

            }

        else

            {

            iB = iInputStream.ReadByteFromStream();

            iC += 0xFF00 - ( iB << 8 );

            iCT = 8;

            }   

        }

    else

        {

        iCT = 8;

        }

    }

// -----------------------------------------------------------------------------

// J2KMQCoder::MqDecodeSymbol

// Decode the symbol

// ( other items were commented in a header ).

// -----------------------------------------------------------------------------

//

TUint8 J2KMQCoder::MqDecodeSymbol( TInt32 aContextIndex )

    {

    // Set the current context to point to the right place in the context list

    iCurrentContext = iContextList[aContextIndex];

    iCurrentState = iCurrentContext->iState;

    iA -= iCurrentState->iQe;

    // Decision returned ( i.e. decoded symbol )

    TInt32 decision = 0;  

    if ( ( iC >> 16 ) < iA )  // Chigh >= A

        {

        MpsExchange( decision );

        }

    else   // lps exchange

        {

        LpsExchange( decision );

        }

    // Return decision 

    return (TUint8)decision;   

    }

// -----------------------------------------------------------------------------

// J2KMQCoder::MqInitDecoder

// Initialize the MQCoder

// ( other items were commented in a header ).

// -----------------------------------------------------------------------------

//

void J2KMQCoder::MqInitDecoder()

    {

    iMarker = 0;

    iB = iInputStream.ReadByteFromStream();

    // Software conventions decoder initialization 

    iC = ( iB ^ 0xFF ) << 16;

    MqByteIn();

    iC <<= 7;

    iCT -= 7;

    iA = 0x8000;

    }

// -----------------------------------------------------------------------------

// J2KMQCoder::MqCheckPrediction

// Check the prediction termination

// ( other items were commented in a header ).

// -----------------------------------------------------------------------------

//

TEntropyErrorState J2KMQCoder::MqCheckPrediction()

    {

    // If no marker was found, B should be == 0xFF and counter zero, 

    // otherwise there is an error

    if ( !iMarker && ( iCT != 0 || iB != 0xFF ) ) 

        {

        return EEntropyCodingError;

        }

    // If counter CT is 1, no need to check any further

    if ( iCT == 1 )

        {

        return ENoError;

        }

    // If counter CT is zero, then next byte must be larger than 0x8F, if the terminating

    // marker has not been reached yet

    if ( iCT == 0 )  

        {

        if ( !iMarker ) 

            {

            // Get next byte and check that it is larger than 0x8F

            iB = iInputStream.ReadByteFromStream();

            if ( iB <= 0x8F )

                {

                return EEntropyCodingError;

                }

            }

        // Set the counter back to 8

        iCT = 8;

        }

    // Number of bits that where added in the termination process

    // Compute the number of bits, k for error resilience information

    TUint32 k = (TUint32)( iCT - 1 );

    // Check for a coded LPS.

    TUint32 q = 0x8000 >> k;

    // Check that we can decode an LPS interval of probability 'q'

    iA -= q;

    if ( ( iC >> 16 ) < iA )   // software convention

        {

        // MPS interval was decoded, thus error occured

        return EEntropyCodingError;

        }

    // Check for coded LPS interval.

    iA = q;

    do  // Renormalization

        {

        if ( iCT == 0 )

            {

            MqByteIn();

            }

        iA <<= 1;

        iC <<= 1;

        iCT--;

        } while ( iA < 0x8000 );

    // No error was found

    return ENoError;

    }

// -----------------------------------------------------------------------------

// J2KMQCoder::ResetMqContexts

// Reset the MQCoder context list to the original state

// ( other items were commented in a header ).

// -----------------------------------------------------------------------------

//

void J2KMQCoder::ResetMqContexts()

    {

    // Reset all context states to initial states and set the mps

    // of every context to 0.

    for ( TInt32 i = KNumberContexts - 1; i >= 0; i-- )

        {

        iContextList[i]->iState = iOriginalStates[KMqInitStates[i]];

        iContextList[i]->iMPS = 0;

        }

    }

// -----------------------------------------------------------------------------

// J2KMQCoder::ResetMQDecoder

// Initialze MQCoder and reset the context

// ( other items were commented in a header ).

// -----------------------------------------------------------------------------

//

void J2KMQCoder::ResetMQDecoder( TInt32 aSegmentLength )

    {

    // Reset all contexts ( states and mps )

    ResetMqContexts();              

    iInputStream.ResetInputStream();

    iInputStream.iPosition = 0;

    iInputStream.iNumBytes = aSegmentLength;

    MqInitDecoder();

    }

// -----------------------------------------------------------------------------

// J2KMQCoder::InitializeOrigMqTable

// Initialize MQCoder original states table

// ( other items were commented in a header ).

// -----------------------------------------------------------------------------

//

void J2KMQCoder::InitializeOrigMqTable()

    {

    for ( TUint8 i = 0; i < KNumberOriginalMQEntries; i++ )

        {

        iOriginalStates[i]->iQe = KMqQeStates[i];

        iOriginalStates[i]->iNextMPS = iOriginalStates[KMqMpsStates[i]];

        iOriginalStates[i]->iNextLPS = iOriginalStates[KMqLpsStates[i]];

        iOriginalStates[i]->iSwitchFlag = KMqSwitchFlagStates[i];

        }

    }

// -----------------------------------------------------------------------------

// J2KMQCoder::ReNormalize

// Renormalize 

// ( other items were commented in a header ).

// -----------------------------------------------------------------------------

//

void J2KMQCoder::ReNormalize()

    {

    do

        {

        if ( iCT == 0 )

            {

            MqByteIn();

            }

        iA <<= 1;

        iC <<= 1;

        --iCT;

        } while ( !( iA & 0x8000 ) );

    }

// -----------------------------------------------------------------------------

// J2KMQCoder::MpsExchange

// MPS exchange

// ( other items were commented in a header ).

// -----------------------------------------------------------------------------

//

void J2KMQCoder::MpsExchange( TInt32& aD )

    {

    aD = iCurrentContext->iMPS;

    if ( !( iA & 0x8000 ) )

        {

        if ( iA < iCurrentState->iQe )

            {

            aD ^= 1;

            if ( iCurrentState->iSwitchFlag )

                {

                iCurrentContext->iMPS ^= 1;

                }

            iCurrentContext->iState = iCurrentState->iNextLPS;

            }

        else

            {

            iCurrentContext->iState = iCurrentState->iNextMPS;

            }

        ReNormalize();

        }

    }

// -----------------------------------------------------------------------------

// J2KMQCoder::LpsExchange

// LPS exchange

// ( other items were commented in a header ).

// -----------------------------------------------------------------------------

//

void J2KMQCoder::LpsExchange( TInt32& aD )

    {

    iC -= iA << 16;

    aD = iCurrentContext->iMPS;

    if ( iA < iCurrentState->iQe )

        {

        iCurrentContext->iState = iCurrentState->iNextMPS;

        }

    else

        {

        aD ^= 1;

        if ( iCurrentState->iSwitchFlag )

            {

            iCurrentContext->iMPS ^= 1;

            }

        iCurrentContext->iState = iCurrentState->iNextLPS;

        }

    iA = iCurrentState->iQe;

    ReNormalize(  );

    }

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

// -----------------------------------------------------------------------------

// CJ2kEntropyDecoder::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CJ2kEntropyDecoder* CJ2kEntropyDecoder::NewL( CJ2kImageInfo& aImageInfo )

    {

    CJ2kEntropyDecoder *self = new ( ELeave ) CJ2kEntropyDecoder;

    CleanupStack::PushL( self );

    self->ConstructL( aImageInfo );

    CleanupStack::Pop();

    return self;

    }

// Destructor

CJ2kEntropyDecoder::~CJ2kEntropyDecoder()

    {  

    delete iMRLutBuf;

    iMRLutBuf = 0;

    delete iSCLutBuf;

    iSCLutBuf = 0;

    delete iZcLutLL;

    iZcLutLL = 0;

    delete iZcLutHL;

    iZcLutHL = 0;

    delete iZcLutHH;

    iZcLutHH = 0;