/*

* Copyright (c) 2002 - 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:  Camera Application Engine implementation video recording methods

*

*/

// INCLUDE FILES

#include <mmf/server/mmffile.h>                        // For MMF definitions (as TMMFFileConfig)

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

#include "CaeEngineImp.h"                   // Engine implementation header.

#include "CaeVideoQualityLevels.h"          // For video recording quality levels.

#include "CaeVideoTimes.h"                  // For generating video recording time estimates.

#include "CaeStillStatesActive.h"                

#ifdef CAE_TEST_VERSION

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

#endif

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

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

// CCaeEngineImp::InitVideoRecorderL

// Initialise the engine for video recording using default parameters.

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

//

void CCaeEngineImp::InitVideoRecorderL()

    {

    LOGTEXT( _L( "Cae: CCaeEngineImp::InitVideoRecorderL() entering" ) );

    iVideoInitialized = EFalse;

    // Close video recording if previously opened/prepared.

    CloseVideoRecording();

    // (Re-)initialize these.

    iVideoTimesInterval = KVideoTimesIntervalDefault; 

    iMaxClipSizeInBytes = KMMFNoMaxClipSize; 

    iMaxClipSizeInBytesPrep = KMMFNoMaxClipSize;

    // Create video quality levels container object.

    delete iVideoQualityLevelsCont;

    iVideoQualityLevelsCont = NULL;

    iVideoQualityLevelsCont = CCaeVideoQualityLevelsCont::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();

    // Create video times generator object.

    delete iVideoTimes;

    iVideoTimes = NULL;

    iVideoTimes = CCaeVideoTimes::NewL();

    // Create call-back function for video times generation.

    delete iVideoTimesCallback;

    iVideoTimesCallback = NULL;

    iVideoTimesCallback = new( ELeave ) TCallBack( VideoRecordingTimesCallback, this );

    // Initialize default video recording quality levels.

    iInfo->iNumVideoQualityLevelsSupported = 

        iVideoQualityLevelsCont->InitDefaultsL();

    iVideoInitialized = ETrue;

    LOGTEXT( _L( "Cae: CCaeEngineImp::InitVideoRecorderL() returning" ) );

    }

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

// CCaeEngineImp::InitVideoRecorderL

// Initialise the engine for video recording using either using default 

// parameters or parameters from ini-file.

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

//

void CCaeEngineImp::InitVideoRecorderL( 

    TUid aSdUidVideoQltyLevels )

    {

    if( aSdUidVideoQltyLevels == KNullUid )

        {

        InitVideoRecorderL();

        }

    else

        {

        LOGTEXT( _L( "Cae: CCaeEngineImp::InitVideoRecorderL(aSdUidVideoQltyLevels): NOT SUPPORTED, leaving" ) );

        User::Leave( KErrNotSupported );

        }

    }

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

// CCaeEngineImp::SetVideoRecordingFileNameL

// If video recording is not prepared then just memorizes the file name.

// If video recording is prepared, then calls variated ChangeVideoFileNameL().

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

//

void CCaeEngineImp::SetVideoRecordingFileNameL( 

    const TDesC& aVideoClipFileName )

    {

    LOGTEXT( _L( "Cae: CCaeEngineImp::SetVideoRecordingFileNameL() entering" ) );

    if ( !iVideoInitialized || iVideoRecordingRunning ) 

        {

        LOGTEXT( _L( "Cae: CCaeEngineImp::SetVideoRecordingFileNameL leaving KErrNotReady" ));

        User::Leave( KErrNotReady );

        }

    if ( aVideoClipFileName.Length() > 0 )

        {

        // Memorize the video clip file name.

        delete iVideoClipFileName;

        iVideoClipFileName = NULL;

        iVideoClipFileName = aVideoClipFileName.AllocL();

        }

    else 

        {

        LOGTEXT( _L( "Cae: CCaeEngineImp::SetVideoRecordingFileNameL leaving KErrArgument (aVideoClipFileName)" ));

        User::Leave( KErrArgument );

        }

    if ( iVideoPrepared ) 

        {

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

        // Note: Variated implementation

        ChangeVideoFileNameL();

        }

    LOGTEXT( _L( "Cae: CCaeEngineImp::SetVideoRecordingFileNameL() returning" ) );

    }

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

// CCaeEngineImp::PrepareVideoRecordingL

// Retrieves video recording parameters from the specified quality level and

// calls overloading PrepareVideoRecordingL().

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

//

void CCaeEngineImp::PrepareVideoRecordingL( 

    TInt aVideoQualityIndex )

    {

    LOGTEXT( _L( "Cae: CCaeEngineImp::PrepareVideoRecordingL() entering" ) );

    if ( ( aVideoQualityIndex < 0 ) || 

         ( aVideoQualityIndex >= iVideoQualityLevelsCont->Count() ) ) 

        {

        LOGTEXT( _L( "Cae: CCaeEngineImp::PrepareVideoRecordingL() leaving KErrArgument" ) );

        User::Leave( KErrArgument );

        }

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

                            iVideoQualityLevelsCont->At( aVideoQualityIndex ).iFrameRate, 

                            iVideoQualityLevelsCont->At( aVideoQualityIndex ).iBitRate, 

                            iVideoQualityLevelsCont->At( aVideoQualityIndex ).iAudioEnabled,

                            iVideoQualityLevelsCont->At( aVideoQualityIndex ).iAudioBitRate, 

                            iVideoQualityLevelsCont->At( aVideoQualityIndex ).iMimeType, 

                            iVideoQualityLevelsCont->At( aVideoQualityIndex ).iPreferredSupplier, 

                            iVideoQualityLevelsCont->At( aVideoQualityIndex ).iVideoType,    

                            iVideoQualityLevelsCont->At( aVideoQualityIndex ).iAudioType );

    iVideoQualityIndex = aVideoQualityIndex;

    LOGTEXT( _L( "Cae: CCaeEngineImp::PrepareVideoRecordingL() returning" ) );

    }

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

// CCaeEngineImp::PrepareVideoRecordingL

// Finds first the UIDs needed for opening a video recording, uses ECOM.

// Then gets camera handle from Camera API.

// Finally calls Video Recorder API OpenFileL().

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

//

void CCaeEngineImp::PrepareVideoRecordingL( 

    const TSize&  aFrameSize, 

    TReal32       aFrameRate, 

    TInt          aBitRate, 

    TBool         aAudioEnabled,

    const TDesC8& aMimeType, 

    const TDesC&  aPreferredSupplier, 

    const TDesC8& aVideoType, 

    const TDesC8& aAudioType )

    {

    LOGTEXT3( _L( "Cae: CCaeEngineImp::PrepareVideoRecordingL() entering aFrameSize wxh=%dx%d" ),

            aFrameSize.iWidth, aFrameSize.iHeight );

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

    if ( !iVideoInitialized || 

         !iVideoClipFileName || 

         iStillStatesActive->IsRunning() || 

         iVideoRecordingRunning   ) 

        {

        LOGTEXT2( _L( "Cae: CCaeEngineImp::PrepareVideoRecordingL leaving KErrNotReady, iVideoInitialized=%d" ), iVideoInitialized );

        User::Leave( KErrNotReady );

        }

    CheckPowerL();

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

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

        {

        LOGTEXT( _L( "Cae: CCaeEngineImp::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 );

    LOGTEXT( _L( "Cae: CCaeEngineImp::PrepareVideoRecordingL() returning" ) );

    }

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

// CCaeEngineImp::CloseVideoRecording

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

//

void CCaeEngineImp::CloseVideoRecording()

    {

    LOGTEXT( _L( "Cae: CCaeEngineImp::CloseVideoRecording() entering" ) );

    if ( iVideoPrepared ) 

        {

        CancelVideoRecording();

        iVideoPrepared = EFalse;

        }

    if ( iVideoOpened )

        {

        iVideoRecorder->Close();

        iVideoOpened = EFalse;

        }

    LOGTEXT( _L( "Cae: CCaeEngineImp::CloseVideoRecording() returning" ) );

    }

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

// CCaeEngineImp::VideoQualityIndex

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

//

TInt CCaeEngineImp::VideoQualityIndex() const

    {

    LOGTEXT( _L( "Cae: CCaeEngineImp::VideoQualityIndex()" ) );

    TInt qualityIndex( -1 );

    if ( iVideoPrepared )

        {

        qualityIndex = iVideoQualityIndex;

        }

    return qualityIndex;

    }

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

// CCaeEngineImp::GetVideoFrameSize

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

//

void CCaeEngineImp::GetVideoFrameSize( 

    TInt aVideoQualityIndex, 

    TSize& aFrameSize ) const

    {

    LOGTEXT( _L( "Cae: CCaeEngineImp::GetVideoFrameSize()" ) );

    if ( aVideoQualityIndex >= 0 &&  

         aVideoQualityIndex < iVideoQualityLevelsCont->Count() )

        {

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

        }

    }

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

// CCaeEngineImp::VideoFrameRate

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

//

TReal32 CCaeEngineImp::VideoFrameRate( 

    TInt aVideoQualityIndex ) const

    {

    LOGTEXT( _L( "Cae: CCaeEngineImp::VideoFrameRate()" ) );

    TReal32 frameRate( 0.0 );

    if ( aVideoQualityIndex >= 0 &&  

         aVideoQualityIndex < iVideoQualityLevelsCont->Count() )

        {

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

        }

    return frameRate;

    }

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

// CCaeEngineImp::EstimatedVideoRecordingBitRateL

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

//

TInt CCaeEngineImp::EstimatedVideoRecordingBitRateL( 

    TInt aVideoQualityIndex ) const

    {

    LOGTEXT( _L( "Cae: CCaeEngineImp::EstimatedVideoRecordingBitRateL()" ) );

    TInt storageRate( 0 );

    if ( aVideoQualityIndex >= 0 &&  

         aVideoQualityIndex < iVideoQualityLevelsCont->Count() )

        {

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

        }

    return storageRate;

    }

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

// CCaeEngineImp::SetVideoClipMaxSizeL

// If video recording is not prepared then just memorizes the clip max size.

// If video recording is prepared, then calls Video Recorder API 

// SetMaxClipSizeL() and Prepare().

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

//

void CCaeEngineImp::SetVideoClipMaxSizeL( 

    TInt aMaxClipSizeInBytes )

    {

    LOGTEXT( _L( "Cae: CCaeEngineImp::SetVideoClipMaxSizeL() entering" ) );

    if ( !iVideoInitialized || iVideoRecordingRunning ) 

        {

        LOGTEXT2( _L( "Cae: CCaeEngineImp::SetVideoClipMaxSizeL leaving KErrNotReady, iVideoInitialized=%d" ), iVideoInitialized );

        User::Leave( KErrNotReady );

        }

    if ( aMaxClipSizeInBytes > 0 ) 

        {

        iMaxClipSizeInBytesPrep = aMaxClipSizeInBytes;

        }

    else 

        {

        iMaxClipSizeInBytesPrep = KMMFNoMaxClipSize;

        }

    if ( iVideoPrepared )

        {

        iPrepPars = ETrue;

        iVideoRecorder->SetMaxClipSizeL( iMaxClipSizeInBytesPrep );

        iVideoRecorder->Prepare();

        }

    LOGTEXT( _L( "Cae: CCaeEngineImp::SetVideoClipMaxSizeL() returning" ) );

    }

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

// CCaeEngineImp::VideoClipMaxSize

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

//

TInt CCaeEngineImp::VideoClipMaxSize() const 

    {

    LOGTEXT( _L( "Cae: CCaeEngineImp::VideoClipMaxSize()" ) );

    TInt maxClipSizeInBytes( 0 );

    if ( iMaxClipSizeInBytes != KMMFNoMaxClipSize ) 

        {

        maxClipSizeInBytes = iMaxClipSizeInBytes;

        }

    return maxClipSizeInBytes;

    }

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

// CCaeEngineImp::SetVideoAudioL

// Calls Video Recorder API SetAudioEnabledL() and Prepare().

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

//

void CCaeEngineImp::SetVideoAudioL( 

    TBool aAudioEnabled )

    {

    LOGTEXT( _L( "Cae: CCaeEngineImp::SetVideoAudioL() entering" ) );

    if ( !iVideoInitialized || iVideoRecordingRunning ) 

        {

        LOGTEXT2( _L( "Cae: CCaeEngineImp::SetVideoAudioL leaving KErrNotReady, iVideoInitialized=%d" ), iVideoInitialized );

        User::Leave( KErrNotReady );

        }

    iVideoAudioEnabledPrep = aAudioEnabled;

    iVideoRecorder->SetAudioEnabledL( iVideoAudioEnabledPrep );

    iPrepPars = ETrue;

    iVideoRecorder->Prepare();

    LOGTEXT( _L( "Cae: CCaeEngineImp::SetVideoAudioL() returning" ) );

    }

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

// CCaeEngineImp::VideoAudio

// Calls Video Recorder API AudioEnabledL().

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

//

TBool CCaeEngineImp::VideoAudio() const

    {

    LOGTEXT( _L( "Cae: CCaeEngineImp::VideoAudio()" ) );

    TBool audioEnabled( EFalse );

    if ( iVideoRecorder )

        {

        TRAPD( error, { audioEnabled = iVideoRecorder->AudioEnabledL(); } );

        if ( error != KErrNone ) 

            {

            audioEnabled = EFalse;

            }

        }

    return audioEnabled;

    }

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

// CCaeEngineImp::SetVideoTimesIntervalL

// Converts from TTimeIntervalMicroSeconds used in the interface to 

// TTimeIntervalMicroSeconds32 used internally.

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

//

void CCaeEngineImp::SetVideoTimesIntervalL( 

    TTimeIntervalMicroSeconds aInterval )

    {

    LOGTEXT( _L( "Cae: CCaeEngineImp::SetVideoTimesIntervalL()" ) );

    if ( iVideoRecordingRunning ) 

        {

        LOGTEXT2( _L( "Cae: CCaeEngineImp::SetVideoTimesIntervalL leaving KErrNotReady, iVideoRecordingRunning=%d" ), iVideoRecordingRunning );

        User::Leave( KErrNotReady );

        }

    // Note: KMaxTInt32 in microseconds is about 35 minutes

    if ( aInterval < TTimeIntervalMicroSeconds( 0 ) || 

         aInterval > TTimeIntervalMicroSeconds( KMaxTInt32 ) )

        {

        LOGTEXT( _L( "Cae: CCaeEngineImp::SetVideoTimesIntervalL leaving KErrArgument" ));

        User::Leave( KErrArgument );

        }

    iVideoTimesInterval = I64INT( aInterval.Int64() );

    }

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

// CCaeEngineImp::VideoTimesInterval

// Converts to TTimeIntervalMicroSeconds used in the interface from  

// TTimeIntervalMicroSeconds32 used internally.

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

//

TTimeIntervalMicroSeconds CCaeEngineImp::VideoTimesInterval() const 

    {

    LOGTEXT( _L( "Cae: CCaeEngineImp::VideoTimesInterval()" ) );

    TInt64 intInterval = iVideoTimesInterval.Int();

    TTimeIntervalMicroSeconds interval( intInterval );

    return interval;

    }

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

// CCaeEngineImp::StartVideoRecording

// Calls Video Recorder API Record().

// Starts generating video recording time information for the client.

// Finally calls McaeoVideoRecordingOn().

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

//

void CCaeEngineImp::StartVideoRecording()

    {

    LOGTEXT( _L( "Cae: CCaeEngineImp::StartVideoRecording() entering" ) );