/*

* 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:  CJp2kReadCodec class implements the ICL read codec interface.

*

*/

#ifndef __JP2KCODEC_H__

#define __JP2KCODEC_H__

//  INCLUDES

#include <icl/imageprocessor.h>

#include <icl/imagecodec.h>

#include <icl/imagecodecdata.h>

// CONSTANTS

// Delimiting marker segments

const TUint16 KSOC = 0xFF4F;    // Start of codestream

const TUint16 KSOT = 0xFF90;    // Start of tile-part

const TUint16 KSOD = 0xFF93;    // Start of data

const TUint16 KEOC = 0xFFD9;    // End of codestream

// Fixed information marker segments

const TUint16 KSIZ = 0xFF51;    // Image and tile size

// Functional marker segments

const TUint16 KCOD = 0xFF52;    // Coding style default

const TUint16 KCOC = 0xFF53;    // Coding style component

const TUint16 KRGN = 0xFF5E;    // Region of interest 

const TUint16 KQCD = 0xFF5C;    // Quantization default

const TUint16 KQCC = 0xFF5D;    // Quantization component

const TUint16 KPOC = 0xFF5F;    // Progression order default

// Pointer marker segments 

const TUint16 KTLM = 0xFF55;    // Tile-part lengths, main header

const TUint16 KPLM = 0xFF57;    // Packet length, main header

const TUint16 KPLT = 0xFF58;    // Packet length, tile-part header

const TUint16 KPPM = 0xFF60;    // Packed packet headers, main header 

const TUint16 KPPT = 0xFF61;    // Packed packet headers, tile-part header 

// Informational marker segments

const TUint16 KCME = 0xFF64;    // Comment and extension 

const TUint16 KCRG = 0xFF63;    // Component registration 

// Packet information 

const TUint16 KSOP = 0xFF91;    // Start of packet

const TUint16 KEPH = 0xFF92;    // End of packet header 

const TUint16 KSOP_LEN = 0x04;  // Length of the SOP 

// Extensions marker segments 

const TUint16 KEXTS = 0xFF30;    // Start of extensions

const TUint16 KEXTE = 0xFF3F;    // End Of extensions

const TUint16 KMarkerSize   = 2; // Size of a marker - 2 bytes 

const TUint16 KMarkerLength = 2; // Size of a length - 2 bytes 

const TUint16 KMarkerMinLength = KMarkerSize + KMarkerLength;

// MACROS

// DATA TYPES

// FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

class TJ2kInfo;

class CJ2kImageInfo;

class TJ2kStreamReader;

class CJ2kEntropyDecoder;

class CJ2kImageWriter;

class CJ2kSynthesis;

class CJ2kTileInfo;

// CLASS DECLARATION

/**

 * CJp2kReadCodec JPEG2000 image read codec class.

 * Implement the ICL read codec interface.

 *

 * JP2KCodec.dll

 * @since 2.6

 */

class CJp2kReadCodec : public CImageProcessorReadCodec //lint !e768 Will be referenced by framework.      

{

    public:  // Constructors and destructor

        /**

        * Two-phased constructor.

        */

        static CJp2kReadCodec* NewL( const TJ2kInfo& aJ2kInfo );

        /**

        * Destructor.

        */

        virtual ~CJp2kReadCodec();

    public: // New functions

        /**

        * Decoding the current tile-part.

        * @since 2.6

        * @return TFrameState: frame state after decoding the current tile-part.

        */

        TFrameState DecodeTileL();

        /**

        * Is codec in the decoding state.

        * @since 2.6

        * @return TBool: false if codec in the parsing state.

        */

        TBool IsDecodeTile() const;

    public: // Functions from base classes

        /**

        * From CImageReadCodec

        * @since 2.6

        * @param aFrameInfo: Frame information.

        * @param aFrameData: Frame data.

        */

        void InitFrameHeader( TFrameInfo& aFrameInfo, CFrameImageData& aFrameData );

        /**

        * From CImageReadCodec

        * @since 2.6

        * @param aData: Data to be processed.

        */

        TFrameState ProcessFrameHeaderL( TBufPtr8& aData );

        /**

        * From CImageReadCodec

        * @since 2.6

        * @param aFrameInfo: Frame information.

        * @param aFrameData: Frame data.

        * @param aDisableErrorDiffusion: Use error diffusion or not.

        * @param aDestination: Destination bitmap.

        * @param aDestinationMask: Destination bitmap mask.

        */

        void InitFrameL( TFrameInfo& aFrameInfo, CFrameImageData& aFrameData, 

                         TBool aDisableErrorDiffusion, CFbsBitmap& aDestination, 

                         CFbsBitmap *aDestinationMask );

        /**

        * From CImageReadCodec

        * @since 2.6

        * @param aSrc: Source data.

        */

        TFrameState ProcessFrameL( TBufPtr8& aSrc );

        /**

        * From CImageReadCodec

        * @since 2.6

        * @param aPosition: New position in data.

        * @param aLength: Number of bytes to read.

        */

        void GetNewDataPosition(TInt& aPosition, TInt& aLength);

    protected:  // New functions

    protected:  // Functions from base classes

    private:

        /**

        * C++ default constructor.

        */

        CJp2kReadCodec( const TJ2kInfo& aJ2kInfo );

        /**

        * By default Symbian 2nd phase constructor is private.

        */

        void ConstructL();

        /**

        * Verify and process Start of Codestream (SOC marker)

        * @since 2.6

        */

        TFrameState ReadSOCL();

        /**

        * Verify and process Image and Tile Size (SIZ marker)

        * @since 2.6

        */

        TFrameState ReadSIZL();

        /**

        * Verify and process Coding Style Default (COD marker)

        * @since 2.6

        * @param aMain: true for Main Header, false for Tile Part Header.

        */

        TFrameState ReadCODL( TBool aMain = ETrue );

        /**

        * Verify and process Coding Style Component (COC marker)

        * @since 2.6

        * @param aMain: true for Main Header, false for Tile Part Header.

        */

        TFrameState ReadCOCL( TBool aMain = ETrue );

        /**

        * Verify and process Quantization Default (QCD marker)

        * @since 2.6

        * @param aMain: true for Main Header, false for Tile Part Header.

        */

        TFrameState ReadQCDL( TBool aMain = ETrue );

        /**

        * Verify and process Quantization Component (QCC marker)

        * @since 2.6

        * @param aMain: true for Main Header, false for Tile Part Header.

        */

        TFrameState ReadQCCL( TBool aMain = ETrue );

        /**

        * Verify and process Region of Interest (RGN marker)

        * @since 2.6

        * @param aMain: true for Main Header, false for Tile Part Header.

        */

        TFrameState ReadRGNL( TBool aMain = ETrue );

        /**

        * Verify and process Progression Order Change (POC marker)

        * @since 2.6

        * @param aMain: true for Main Header, false for Tile Part Header.

        */

        TFrameState ReadPOCL( TBool aMain = ETrue );

        /**

        * Verify and process Packed Packet Headers, Main Header (PPM marker)

        * @since 2.6

        */

        TFrameState ReadPPML();

        /**

        * Verify and process Tile Part Lengths, Main Header (TLM marker)

        * @since 2.6

        */

        TFrameState ReadTLML();

        /**

        * Verify and process Packet Length, Main Header (PLM marker)

        * @since 2.6

        */

        TFrameState ReadPLML();

        /**

        * Verify and process Component Registration, Main Header (CRG marker)

        * @since 2.6

        */

        TFrameState ReadCRGL();

        /**

        * Verify and process Comment (COM marker)

        * @since 2.6

        * @param aMain: true for Main Header, false for Tile Part Header.

        */

        TFrameState ReadCOML( TBool aMain = ETrue );

        /**

        * Verify and process Start of Tile Part (SOT marker)

        * @since 2.6

        */

        TFrameState ReadSOTL();

        /**

        * Verify and process Start of Data (SOD marker)

        * @since 2.6

        */

        TFrameState ReadSODL();

        /**

        * Verify and process BitStream Data

        * @since 2.6

        */

        TFrameState ReadBitStreamL();

        /**

        * Verify and process Packed Packet Headers, Tile Part Header (PPT marker)

        * @since 2.6

        */

        TFrameState ReadPPTL();

        /**

        * Verify and process Packet Length, Tile Part Header (PLT marker)

        * @since 2.6

        */

        TFrameState ReadPLTL();

        /**

        * Ignore the content and advance the iterator to the next marker

        * @since 2.6

        */

        TFrameState ReadSkipTileL();

        /**

        * Update the current state according to the marker type

        * @since 2.6

        */

        TFrameState UpdateStateFromMarkerL();

        /**

        * Decode the tile and delete it after decoding

        * @since 2.6

        * @param aTile: a reference to the tile to decode.

        */

        void DecodeAndDeleteTileL( CJ2kTileInfo& aTile );

        /**

        * Convert metadata from file format to TImageDataBlock derived objects

        * @since 2.6

        */

        void ConvertImageDataL();

    public:     // Data

        // State machine represent the state when parsing of the JP2 codestream.        

        enum TFrameHeaderState

            {

            EStateInSOC,

            EStateInSIZ,

            EStateInCOD,

            EStateInCOC,

            EStateInQCD,

            EStateInQCC,

            EStateInRGN,

            EStateInPOC,

            EStateInPPM,

            EStateInTLM,

            EStateInPLM,

            EStateInCRG,

            EStateInCOM,

            EStateInSOT,

            EStateInPPT,

            EStateInPLT,

            EStateInSOD,

            EStateInBITSTREAM,

            EStateInEOC,

            EStateInSkipTile,

            EStateInUnknown

            };

    protected:  // Data

    private:    // Data

        // Decoding style.

        enum TDecoderStyle

        {

        ETileBasedDecoder,   // Tile-based decoding

        EBlockBasedDecoder,  // Block-based wavelet 

        EUnknownDecoder      // Use some logic to choose the style to use

        };

        // JP2 file format information

        const TJ2kInfo& iJ2kInfo;  

        // Frame information

        TFrameInfo *iFrame;        

        // Frame data, owned by framework

        CFrameImageData *iFrameData;

        // Index of last tile processed

        TUint16 iLastTileIndex;

        // Current state

        TFrameHeaderState iFHState;    

        // Indicate new tile to be processed

        TUint8 iUseNewTile;   

        // Indicate next tile to be processed

        TUint8 iUseNextTile;  

        // Tiles are in sequential order

        TUint8 iSequential;   

        // Reference to stream reader

        TJ2kStreamReader iReader;       

        // .jp2 image information

        CJ2kImageInfo *iImageInfo;    

        // To handle the underflow PPM

        TPPMMarker *iPreviousPPM;

        // To handle the underflow COM

        TCOMMarker *iPreviousCOM;  

        // The entropy decoder

        CJ2kEntropyDecoder *iEntropy;    

        // The image write

        CJ2kImageWriter *iImageWriter;

        // The synthesis

        CJ2kSynthesis *iSynthesis;  

        // The decoding mechanism used

        TDecoderStyle iStyleUsed;  

        // Indicate a progression bar is needed for single tile image

        TBool iProgressBar;

        // Indicate the codec state

        TBool iDecodeTile;

    public:     // Friend classes

    protected:  // Friend classes

    private:    // Friend classes

    };

#endif // __JP2KCODEC_H__