/*

* Copyright (c) 2005 - 2007 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 capture state machine implementation class

*

*/

// INCLUDE FILES

#include <hal.h>                    // For getting the display mode

#include <ExifRead.h>

#include "CaeStillStatesActive.h"

#include "CaeImageQueueExtPro.h"

#ifdef CAE_TEST_VERSION

#include "CaeEngineImpTestErrors.h" // For TEST_VERSION compilation only

#endif

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "CaeStillStatesActiveTraces.h"

#endif

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

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

// CCaeStillStatesActive::CCaeStillStatesActive()

// C++ constructor.

// Adds the object to the Active Scheduler.

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

//

CCaeStillStatesActive::CCaeStillStatesActive( 

    CCamera& aCamera,

    const TCamAppEngineInfo& aInfo,

    RArray<TCaeExtensionInterfaceImplItem>& aProcessImageImplList )

    : CActive( EPriorityStandard ), 

      iCamera( aCamera ),

      iInfo( aInfo ),

      iProcessImageImplList( aProcessImageImplList ),

      iStillInputFormat( CCamera::EFormatFbsBitmapColor16M ), 

      iStillOutputFormat( CCamera::EFormatFbsBitmapColor16M ), 

      iStillCompressionQuality( KCaeDefaultCompressionQuality ),

      iCurrentExtensionIndex( -1 )

    {

    CActiveScheduler::Add( this );

    }

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

// CCaeStillStatesActive::~CCaeStillStatesActive()

// Destructor. 

// Cancels operation and closes the timer.

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

//

CCaeStillStatesActive::~CCaeStillStatesActive()

    {

    Cancel();

    iDelayedCallTimer.Close();

    DeleteStillBurst(); // Using this removes dependency to still burst class

    CancelAndCleanup();

    // Check that extensions handle flag registration properly

    CAE_ASSERT_DEBUG( iRequireFullColorSnapInputImageRefCount == 0 );

    delete iEmptySnapImage;

    delete iStillDecoder;

    delete iStillEncoder;

	delete iSnapBitmap;

	delete iBitmap;

	delete iImageData;

	delete iImageHeaderData;

    delete iImageQueueExtPro;

    iFs.Close();

    }

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

// CCaeStillStatesActive::NewL()

// Symbian OS two-phased constructor.

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

//

CCaeStillStatesActive* CCaeStillStatesActive::NewL( 

    CCamera& aCamera,

    const TCamAppEngineInfo& aInfo,

    RArray<TCaeExtensionInterfaceImplItem>& aProcessImageImplList )

    {

    CCaeStillStatesActive* self = new( ELeave ) CCaeStillStatesActive( aCamera, aInfo, 

        aProcessImageImplList );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CCaeStillStatesActive::ConstructL()

// Symbian OS 2nd phase constructor that can leave.

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

//

void CCaeStillStatesActive::ConstructL()

    {

    // Get native screen mode. This can be used as default mode for the snap bitmap.

    iSnapImageColorMode = KCaeDefaultDisplayMode;

    (void)GetSystemDisplayMode( iSnapImageColorMode );

    LOGTEXT2( _L( "Cae: CCaeStillStatesActive::ConstructL(). Use display mode %d for the snap image" ), iSnapImageColorMode );

    // Create still image encoder object, e.g. for JPEG encoding.

    iStillEncoder = CCaeStillEncoder::NewL();

    iStillEncoder->SetObserver( this );

    // Create still image decoder object, e.g. for JPEG decoding.

    iStillDecoder = CCaeStillDecoder::NewL();

    iStillDecoder->SetObserver( this );

    // This empty snap image is currently used just for error cases.

    iEmptySnapImage = new( ELeave ) CFbsBitmap;

    // Create timer 

    iDelayedCallTimer.CreateLocal();

    // Connect to file server.

    User::LeaveIfError( iFs.Connect() );

    // Start in normal mode    

  	iExtModeActive = EFalse;

    iStillPrepared = EFalse;

    // Burst mode VF stopping optimization is not used as default

    iBurstModeVFOptimization = EFalse;

    }

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

// CCaeStillStatesActive::GetSystemDisplayMode()

// In some devices Hal:Get(HAL::EDisplayMode) returns directly TDisplayMode, 

// in other devices it returns a display mode index.

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

//

TBool CCaeStillStatesActive::GetSystemDisplayMode( TDisplayMode& aDisplayMode )

    {

    TBool found = EFalse;

    TInt halInOut = 0;

    TInt err = HAL::Get( HAL::EDisplayMode, halInOut );

    if (  err == KErrNone )

        {       

        if ( halInOut >= EColor256)

            {

            // halInOut contains TDisplayMode

            aDisplayMode = (TDisplayMode) halInOut;

            found = ETrue;

            LOGTEXT( _L( "Cae: CCaeStillStatesActive::GetSystemDisplayMode(). HAL returned a display mode." ) );

            }

        else

            {

             // halInOut contains index

           LOGTEXT( _L( "Cae: CCaeStillStatesActive::GetSystemDisplayMode(). HAL returned index." ) );

            err = HAL::Get( HAL::EDisplayBitsPerPixel, halInOut );

            // Get the color mode. Note: grayscale modes are not supported. 

            if (  err == KErrNone )

                {

				switch (halInOut)

					{

				    case 4:

					    aDisplayMode = EColor16;

                        found = ETrue;

                        break;

			    	case 8:

					    aDisplayMode = EColor256;

                        found = ETrue;

                        break;

				    case 12:

				    	aDisplayMode = EColor4K;

                        found = ETrue;

                        break;

				    case 16:

					    aDisplayMode = EColor64K;

                        found = ETrue;

                        break;

				    case 24:

					    aDisplayMode = EColor16M;

                        found = ETrue;

                        break;

			    	case 32:

					    aDisplayMode = EColor16MU;

                        found = ETrue;

                        break;

				    default:

					    break;

					}

                }

            }

        } 

    #ifdef _DEBUG

    if ( err || !found )

        {

        TBuf<256> text;

        text.Format(_L( "Cae: CCaeStillStatesActive::GetSystemDisplayMode(). Cannot get the display mode from HW. Err:%d, found:%d" ), err, found );

        LOGTEXT( text );        

        }

    else

        {   

        LOGTEXT2( _L( "Cae: CCaeStillStatesActive::GetSystemDisplayMode(). Found the display mode:%d" ), aDisplayMode );

        }

    #endif

    if ( found && !err && aDisplayMode == EColor16MA )

        {

        aDisplayMode = EColor16MU;

        LOGTEXT2( _L( "Cae: CCaeStillStatesActive::GetSystemDisplayMode(). Display mode EColor16MA changed to EColor16MU (%d)" ), aDisplayMode );

        }

    return found;   

    }

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

// CCaeStillStatesActive::SetCamAppEngineObserver()

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

//

void CCaeStillStatesActive::SetCamAppEngineObserver( MCamAppEngineObserver& aObserver )

    {

    iCaeObserver = &aObserver;    

    }

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

// CCaeStillStatesActive::SetSnapImageCreation()

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

//

void CCaeStillStatesActive::SetSnapImageCreation( 

    TBool aCreateSnapImage )

    {

    iCreateSnapImage = aCreateSnapImage;

    }

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

// CCaeStillStatesActive::SetSnapImageSourceL()

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

//

void CCaeStillStatesActive::SetSnapImageSourceL( 

    CCaeEngine::TSnapImageSource aSnapImageSource )

    {

    LOGTEXT2( _L( "Cae: CCaeStillStatesActive::SetSnapImageSourceL(). aSnapImageSource=%d" ), aSnapImageSource );

    if ( ( aSnapImageSource < 0 ) || 

         ( aSnapImageSource > CCaeEngine::ESnapImageSourceThumbnail ) )

        {

        LOGTEXT( _L( "Cae: CCaeStillStatesActive::SetSnapImageSourceL(). leaving KErrNotSupported" ));

        User::Leave( KErrNotSupported );

        }

    iSnapImageSource = aSnapImageSource;

    }

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

// CCaeStillStatesActive::SetSnapImageSizeL()

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

//

void CCaeStillStatesActive::SetSnapImageSizeL( 

    TSize& aSize )

    {

    LOGTEXT3( _L( "Cae: CCaeStillStatesActive::SetSnapImageSizeL(). iWidth=%d, iHeight=%d" ), aSize.iWidth, aSize.iHeight );

	// Calc downscaled size.

    // Use always the default snap size for the snap image. It is the best compromise 

    // between memory usage and image quality.

    TSize stepwiseScaledOptimalSize( KCaeDefaultSnapWidth, KCaeDefaultSnapHeight);

    CalcDownscaledSnapSize( stepwiseScaledOptimalSize ); 

    // Empty calculated size means that PrepareStillCapture() has not been called.

    if ( stepwiseScaledOptimalSize == TSize() ) 

        {

        LOGTEXT( _L( "Cae: CCaeStillStatesActive::SetSnapImageSizeL(). leaving KErrNotReady (no prepare)" ));

		User::Leave( KErrNotReady ); 

        }

    else

        {

        iOptimalSnapImageSize = stepwiseScaledOptimalSize;

        // If empty, use the still image size

        if ( aSize == TSize() )

            {

            aSize = iStillFrameSize;

            }

        iSnapImageSize = aSize;

        }

    }

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

// CCaeStillStatesActive::SnapImageSize

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

TSize CCaeStillStatesActive::SnapImageSize() const

    {

    return( iSnapImageSize );

    }

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

// CCaeStillStatesActive::StillImageSize

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

TSize CCaeStillStatesActive::StillImageSize() const

    {

    return( iStillFrameSize );

    }

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

// CCaeStillStatesActive::SetSnapImageColorMode

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

//

void CCaeStillStatesActive::SetSnapImageColorMode( 

    TDisplayMode aMode )

    {

    iSnapImageColorMode = aMode;

    }

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

// CCaeStillStatesActive::SetJpegQuality

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

//

void CCaeStillStatesActive::SetJpegQuality(

    TInt aQuality )

    {

    iStillCompressionQuality = aQuality;

    }

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

// CCaeStillStatesActive::JpegQuality

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

//

TInt CCaeStillStatesActive::JpegQuality() const

    {

    return( iStillCompressionQuality );

    }

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

// CCaeStillStatesActive::SetImageCodecsL

// Sets the specific image codec implementation to be used in decoding and 

// encoding.

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

//

void CCaeStillStatesActive::SetImageCodecsL( 

	TUid aDecoderUid, TUid aEncoderUid )

    {

    iStillEncoder->SetImageCodecL( aEncoderUid );

    iStillDecoder->SetImageCodecL( aDecoderUid );

    }

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

// CCaeStillStatesActive::SetViewFinderMode

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

//

void CCaeStillStatesActive::SetViewFinderMode(

    TBool aIsEnabled )

    {

    iIsViewFinderEnabled = aIsEnabled;

    // Issue event, if the view finder is stopped, and the state machine is 

    // waiting for it. Do not issue the same event twice (it will panic).

    if ( !iIsViewFinderEnabled 

         && ( iCurrentState == CCaeStillStatesActive::ECaeStateBurstWaitingForViewFinder ) 

         && !( IsActive() && ( iStatus == CCaeStillStatesActive::ECaeEventViewFinderForBurstReady ) ) )

        {

        Event( CCaeStillStatesActive::ECaeEventViewFinderForBurstReady );        

        }

    }

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

// CCaeStillStatesActive::IsRunning

// Check if the state is other than ECaeStateNone.

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

//

TBool CCaeStillStatesActive::IsRunning() const

    {

    return( iCurrentState != CCaeStillStatesActive::ECaeStateNone );

    }

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

// CCaeEngineImp::RegisterFlags

// Increment reference counters.

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

//

void CCaeStillStatesActive::RegisterFlags( TUint32 aFlags )

	{

    if ( aFlags & ECaeExtFlagRequireFullColorSnapInputImage )

        { 

        CAE_ASSERT_DEBUG( iRequireFullColorSnapInputImageRefCount < KMaxTInt32 );

        if ( iRequireFullColorSnapInputImageRefCount < KMaxTInt32 )

            {

            iRequireFullColorSnapInputImageRefCount++;

            }

        }

	}

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

// CCaeEngineImp::DeregisterFlags

// Decrement reference counters.

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

//

void CCaeStillStatesActive::DeregisterFlags( TUint32 aFlags )

    {

    if ( aFlags & ECaeExtFlagRequireFullColorSnapInputImage )

        {

        CAE_ASSERT_DEBUG( iRequireFullColorSnapInputImageRefCount > 0 );

        if ( iRequireFullColorSnapInputImageRefCount > 0 )

            {

            iRequireFullColorSnapInputImageRefCount--;

            }

        }

    }

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

// CCaeStillStatesActive::PrepareStillCaptureL

// Using cropping only if supported by Camera API impl.

// Calls RetrieveStillSizeIndex() that calls Camera API EnumerateCaptureSizes().

// Calls Camera API PrepareImageCaptureL().

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

//

void CCaeStillStatesActive::PrepareStillCaptureL( 

    const TSize&      aFrameSize, 

    CCamera::TFormat  aFormat, 

    const TRect&      aCropRect,

    TSize&            aSnapSize )

    {

    LOGTEXT3( _L( "Cae: CCaeStillStatesActive::PrepareStillCaptureL() entering aFrameSize=(w=%d,h=%d)" ), aFrameSize.iWidth, aFrameSize.iHeight );

    // Handle empty crop rect

    TRect cropRect( aCropRect );

    if ( cropRect.IsEmpty() )

        cropRect = TRect(TPoint(0, 0 ), aFrameSize);

    CCamera::TFormat stillOutputFormat = aFormat;

    CCamera::TFormat stillInputFormat = aFormat;

    // Try if this size and format is supported by the Camera API.

    TInt sizeIndex = RetrieveStillSizeIndex( aFrameSize, aFormat );

    if ( sizeIndex != -1 )

        {

        stillInputFormat = aFormat;

        }

    // If the application requires Jpeg we can encode it from bitmap

    else if ( aFormat == CCamera::EFormatJpeg )

        {

        // Try if this size and format KBaseStillInputFormat1 

        // is supported by the Camera API.

        stillInputFormat = KBaseStillInputFormat1;

        sizeIndex = RetrieveStillSizeIndex( aFrameSize, stillInputFormat );

        if ( sizeIndex == -1 )

            {

            // Try if this size and format KBaseStillInputFormat2 

            // is supported by the Camera API.

            stillInputFormat = KBaseStillInputFormat2;

            sizeIndex = RetrieveStillSizeIndex( aFrameSize, stillInputFormat );

            if ( sizeIndex == -1 )

                {

                LOGTEXT2( _L( "Cae: CCaeStillStatesActive::PrepareStillCaptureL() leaving KErrNotSupported, stillInputFormat=%d" ), stillInputFormat );

                User::Leave( KErrNotSupported );

                }

            }

        }

    else 

        {

        LOGTEXT2( _L( "Cae: CCaeStillStatesActive::PrepareStillCaptureL() leaving KErrNotSupported, aFormat=%d" ), aFormat );

        User::Leave( KErrNotSupported );

        }

    // Prepare still image capturing on Camera API.

    if ( !( iInfo.iOptionsSupported & TCameraInfo::EImageClippingSupported ) ) 

        {

        iCamera.PrepareImageCaptureL( stillInputFormat, sizeIndex );

        }

    else 

        {

        iCamera.PrepareImageCaptureL( stillInputFormat, sizeIndex, cropRect );

        }

    // Store values 

    iStillFrameSize = aFrameSize;

    iStillInputFormat = stillInputFormat;

    iStillOutputFormat = stillOutputFormat;

    // Calc downscaled size if needed

    SetSnapImageSizeL( aSnapSize );     

    // Prepare done

    iStillPrepared = ETrue;

    LOGTEXT( _L( "Cae: CCaeStillStatesActive::PrepareStillCaptureL() returning" ) );    

    }

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

// CCaeStillStatesActive::RetrieveStillSizeIndex

// Retrieves/fetches still image size index from Camera API.

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

//

TInt CCaeStillStatesActive::RetrieveStillSizeIndex( 

    const TSize& aFrameSize, 

    CCamera::TFormat aStillDataFormat ) const

    {

    LOGTEXT( _L( "Cae: CCaeStillStatesActive::RetrieveStillSizeIndex() entering" ) );