/*

* Copyright (c) 2002 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 Encoder for Camera Application Engine

*

*/

// INCLUDE FILES

#include <eikenv.h>

#include "CaeStillConverter.h"

#include "CaeStillEncoder.h"

#include "CaeStillCommon.h"

#ifdef CAE_TEST_VERSION

#include "CaeStillConverterTestErrors.h"

#endif

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

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

// CCaeStillEncoder::NewL

// Two-phased constructor.

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

//

EXPORT_C CCaeStillEncoder* CCaeStillEncoder::NewL()

    {

    CCaeStillEncoder* self = new( ELeave ) CCaeStillEncoder;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CCaeStillEncoder::~CCaeStillEncoder

// Destructor.

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

//

EXPORT_C CCaeStillEncoder::~CCaeStillEncoder()

    {

    Cancel();

    Cleanup();

    // For RTRT code coverage analysis.

    // #pragma attol insert _ATCPQ_DUMP(0);

    }

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

// CCaeStillEncoder::SetObserver

// Sets Still encoder observer.

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

//

EXPORT_C void CCaeStillEncoder::SetObserver( 

    MCaeStillEncoderObserver* aObserver )

    {

    iObserver = aObserver;

    }

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

// CCaeStillEncoder::SetImageCodecL

// Sets the specific image codec implementation to be used in encoding.

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

//

void CCaeStillEncoder::SetImageCodecL( 

	TUid aCodecUid )

    {

    iImageCodecUid = aCodecUid;

    }

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

// CCaeStillEncoder::SetCompressionQuality

// Sets compression quality.

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

//

EXPORT_C void CCaeStillEncoder::SetCompressionQuality( 

    TInt aQuality )

    {

    iJpegQuality = Min( KJpegQualityMax, Max( KJpegQualityMin, aQuality ) );

    }

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

// CCaeStillEncoder::CompressionQuality

// Gets compression quality.

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

//

EXPORT_C TInt CCaeStillEncoder::CompressionQuality() const

    {

    return iJpegQuality;

    }

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

// CCaeStillEncoder::ConvertCFbsBitmapToHBufC8L

// Creates CImageItem object, places it in the internal 

// queue and starts bitmap to memory image conversion.

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

//

EXPORT_C void CCaeStillEncoder::ConvertCFbsBitmapToHBufC8L( 

    CFbsBitmap* aBitmap,  

    TTargetFormat aTargetFormat )

    {

    LOGTEXT( _L( "Cae: CCaeStillEncoder::ConvertCFbsBitmapToHBufC8L() entering" ) );

    CleanupStack::PushL( aBitmap );

    // Create image item and set up image data.

    CImageItem* imageItem = new( ELeave ) CImageItem;

    imageItem->iBitmap = aBitmap;

    CleanupStack::Pop( aBitmap );

    CleanupStack::PushL( imageItem );

    switch ( aTargetFormat )

        {

        case ETargetFormatJPEG:

        default:

            {

            imageItem->iImageTypeUid = KImageTypeJPGUid;

            imageItem->iFrameImageData = CFrameImageData::NewL(); 

            // ( do not push member variable to cleanup stack )

            TJpegImageData* imagedata = new( ELeave ) TJpegImageData;

            CleanupStack::PushL( imagedata );

            imagedata->iSampleScheme = KCaeJpegColorSampling;

            imagedata->iQualityFactor = iJpegQuality;

            User::LeaveIfError ( imageItem->iFrameImageData->AppendImageData( imagedata ) );

            CleanupStack::Pop( imagedata );

            break;

            }

        }

    #ifdef CAE_TEST_VERSION

    // For simulating errors when compiled as special "test version".

    CaeConvertCFbsBitmapToHBufC8ErrorL();

    #endif    

    // Append image to the queue.

    User::LeaveIfError ( iImageQueue->Append( imageItem ) );

    CleanupStack::Pop( imageItem );

    // Start image conversion if not busy.

    if ( !IsBusy() )

        {

        TRAPD( error, ConvertL() );

        if ( error != KErrNone )

            {

            ConversionComplete( error );

            }

        }

    LOGTEXT( _L( "Cae: CCaeStillEncoder::ConvertCFbsBitmapToHBufC8L() returning" ) );

    }

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

// CCaeStillEncoder::Cleanup

// Destroy all allocations.

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

//

EXPORT_C void CCaeStillEncoder::Cleanup()

    {

    if ( iEncoder )

        {

        iEncoder->Cancel();

        delete iEncoder;

        iEncoder = NULL;

        }

    if ( iState != EIdle )

        {

        delete iEncodedImage;

        iEncodedImage = NULL;

        }

    if ( iImageQueue )

        {

        iImageQueue->ResetAndDestroy();

        }

    }

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

// CCaeStillEncoder::CCaeStillEncoder

// Default constructor. 

// This can NOT leave.

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

//

CCaeStillEncoder::CCaeStillEncoder() :

iJpegQuality( KJpegQualityMax )

    {

    CActiveScheduler::Add( this );

    }

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

// CCaeStillEncoder::ConstructL

// Symbian 2nd phase constructor that can leave.

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

//

void CCaeStillEncoder::ConstructL()

    {

    CCaeStillConverter::ConstructL();

    }

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

// CCaeStillEncoder::DoCancel

// From CActive, implements cancellation of an outstanding request.

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

//

void CCaeStillEncoder::DoCancel()

    {

    Cleanup();

    iState = EIdle;

    }

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

// CCaeStillEncoder::ConvertL

// Converts bitmap to memory JPEG image.

// Allocates Image Conversion Library (ICL) encoder and 

// starts conversion.

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

//

void CCaeStillEncoder::ConvertL()

    {

    LOGTEXT( _L( "Cae: CCaeStillEncoder::ConvertL() entering" ) );

    // Do not delete the encoded image here, just set to NULL.

    iEncodedImage = NULL;

    // Allocate new ICL encoder.

    delete iEncoder;

    iEncoder = NULL;

    // Use the default codec or the specific codec

    iEncoder = CImageEncoder::DataNewL( iEncodedImage, 

    	CImageEncoder::EOptionNone, (*iImageQueue)[0]->iImageTypeUid, 

    	KNullUid, iImageCodecUid ); 

    LOGTEXT3( _L( "Cae: CCaeStillEncoder::ConvertL(). Requested encoder: %x, Found encoder: %x" ), iImageCodecUid.iUid, iEncoder->ImplementationUid().iUid );

    #ifdef CAE_TEST_VERSION

    // For simulating errors when compiled as special "test version".

    CaeStillConvertErrorL();

    #endif    

    iState = EConvert;

    iStatus = KRequestPending;

    iEncoder->Convert( &iStatus, 

                       *(*iImageQueue)[0]->iBitmap, 

                       (*iImageQueue)[0]->iFrameImageData );

    SetActive();

    LOGTEXT( _L( "Cae: CCaeStillEncoder::ConvertL() returning" ) );

    }

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

// CCaeStillEncoder::ConversionComplete

// Perfoms necessary cleanup and delivers result 

// to the client.

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

//

void CCaeStillEncoder::ConversionComplete( 

    TInt aError )

    {

    LOGTEXT( _L( "Cae: CCaeStillEncoder::ConversionComplete() entering" ) );

    #ifdef _DEBUG

    if ( aError ) 

        {

        LOGTEXT2( _L( "Cae: CCaeStillEncoder::ConversionComplete(): error detected: %d" ), aError );

        }

    #endif

    if ( iEncoder )

        {

        iEncoder->Cancel();

        delete iEncoder;

        iEncoder = NULL;

        }

    // To be outputted via call-back.

    CFbsBitmap* bitmap = NULL;

    if ( iImageQueue->Count() > 0 )

        {

        bitmap = (*iImageQueue)[0]->iBitmap;

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

        delete ( *iImageQueue )[0];

        // Remove item pointer from the queue and compress the queue.

        iImageQueue->Remove( 0 );

        }

    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 bitmap 

    // and iEncodedImage.

    iObserver->McaeseoHBufC8ImageReady( bitmap, iEncodedImage, aError, KZeroImageSize );

    iEncodedImage = NULL; // Ownership has been given away

    LOGTEXT( _L( "Cae: CCaeStillEncoder::ConversionComplete() returning" ) );

    }

//  End of File