/*
* Copyright (c) 2003 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:  Still Image Decoder for Camera Application Engine
*
*/



// INCLUDE FILES
#include <eikenv.h>

#include "CaeStillConverter.h"
#include "CaeStillDecoder.h"
#include "CaeStillCommon.h"

#ifdef CAE_TEST_VERSION
#include "CaeStillConverterTestErrors.h"
#endif


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


// ---------------------------------------------------------
// CCaeStillDecoder::NewL
// Two-phased constructor.
// ---------------------------------------------------------
//
EXPORT_C CCaeStillDecoder* CCaeStillDecoder::NewL()
    {
    CCaeStillDecoder* self = new( ELeave ) CCaeStillDecoder;
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------
// CCaeStillDecoder::~CCaeStillDecoder
// Destructor.
// ---------------------------------------------------------
//
EXPORT_C CCaeStillDecoder::~CCaeStillDecoder()
    {
    delete iDecoder;
    delete iDecodedImage;
    iFs.Close(); 

    // For RTRT code coverage analysis.
    // #pragma attol insert _ATCPQ_DUMP(0);
    }


// ---------------------------------------------------------
// CCaeStillDecoder::SetObserver
// Sets Still Decoder observer.
// ---------------------------------------------------------
//
EXPORT_C void CCaeStillDecoder::SetObserver( 
    MCaeStillDecoderObserver* aObserver )
    {
    iObserver = aObserver;
    }


// -----------------------------------------------------------------------------
// CCaeStillDecoder::SetImageCodecL
// Sets the specific image codec implementation to be used in decoding.
// -----------------------------------------------------------------------------
//
void CCaeStillDecoder::SetImageCodecL( 
	TUid aCodecUid )
    {
    iImageCodecUid = aCodecUid;
    }

        
// ---------------------------------------------------------
// CCaeStillDecoder::ConvertHBufC8ToCFbsBitmapL
// Creates CImageItem object, places it in the internal 
// queue and starts memory image to bitmap conversion.
// ---------------------------------------------------------
//
EXPORT_C void CCaeStillDecoder::ConvertHBufC8ToCFbsBitmapL( 
    HBufC8* aImageBuffer,
    TDisplayMode aTargetBitmapMode,
    const TSize& aTargetBitmapSize,
    const TSize& aFullyScaledTargetBitmapSize )
    {
    LOGTEXT( _L( "Cae: CCaeStillDecoder::ConvertHBufC8ToCFbsBitmapL() entering" ) );

    CleanupStack::PushL( aImageBuffer );

    // Create image item and set up image data.

    CImageItem* imageItem = new( ELeave ) CImageItem;
    imageItem->iBitmapDisplayMode = aTargetBitmapMode;
    imageItem->iImageBuffer = aImageBuffer;
    imageItem->iBitmapSize = aTargetBitmapSize;
    imageItem->iFullyScaledBitmapSize = aFullyScaledTargetBitmapSize;
    CleanupStack::Pop( aImageBuffer );
    CleanupStack::PushL( imageItem ); 

    #ifdef CAE_TEST_VERSION
    // For simulating errors when compiled as special "test version".
    CaeConvertHBufC8ToCFbsBitmapErrorL();
    #endif    

    // Add image to the queue.
    User::LeaveIfError ( iImageQueue->Append( imageItem ) );

    CleanupStack::Pop( imageItem );

    // Start image conversion if not busy. Busy means that e.g. conversion is currently running. 
    if ( !IsBusy() )
        {
        TRAPD( error, ConvertL() );
        if ( error != KErrNone )
            {
            ConversionComplete( error );
            }
        }

    LOGTEXT( _L( "Cae: CCaeStillDecoder::ConvertHBufC8ToCFbsBitmapL() returning" ) );
    }


// ---------------------------------------------------------
// CCaeStillDecoder::Cleanup
// Destroy all allocations.
// ---------------------------------------------------------
//
EXPORT_C void CCaeStillDecoder::Cleanup()
    {
    if ( iDecoder )
        {
        iDecoder->Cancel();
        delete iDecoder;
        iDecoder = NULL;
        }

    if ( iState != EIdle )
        {
        delete iDecodedImage;
        iDecodedImage = NULL;
        }
    
    if ( iImageQueue )
        {
        iImageQueue->ResetAndDestroy();
        }
    }


// ---------------------------------------------------------
// CCaeStillDecoder::CCaeStillDecoder
// Default constructor. 
// This can NOT leave.
// ---------------------------------------------------------
//
CCaeStillDecoder::CCaeStillDecoder()
    {
    CActiveScheduler::Add( this );
    }


// ---------------------------------------------------------
// CCaeStillDecoder::ConstructL
// Symbian 2nd phase constructor that can leave.
// ---------------------------------------------------------
//
void CCaeStillDecoder::ConstructL()
    {
    CCaeStillConverter::ConstructL();
    User::LeaveIfError( iFs.Connect() );
    }


// ---------------------------------------------------------
// CCaeStillDecoder::DoCancel
// From CActive, implements cancellation of an outstanding request.
// ---------------------------------------------------------
//
void CCaeStillDecoder::DoCancel()
    {
    Cleanup();
    iState = EIdle;
    }


// ---------------------------------------------------------
// CCaeStillDecoder::ConvertL
// Converts bitmap to memory JPEG image.
// ---------------------------------------------------------
//
void CCaeStillDecoder::ConvertL()
    {
    LOGTEXT( _L( "Cae: CCaeStillDecoder::ConvertL() entering" ) );

    iState = EConvert;
    
    // Use the default codec or the specific codec
    iDecoder = CImageDecoder::DataNewL( iFs, *(*iImageQueue)[0]->iImageBuffer, 
    	CImageDecoder::EOptionNone, KNullUid, KNullUid, iImageCodecUid );
    
    iDecodedImage = NULL;
    iDecodedImage = new( ELeave ) CFbsBitmap;

    // Set target bitmap size
    TSize targetBitmapSize = (*iImageQueue)[0]->iBitmapSize;

    const TFrameInfo& frameInfo = iDecoder->FrameInfo( 0 );
    TUid impUid = iDecoder->ImplementationUid();
    LOGTEXT3( _L( "Cae: CCaeStillDecoder::ConvertL() Requested decoder: %x, Found decoder: %x" ), iImageCodecUid.iUid, impUid.iUid );
    LOGTEXT2( _L( "Cae: CCaeStillDecoder::ConvertL() Free scaling support: %d" ), frameInfo.iFlags & TFrameInfo::EFullyScaleable );

    //
    // Use free scaling always with special decoder or with any decoder that supports it
    //
    if ( (( impUid == KUidSpecialFreeScalingDecoder ) || ( frameInfo.iFlags & TFrameInfo::EFullyScaleable ))  
         && ( (*iImageQueue)[0]->iFullyScaledBitmapSize != TSize( 0, 0 ) ) )
        {
        LOGTEXT( _L( "Cae: CCaeStillDecoder::ConvertL(). Use free scaling in decoding" ) );
        targetBitmapSize = (*iImageQueue)[0]->iFullyScaledBitmapSize;
        }

    User::LeaveIfError( iDecodedImage->Create(
        targetBitmapSize, 
        (*iImageQueue)[0]->iBitmapDisplayMode ) );

    #ifdef CAE_TEST_VERSION
    // For simulating errors when compiled as special "test version".
    CaeStillConvertErrorL();
    #endif    

    iState = EConvert;
    iStatus = KRequestPending;
    iDecoder->Convert( &iStatus, *iDecodedImage );
    SetActive();

    LOGTEXT( _L( "Cae: CCaeStillDecoder::ConvertL() returning" ) );
    }


// ---------------------------------------------------------
// CCaeStillDecoder::ConversionComplete
// Perfoms necessary cleanup and delivers result to the client.
// ---------------------------------------------------------
//
void CCaeStillDecoder::ConversionComplete( 
    TInt aError )
    {
    LOGTEXT( _L( "Cae: CCaeStillDecoder::ConversionComplete() entering" ) );
    #ifdef _DEBUG
    if ( aError ) 
        {
        LOGTEXT( _L( "Cae: CCaeStillDecoder::ConversionComplete(): error detected" ) );
        }
    #endif

    // Delete the decoder object and image queue item
    if ( iDecoder )
        {
        iDecoder->Cancel();
        delete iDecoder;
        iDecoder = NULL;
        }

    // To be outputted via call-back.
    HBufC8* imageBuffer = NULL;

    if ( iImageQueue->Count() > 0 )
        {
        imageBuffer = (*iImageQueue)[0]->iImageBuffer;

        (*iImageQueue)[0]->iImageBuffer = NULL; // Prevent deletion of source image.
        delete ( *iImageQueue )[0];

        // Remove item pointer from the queue and compress the queue.
        iImageQueue->Remove( 0 ); // Remove item pointer from the queue and compress the queue.
        }

    iState = EIdle;

    const TInt KZeroImageSize = 0; // Image size argument currently not in use.

    // Call back the client to deliver the result image. Gives away the ownership of the imageBuffer
    // and iDecodedImage.
    iObserver->McaesdoCFbsBitmapImageReady( imageBuffer, iDecodedImage, aError, KZeroImageSize );
    iDecodedImage = NULL; // Ownership has been given away

    LOGTEXT( _L( "Cae: CCaeStillDecoder::ConversionComplete() returning" ) );
    }


//  End of File