/*

* 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:  CJ2kTileInfo class used to collect tile related information 

*                such as Tile Part Header, SOT marker and list of components.

*

*/

// INCLUDE FILES

#include <icl/imagecodec.h>

#include "JP2KImageUtils.h"

#include "JP2KFormat.h"

#include "JP2KStreamReader.h"

#include "JP2KTileInfo.h"

#include "JP2KImageInfo.h"

#include "JP2KCodec.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 ===============================

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

// CJ2kTileInfo::NewLC

// Two-phased constructor.

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

//

CJ2kTileInfo* CJ2kTileInfo::NewLC( CJ2kImageInfo& aImageInfo, TJ2kStreamReader& aReader )

    {

    CJ2kTileInfo* self = new ( ELeave ) CJ2kTileInfo( aImageInfo, aReader );

    CleanupStack::PushL( self );

    return self;

    }

// Destructor

CJ2kTileInfo::~CJ2kTileInfo()

    {

    DoReleaseUnusedMarkers();

    iComponentList.ResetAndDestroy();

    delete iPpt;

    iPpt = 0;

    delete iPptBuffer;

    iPptBuffer = 0;

    // iPOC not owned - not deleted. 

    }

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

// CJ2kTileInfo::InitializeL

// Initialize the components in the tile.

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

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

//

void CJ2kTileInfo::InitializeL()

    {

    const TSizMarker &sizMarker = iImageInfo.SizMarker();

    TUint16 numOfHorizTiles = iImageInfo.NumOfHorizTilesL();

    // Calculate the tile canvas

    TDiv    tDiv = TJ2kUtils::DivL( iSot.iIsot, numOfHorizTiles );

    iTileCanvas.iTl = TPoint( Max( sizMarker.iXTOsiz + tDiv.rem * sizMarker.iXTsiz, sizMarker.iXOsiz ),

                              Max( sizMarker.iYTOsiz + tDiv.quot * sizMarker.iYTsiz, sizMarker.iYOsiz ) );

    iTileCanvas.iBr = TPoint( Min( sizMarker.iXTOsiz + ( tDiv.rem + 1 ) * sizMarker.iXTsiz, sizMarker.iXsiz ),

                              Min( sizMarker.iYTOsiz + ( tDiv.quot + 1 ) * sizMarker.iYTsiz, sizMarker.iYsiz ) );

    CJ2kComponentInfo *component = 0;

    for ( TUint16 index = 0; index < sizMarker.iCsiz; ++index )

        {

        // Instantiate the components in the tile

        component = CJ2kComponentInfo::NewLC( *this, index );

        User::LeaveIfError( iComponentList.Append( component ) );

        CleanupStack::Pop();

        }

    iLastN1 = iTileCanvas.iTl.iY;

    iLastN2 = iTileCanvas.iTl.iX;

    // Initialize the end of layer, resolution level, component to process

    iNumOfLayersPOC = NumOfLayers();

    iNumOfLevelsPOC = NumOfLevels();

    iNumOfComponentsPOC = sizMarker.iCsiz;

    if ( IsSpeedup() )

        {

        iNumOfLevelsPOC = (TUint8)( iNumOfLevelsPOC - iImageInfo.LevelDrop() );

        }

    // Let iPOC points to the POC marker in Tile Part Header

    iPOC = iTileMarker.iPoc;

    if ( !iPOC )

        {

        // Let iPOC points to the POC marker in the Main Header

        iPOC = iImageInfo.MainMarker().iPoc;

        }

    }

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

// CJ2kTileInfo::AppendCOD

// Verify and append COD to the tile part header.

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

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

//

void CJ2kTileInfo::AppendCOD( TCODMarker *aMarker, TUint32 aLength )

    {

    if ( iSot.iTPsot == 0 )

        {

        // Use only for the first tile part of a tile

        if ( iTileMarker.iCod == 0 )

            {

            iTileMarker.iCod = aMarker;

            }

        else

            {

            // No more than one COD per tile

            delete aMarker;

            aMarker = 0;

            }

        }

    else

        {

        // Read but ignore it

        delete aMarker;

        aMarker = 0;

        }

    if ( iTileLength )

        {

        iTileLength -= aLength;

        }

    }

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

// CJ2kTileInfo::AppendCOCL

// Verify and append COC to the tile part header.

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

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

//

void CJ2kTileInfo::AppendCOCL( TCOCMarker *aMarker, TUint32 aLength )

    {

    if ( iSot.iTPsot == 0 )

        {

        // Use only for the first tile part of a tile

        TUint8 found = EFalse;

        for ( TUint16 index = 0; index < iTileMarker.iCoc.Count(); ++index )

            {

            if ( iTileMarker.iCoc[index]->iCcoc == aMarker->iCcoc )

                {

                found = ETrue; 

                index = (TUint16)iTileMarker.iCoc.Count();   

                }

            }

        if ( !found )

            {

            User::LeaveIfError( iTileMarker.iCoc.Append( aMarker ) );

            }

        else

            {

            // No more than one COC per component

            delete aMarker;

            aMarker = 0;

            }

        }

    else

        {

        // Read but ignore it

        delete aMarker;

        aMarker = 0;

        }

    if ( iTileLength )

        {

        iTileLength -= aLength;

        }

    }

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

// CJ2kTileInfo::AppendQCD

// Verify and append QCD to the tile part header.

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

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

//

void CJ2kTileInfo::AppendQCD( TQCDMarker *aMarker, TUint32 aLength )

    {

    if ( iSot.iTPsot == 0 )

        {

        // Use only for the first tile part of a tile

        if ( iTileMarker.iQcd == 0 )

            {

            iTileMarker.iQcd = aMarker;

            }

        else

            {

            // No more than one QCD per tile

            delete aMarker;

            aMarker = 0;

            }

        }

    else

        {

        // Read but ignore it

        delete aMarker;

        aMarker = 0;

        }

    if ( iTileLength )

        {

        iTileLength -= aLength;

        }

    }

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

// CJ2kTileInfo::AppendQCCL

// Verify and append QCC to the tile part header.

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

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

//

void CJ2kTileInfo::AppendQCCL( TQCCMarker *aMarker, TUint32 aLength )

    {

    if ( iSot.iTPsot == 0 )

        {

        // Use only for the first tile part of a tile

        TUint8 found = EFalse;

        for ( TUint16 index = 0; index < iTileMarker.iQcc.Count(); ++index )

            {

            if ( iTileMarker.iQcc[index]->iCqcc == aMarker->iCqcc )

                {

                found = ETrue;

                index = (TUint16)iTileMarker.iQcc.Count();  

                }

            }

        if ( !found )

            {

            User::LeaveIfError( iTileMarker.iQcc.Append( aMarker ) );

            }

        else

            {

            // No more than one QCC per component

            delete aMarker;

            aMarker = 0;

            }

        }

    else

        {

        // read but ignore it

        delete aMarker;

        aMarker = 0;

        }

    if ( iTileLength )

        {

        iTileLength -= aLength;

        }

    }

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

// CJ2kTileInfo::AppendRGNL

// Verify and append RGN to the tile part header.

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

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

//

void CJ2kTileInfo::AppendRGNL( TRGNMarker *aMarker, TUint32 aLength )

    {

    if ( iSot.iTPsot == 0 )

        {

        // Use only for the first tile part of a tile

        TUint8 found = EFalse;

        for ( TUint16 index = 0; index < iTileMarker.iRgn.Count(); ++index )

            {

            if ( iTileMarker.iRgn[index]->iCrgn == aMarker->iCrgn )

                {

                found = ETrue;

                index = (TUint16)iTileMarker.iRgn.Count();   

                }

            }

        if ( !found )

            {

            User::LeaveIfError( iTileMarker.iRgn.Append( aMarker ) );

            }

        else

            {

            // No more than one RGN per component

            delete aMarker;

            aMarker = 0;

            }

        }

    else

        {

        // Read but ignore it

        delete aMarker;

        aMarker = 0;

        }

    if ( iTileLength )

        {

        iTileLength -= aLength;

        }

    }

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

// CJ2kTileInfo::AppendPOCL

// Verify and append POC to the tile part header.

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

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

//

void CJ2kTileInfo::AppendPOCL( TPOCMarker *aMarker, TUint32 aLength )

    {

    if ( iTileMarker.iPoc == 0 )

        {

        iTileMarker.iPoc = aMarker;

        }

    else

        {

        // Appending the content of the POC to the

        // existing tile part header POC

        for ( TInt index = 0; index < aMarker->iPpoc.Count(); ++index )

            {

            User::LeaveIfError( iTileMarker.iPoc->iRSpoc.Append( aMarker->iRSpoc[index] ) );

            User::LeaveIfError( iTileMarker.iPoc->iCSpoc.Append( aMarker->iCSpoc[index] ) );

            User::LeaveIfError( iTileMarker.iPoc->iLYEpoc.Append( aMarker->iLYEpoc[index] ) );

            User::LeaveIfError( iTileMarker.iPoc->iREpoc.Append( aMarker->iREpoc[index] ) );

            User::LeaveIfError( iTileMarker.iPoc->iCEpoc.Append( aMarker->iCEpoc[index] ) );

            User::LeaveIfError( iTileMarker.iPoc->iPpoc.Append( aMarker->iPpoc[index] ) );

            }

        // At most one POC may exist in tile part header

        delete aMarker;

        aMarker = 0;

        }

    if ( iTileLength )

        {

        iTileLength -= aLength;

        }

    }

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

// CJ2kTileInfo::AppendCOML

// Verify and append COM to the tile part header.

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

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

//

void CJ2kTileInfo::AppendCOML( TCOMMarker *aMarker, TUint32 aLength )

    {

    User::LeaveIfError( iTileMarker.iCom.Append( aMarker ) );

    if ( iTileLength )

        {

        iTileLength -= aLength;

        }

    }

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

// CJ2kTileInfo::AppendPPTL

// Verify and append PPT to the tile part header.

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

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

//

void CJ2kTileInfo::AppendPPTL( TPPTMarker *aMarker, TUint32 aLength )

    {

    TUint8 inserted = EFalse;

    // Insert the new PPT marker into the right order

    for ( TUint16 index = 0; index < iTileMarker.iPpt.Count(); ++index )

        {

        // Order by iZppt of the PPT marker

        if ( iTileMarker.iPpt[index]->iZppt > aMarker->iZppt )

            {

            User::LeaveIfError( iTileMarker.iPpt.Insert( aMarker, index ) );

            inserted = ETrue;

            index = (TUint16)( iTileMarker.iPpt.Count() );   

            }

        }

    if ( !inserted )

        {

        User::LeaveIfError( iTileMarker.iPpt.Append( aMarker ) );

        }

    if ( iTileLength )

        {

        iTileLength -= aLength;

        }

    }

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

// CJ2kTileInfo::AppendPLTL

// Verify and append PLT to the tile part header.

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

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

//

void CJ2kTileInfo::AppendPLTL( TPLTMarker *aMarker, TUint32 aLength )

    {

    TUint8 inserted = EFalse;

    // Insert the new PLT marker into the right order

    for ( TUint16 index = 0; index < iTileMarker.iPlt.Count(); ++index )

        {

        // Order by iZplt of the PLT marker

        if ( iTileMarker.iPlt[index]->iZplt > aMarker->iZplt )

            {

            User::LeaveIfError( iTileMarker.iPlt.Insert( aMarker, index ) );

            inserted = ETrue;

            index = (TUint16)( iTileMarker.iPlt.Count() );   

            }

        }

    if ( !inserted )

        {

        User::LeaveIfError( iTileMarker.iPlt.Append( aMarker ) );

        }

    if ( iTileLength )

        {

        iTileLength -= aLength;

        }

    }

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

// CJ2kTileInfo::ReadBitStreamL

// Parsing the bitstream data based on progression order.

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

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

//

void CJ2kTileInfo::ReadBitStreamL( TUint8 aBool )

    {

    SetCheckMarker( aBool );

    if ( iPOC )

        {

        TUint8 incomplete = EFalse;

        while ( iLastPOC < iPOC->iPpoc.Count() )

            {

            if ( !iDoLoadPOC )

                {

                // Reload progression order change from POC marker

                iDoLoadPOC = ETrue;

                iLastLayer = 0;

                iLastLevelOrig = iLastLevel = (TUint8)iPOC->iRSpoc[iLastPOC];

                iLastComponentOrig = iLastComponent = (TUint16)iPOC->iCSpoc[iLastPOC];

                iNumOfLayersPOC = (TUint16)iPOC->iLYEpoc[iLastPOC];

                if ( iNumOfLayersPOC > NumOfLayers() )

                    {

                    iNumOfLayersPOC = NumOfLayers();

                    }

                iNumOfLevelsPOC = (TUint8)( iPOC->iREpoc[iLastPOC] - 1 );

                if ( iNumOfLevelsPOC > (TUint8)NumOfLevels() )

                    {

                    iNumOfLevelsPOC = (TUint8)NumOfLevels();

                    }

                iNumOfComponentsPOC = (TUint16)iPOC->iCEpoc[iLastPOC];

                if ( iNumOfComponentsPOC > NumOfComponents() )

                    {

                    iNumOfComponentsPOC = NumOfComponents();

                    }

                for ( TUint16 index = 0; index < iNumOfComponentsPOC; ++index )

                    {

                    iComponentList[index]->ResetLastPacketProcessed();

                    }

                iLastN2 = iTileCanvas.iTl.iX;

                iLastN1 = iTileCanvas.iTl.iY;

                }

            switch ( iPOC->iPpoc[iLastPOC] )

                {

                case EProgression_L_R_C_P:

                    {

                    incomplete = LRCPProgressionL();

                    break;

                    }

                case EProgression_R_L_C_P:

                    {

                    incomplete = RLCPProgressionL();

                    break;

                    }

                case EProgression_R_P_C_L:

                    {

                    incomplete = RPCLProgressionL();

                    break;

                    }

                case EProgression_P_C_R_L:

                    {

                    incomplete = PCRLProgressionL();

                    break;

                    }

                case EProgression_C_P_R_L:

                    {

                    incomplete = CPRLProgressionL();

                    break;

                    }

                default:

                    {

                    // Unrecognized progressin order

                    User::Leave( KErrCorrupt );

                    break;

                    }

                }