/*

* 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:  JPEG2000 image encoder/decoder plugin class.

*

*/

// INCLUDE FILES

#include "JP2KImageUtils.h"

#include "JP2KFormat.h"

#include "JP2KConvert.h"

#include "JP2KStreamReader.h"

#include "JP2KImageClientMain.h"

#include "JP2KCodec.h"

#include <barsc.h>

#include <imageconversion.h>

#include <barsread.h>

#include <bautils.h>

#include <e32math.h>

#include <101F862D_extra.rsg>

#include <icl/icl_uids.hrh>

#include "JP2KUids.hrh"

#include <JP2KImageData.h>

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

_LIT( KJ2KPanicCategory, "J2KConvertPlugin" );

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

// CJp2kDecoder::NewL

// Two-phased constructor.

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

//

CJp2kDecoder* CJp2kDecoder::NewL()

    {

    return new ( ELeave ) CJp2kDecoder;

    }

// Destructor

CJp2kDecoder::~CJp2kDecoder()

    {

    // Call base class Cleanup(), else there is a possibility

    // of memory leak

    CImageDecoderPlugin::Cleanup();

    }

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

// CJp2kDecoder::ImageType

// Get the image type uid of this plugin.

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

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

//

void CJp2kDecoder::ImageType( TInt aFrameNumber, TUid& aImageType, TUid& aImageSubType ) const

    {

    __ASSERT_ALWAYS( aFrameNumber == 0, Panic( EFrameNumberOutOfRange ) );

    TUid uid = {KImageTypeJ2KUid};

    aImageType = uid;

    aImageSubType = KNullUid;

    }

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

// CJp2kDecoder::NumberOfImageComments

// Get the number of image comment.

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

//

TInt CJp2kDecoder::NumberOfImageComments() const

    {

    __ASSERT_ALWAYS( IsImageHeaderProcessingComplete(), Panic( EHeaderProcessingNotComplete ) );

    const TUid commentUid = { KJ2KCommentUid };

    const CFrameImageData& frameImageData = FrameData( 0 );

    const TInt imageDataCount = frameImageData.ImageDataCount();

    const TImageDataBlock *imageData = 0;

    TInt imageCommentCount = 0;

    for ( TInt index = 0; index < imageDataCount; ++index )

        {

        imageData = frameImageData.GetImageData( index );

        if ( imageData->DataType() == commentUid )

            {

            imageCommentCount++;

            }

        }

    return imageCommentCount;

    }

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

// CJp2kDecoder::ImageCommentL

// Get the image comment.

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

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

//

HBufC* CJp2kDecoder::ImageCommentL( TInt aCommentNumber ) const

    {

    __ASSERT_ALWAYS( IsImageHeaderProcessingComplete(), Panic( EHeaderProcessingNotComplete ) );

    __ASSERT_ALWAYS( ( aCommentNumber >= 0 ) && ( aCommentNumber < NumberOfImageComments() ), 

                     Panic( ECommentNumberOutOfRange ) );

    HBufC *comment = 0;

    if( FrameData( 0 ).ImageDataCount() > 0 )

        {

        const TUid commentUid = { KJ2KCommentUid };

        const CFrameImageData& frameImageData = FrameData( 0 );

        const TInt imageDataCount = frameImageData.ImageDataCount();

        const TImageDataBlock *imageData = 0;

        TInt commentCount = 0;

        for ( TInt index = 0; index < imageDataCount; ++index )

            {

            imageData = frameImageData.GetImageData( index );

            if ( imageData->DataType() == commentUid )

                {

                if ( commentCount == aCommentNumber )

                    {

                    index = imageDataCount; // Break from the for loop

                    }

                else

                    {

                    commentCount++;

                    }

                }

            }

        if( imageData != 0 )

            {

            const TJp2kComment *jp2kComment = STATIC_CAST( const TJp2kComment*, imageData );

            comment = HBufC::NewL( jp2kComment->iComment->Length() );

            // Create 16 bit copy of the 8 bit original

            comment->Des().Copy( *( jp2kComment->iComment ) );

            }

        }

    return comment;

    }

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

// CJp2kDecoder::NumberOfFrameComments

// Get the number of frame comment.

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

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

//

TInt CJp2kDecoder::NumberOfFrameComments( TInt aFrameNumber ) const

    {

    __ASSERT_ALWAYS( IsImageHeaderProcessingComplete(), Panic( EHeaderProcessingNotComplete ) );

    __ASSERT_ALWAYS( aFrameNumber == 0, Panic( EFrameNumberOutOfRange ) );

    return NumberOfImageComments();

    }

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

// CJp2kDecoder::FrameCommentL

// Get the frame comment.

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

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

//

HBufC* CJp2kDecoder::FrameCommentL( TInt aFrameNumber, TInt aCommentNumber ) const

    {

    __ASSERT_ALWAYS( IsImageHeaderProcessingComplete(), Panic( EHeaderProcessingNotComplete ) );

    __ASSERT_ALWAYS( aFrameNumber == 0, Panic( EFrameNumberOutOfRange ) );

    return ImageCommentL( aCommentNumber );

    }

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

// CJp2kDecoder::FrameInfoStringsL

// Retrieve frame information and format it according to info stored in .rss file.

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

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

//

CFrameInfoStrings* CJp2kDecoder::FrameInfoStringsL( RFs& aFs, TInt aFrameNumber )

    {

    const TUid KJp2kCodecDllUid = { KJ2KCodecDllUidValue };

    RResourceFile resourceFile;

    OpenExtraResourceFileLC( aFs, KJp2kCodecDllUid, resourceFile );

    HBufC8* resourceInfo = resourceFile.AllocReadLC( THEDECODERINFO );

    TResourceReader resourceReader;

    resourceReader.SetBuffer( resourceInfo );

    TBuf<KCodecResourceStringMax> info;

    TBuf<KCodecResourceStringMax> templte;

    const TFrameInfo& frameInfo = FrameInfo( aFrameNumber );

    CFrameInfoStrings* frameInfoStrings = CFrameInfoStrings::NewLC();

    info = resourceReader.ReadTPtrC();

    frameInfoStrings->SetDecoderL( info );

    info = resourceReader.ReadTPtrC();

    frameInfoStrings->SetFormatL( info );

    TInt width = frameInfo.iOverallSizeInPixels.iWidth;

    TInt height = frameInfo.iOverallSizeInPixels.iHeight;

    TInt depth = frameInfo.iBitsPerPixel;

    templte = resourceReader.ReadTPtrC();

    info.Format( templte, width, height );

    frameInfoStrings->SetDimensionsL( info );

    CDesCArrayFlat* resourceArray = resourceReader.ReadDesCArrayL();

    CleanupStack::PushL( resourceArray );

    TUint formatIndex = ( frameInfo.iFlags & TFrameInfo::EColor ) ? 1 : 0;

    templte = ( *resourceArray )[formatIndex];

    CleanupStack::PopAndDestroy( resourceArray );

    info.Format( templte, depth );

    frameInfoStrings->SetDepthL( info );

    resourceArray = resourceReader.ReadDesCArrayL();

    CleanupStack::PushL( resourceArray );

    formatIndex = 0;

    info = ( *resourceArray )[formatIndex];

    CleanupStack::PopAndDestroy( resourceArray );

    frameInfoStrings->SetDetailsL( info );

    CleanupStack::Pop( frameInfoStrings );

    CleanupStack::PopAndDestroy( 2 ); // resourceInfo + resourceFile

    return frameInfoStrings;

    }

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

// CJp2kDecoder::FrameHeaderBlockSize

// Returns the frame header block size.

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

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

//

TInt CJp2kDecoder::FrameHeaderBlockSize( TInt aFrameNumber ) const

    {

    __ASSERT_ALWAYS( aFrameNumber == 0, Panic( EFrameNumberOutOfRange ) );

    return KJ2kInputBufferSize;

    }

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

// CJp2kDecoder::FrameBlockSize

// Returns the frame block size.

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

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

//

TInt CJp2kDecoder::FrameBlockSize(TInt aFrameNumber) const

    {

    __ASSERT_ALWAYS( aFrameNumber == 0, Panic( EFrameNumberOutOfRange ) );

    return KJ2kInputBufferSize;

    }

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

// CJp2kDecoder::DoConvert

// Override the default DoConvert to split out the parsing and decoding

// process into multiple steps.

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

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

//

void CJp2kDecoder::DoConvert()

    {

    TFrameState codecState = EFrameIncomplete;

    TInt errCode = KErrNone;

    CJp2kReadCodec *j2kCodec = static_cast<CJp2kReadCodec*>( ImageReadCodec() );

    if ( !j2kCodec->IsDecodeTile() )

        {

        // parsing of a tile-part

        TRAP( errCode, PrepareForProcessFrameL() );

        if ( errCode != KErrNone )

            {

            RequestComplete( errCode );

            return;

            }

        TBufPtr8& sourceData = SourceData();

        TInt sourceLength = sourceData.Length();

        if ( sourceLength != 0 )

            {

            TRAP( errCode, codecState = j2kCodec->ProcessFrameL( sourceData ) );

            if ( j2kCodec->IsDecodeTile() )

                {

                // tile-part contains all compressed data

                // and proceed to the decoding

                SelfComplete( KErrNone );

                return;

                }

            }

        // continue on parsing the tile-part

        HandleProcessFrameResult( errCode, codecState );

        }

    else

        {

        // decoding of the tile-part

        TRAP( errCode, codecState = j2kCodec->DecodeTileL() );

        if ( errCode == KErrNone )

            {

            if ( j2kCodec->IsDecodeTile() )

                {

                // continue on decoding the tile-part

                // if we split the decoding into multiple steps

                SelfComplete( KErrNone );

                return;

                }

            }

        // either continue on parsing the next tile-part

        // or done with the whole image

        HandleProcessFrameResult( errCode, codecState );

        }

    }

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

// CJp2kDecoder::CJp2kDecoder

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

// might leave.

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

//

CJp2kDecoder::CJp2kDecoder()

    {

    }  

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

// CJp2kDecoder::ReadFormatL

// JP2 File Format detection state machine.

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

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

//

void CJp2kDecoder::ReadFormatL()

    {

    // Verify the JP2 file format if it exist

    iCallFromFramework = ETrue;

    while ( iState != EStateInCodestreamBox )

        {

        switch ( iState )

            {

            case EStateInSignatureBox:

                {

                ReadSignatureBoxL();

                break;

                }

            case EStateInFileTypeBox:

                {

                ReadFileTypeBoxL();

                break;

                }

            case EStateInJP2SuperBox:

                {

                ReadJp2HeaderBoxL();

                break;

                }

            case EStateInIPRBox:

                {

                ReadIPRBoxL();

                break;

                }

            case EStateInXMLBox:

                {

                ReadXMLBoxL();

                break;

                }

            case EStateInUUIDBox:

                {

                ReadUUIDBoxL();

                break;

                }

            case EStateInUUIDInfoBox:

                {

                ReadUUIDInfoBoxL();

                break;

                }

            case EStateInUnknown:

                {

                if ( iCallFromFramework )

                    {

                    // Always read the length and type of the box

                    ReadDataL( iLastRead, iBufferDes, KJ2kBoxTypeLength );

                    if ( (TUint32)iBufferDes.Length() < KJ2kBoxTypeLength )

                        {

                        if ( ( iJ2kInfo.iCSOffset != 0 ) && 

                             ( (TUint32)iBufferDes.Length() == 0 ) )

                            {

                            // We have reach the end of file/stream and 

                            // CodeStream box has been recognized

                            iState = EStateInCodestreamBox;

                            }

                        else

                            {

                            // Need more data from the ICL framework

                            User::Leave( KErrUnderflow );

                            }

                        }

                    iPtr = iBufferDes.Ptr();

                    }

                if ( iState != EStateInCodestreamBox )

                    {

                    // Length and Type of next box

                    iBoxLength = PtrReadUtil::ReadBigEndianUint32Inc( iPtr );

                    iBoxType = PtrReadUtil::ReadBigEndianUint32( iPtr );

                    // Update the internal state based on the iBoxType

                    UpdateStateFromBoxTypeL();

                    if ( iState != EStateInCodestreamBox )

                        {

                        // Corrupted box length

                        if ( ( (TInt32)iBoxLength ) < 0 )

                            {

                            User::Leave( KErrCorrupt );

                            }

                        }

                    }

                break;

                }

            default:

                {

                break;

                }

            }

        iCallFromFramework = EFalse;

        }

    // When the code reach here, it means that we have found the 

    // codestream box in JP2 file format or the codestream SOC itself

    // in case of the JP2 file format, all the boxes after the

    // codestream box will not be read and parsed.

    // In JP2 file format, iLastRead points to codestream box

    // in JP2 codestream, iLastRead points to SOC marker

    // it is the offset that ICL framework used to read

    // in more data from the image file.

    SetStartPosition( iJ2kInfo.iCSOffset );

    // Always set the image data length to KMaxTInt32

    SetDataLength( KMaxTInt );

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

    // in JP2 file format, else defer the setting of the

    // image info til SIZ marker in the codestream has

    // been processed.

    if ( iJ2kInfo.iOption & TJ2kInfo::EJP2file )

        {

        TFrameInfo& imageInfo = CONST_CAST( TFrameInfo&, ImageInfo() );

        imageInfo.iOverallSizeInPixels = iJ2kInfo.iImageSize;

        imageInfo.iFrameCoordsInPixels.SetRect( TPoint( 0, 0 ), iJ2kInfo.iImageSize );

        imageInfo.iFrameSizeInTwips = iJ2kInfo.iImageSizeInTwips;

        if ( iJ2kInfo.iBPCList.Count() > 0 )

            {

            // Calculate based on the bitdepth per component

            for ( TUint16 index = 0; index < iJ2kInfo.iNC; ++index )

                {

                imageInfo.iBitsPerPixel += ( ( 0x7f & iJ2kInfo.iBPCList[index] ) + 1 );

                }

            }

        else

            {            

            if ( iJ2kInfo.iBPC == KJ2kIsBPCBoxExist )

                {

                User::Leave( KErrCorrupt );

                }

            // Has the same bitdepth on each component

            imageInfo.iBitsPerPixel = ( ( 0x7f & iJ2kInfo.iBPC ) + 1 ) * iJ2kInfo.iNC;

            }

        imageInfo.iFlags |= TFrameInfo::ECanDither;

        // Decoder is able to handle scaleable resolution

        imageInfo.iFlags |= TFrameInfo::EConstantAspectRatio;

        if ( iJ2kInfo.iEnumCS != KJ2kColourSpecGrayScale )

            {

            imageInfo.iFlags |= TFrameInfo::EColor;

            }

        // No animation.

        imageInfo.iDelay = 0;

        switch ( imageInfo.iBitsPerPixel )

            {

            case 1:

                {

                imageInfo.iFrameDisplayMode = EGray2;

                break;

                }

            case 2:

                {

                imageInfo.iFrameDisplayMode = EGray4;

                break;

                }

            case 4:

                {

                imageInfo.iFrameDisplayMode = ( imageInfo.iFlags & TFrameInfo::EColor ) ? EColor16 : EGray16;

                break;

                }

            case 8:

                {

                imageInfo.iFrameDisplayMode = ( imageInfo.iFlags & TFrameInfo::EColor ) ? EColor16M : EGray256;

                break;

                }

            case 12:

                {

                imageInfo.iFrameDisplayMode = ( imageInfo.iFlags & TFrameInfo::EColor ) ? EColor4K : EGray256;

                break;