/*

* Copyright (c) 2003-2006 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:  CJp2kReadCodec class implements the ICL read codec interface.

*

*/

// INCLUDE FILES

#include <fbs.h>

#include <JP2KImageData.h>

#include "JP2KImageUtils.h"

#include "JP2KFormat.h"

#include "JP2KStreamReader.h"

#include "JP2KTileInfo.h"

#include "JP2KImageInfo.h"

#include "JP2KCodec.h"

#include "JP2KEntropyDecoder.h"

#include "JP2KImageWriter.h"

#include "JP2KSynthesis.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CJp2kReadCodec::NewL

// Two-phased constructor.

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

//

CJp2kReadCodec* CJp2kReadCodec::NewL( const TJ2kInfo& aJ2kInfo )

    {

    CJp2kReadCodec* self = new ( ELeave ) CJp2kReadCodec( aJ2kInfo );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self ); 

    return self;

    }

// Destructor

CJp2kReadCodec::~CJp2kReadCodec()

    {

    delete iImageInfo;

    iImageInfo = 0;

    delete iEntropy;

    iEntropy = 0;

    delete iImageWriter;

    iImageWriter = 0;

    delete iSynthesis;

    iSynthesis = 0;

    }

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

// CJp2kReadCodec::DecodeTileL

// Decoding the current tile-part

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

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

//

TFrameState CJp2kReadCodec::DecodeTileL()

    {

    CJ2kTileInfo& tile = CONST_CAST( CJ2kTileInfo&, iImageInfo->TileAt( iLastTileIndex ) );

    // Decode and delete the tile

    DecodeAndDeleteTileL( tile );

    // reset the codec back to the parsing state

    iDecodeTile = EFalse;

    TFrameState retCode = EFrameIncomplete;

    // Start with new tile

    iUseNewTile = ETrue;

    if ( !iUseNextTile )

        {

        iFHState = EStateInUnknown;

        retCode = EFrameIncompleteRepositionRequest;

        }

    else

        {

        if ( !iSequential )

            {

            // Must be End of Codestream EOC

            iFHState = EStateInEOC;

            retCode = EFrameComplete;

            }

        else if ( iFHState == EStateInEOC )

            {

            retCode = EFrameComplete;

            }

        else

            {

            iFHState = EStateInUnknown;

            }

        }

    return retCode;

    }

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

// CJp2kReadCodec::IsDecodeTile

// Is codec in the decoding state

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

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

//

TBool CJp2kReadCodec::IsDecodeTile() const

    {

    return iDecodeTile;

    }

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

// CJp2kReadCodec::InitFrameHeader

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

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

//

void CJp2kReadCodec::InitFrameHeader( TFrameInfo& aFrameInfo, CFrameImageData& aFrameData )

    {

    // Initialize internal data structure for holding frame header

    ASSERT( aFrameInfo.CurrentFrameState() == TFrameInfo::EFrameInfoUninitialised );

    iFrame = &aFrameInfo;

    iFrameData = &aFrameData;

    aFrameInfo.SetCurrentFrameState( TFrameInfo::EFrameInfoProcessingFrameHeader );

    }

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

// CJp2kReadCodec::ProcessFrameHeaderL

// Collect the JP2 codestream Main Header information.

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

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

//

TFrameState CJp2kReadCodec::ProcessFrameHeaderL( TBufPtr8& aData )

    {

    // Read frame header and fill up internal data structure

    TFrameState retCode = EFrameIncomplete;

    iReader.iPtr = aData.Ptr();

    iReader.iPtrStart = CONST_CAST( TUint8*, iReader.iPtr );

    iReader.iPtrEnd   = iReader.iPtrStart + aData.Length();

    while ( iFHState != EStateInSOT )

        {

        iReader.iPtrStartMarker = CONST_CAST( TUint8*, iReader.iPtr );

        switch ( iFHState )

            {

            case EStateInSOC:

                {

                retCode = ReadSOCL();

                break;

                }

            case EStateInSIZ:

                {

                retCode = ReadSIZL();

                break;

                }

            case EStateInCOD:

                {

                retCode = ReadCODL();

                break;

                }

            case EStateInCOC:

                {

                retCode = ReadCOCL();

                break;

                }

            case EStateInQCD:

                {

                retCode = ReadQCDL();

                break;

                }

            case EStateInQCC:

                {

                retCode = ReadQCCL();

                break;

                }

            case EStateInRGN:

                {

                retCode = ReadRGNL();

                break;

                }

            case EStateInPOC:

                {

                retCode = ReadPOCL();

                break;

                }

            case EStateInPPM:

                {

                retCode = ReadPPML();

                break;

                }

            case EStateInTLM:

                {

                retCode = ReadTLML();

                break;

                }

            case EStateInPLM:

                {

                retCode = ReadPLML();

                break;

                }

            case EStateInCRG:

                {

                retCode = ReadCRGL();

                break;

                }

            case EStateInCOM:

                {

                retCode = ReadCOML();

                break;

                }

            case EStateInUnknown:

                {

                // Update the internal state based on the Marker

                retCode = UpdateStateFromMarkerL(); 

                break;

                }

            default:

                {

                // Unrecognized marker

                User::Leave( KErrCorrupt );

                break;

                }

            }

        // Check for underflow

        if ( retCode != EFrameComplete ) 

            {

            aData.Shift( iReader.iPtr - iReader.iPtrStart );

            return retCode;

            }

        // Update the internal counter for data processed

        iReader.UpdateMainHeader();

        }

    // Convert the MainHeader's COM marker to TJp2kComment

    // and let the framework managing the buffer.

    TMainMarker& mainMarker = CONST_CAST( TMainMarker&, iImageInfo->MainMarker() );

    for ( TInt index = 0; index < mainMarker.iCom.Count(); ++index )

        {

        TJp2kComment* jp2kComment = new ( ELeave ) TJp2kComment;

        CleanupDeletePushL( jp2kComment );

        jp2kComment->iComment = mainMarker.iCom[index]->iCcom;

        User::LeaveIfError( iFrameData->AppendImageData( jp2kComment ) );

        CleanupStack::Pop();

        // Transfer the ownership of the buffer from TMainMarker to framework

        User::LeaveIfError( iFrameData->AppendImageBuffer( jp2kComment->iComment ) );

        mainMarker.iCom[index]->iCcom = 0;

        }

    // Convert some metadata from file format to TImageDataBlock derived objects

    ConvertImageDataL();

    // Try to sort PPM and PLM if there is one

    iImageInfo->DoCompactMainHeaderL();

    aData.Shift( iReader.iPtr - iReader.iPtrStart );

    // Fill up the image related information if it is not

    // JP2 file format

    if ( !( iJ2kInfo.iOption & TJ2kInfo::EJP2file ) )

        {

        const TSizMarker &sizMarker = iImageInfo->SizMarker();

        // To get the right output image size, we must compute the size tile by tile.

        // Compute the width of the output image

        TInt32 tileCompCanvasWidth = 0;

        TInt32 tileStartCanvas;

        TInt32 tileEndCanvas;

        TInt32 tileCompStartCanvas;

        for(TUint16 indexX = 0; indexX < numHorTiles; ++indexX )  

            {

            tileStartCanvas = Max( ( sizMarker.iXTOsiz + indexX * sizMarker.iXTsiz ), sizMarker.iXOsiz );

            tileEndCanvas = Min( ( sizMarker.iXTOsiz + ( indexX + 1 ) * sizMarker.iXTsiz ), sizMarker.iXsiz );

            // Add this tile's contribution to the total size

            }

        // Compute the height of the output image

        TInt32 tileCompCanvasHeight = 0;

        for(TUint16 indexY = 0; indexY < numVerTiles; ++indexY )  

            {

            tileStartCanvas = Max( ( sizMarker.iYTOsiz + indexY * sizMarker.iYTsiz ), sizMarker.iYOsiz );

            tileEndCanvas = Min( ( sizMarker.iYTOsiz + ( indexY + 1 ) * sizMarker.iYTsiz ), sizMarker.iYsiz );

            // Add this tile's contribution to the total size

            }

        iFrame->iOverallSizeInPixels = TSize( tileCompCanvasWidth, tileCompCanvasHeight );

        iFrame->iFrameCoordsInPixels.SetRect( TPoint( 0, 0 ), iFrame->iOverallSizeInPixels );

        iFrame->iFrameSizeInTwips.SetSize( 0, 0 );

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

            {

            iFrame->iBitsPerPixel += ( ( sizMarker.iSsiz[index] & 0x7f ) + 1 );

            }

        // We can dither.

        iFrame->iFlags |= TFrameInfo::ECanDither;

        // Decoder is able to handle scaleable resolution

        iFrame->iFlags |= TFrameInfo::EConstantAspectRatio;

        if ( sizMarker.iCsiz > 1 )

            {

            iFrame->iFlags |= TFrameInfo::EColor;

            }

        // Animation is not allowed

        iFrame->iDelay = 0;

        switch ( iFrame->iBitsPerPixel )

            {

            case 1:

                {

                iFrame->iFrameDisplayMode = EGray2;

                break;

                }

            case 2:

                {

                iFrame->iFrameDisplayMode = EGray4;

                break;

                }

            case 4:

                {

                iFrame->iFrameDisplayMode = ( iFrame->iFlags & TFrameInfo::EColor ) ? EColor16 : EGray16;

                break;

                }

            case 8:

                {

                iFrame->iFrameDisplayMode = ( iFrame->iFlags & TFrameInfo::EColor ) ? EColor16M : EGray256;

                break;

                }

            case 12:

                {

                iFrame->iFrameDisplayMode = ( iFrame->iFlags & TFrameInfo::EColor ) ? EColor4K : EGray256;

                break;

                }

            case 16:

                {

                iFrame->iFrameDisplayMode = EColor64K;

                break;

                }

            case 24:

                {

                iFrame->iFrameDisplayMode = EColor16M;

                break;

                }

            default:

                {

                iFrame->iFrameDisplayMode = EColor64K;

                break;

                }

            }

        }

    // It is the offset that ICL framework used to read in

    // more data from the image file.

    iFrame->SetFrameDataOffset( iReader.iStartSOT );

    // Frame header has been processed without error

    // the flag is used by the ICL framework to determine

    // whether it should continue processing or halt with error

    iFrame->SetCurrentFrameState( TFrameInfo::EFrameInfoProcessingComplete );

    return retCode;

    }

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

// CJp2kReadCodec::InitFrameL

// Called from ICL framework to initialise frame.

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

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

//

void CJp2kReadCodec::InitFrameL( TFrameInfo& /*aFrameInfo*/, CFrameImageData& /*aFrameData*/, 

                                 TBool aDisableErrorDiffusion, CFbsBitmap& aDestination, 

                                 CFbsBitmap* /*aDestinationMask*/ )

    {

    // Always use ERgb mode unless specified in the JP2 file format

    TDisplayMode mode = ERgb;  

    TInt reductionFactor = ImageProcessorUtility::ReductionFactor( iFrame->iOverallSizeInPixels,

                                                                   aDestination.SizeInPixels() );

    iImageInfo->SetLevelDrop( (TUint8)reductionFactor );

    // If the codestream doesn't contain enough wavelet levels to do the resolution 

    // reduction required by the framework / calling application, "extraLevels" are 

    // assigned to perform the resolution reduction. The "extra" resolution drop is

    // performed at the output stage, i.e. all the samples are decoded, but only 

    // 1/4, 1/16, etc. are written to output.

    if(reductionFactor > iImageInfo->MainMarker().iCod.iNumOfLevels)

        {

        iImageInfo->SetExtraLevelDrop( (TUint8)(reductionFactor - iImageInfo->MainMarker().iCod.iNumOfLevels) );

        }

    else

        {

        iImageInfo->SetExtraLevelDrop( 0 );

        }

    CImageProcessor* imageProc = ImageProcessorUtility::NewImageProcessorL( aDestination, 

                                                                            0,

                                                                            mode,

                                                                            aDisableErrorDiffusion );

    TPoint startAt( iFrame->iFrameCoordsInPixels.iTl.iX,

                    iFrame->iFrameCoordsInPixels.iTl.iY );

    TRect imageSize( startAt, aDestination.SizeInPixels() );

    // Prepare the bitmap using the image size

    SetImageProcessor( imageProc );

    imageProc->PrepareL( aDestination, imageSize );

    // Clear bitmap so sensibly draw partial decodes

    ClearBitmapL(aDestination, KRgbWhite);

    iUseNewTile = ETrue;

    iReader.iNewDataStart = iFrame->FrameDataOffset();

    iStyleUsed = EUnknownDecoder;

    iProgressBar = EFalse;

        {

        // To force a return immediately from ProcessFrameL()

        // on first entry to stimulate the occurrance of

        // the progress bar

        iProgressBar = ETrue;

        }

    if ( iFHState != EStateInSOT )

        {

        // We are in zoom in mode

        iUseNextTile = iSequential = EFalse;

        iFHState = EStateInSOT;

        iLastTileIndex = 0;

        iImageInfo->SetLastTilePartProcessed( (TUint16)0xffff );

        iImageWriter->SetNewImageProcessor( imageProc );

        if ( iJ2kInfo.iOption & TJ2kInfo::EJP2file )

            {

            iReader.iCSLength = iJ2kInfo.iCSBoxLength;

            // We have read in all header information, so skip it

            if ( iReader.iCSLength > iReader.iStartSOT )

                {

                iReader.iCSLength -= iReader.iStartSOT;

                }

            iReader.iDataUsed = 0;

            }

        }

    }

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

// CJp2kReadCodec::ProcessFrameL

// Collect the JP2 codestream Tile Part information.

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

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

//

TFrameState CJp2kReadCodec::ProcessFrameL(TBufPtr8& aSrc)

    {

    // Start decoding the compressed data stream

    TFrameState retCode = EFrameIncomplete;

    iReader.iPtr = aSrc.Ptr();

    iReader.iPtrStart = CONST_CAST( TUint8*, iReader.iPtr );

    iReader.iPtrEnd   = iReader.iPtrStart + aSrc.Length();

    while ( iFHState != EStateInEOC )

        {

        iReader.iPtrStartMarker = CONST_CAST( TUint8*, iReader.iPtr );

        switch ( iFHState )

            {

            case EStateInSOT:

                {

                retCode = ReadSOTL();

                break;

                }

            case EStateInSOD:

                {

                retCode = ReadSODL();

                break;

                }

            case EStateInBITSTREAM:

                {

                retCode = ReadBitStreamL();

                break;

                }

            case EStateInCOD: