/*

* Copyright (c) 2006-2008 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:  Implementation of CVisualFrame, CExtJpegDecoder and CExtJpegEncoder

*

*/

// INCLUDE FILES

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <icl_uids_def.hrh>

#endif

#include "IclExtJpegApi.h"

#include "IclExtJpegApiFrameImpl.h"

/*****************************************************/

/* Visual Frame Data Structure in Extended ICL API   */

/*****************************************************/

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

// CVisualFrame* CVisualFrame::NewL

// Two-phased constructor.

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

//

EXPORT_C CVisualFrame* CVisualFrame::NewL( 

                                    TDes8& aBuffer, 

                                    const TSize& aDimension, 

                                    TInt aFrameFormat )

    {

    CVisualFrame* self = new ( ELeave ) CVisualFrame();

    CleanupStack::PushL( self );

    self->iVisualFrameImpl = CVisualFrameImpl::NewL( aBuffer, aDimension, aFrameFormat );

    CleanupStack::Pop( self );

    return self;

    }

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

// CVisualFrame* CVisualFrame::NewL

// Two-phased constructor.

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

//

EXPORT_C CVisualFrame* CVisualFrame::NewL( 

                                    RChunk& aChunk, 

                                    TInt aSize, 

                                    TInt aMaxSize, 

                                    TInt aDataOffset,

                                    const TSize& aDimension, 

                                    TInt aFrameFormat )

    {

    CVisualFrame* self = new ( ELeave ) CVisualFrame();

    CleanupStack::PushL( self );

    self->iVisualFrameImpl = CVisualFrameImpl::NewL( aChunk, aSize, aMaxSize, 

                                                     aDataOffset, aDimension, aFrameFormat );

    CleanupStack::Pop( self );

    return self;

    }

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

// CVisualFrame* CVisualFrame::NewL

// Two-phased constructor.

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

//

EXPORT_C CVisualFrame* CVisualFrame::NewL( 

                                    TDes8& aBuffer, 

                                    const TSize& aDimension, 

                                    TInt aFrameFormat, 

                                    const TFrameLayout& aFrameLayout )

    {

    CVisualFrame* self = new ( ELeave ) CVisualFrame();

    CleanupStack::PushL( self );

    self->iVisualFrameImpl = CVisualFrameImpl::NewL( aBuffer, aDimension, 

                                                     aFrameFormat, aFrameLayout );

    CleanupStack::Pop( self );

    return self;

    }

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

// CVisualFrame* CVisualFrame::NewL

// Two-phased constructor.

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

//

EXPORT_C CVisualFrame* CVisualFrame::NewL( 

                                    RChunk& aChunk, 

                                    TInt aSize, 

                                    TInt aMaxSize, 

                                    const TSize& aDimension, 

                                    TInt aFrameFormat, 

                                    const TFrameLayout& aFrameLayout )

    {

    CVisualFrame* self = new ( ELeave ) CVisualFrame();

    CleanupStack::PushL( self );

    self->iVisualFrameImpl = CVisualFrameImpl::NewL( aChunk, aSize, aMaxSize, 

                                                     aDimension, aFrameFormat, 

                                                     aFrameLayout );

    CleanupStack::Pop( self );

    return self;

    }

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

// CVisualFrame::DataChunkL

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

//

EXPORT_C const RChunk& CVisualFrame::DataChunkL() const

    {

    return iVisualFrameImpl->DataChunkL();

    }

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

// CVisualFrame::DataPtrL

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

//

EXPORT_C TPtr8 CVisualFrame::DataPtrL() const

    {

    return iVisualFrameImpl->DataPtrL();

    }

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

// CVisualFrame::Dimension

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

//

EXPORT_C TSize CVisualFrame::Dimension() const

    {

    return iVisualFrameImpl->Dimension();

    }

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

// CVisualFrame::FrameFormat

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

//

EXPORT_C TInt CVisualFrame::FrameFormat() const

    {

    return iVisualFrameImpl->FrameFormat2();

    }

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

// CVisualFrame::DataOffset

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

//

EXPORT_C TInt CVisualFrame::DataOffset() const

    {

    return iVisualFrameImpl->DataOffset();

    }

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

// CVisualFrame::Size

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

//

EXPORT_C TInt CVisualFrame::Size() const

    {

    return iVisualFrameImpl->Size();

    }

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

// CVisualFrame::SetSizeL

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

//

EXPORT_C void CVisualFrame::SetSizeL( TInt aSize )

    {

    iVisualFrameImpl->SetSizeL( aSize );

    }

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

// CVisualFrame::MaxSize

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

//

EXPORT_C TInt CVisualFrame::MaxSize() const

    {

    return iVisualFrameImpl->MaxSize();

    }

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

// CVisualFrame::DataContainer

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

//

EXPORT_C CVisualFrame::TDataContainer CVisualFrame::DataContainer() const

    {

    return ( TDataContainer )iVisualFrameImpl->DataContainer();

    }

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

// CVisualFrame::FrameLayout

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

//

EXPORT_C const CVisualFrame::TFrameLayout& CVisualFrame::FrameLayout() const

    {

    return iVisualFrameImpl->FrameLayout2();

    }

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

// CVisualFrame::~CVisualFrame

// Destructor

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

//

EXPORT_C CVisualFrame::~CVisualFrame()

    {

    delete iVisualFrameImpl;

    } 

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

// CVisualFrame* CVisualFrame::NewL

// Two-phased constructor.

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

//

EXPORT_C CVisualFrame* CVisualFrame::NewL( const CImageFrame* aImageFrame )

    {

    CVisualFrame* self = new ( ELeave ) CVisualFrame();

    CleanupStack::PushL( self );

    self->iVisualFrameImpl = CVisualFrameImpl::NewL( aImageFrame );

    CleanupStack::Pop( self );

    return self;

    }

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

// CVisualFrame::GetImageFrameL

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

//

EXPORT_C CImageFrame* CVisualFrame::GetImageFrameL()

    {

    return iVisualFrameImpl->GetImageFrameL();    

    }

/*****************************************************/

/* Extended ICL Jpeg Decoder API                     */

/*****************************************************/

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

// CExtJpegDecoder* CExtJpegDecoder::NewL

// Two-phased constructor.

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

//

EXPORT_C CExtJpegDecoder* CExtJpegDecoder::NewL()

    {

    return new (ELeave) CExtJpegDecoder();

    }

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

// CExtJpegDecoder* CExtJpegDecoder::FileNewL

// Creates, initializes and returns a pointer to an object of 

// class CExtJpegDecoder

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

//

EXPORT_C CExtJpegDecoder* CExtJpegDecoder::FileNewL( 

                                        RFs& aFs, const TDesC& aSourceFilename, 

                                        const TDesC8& aMIMEType, 

                                        const TOptions aOptions )

    {

    CExtJpegDecoder* dec = reinterpret_cast<CExtJpegDecoder*>( 

                                CImageDecoder::FileNewL( aFs, aSourceFilename, 

                                aMIMEType, aOptions ) );

    CleanupStack::PushL( dec );

    if ( dec->CapabilitiesL() < ECapNone )

        {

        User::Leave( KErrNotFound );

        }

    CleanupStack::Pop();

    return dec;

    }

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

// CExtJpegDecoder* CExtJpegDecoder::FileNewL

// Creates, initializes and returns a pointer to an object of 

// class CExtJpegDecoder

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

//

EXPORT_C CExtJpegDecoder* CExtJpegDecoder::FileNewL( 

                                        RFs& aFs, 

                                        const TDesC& aSourceFilename, 

                                        const TOptions aOptions, 

                                        const TUid aImageType, 

                                        const TUid aImageSubType, 

                                        const TUid aDecoderUid )

    {

    CExtJpegDecoder* dec = reinterpret_cast<CExtJpegDecoder*>( 

                                CImageDecoder::FileNewL( aFs, aSourceFilename, aOptions, 

                                aImageType, aImageSubType, aDecoderUid ) );

    CleanupStack::PushL( dec );

    if ( dec->CapabilitiesL() < ECapNone )

        {

        User::Leave( KErrNotFound );

        }

    CleanupStack::Pop();

    return dec;

    }

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

// CExtJpegDecoder* CExtJpegDecoder::DataNewL

// Creates, initializes and returns a pointer to an object of 

// class CExtJpegDecoder

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

//

EXPORT_C CExtJpegDecoder* CExtJpegDecoder::DataNewL( 

                                        RFs& aFs, 

                                        const TDesC8& aSourceData, 

                                        const TDesC8& aMIMEType, 

                                        const TOptions aOptions )

    {

    CExtJpegDecoder* dec = reinterpret_cast<CExtJpegDecoder*>( 

                                CImageDecoder::DataNewL( aFs, aSourceData, 

                                aMIMEType, aOptions ) );

    CleanupStack::PushL( dec );

    if ( dec->CapabilitiesL() < ECapNone )

        {

        User::Leave( KErrNotFound );

        }

    CleanupStack::Pop();

    return dec;

    }

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

// CExtJpegDecoder* CExtJpegDecoder::DataNewL

// Creates, initializes and returns a pointer to an object of 

// class CExtJpegDecoder

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

//

EXPORT_C CExtJpegDecoder* CExtJpegDecoder::DataNewL( 

                                        RFs& aFs, 

                                        const TDesC8& aSourceData, 

                                        const TOptions aOptions, 

                                        const TUid aImageType, 

                                        const TUid aImageSubType, 

                                        const TUid aDecoderUid )

    {

    CExtJpegDecoder* dec = reinterpret_cast<CExtJpegDecoder*>( 

                                CImageDecoder::DataNewL( aFs, aSourceData, aOptions, 

                                aImageType, aImageSubType, aDecoderUid ) );

    CleanupStack::PushL( dec );

    if ( dec->CapabilitiesL() < ECapNone )

        {

        User::Leave( KErrNotFound );

        }

    CleanupStack::Pop();

    return dec;

    }

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

// CExtJpegDecoder* CExtJpegDecoder::DataNewL

// Creates, initializes and returns a pointer to an object of 

// class CExtJpegDecoder

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

//

EXPORT_C CExtJpegDecoder* CExtJpegDecoder::DataNewL( 

                                        RFs& aFs, 

                                        const CVisualFrame* aSourceData, 

                                        const TDesC8& aMIMEType, 

                                        const TOptions aOptions )

    {

    TUint8* sourcePtr = NULL;

    CVisualFrame* sourceDataFrame = const_cast<CVisualFrame*>( aSourceData );

    if ( sourceDataFrame->DataContainer() == CVisualFrame::EInChunk )

        {

        sourcePtr = sourceDataFrame->DataChunkL().Base() + sourceDataFrame->DataOffset();

        }

    else if ( sourceDataFrame->DataContainer() == CVisualFrame::EInDescriptor )

        {

        sourcePtr = const_cast<TUint8*>( sourceDataFrame->DataPtrL().Ptr() ) 

                                       + sourceDataFrame->DataOffset();

        }

    else

        {

        User::Leave( KErrArgument );            

        }

    TPtrC8 sourceData( sourcePtr, sourceDataFrame->Size() );

    CExtJpegDecoder* dec = reinterpret_cast<CExtJpegDecoder*>( 

                                CImageDecoder::DataNewL( aFs, sourceData, 

                                aMIMEType, aOptions ) );

    CleanupStack::PushL( dec );

    if ( dec->CapabilitiesL() < ECapNone )

        {

        User::Leave( KErrNotFound );

        }

    CleanupStack::Pop();

    return dec;

    }

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

// CExtJpegDecoder* CExtJpegDecoder::DataNewL

// Creates, initializes and returns a pointer to an object of 

// class CExtJpegDecoder

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

//

EXPORT_C CExtJpegDecoder* CExtJpegDecoder::DataNewL( 

                                        RFs& aFs, 

                                        const CVisualFrame* aSourceData, 

                                        const TOptions aOptions, 

                                        const TUid aImageType, 

                                        const TUid aImageSubType, 

                                        const TUid aDecoderUid )

    {

    TUint8* sourcePtr = NULL;

    CVisualFrame* sourceDataFrame = const_cast<CVisualFrame*>( aSourceData );    

    if ( sourceDataFrame->DataContainer() == CVisualFrame::EInChunk )

        {

        sourcePtr = sourceDataFrame->DataChunkL().Base() + sourceDataFrame->DataOffset();

        }

    else if ( aSourceData->DataContainer() == CVisualFrame::EInDescriptor )

        {

        sourcePtr = const_cast<TUint8*>( sourceDataFrame->DataPtrL().Ptr() ) 

                                       + sourceDataFrame->DataOffset();

        }

    else

        {

        User::Leave( KErrArgument );            

        }

    TPtrC8 sourceData( sourcePtr, sourceDataFrame->Size() );

    CExtJpegDecoder* dec = reinterpret_cast<CExtJpegDecoder*>( 

                                CImageDecoder::DataNewL( aFs, sourceData, aOptions, 

                                aImageType, aImageSubType, aDecoderUid ) );

    CleanupStack::PushL( dec );

    if ( dec->CapabilitiesL() < ECapNone )

        {

        User::Leave( KErrNotFound );

        }

    CleanupStack::Pop();

    return dec;

    }

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

// CExtJpegDecoder::~CExtJpegDecoder

// Destructor

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

//

EXPORT_C CExtJpegDecoder::~CExtJpegDecoder()

    {

    }

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

// CExtJpegDecoder::SetCroppingL

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

//

EXPORT_C void CExtJpegDecoder::SetCroppingL( TRect aCropRect )

    {

    CustomSyncL( KExtensionUID );

    CustomSyncL( ECapCropping );

    CustomSyncL( reinterpret_cast<TInt>( &aCropRect ) );

    CustomSyncL( EEnd );

    }

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

// CExtJpegDecoder::SetStreamingL

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

//

EXPORT_C void CExtJpegDecoder::SetStreamingL( TSize& aMacroBlockSize )

    {

    CustomSyncL( KExtensionUID );

    CustomSyncL( ECapStreaming );

    CustomSyncL( reinterpret_cast<TInt>( &aMacroBlockSize ) );

    CustomSyncL( EEnd );

    }

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

// CExtJpegDecoder::SetRotationL

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

//

EXPORT_C void CExtJpegDecoder::SetRotationL( TInt aDegree )

    {

    CustomSyncL( KExtensionUID );

    CustomSyncL( ECapRotation );

    CustomSyncL( aDegree );

    CustomSyncL( EEnd );

    }

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

// CExtJpegDecoder::SetFlippingL

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

//

EXPORT_C void CExtJpegDecoder::SetFlippingL()

    {

    CustomSyncL( KExtensionUID );

    CustomSyncL( ECapFlipping );

    CustomSyncL( EEnd );

    }

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

// CExtJpegDecoder::SetMirroringL

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

//

EXPORT_C void CExtJpegDecoder::SetMirroringL()

    {

    CustomSyncL( KExtensionUID );

    CustomSyncL( ECapMirroring );

    CustomSyncL( EEnd );

    }

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

// CExtJpegDecoder::SetDctDecodingL

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

//

EXPORT_C void CExtJpegDecoder::SetDctDecodingL()

    {

    CustomSyncL( KExtensionUID );

    CustomSyncL( ECapDctDecoding );

    CustomSyncL( EEnd );

    }

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

// CExtJpegDecoder::ConvertL

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

//

EXPORT_C void CExtJpegDecoder::ConvertL( 

                        TRequestStatus* aRequestStatus, 

                        const CVisualFrame* aDestinationFrame, 

                        TInt& aNoOfDecodedMBlocks,

                        TInt aFrameNumber )

    {

    iIsExtConvert = ETrue;

    CustomSyncL( KExtensionUID );

    CustomSyncL( EConvert );

    CustomSyncL( reinterpret_cast<TInt>( aDestinationFrame ) );

    CustomSyncL( reinterpret_cast<TInt>( &aNoOfDecodedMBlocks ) );