/*

* Copyright (c) 2009 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:  Engine implementation video recording methods.

*

*/

// INCLUDE FILES

#include <HtiLogging.h>

#include <AudioPreference.h>                // For MMF audio preference definitions.

#include "EngineVideoRecording.h"

#include "VideoRecordingQualityLevels.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CEngineVideoRecording::CEngineVideoRecording

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

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

//

CEngineVideoRecording::CEngineVideoRecording() :

    iZoomMode( EZoomModeDigital ), 

    iExposureMode( CCamera::EExposureAuto ),

    iWhiteBalanceMode( CCamera::EWBAuto ), 

    iFlashMode( CCamera::EFlashNone ),

    iMaxClipSizeInBytes( KMMFNoMaxClipSize ), 

    iMaxClipSizeInBytesPrep( KMMFNoMaxClipSize )

    {

    }

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

// CEngineVideoRecording::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CEngineVideoRecording::ConstructL(MEngineVideoRecordingObserver& aObserver,

        TInt aCameraIndex)

    {

    HTI_LOG_FUNC_IN( "CEngineVideoRecording::ConstructL" );

    iVideoRecordingObserver = &aObserver;

    if ( ( aCameraIndex < 0 ) || 

         ( aCameraIndex >= CCamera::CamerasAvailable() ) )

        {

        HTI_LOG_FORMAT("Cae: CEngineVideoRecording::ConstructL leaving KErrHardwareNotAvailable, aCameraIndex=%d", aCameraIndex );

        User::Leave( KErrHardwareNotAvailable );

        }

    // Create a new Camera API implementation object, if supported

    TRAPD( err, iCamera = CCamera::New2L( static_cast<MCameraObserver2&>(*this), aCameraIndex, KCameraPriority ) );

    if ( err )

        {

        HTI_LOG_FORMAT("CEngineVideoRecording::ConstructL() CCamera::New2L return code=%d", err ); 

        // Create old Camera API implementation object.

        iCamera = CCamera::NewL( static_cast<MCameraObserver&>(*this), aCameraIndex );

        HTI_LOG_TEXT("CEngineVideoRecording::ConstructL() using MCameraObserver"); 

        }

    else

        {

    HTI_LOG_TEXT("CEngineVideoRecording::ConstructL() using MCameraObserver2"); 

        }

    // Get camera handle.

    iCameraHandle = iCamera->Handle();

    // Create and initialize info object.

    iInfo = new( ELeave ) TEngineVideoRecordingInfo;

    InitializeInfo( *iCamera );

    HTI_LOG_FUNC_OUT( "CEngineVideoRecording::ConstructL" );

    }

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

// CEngineVideoRecording::NewL

// Two-phased constructor.

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

//

CEngineVideoRecording* CEngineVideoRecording::NewL(MEngineVideoRecordingObserver& aObserver,

        TInt aCameraIndex)

    {

    CEngineVideoRecording* self = new (ELeave) CEngineVideoRecording;

    CleanupStack::PushL( self );

    self->ConstructL(aObserver, aCameraIndex);

    CleanupStack::Pop();

    return self;

    }

// Destructor

CEngineVideoRecording::~CEngineVideoRecording()

    {

    HTI_LOG_FUNC_IN( "CEngineVideoRecording::~CEngineVideoRecording");

        delete iVideoType;

        delete iVideoClipFileName;

        // Turn camera power off first, then release camera.

        if ( iCamera ) 

            {

            if ( iReserved ) 

                {

                if ( iPowerOn ) 

                    {

                    iCamera->PowerOff();

                    }

                iCamera->Release();

                }

            }

        delete iVideoFrameSizePrep;

        delete iVideoFrameSize;

        delete iVideoRecorder;

        delete iVideoQualityLevels;

        delete iCamera;

        REComSession::FinalClose();

        HTI_LOG_FUNC_OUT( "CEngineVideoRecording::~CEngineVideoRecording");

    }

void CEngineVideoRecording::InitL( )

    {

    HTI_LOG_FUNC_IN( "CEngineVideoRecording::InitL");

    // To allow re-initialization, release the camera (first cancels possible 

    // activities and turns camera power off).

    Release();

    iCamera->Reserve();

    HTI_LOG_FUNC_OUT( "CEngineVideoRecording::InitL");

    }

void CEngineVideoRecording::InitializeInfo( 

    const CCamera& aCamera )

    {

    // Initialise Camera (API) info.

    TCameraInfo cameraInfo;

    aCamera.CameraInfo( cameraInfo );

    iInfo->iHardwareVersion = cameraInfo.iHardwareVersion;

    iInfo->iSoftwareVersion = cameraInfo.iSoftwareVersion;

    iInfo->iOrientation = cameraInfo.iOrientation;

    iInfo->iOptionsSupported = cameraInfo.iOptionsSupported;

    iInfo->iFlashModesSupported = cameraInfo.iFlashModesSupported;

    iInfo->iExposureModesSupported = cameraInfo.iExposureModesSupported;

    iInfo->iWhiteBalanceModesSupported = cameraInfo.iWhiteBalanceModesSupported;

    iInfo->iMinZoom = cameraInfo.iMinZoom;

    iInfo->iMaxZoom = cameraInfo.iMaxZoom;

    iInfo->iMaxDigitalZoom = cameraInfo.iMaxDigitalZoom;

    iInfo->iMinZoomFactor = cameraInfo.iMinZoomFactor;

    iInfo->iMaxZoomFactor = cameraInfo.iMaxZoomFactor;

    iInfo->iMaxDigitalZoomFactor = cameraInfo.iMaxDigitalZoomFactor;

    iInfo->iNumImageSizesSupported = cameraInfo.iNumImageSizesSupported;

    iInfo->iImageFormatsSupported = cameraInfo.iImageFormatsSupported;

    // Initialize EV compensation info (no supported in this version)

    iInfo->iMinEvCompensation = 0;

    iInfo->iMaxEvCompensation = 0;

    iInfo->iMinEvCompensationValue = 0;

    iInfo->iMaxEvCompensationValue = 0;

    // Initialize engine info.

    iInfo->iNumStillQualityLevelsSupported = 0; // Quality levels are initialized separately.

    iInfo->iNumVideoQualityLevelsSupported = 0; // Quality levels are initialized separately.

    }

void CEngineVideoRecording::InitVideoRecorderL()

    {

    HTI_LOG_FUNC_IN( "CEngineVideoRecording::InitVideoRecorderL()");

    iVideoInitialized = EFalse;

    // Close video recording if previously opened/prepared.

    CloseVideoRecording();

    // (Re-)initialize these.

    iMaxClipSizeInBytes = KMMFNoMaxClipSize; 

    iMaxClipSizeInBytesPrep = KMMFNoMaxClipSize;

    // Create video quality levels container object.

    iVideoQualityLevels = CVideoRecordingQualityLevels::NewL();

    // Destroy possible video clip file name. (Its allocated elsewhere when file name is set.)

    delete iVideoClipFileName;

    iVideoClipFileName = NULL;

    // Create video recorder.

    delete iVideoRecorder;

    iVideoRecorder = NULL;

    iVideoRecorder = CVideoRecorderUtility::NewL( *this , KAudioPriorityVideoRecording,

        TMdaPriorityPreference( KAudioPrefVideoRecording ) );

    delete iVideoFrameSize;

    iVideoFrameSize = NULL;

    iVideoFrameSize = new( ELeave ) TSize();

    delete iVideoFrameSizePrep;

    iVideoFrameSizePrep = NULL;

    iVideoFrameSizePrep = new( ELeave ) TSize();

    iInfo->iNumVideoQualityLevelsSupported = iVideoQualityLevels->InitDefaultsL();

    iVideoInitialized = ETrue;

    HTI_LOG_FUNC_OUT( "CEngineVideoRecording::InitVideoRecorderL()");

    }

void CEngineVideoRecording::SetVideoRecordingFileNameL( 

    const TDesC& aVideoClipFileName )

    {

    HTI_LOG_FUNC_IN("CEngineVideoRecording::SetVideoRecordingFileNameL");

    if ( !iVideoInitialized || iVideoRecordingRunning ) 

        {

        HTI_LOG_TEXT("CEngineVideoRecording::SetVideoRecordingFileNameL leaving KErrNotReady" );

        User::Leave( KErrNotReady );

        }

    if ( aVideoClipFileName.Length() > 0 )

        {

        // Memorize the video clip file name.

        delete iVideoClipFileName;

        iVideoClipFileName = NULL;

        iVideoClipFileName = aVideoClipFileName.AllocL();

        }

    else 

        {

        HTI_LOG_TEXT("CEngineVideoRecording::SetVideoRecordingFileNameL leaving KErrArgument");

        User::Leave( KErrArgument );

        }

    if ( iVideoPrepared ) 

        {

        // Does the actual change of file name, only if video is prepared.

        // Note: Variated implementation

        ChangeVideoFileNameL();

        }

    HTI_LOG_FUNC_OUT("CEngineVideoRecording::SetVideoRecordingFileNameL");

    }

void CEngineVideoRecording::ChangeVideoFileNameL()

    {

    HTI_LOG_FUNC_IN("CEngineVideoRecording::ChangeVideoFileNameL");

    // Close if previously prepared.

    CloseVideoRecording();

    // Open video recorder.

    iVideoOpened = ETrue; // This is always set to ETrue when 

                          // OpenFileL has been called to allow 

                          // freeing resources by CloseVideoRecording().

    iVideoRecorder->OpenFileL( iVideoClipFileName->Des(),

                               iCameraHandle,

                               iVideoControllerUid,

                               iVideoFormatUid, 

                               iVideoType->Des(),  

                               iVideoAudioType );

    HTI_LOG_FUNC_OUT("CEngineVideoRecording::ChangeVideoFileNameL");

    }

void CEngineVideoRecording::PrepareVideoRecordingL( 

    TInt aVideoQualityIndex )

    {

    HTI_LOG_TEXT("CEngineVideoRecording::PrepareVideoRecordingL with video quality index");

    if ( ( aVideoQualityIndex < 0 ) || 

         ( aVideoQualityIndex >= iVideoQualityLevels->Count() ) ) 

        {

        HTI_LOG_TEXT("PrepareVideoRecordingL() leaving KErrArgument");

        User::Leave( KErrArgument );

        }

    PrepareVideoRecordingL( iVideoQualityLevels->At( aVideoQualityIndex ).iFrameSize, 

                            iVideoQualityLevels->At( aVideoQualityIndex ).iFrameRate, 

                            iVideoQualityLevels->At( aVideoQualityIndex ).iBitRate, 

                            iVideoQualityLevels->At( aVideoQualityIndex ).iAudioEnabled,

                            iVideoQualityLevels->At( aVideoQualityIndex ).iAudioBitRate, 

                            iVideoQualityLevels->At( aVideoQualityIndex ).iMimeType, 

                            iVideoQualityLevels->At( aVideoQualityIndex ).iPreferredSupplier, 

                            iVideoQualityLevels->At( aVideoQualityIndex ).iVideoType,    

                            iVideoQualityLevels->At( aVideoQualityIndex ).iAudioType );

    iVideoQualityIndex = aVideoQualityIndex;

    }

void CEngineVideoRecording::PrepareVideoRecordingL( 

    const TSize&  aFrameSize, 

    TReal32       aFrameRate, 

    TInt          aBitRate, 

    TBool         aAudioEnabled,

    const TDesC8& aMimeType, 

    const TDesC&  aPreferredSupplier, 

    const TDesC8& aVideoType, 

    const TDesC8& aAudioType )

    {

    HTI_LOG_FUNC_IN("CEngineVideoRecording::PrepareVideoRecordingL");

    // Leave if not initialized properly or busy doing something else.

    if ( !iVideoInitialized || 

         !iVideoClipFileName || 

         iVideoRecordingRunning   ) 

        {

        HTI_LOG_TEXT("PrepareVideoRecordingL leaving KErrNotReady");

        User::Leave( KErrNotReady );

        }

    CheckPowerL();

    // Leave if video clip file name is not set properly.

    if ( iVideoClipFileName->Length() == 0 )

        {

        HTI_LOG_TEXT("PrepareVideoRecordingL() leaving KErrArgument (iVideoClipFileName)");

        User::Leave( KErrArgument );

        }

    // Close if previously opened/prepared.

    CloseVideoRecording();

    // Find values for iVideoControllerUid and iVideoFormatUid.

    // Those are also needed if clip file name is changed when prepared.

    FindVideoUidsL( aMimeType, aPreferredSupplier );

    // Memorize video type.

    delete iVideoType;

    iVideoType = NULL;

    iVideoType = aVideoType.AllocL();

    // Convert audio type from TDesC8 to TFourCC.

    iVideoAudioType = ConvertAndSetVideoAudioTypeL( aAudioType );

    // Memorize the parameters to be prepared.

    *iVideoFrameSizePrep   = aFrameSize;

    iVideoFrameRatePrep    = aFrameRate;

    iVideoBitRatePrep      = aBitRate;

    iVideoAudioEnabledPrep = aAudioEnabled;

    // Open video recorder.

    iVideoOpened = ETrue; // This is always set to ETrue when 

                          // OpenFileL has been called to allow 

                          // freeing resources by CloseVideoRecording().

    iVideoRecorder->OpenFileL( iVideoClipFileName->Des(),

                               iCameraHandle,

                               iVideoControllerUid,

                               iVideoFormatUid, 

                               iVideoType->Des(),  

                               iVideoAudioType );

    HTI_LOG_FUNC_OUT("CEngineVideoRecording::PrepareVideoRecordingL");

    }

void CEngineVideoRecording::PrepareVideoRecordingL( 

    const TSize&  aFrameSize, 

    TReal32       aFrameRate, 

    TInt          aBitRate, 

    TBool         aAudioEnabled,

    TInt          aAudioBitRate, 

    const TDesC8& aMimeType, 

    const TDesC&  aPreferredSupplier, 

    const TDesC8& aVideoType, 

    const TDesC8& aAudioType )

    {

    HTI_LOG_TEXT("CEngineVideoRecording::PrepareVideoRecordingL with audio bit rate");

    // Memorize video audio bit rate value to be prepared.

    iVideoAudioBitRatePrep = aAudioBitRate;

    // Force audio bit rate preparation.

    iPrepareVideoAudioBitRate = ETrue;

    // Call the version without audio bit rate argument.

    // This is possible because the separate PrepareVideoSettingsL() is doing

    // settings after succesfull opening of video recording.

    PrepareVideoRecordingL( aFrameSize, 

                            aFrameRate, 

                            aBitRate, 

                            aAudioEnabled, 

                            aMimeType, 

                            aPreferredSupplier, 

                            aVideoType, 

                            aAudioType );

    }

void CEngineVideoRecording::CloseVideoRecording()

    {

    HTI_LOG_FUNC_IN("CEngineVideoRecording::CloseVideoRecording");

    if ( iVideoPrepared ) 

        {

        CancelVideoRecording();

        iVideoPrepared = EFalse;

        }

    if ( iVideoOpened )

        {

        iVideoRecorder->Close();

        iVideoOpened = EFalse;

        }

    HTI_LOG_FUNC_OUT("CEngineVideoRecording::CloseVideoRecording");

    }

TInt CEngineVideoRecording::VideoQualityIndex() const

    {

    HTI_LOG_FUNC_IN("CEngineVideoRecording::VideoQualityIndex");

    TInt qualityIndex( -1 );

    if ( iVideoPrepared )

        {

        qualityIndex = iVideoQualityIndex;

        }

    HTI_LOG_FUNC_OUT("CEngineVideoRecording::VideoQualityIndex");

    return qualityIndex;

    }

TInt CEngineVideoRecording::VideoQualityCount() const

        {

        return iVideoQualityLevels->Count();

        }

void CEngineVideoRecording::GetVideoFrameSize( 

    TInt aVideoQualityIndex, 

    TSize& aFrameSize ) const

    {

    HTI_LOG_FUNC_IN("CEngineVideoRecording::GetVideoFrameSize");

    if ( aVideoQualityIndex >= 0 &&  

         aVideoQualityIndex < iVideoQualityLevels->Count() )

        {

        aFrameSize = iVideoQualityLevels->At( aVideoQualityIndex ).iFrameSize;

        }

    HTI_LOG_FUNC_OUT("CEngineVideoRecording::GetVideoFrameSize");

    }

TReal32 CEngineVideoRecording::VideoFrameRate( 

    TInt aVideoQualityIndex ) const

    {

    HTI_LOG_FUNC_IN("CEngineVideoRecording::VideoFrameRate");

    TReal32 frameRate( 0.0 );

    if ( aVideoQualityIndex >= 0 &&  

         aVideoQualityIndex < iVideoQualityLevels->Count() )

        {

        frameRate = iVideoQualityLevels->At( aVideoQualityIndex ).iFrameRate;

        }

    HTI_LOG_FUNC_OUT("CEngineVideoRecording::VideoFrameRate");

    return frameRate;

    }

TInt CEngineVideoRecording::EstimatedVideoRecordingBitRateL( 

    TInt aVideoQualityIndex ) const

    {

    HTI_LOG_FUNC_IN("CEngineVideoRecording::EstimatedVideoRecordingBitRateL");

    TInt storageRate( 0 );

    if ( aVideoQualityIndex >= 0 &&  

         aVideoQualityIndex < iVideoQualityLevels->Count() )

        {

        storageRate = iVideoQualityLevels->At( aVideoQualityIndex ).iStorageRate;

        }

    HTI_LOG_FUNC_OUT("CEngineVideoRecording::EstimatedVideoRecordingBitRateL");

    return storageRate;

    }

void CEngineVideoRecording::SetVideoClipMaxSizeL( 

    TInt aMaxClipSizeInBytes )

    {

    HTI_LOG_FUNC_IN("CEngineVideoRecording::SetVideoClipMaxSizeL");

    if ( !iVideoInitialized || iVideoRecordingRunning ) 

        {

        HTI_LOG_TEXT("SetVideoClipMaxSizeL leaving KErrNotReady");

        User::Leave( KErrNotReady );

        }

    if ( aMaxClipSizeInBytes > 0 ) 

        {

        iMaxClipSizeInBytesPrep = aMaxClipSizeInBytes;

        }

    else 

        {

        iMaxClipSizeInBytesPrep = KMMFNoMaxClipSize;

        }