/*

* 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:  JP2KPacket class used to collect packet related

*                information such as tag tree and list of codeblocks.

*

*/

// INCLUDE FILES

#include <icl/imagecodec.h>

#include "JP2KImageUtils.h"

#include "JP2KStreamReader.h"

#include "JP2KTileInfo.h"

#include "JP2KImageInfo.h"

#include "JP2KCodeBlock.h"

#include "JP2KPacket.h"

#include "JP2KSubband.h"

#include "JP2KComponentInfo.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

// CJ2kPacket::CJ2kPacket

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CJ2kPacket::CJ2kPacket( TUint16 aLayer ) : 

    iTagTreeLevel(1),

    iLayer(aLayer), 

    iCodeBlockList(1)

    {

    }

// Destructor

CJ2kPacket::~CJ2kPacket()

    {

    delete iIncluded;

    iIncluded = 0;

    delete iTagTreeInfo;

    iTagTreeInfo = 0;

    delete iIncTagTreeValue;

    iIncTagTreeValue = 0;

    delete iIncTagTreeState;

    iIncTagTreeState = 0;

    delete iMsbTagTreeValue;

    iMsbTagTreeValue = 0;

    delete iMsbTagTreeState;

    iMsbTagTreeState = 0;

    iCodeBlockList.ResetAndDestroy();

    }

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

// CJ2kPacket::SetPacketCanvas

// Set the canvas of the packet

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

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

//

void CJ2kPacket::SetPacketCanvas( TInt32 aX, TInt32 aY, TInt32 aWidth, TInt32 aHeight )

    {

    iPacketCanvas.iTl = TPoint( aX, aY );

    iPacketCanvas.SetWidth( aWidth );

    iPacketCanvas.SetHeight( aHeight );

    }

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

// CJ2kPacket::SetNumOfBlocksL

// Set the number of blocks

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

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

//

void CJ2kPacket::SetNumOfBlocksL( TSize& aCodeBlock )

    {

    TInt32 x0 = TJ2kUtils::FloorL( iPacketCanvas.iTl.iX, aCodeBlock.iWidth ) * aCodeBlock.iWidth;

    TInt32 y0 = TJ2kUtils::FloorL( iPacketCanvas.iTl.iY, aCodeBlock.iHeight ) * aCodeBlock.iHeight;

    TInt32 x1 = TJ2kUtils::CeilL( iPacketCanvas.iTl.iX + iPacketCanvas.Width(), aCodeBlock.iWidth ) * aCodeBlock.iWidth;

    TInt32 y1 = TJ2kUtils::CeilL( iPacketCanvas.iTl.iY + iPacketCanvas.Height(), aCodeBlock.iHeight ) * aCodeBlock.iHeight;

    iCodeBlockSize.iWidth  = ( x1 - x0 ) / aCodeBlock.iWidth;

    iCodeBlockSize.iHeight = ( y1 - y0 ) / aCodeBlock.iHeight;

    }

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

// CJ2kPacket::BuildInclusiveInfoL

// Build the inclusive information of the packet

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

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

//

void CJ2kPacket::BuildInclusiveInfoL()

    {

    TInt entries = ( iLayer % 8 ) ? ( ( iLayer / 8 ) + 1 ) : ( iLayer / 8 );

    iIncluded = HBufC8::NewMaxL( entries );

    iIncluded->Des().FillZ();

    }

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

// CJ2kPacket::BuildCodeBlocksL

// Build the codeblocks in the packet

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

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

//

void CJ2kPacket::BuildCodeBlocksL( TInt32 aX, TInt32 aY, TSize& aCodeBlock )

    {

    TUint16 numOfBlocks = NumOfBlocks();

    if ( numOfBlocks )

        {

        BuildTagtreeL();

        TInt32 x0 = 0;

        TInt32 y0 = 0;

        TInt32 x1 = 0;

        TInt32 y1 = 0;

        TInt32 origX = aX;

        TUint16 index = 0;

        while ( index < numOfBlocks )

            {

            x0 = Max( aX, iPacketCanvas.iTl.iX );

            y0 = Max( aY, iPacketCanvas.iTl.iY );

            x1 = Min( aX + aCodeBlock.iWidth, iPacketCanvas.iTl.iX + iPacketCanvas.Width() ) - x0;

            y1 = Min( aY + aCodeBlock.iHeight, iPacketCanvas.iTl.iY + iPacketCanvas.Height() ) - y0;

            if ( x1 > 0 && y1 > 0 )

                {

                CJ2kCodeBlock *block = new ( ELeave ) CJ2kCodeBlock;

                CleanupStack::PushL( block );

                User::LeaveIfError( iCodeBlockList.Append( block ) );

                CleanupStack::Pop( 1 );

                iCodeBlockList[index]->SetCodeBlockCanvas( x0, y0, x1, y1 );

                // Initialize the codeblock

                iCodeBlockList[index]->InitializeL( iLayer );

                ++index;

                }

            aX += aCodeBlock.iWidth;

            if ( aX >= iPacketCanvas.iTl.iX + iPacketCanvas.Width() )

                {

                aX = origX;

                aY += aCodeBlock.iHeight;

                }

            }

        }

    }

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

// CJ2kPacket::ReadPacketHeaderL

// Read the packet header

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

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

//

TUint8 CJ2kPacket::ReadPacketHeaderL( CJ2kTileInfo& aTile, CJ2kComponentInfo& aComponent, CJ2kSubband& aSubband )

    {

    if ( IsIncludedL( aTile.LastLayerProcessed() ) )

        {

        return EFalse;

        }

    TUint8 incomplete = ETrue;

    if ( LastCodeBlockProcessed() == 0 )

        {

        if ( ReadSOP_EPHMarker( aComponent, aTile ) )

            {

            return incomplete;

            }

        }

    TJ2kStreamReader& reader = CONST_CAST( TJ2kStreamReader&, aTile.StreamReader() );

    TUint8 *rollbackPtr = CONST_CAST( TUint8*, reader.iPtr );

    if ( !StartReadBit( aTile ) )

        {

        TUint8 bit = 0;

        if ( LastCodeBlockProcessed() == 0 )

            {

            if ( !IsRecoverFromIncomplete() )

                {

                ReadBit( bit, aTile );

                if ( bit == 0 )

                    {

                    // Empty packet

                    incomplete = EFalse;

                    }

                }

            }

        if ( incomplete )

            {

            // Packet header has not been processed yet

            if ( !IsHeader() )

                {

                TUint8 isBackup = IsBackupNeeded( aTile );

                CJ2kSubband *subband = &aSubband;

                if ( subband->SubbandResLevel() > 0 )

                    {

                    if ( subband->LastSubbandProcessed() == CJ2kSubband::EBandLL )

                        {

                        subband->SetLastSubbandProcessed( CJ2kSubband::EBandHL );

                        }

                    else

                        {

                        // Move to last subband processed

                        while ( subband->SubbandType() != aSubband.LastSubbandProcessed() )

                            {

                            subband = subband->NextSubbandRaster();

                            User::LeaveIfNull(subband);

                            }

                        }

                    }

                TUint16 bandIndex = 0;

                TUint16 cbIndex = 0;

                TUint16 cbYIndex = 0;

                TUint16 xIndex = 0;

                TUint16 yIndex = 0;

                TUint16 incValue = 0;

                TUint16 msbValue = 0;

                TUint16 index = 0;

                TUint16 layer = aTile.LastLayerProcessed();

                TUint16 numPass = 0;

                TUint16 codePass = 0;

                TUint16 numSegment = 0;

                TUint8  recoverIncTag = 0;

                TUint8  recoverMsbTag = 0;

                TUint8  firstRecovery = ETrue;

                TUint8  recoverData = 0;

                TUint8  recoverPos = 0;

                TUint8  recoverNextPos = 0;

                TUint8  origPassIndex = 0;

                TUint8  origLengthBits = 0;

                TInt8   origLastPass = 0;

                TUint32 origDataLength = 0;

                HBufC16 *recoverIncTagTreeValue = 0;

                HBufC16 *recoverIncTagTreeState = 0;

                HBufC16 *recoverMsbTagTreeValue = 0;

                HBufC16 *recoverMsbTagTreeState = 0;

                if ( IsRecoverFromIncomplete() )

                    {

                    recoverData = reader.iData;

                    recoverPos = reader.iPos;

                    recoverNextPos = reader.iNextPos;

                    }

                CJ2kPacket *packet = CONST_CAST( CJ2kPacket*, &subband->PacketAt( aSubband.LastPacketProcessed() ) );

                CJ2kCodeBlock *codeBlock;

                incomplete = EFalse;

                do

                    {

                    if ( aComponent.QuantizationStyle() != 1 )

                        {

                        bandIndex = subband->SubbandTreeIndex();

                        }

                    for ( yIndex = 0; yIndex < packet->NumOfBlocksY(); ++yIndex )

                        {

                        cbYIndex = (TUint16)( yIndex * packet->NumOfBlocksX() );

                        for ( xIndex = 0; xIndex < packet->NumOfBlocksX(); ++xIndex )

                            {

                            cbIndex = (TUint16)( cbYIndex + xIndex );

                            if ( cbIndex < packet->LastCodeBlockProcessed() ||

                                ( packet->IsMatch() && cbIndex == packet->LastCodeBlockProcessed() ) )

                                {

                                // Has been processed, skip to the next codeblock

                                continue;   //lint !e960    Using continue saves a lot of code here.

                                }

                            else

                                {

                                packet->ResetMatch();

                                recoverIncTag = recoverMsbTag = EFalse;

                                codeBlock = CONST_CAST( CJ2kCodeBlock*, &packet->CodeBlockAt( cbIndex ) );

                                TPtr16 numSegPtr = codeBlock->iNumSegment->Des();

                                origPassIndex = codeBlock->iPassIndex;

                                origLastPass  = codeBlock->iLastPass;

                                if ( codeBlock->iLastPass < 0 && codeBlock->iPassIndex == 0 )

                                    {

                                    if ( isBackup )

                                        {

                                        packet->BackupIncTagtreeL( recoverIncTagTreeValue, recoverIncTagTreeState );

                                        recoverIncTag = ETrue;

                                        }

                                    msbValue = (TUint16)0;

                                    incomplete = packet->DecodeIncTagtree( aTile, xIndex, yIndex, incValue );

                                    if ( !incomplete )

                                        {

                                        if ( incValue <= layer )

                                            {

                                            if ( isBackup )

                                                {

                                                packet->BackupMsbTagtreeL( recoverMsbTagTreeValue, recoverMsbTagTreeState );

                                                recoverMsbTag = ETrue;

                                                }

                                            incomplete = packet->DecodeMsbTagtree( aTile, xIndex, yIndex, msbValue );

                                            }

                                        else

                                            {

                                            packet->SetLastCodeBlockProcessed( cbIndex );

                                            firstRecovery  = EFalse;

                                            recoverData    = reader.iData;

                                            recoverPos     = reader.iPos;

                                            recoverNextPos = reader.iNextPos;

                                            recoverIncTag = recoverMsbTag = EFalse;

                                            rollbackPtr   =  CONST_CAST( TUint8*, reader.iPtr );

                                            // Move on to the next codeblock

                                            continue;   //lint !e960    Using continue saves a lot of code here.

                                            }

                                        }

                                    if ( incomplete )

                                        {

                                        // Underflow, should backup the iterator position

                                        if ( cbIndex > packet->LastCodeBlockProcessed() )

                                            {

                                            // Next read should match the codeblock index

                                            packet->SetMatch();

                                            }

                                        if ( !firstRecovery )

                                            {

                                            SetRecoverFromIncomplete();

                                            reader.iData    = recoverData;

                                            reader.iPos     = recoverPos;

                                            reader.iNextPos = recoverNextPos;

                                            }

                                        else

                                            {

                                            if ( IsRecoverFromIncomplete() )

                                                {

                                                reader.iData    = recoverData;

                                                reader.iPos     = recoverPos;

                                                reader.iNextPos = recoverNextPos;

                                                }

                                            }

                                        if ( isBackup )

                                            {

                                            if ( recoverIncTag )

                                                {

                                                packet->RestoreIncTagtree( recoverIncTagTreeValue, recoverIncTagTreeState );

                                                }

                                            if ( recoverMsbTag )

                                                {

                                                packet->RestoreMsbTagtree( recoverMsbTagTreeValue, recoverMsbTagTreeState );

                                                }

                                            // Release memory

                                            packet->FreeBackupTagtree( recoverIncTagTreeValue, recoverIncTagTreeState, 

                                                                       recoverMsbTagTreeValue, recoverMsbTagTreeState );

                                            }

                                        reader.iPtr = rollbackPtr;

                                        // Return from the packet header decoding

                                        return incomplete;

                                        }

                                    codeBlock->iLastPass = 0;

                                    numSegPtr[layer] = 1;

                                    codeBlock->iEmptyBitplane = (TUint8)msbValue;

                                    if ( aComponent.RoiShift() > 0 )

                                        {

                                        numPass = (TUint16)( ( aComponent.MagnitudeBits( bandIndex ) + aComponent.RoiShift() ) * 3 + 1 );

                                        }

                                    else

                                        {

                                        numPass = (TUint16)( ( aComponent.MagnitudeBits( bandIndex ) - msbValue  ) * 3 + 1 );

                                        }

                                    if ( codeBlock->iDataSize == 0 || codeBlock->iDataSize->Length() < numPass )

                                        {

                                        if ( codeBlock->iDataSize == 0 )

                                            {

                                            codeBlock->iDataSize = HBufC16::NewMaxL( numPass );

                                            codeBlock->iDataSize->Des().FillZ();

                                            codeBlock->iPassesPerSegment = HBufC16::NewMaxL( numPass );

                                            codeBlock->iPassesPerSegment->Des().FillZ();

                                            }

                                        else

                                            {

                                            incValue = ( TUint16 )( numPass - codeBlock->iDataSize->Length() );

                                            codeBlock->iDataSize = codeBlock->iDataSize->ReAllocL( numPass );

                                            codeBlock->iPassesPerSegment = codeBlock->iPassesPerSegment->ReAllocL( numPass );

                                            while ( incValue-- )

                                                {

                                                codeBlock->iDataSize->Des().Append( 0 );

                                                codeBlock->iPassesPerSegment->Des().Append( 0 );

                                                }

                                            }

                                        }

                                    }

                                else

                                    {

                                    incomplete = ReadBit( bit, aTile );

                                    if ( incomplete )

                                        {

                                        // Underflow, should backup the iterator position

                                        if ( cbIndex > packet->LastCodeBlockProcessed() )

                                            {

                                            // Next read should match the codeblock index

                                            packet->SetMatch();

                                            }

                                        if ( !firstRecovery )

                                            {

                                            SetRecoverFromIncomplete();

                                            reader.iData = recoverData;

                                            reader.iPos = recoverPos;

                                            reader.iNextPos = recoverNextPos;

                                            }

                                        else

                                            {

                                            if ( IsRecoverFromIncomplete() )

                                                {

                                                reader.iData    = recoverData;

                                                reader.iPos     = recoverPos;

                                                reader.iNextPos = recoverNextPos;

                                                }

                                            }

                                        if ( isBackup )

                                            {

                                            // Release memory

                                            packet->FreeBackupTagtree( recoverIncTagTreeValue, recoverIncTagTreeState, 

                                                                       recoverMsbTagTreeValue, recoverMsbTagTreeState );

                                            }

                                        reader.iPtr = rollbackPtr;

                                        // Return from the packet header decoding

                                        return incomplete;

                                        }

                                    numSegPtr[layer] = bit;

                                    if ( bit == 0 )

                                        {

                                        packet->SetLastCodeBlockProcessed( cbIndex );

                                        firstRecovery  = EFalse;

                                        recoverData = reader.iData;

                                        recoverPos  = reader.iPos;

                                        recoverNextPos = reader.iNextPos;

                                        recoverIncTag = recoverMsbTag = EFalse;

                                        rollbackPtr   =  CONST_CAST( TUint8*, reader.iPtr );

                                        // Move on to the next codeblock

                                        continue;   //lint !e960    Using continue saves a lot of code here.

                                        }

                                    }

                                incomplete = ReadBit( bit, aTile );

                                codePass = (TUint16)0;

                                if ( !incomplete )

                                    {

                                    if ( bit ) // 1

                                        {

                                        incomplete = ReadBit( bit, aTile );

                                        if ( !incomplete )

                                            {

                                            if ( bit ) // 11

                                                {

                                                incomplete = ReadBits( bit, 2, aTile );

                                                if ( !incomplete )

                                                    {

                                                    if ( bit == 0x03 ) // 1111

                                                        {

                                                        incomplete = ReadBits( bit, 5, aTile );

                                                        if ( !incomplete )

                                                            {

                                                            if ( bit == 0x1f ) // 1111 11111

                                                                {

                                                                incomplete = ReadBits( bit, 7, aTile );

                                                                if ( !incomplete )

                                                                    {

                                                                    codePass = (TUint16)( 0x25 + bit );

                                                                    }

                                                                }

                                                            else

                                                                {

                                                                // 1111 XXXXX, at least one of them is not 1

                                                                codePass = (TUint16)( 6 + bit );

                                                                }

                                                            }

                                                        }

                                                    else

                                                        {

                                                        // 11XX

                                                        codePass = (TUint16)( 3 + bit );

                                                        }

                                                    }

                                                }