diff -r e3cdd00b5ae3 -r 27fe719c32e6 camappengine/Engine/Src/CaeEngineImpVideoRecording.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/camappengine/Engine/Src/CaeEngineImpVideoRecording.cpp Wed Sep 01 12:23:23 2010 +0100 @@ -0,0 +1,1365 @@ +/* +* 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 // For MMF definitions (as TMMFFileConfig) +#include // 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 + +#include "OstTraceDefinitions.h" +#ifdef OST_TRACE_COMPILER_IN_USE +#include "CaeEngineImpVideoRecordingTraces.h" +#endif + +// ============================ MEMBER FUNCTIONS =============================== + + +// ----------------------------------------------------------------------------- +// CCaeEngineImp::InitVideoRecorderL +// Initialise the engine for video recording using default parameters. +// ----------------------------------------------------------------------------- +// +void CCaeEngineImp::InitVideoRecorderL() + { + OstTrace0( CAMERASRV_PERFORMANCE, CCAEENGINEIMP_INITVIDEORECORDERL, "e_CAM_CAE_INITVIDEORECORDER 1" ); + 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" ) ); + OstTrace0( CAMERASRV_PERFORMANCE, DUP1_CCAEENGINEIMP_INITVIDEORECORDERL, "e_CAM_CAE_INITVIDEORECORDER 0" ); + } + + +// ----------------------------------------------------------------------------- +// 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 ) + { + OstTrace0( CAMERASRV_PERFORMANCE, CCAEENGINEIMP_PREPAREVIDEORECORDINGL, "e_CAM_CAE_PREPAREVIDEORECORDING 1" ); + 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(). + OstTrace0( CAMERASRV_PERFORMANCE, DUP2_CCAEENGINEIMP_PREPAREVIDEORECORDINGL, "e_CAM_CAE_VIDEORECORDER_OPENFILE 1" ); + iVideoRecorder->OpenFileL( iVideoClipFileName->Des(), + iCameraHandle, + iVideoControllerUid, + iVideoFormatUid, + iVideoType->Des(), + iVideoAudioType ); + OstTrace0( CAMERASRV_PERFORMANCE, DUP3_CCAEENGINEIMP_PREPAREVIDEORECORDINGL, "e_CAM_CAE_VIDEORECORDER_OPENFILE 0" ); + + LOGTEXT( _L( "Cae: CCaeEngineImp::PrepareVideoRecordingL() returning" ) ); + OstTrace0( CAMERASRV_PERFORMANCE, DUP1_CCAEENGINEIMP_PREPAREVIDEORECORDINGL, "e_CAM_CAE_PREPAREVIDEORECORDING 0" ); + } + + +// ----------------------------------------------------------------------------- +// CCaeEngineImp::CloseVideoRecording +// ----------------------------------------------------------------------------- +// +void CCaeEngineImp::CloseVideoRecording() + { + OstTrace0( CAMERASRV_PERFORMANCE, CCAEENGINEIMP_CLOSEVIDEORECORDING, "e_CAM_CAE_CLOSEVIDEORECORDING 1" ); + LOGTEXT( _L( "Cae: CCaeEngineImp::CloseVideoRecording() entering" ) ); + + if ( iVideoPrepared ) + { + CancelVideoRecording(); + iVideoPrepared = EFalse; + } + + if ( iVideoOpened ) + { + OstTrace0( CAMERASRV_PERFORMANCE, DUP2_CCAEENGINEIMP_CLOSEVIDEORECORDING, "e_CAM_CAE_VIDEORECORDER_CLOSE 1" ); + iVideoRecorder->Close(); + OstTrace0( CAMERASRV_PERFORMANCE, DUP3_CCAEENGINEIMP_CLOSEVIDEORECORDING, "e_CAM_CAE_VIDEORECORDER_CLOSE 0" ); + iVideoOpened = EFalse; + } + + LOGTEXT( _L( "Cae: CCaeEngineImp::CloseVideoRecording() returning" ) ); + OstTrace0( CAMERASRV_PERFORMANCE, DUP1_CCAEENGINEIMP_CLOSEVIDEORECORDING, "e_CAM_CAE_CLOSEVIDEORECORDING 0" ); + } + + +// ----------------------------------------------------------------------------- +// 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 ); + OstTrace0( CAMERASRV_PERFORMANCE, CCAEENGINEIMP_SETVIDEOCLIPMAXSIZEL, "e_CAM_CAE_VIDEORECORDER_PREPARE 1" ); + iVideoRecorder->Prepare(); + OstTrace0( CAMERASRV_PERFORMANCE, DUP1_CCAEENGINEIMP_SETVIDEOCLIPMAXSIZEL, "e_CAM_CAE_VIDEORECORDER_PREPARE 0" ); + } + + 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; + OstTrace0( CAMERASRV_PERFORMANCE, CCAEENGINEIMP_SETVIDEOAUDIOL, "e_CAM_CAE_VIDEORECORDER_PREPARE 1" ); + iVideoRecorder->Prepare(); + OstTrace0( CAMERASRV_PERFORMANCE, DUP1_CCAEENGINEIMP_SETVIDEOAUDIOL, "e_CAM_CAE_VIDEORECORDER_PREPARE 0" ); + + 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() + { + OstTrace0( CAMERASRV_PERFORMANCE, CCAEENGINEIMP_STARTVIDEORECORDING, "e_CAM_CAE_STARTVIDEORECORDING 1" ); + LOGTEXT( _L( "Cae: CCaeEngineImp::StartVideoRecording() entering" ) ); + + TInt error( KErrNone ); + + if ( iVideoPrepared && !iVideoRecordingRunning ) + { + iVideoRecordingRunning = ETrue; + iVideoRecordingPaused = EFalse; + + // Reset previous time information + iPrevTimeElapsed = 0; + iPrevTimeRemaining = 0; + + // Start video recording. + OstTrace0( CAMERASRV_PERFORMANCE, DUP2_CCAEENGINEIMP_STARTVIDEORECORDING, "e_CAM_CAE_VIDEORECORDER_RECORD 1" ); + iVideoRecorder->Record(); + OstTrace0( CAMERASRV_PERFORMANCE, DUP3_CCAEENGINEIMP_STARTVIDEORECORDING, "e_CAM_CAE_VIDEORECORDER_RECORD 0" ); + if ( iVideoTimesInterval > TTimeIntervalMicroSeconds32( 0 ) ) + { + // Start generating video recording time information for the client. + iVideoTimes->Start( KVideoTimesDelay, // delay + iVideoTimesInterval, // interval + *iVideoTimesCallback ); // callback + } + } + else + { + error = KErrNotReady; + } + + + OstTrace0( CAMERASRV_PERFORMANCE, DUP4_CCAEENGINEIMP_STARTVIDEORECORDING, "e_CAM_CAE_MCAEOVIDEORECORDINGON 1" ); + iCaeObserver->McaeoVideoRecordingOn( error ); + OstTrace0( CAMERASRV_PERFORMANCE, DUP5_CCAEENGINEIMP_STARTVIDEORECORDING, "e_CAM_CAE_MCAEOVIDEORECORDINGON 0" ); + + LOGTEXT( _L( "Cae: CCaeEngineImp::StartVideoRecording() returning" ) ); + OstTrace0( CAMERASRV_PERFORMANCE, DUP1_CCAEENGINEIMP_STARTVIDEORECORDING, "e_CAM_CAE_STARTVIDEORECORDING 0" ); + } + + +// ----------------------------------------------------------------------------- +// CCaeEngineImp::StopVideoRecording +// Calls Video Recorder API Record(), DurationL(), and RecordTimeAvailable(). +// Stops generating video recording time information for the client. +// Delivers video recording time info to the client once right after stopping, +// by calling McaeoVideoRecordingTimes(). +// Finally calls McaeoVideoRecordingComplete(). +// ----------------------------------------------------------------------------- +// +void CCaeEngineImp::StopVideoRecording() + { + OstTrace0( CAMERASRV_PERFORMANCE, CCAEENGINEIMP_STOPVIDEORECORDING, "e_CAM_CAE_STOPVIDEORECORDING 1" ); + LOGTEXT( _L( "Cae: CCaeEngineImp::StopVideoRecording() entering" ) ); + + TInt stoppingError( KErrNone ); + TInt asyncStopErr( KErrNone ); + + if ( iVideoRecordingRunning ) + { + TInt timesError( KErrNone ); + TTimeIntervalMicroSeconds timeElapsed( 0 ); + + iVideoRecordingRunning = EFalse; + + // Stop generating video recording time information for the client. + iVideoTimes->Cancel(); + + if ( iVideoTimesInterval > TTimeIntervalMicroSeconds32( 0 ) ) + { + // Query elapsed time before stop (it is set to zero after stop). + TRAP( timesError, { timeElapsed = iVideoRecorder->DurationL(); } ); + // Possible error is ignored locally because not so crucial. Error code is delivered by call-back. + } + + // Stop video recording. + if ( iAsyncVideoStopEnabled ) + { + LOGTEXT( _L( "Cae: CCaeEngineImp::StopVideoRecording(). using custom command ECamCControllerCCVideoStopAsync" )); + OstTrace0( CAMERASRV_PERFORMANCE, DUP2_CCAEENGINEIMP_STOPVIDEORECORDING, "e_CAM_CAE_VIDEORECORDER_STOP_ASYNC 1" ); + asyncStopErr = iVideoRecorder->CustomCommandSync( TMMFMessageDestination( iVideoControllerUid, KMMFObjectHandleController ), + ECamCControllerCCVideoStopAsync, + KNullDesC8, + KNullDesC8 ); + OstTrace0( CAMERASRV_PERFORMANCE, DUP3_CCAEENGINEIMP_STOPVIDEORECORDING, "e_CAM_CAE_VIDEORECORDER_STOP_ASYNC 0" ); + if ( asyncStopErr ) // async stop was not supported, use sync stop + { + LOGTEXT2( _L( "Cae: CCaeEngineImp::StopVideoRecording(). async stop err=%d, using sync stop" ), asyncStopErr); + OstTrace0( CAMERASRV_PERFORMANCE, DUP4_CCAEENGINEIMP_STOPVIDEORECORDING, "e_CAM_CAE_VIDEORECORDER_STOP 1" ); + stoppingError = iVideoRecorder->Stop(); + OstTrace0( CAMERASRV_PERFORMANCE, DUP5_CCAEENGINEIMP_STOPVIDEORECORDING, "e_CAM_CAE_VIDEORECORDER_STOP 0" ); + OstTrace0( CAMERASRV_PERFORMANCE, DUP8_CCAEENGINEIMP_STOPVIDEORECORDING, "e_CAM_CAE_MCAEOVIDEORECORDINGSTOPPED 1" ); + iCaeObserver->McaeoVideoRecordingStopped(); + OstTrace0( CAMERASRV_PERFORMANCE, DUP9_CCAEENGINEIMP_STOPVIDEORECORDING, "e_CAM_CAE_MCAEOVIDEORECORDINGSTOPPED 0" ); + } + } + else + { + // Synchronous, quaranteed that video recording is stopped when returning. + OstTrace0( CAMERASRV_PERFORMANCE, DUP6_CCAEENGINEIMP_STOPVIDEORECORDING, "e_CAM_CAE_VIDEORECORDER_STOP 1" ); + stoppingError = iVideoRecorder->Stop(); + OstTrace0( CAMERASRV_PERFORMANCE, DUP7_CCAEENGINEIMP_STOPVIDEORECORDING, "e_CAM_CAE_VIDEORECORDER_STOP 0" ); + } + + // Can't be paused anymore. + iVideoRecordingPaused = EFalse; + + /* + #ifdef CAE_TEST_VERSION + // For simulating errors when compiled as special "test version". + CaeStopVideoRecordingError( stoppingError ); + #endif + */ + + if ( iVideoTimesInterval > TTimeIntervalMicroSeconds32( 0 ) ) + { + // Query remaining time after stop. + TTimeIntervalMicroSeconds timeRemaining = iVideoRecorder->RecordTimeAvailable(); + + // The elapsed time could have been reseted to zero by the video recorder + // if there is stopping ongoing in video recorder, even if we do + // not have had the notification yet. In that case McaeoVideoRecordingTimes + // should be called with previous valid values. + if ( ( timeElapsed == 0 ) && ( iPrevTimeElapsed != 0 ) ) + { + // Invalid time. Use previous time information + LOGTEXT2( _L( "Cae: CCaeEngineImp::StopVideoRecording(). Got invalid elapsed time from the video recorder: %f s." ), + I64LOW( timeElapsed.Int64() ) * 1.0 / KOneSecond); + LOGTEXT3( _L( "Cae: CCaeEngineImp::StopVideoRecording(). Use previous valid elapsed time %f s. and remaining time %f s." ), + I64LOW( iPrevTimeElapsed.Int64() ) * 1.0 / KOneSecond, + I64LOW( iPrevTimeRemaining.Int64() ) * 1.0 / KOneSecond ); + timeElapsed = iPrevTimeElapsed; + timeRemaining =iPrevTimeRemaining; + } + + // Deliver video times (elapsed, remaining) information. + iCaeObserver->McaeoVideoRecordingTimes( timeElapsed, timeRemaining, timesError ); + } + } + else + { + stoppingError = KErrNotReady; + } + + // Reset previous time information + iPrevTimeElapsed = 0; + iPrevTimeRemaining = 0; + + if ( !iAsyncVideoStopEnabled || asyncStopErr ) + { + OstTrace0( CAMERASRV_PERFORMANCE, DUP10_CCAEENGINEIMP_STOPVIDEORECORDING, "e_CAM_CAE_MCAEOVIDEORECORDINGCOMPLETE 1" ); + iCaeObserver->McaeoVideoRecordingComplete( stoppingError ); + OstTrace0( CAMERASRV_PERFORMANCE, DUP11_CCAEENGINEIMP_STOPVIDEORECORDING, "e_CAM_CAE_MCAEOVIDEORECORDINGCOMPLETE 0" ); + } + + + LOGTEXT( _L( "Cae: CCaeEngineImp::StopVideoRecording() returning" ) ); + OstTrace0( CAMERASRV_PERFORMANCE, DUP1_CCAEENGINEIMP_STOPVIDEORECORDING, "e_CAM_CAE_STOPVIDEORECORDING 0" ); + } + + +// ----------------------------------------------------------------------------- +// CCaeEngineImp::PauseVideoRecording +// Stops generating video recording time info for the client. +// Calls Video Recorder API PauseL(). +// Delivers video recording time info to the client once right after pausing +// by calling VideoRecordingTimesCallback() that calls Video Recorder API +// DurationL() and RecordTimeAvailable(), and then McaeoVideoRecordingTimes(). +// Finally calls McaeoVideoRecordingPaused(). +// ----------------------------------------------------------------------------- +// +void CCaeEngineImp::PauseVideoRecording() + { + LOGTEXT( _L( "Cae: CCaeEngineImp::PauseVideoRecording() entering" ) ); + + TInt error( KErrNone ); + + if ( iVideoRecordingRunning && !iVideoRecordingPaused ) + { + // Stop generating video recording time info for the client. + iVideoTimes->Cancel(); + // Pause video recording. + TRAP( error, iVideoRecorder->PauseL() ); + if ( iVideoTimesInterval > TTimeIntervalMicroSeconds32( 0 ) ) + { + // Deliver video recording times (elapsed, remaining) info once. + VideoRecordingTimesCallback( this ); + } + // Intentionally setting iVideoRecordingPaused after (possibly) calling VideoRecordingTimesCallback(). + if ( error == KErrNone ) + { + iVideoRecordingPaused = ETrue; + } + } + else + { + error = KErrNotReady; + } + + iCaeObserver->McaeoVideoRecordingPaused( error ); + + LOGTEXT( _L( "Cae: CCaeEngineImp::PauseVideoRecording() returning" ) ); + } + + +// ----------------------------------------------------------------------------- +// CCaeEngineImp::ResumeVideoRecording +// Calls Video Recorder API Record(). +// Starts generating video recording time information for the client. +// Finally calls McaeoVideoRecordingOn(). +// ----------------------------------------------------------------------------- +// +void CCaeEngineImp::ResumeVideoRecording() + { + LOGTEXT( _L( "Cae: CCaeEngineImp::ResumeVideoRecording() entering" ) ); + + TInt error( KErrNone ); + + if ( iVideoRecordingRunning && iVideoRecordingPaused ) + { + // Start video recording. + OstTrace0( CAMERASRV_PERFORMANCE, CCAEENGINEIMP_RESUMEVIDEORECORDING, "e_CAM_CAE_VIDEORECORDER_RECORD 1" ); + iVideoRecorder->Record(); + OstTrace0( CAMERASRV_PERFORMANCE, DUP1_CCAEENGINEIMP_RESUMEVIDEORECORDING, "e_CAM_CAE_VIDEORECORDER_RECORD 0" ); + iVideoRecordingPaused = EFalse; + if ( iVideoTimesInterval > TTimeIntervalMicroSeconds32( 0 ) ) + { + // Start generating video recording time information for the client. + iVideoTimes->Start( KVideoTimesDelay, // delay + iVideoTimesInterval, // interval + *iVideoTimesCallback ); // callback + } + } + else + { + error = KErrNotReady; + } + + iCaeObserver->McaeoVideoRecordingOn( error ); + + LOGTEXT( _L( "Cae: CCaeEngineImp::ResumeVideoRecording() returning" ) ); + } + + +// ----------------------------------------------------------------------------- +// CCaeEngineImp::RemainingVideoRecordingTime +// Calls Video Recorder API RecordTimeAvailable(). +// ----------------------------------------------------------------------------- +// +TTimeIntervalMicroSeconds CCaeEngineImp::RemainingVideoRecordingTime() const + { + LOGTEXT( _L( "Cae: CCaeEngineImp::RemainingVideoRecordingTime()" ) ); + + TTimeIntervalMicroSeconds remaining( 0 ); + if ( iVideoRecorder ) + { + remaining = iVideoRecorder->RecordTimeAvailable(); + } + return remaining; + } + + +// ----------------------------------------------------------------------------- +// CCaeEngineImp::IsVideoRecording +// ----------------------------------------------------------------------------- +// +TBool CCaeEngineImp::IsVideoRecording() const + { + return iVideoRecordingRunning; + } + + +// ----------------------------------------------------------------------------- +// CCaeEngineImp::PrepareVideoRecordingL +// Overloading version with audio bit rate argument. +// ----------------------------------------------------------------------------- +// +void CCaeEngineImp::PrepareVideoRecordingL( + const TSize& aFrameSize, + TReal32 aFrameRate, + TInt aBitRate, + TBool aAudioEnabled, + TInt aAudioBitRate, + const TDesC8& aMimeType, + const TDesC& aPreferredSupplier, + const TDesC8& aVideoType, + const TDesC8& aAudioType ) + { + OstTrace0( CAMERASRV_PERFORMANCE, DUP4_CCAEENGINEIMP_PREPAREVIDEORECORDINGL, "e_CAM_CAE_PREPAREVIDEORECORDINGL 1" ); + // 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 ); + OstTrace0( CAMERASRV_PERFORMANCE, DUP5_CCAEENGINEIMP_PREPAREVIDEORECORDINGL, "e_CAM_CAE_PREPAREVIDEORECORDINGL 0" ); + } + + +// ----------------------------------------------------------------------------- +// CCaeEngineImp::MvruoOpenComplete +// The status of the video recorder after initialisation. +// This is either KErrNone if the open has completed successfully, +// or one of the system wide error codes +// ----------------------------------------------------------------------------- +// +void CCaeEngineImp::MvruoOpenComplete( + TInt aError ) + { + LOGTEXT2( _L( "Cae: CCaeEngineImp::MvruoOpenComplete() entering, aError=%d" ), aError ); + + #ifdef CAE_TEST_VERSION + // For simulating errors when compiled as special "test version". + CaeMvruoOpenCompleteError( aError ); + #endif + + if ( aError == KErrNone ) + { + // To get default video audio bit rate. + TRAP( aError, { iVideoAudioBitRate = iVideoRecorder->AudioBitRateL(); } ); + // (ignore possible error) + // Prepare settings only if no errors in opening. + TRAP( aError, PrepareVideoSettingsL() ); + if ( aError != KErrNone ) + { + OstTrace0( CAMERASRV_PERFORMANCE, CCAEENGINEIMP_MVRUOOPENCOMPLETE, "e_CAM_CAE_MCAEOVIDEOPREPARECOMPLETE 1" ); + iCaeObserver->McaeoVideoPrepareComplete( aError ); + OstTrace0( CAMERASRV_PERFORMANCE, DUP1_CCAEENGINEIMP_MVRUOOPENCOMPLETE, "e_CAM_CAE_MCAEOVIDEOPREPARECOMPLETE 0" ); + } + } + else + { + OstTrace0( CAMERASRV_PERFORMANCE, DUP2_CCAEENGINEIMP_MVRUOOPENCOMPLETE, "e_CAM_CAE_MCAEOVIDEOPREPARECOMPLETE 1" ); + iCaeObserver->McaeoVideoPrepareComplete( aError ); + OstTrace0( CAMERASRV_PERFORMANCE, DUP3_CCAEENGINEIMP_MVRUOOPENCOMPLETE, "e_CAM_CAE_MCAEOVIDEOPREPARECOMPLETE 0" ); + } + + LOGTEXT( _L( "Cae: CCaeEngineImp::MvruoOpenComplete() returning" ) ); + } + + +// ----------------------------------------------------------------------------- +// CCaeEngineImp::MvruoPrepareComplete +// Notification that video recorder is ready to begin recording. This callback +// is generated in response to a call to VR's Prepare. +// ----------------------------------------------------------------------------- +// +void CCaeEngineImp::MvruoPrepareComplete( + TInt aError ) + { + LOGTEXT2( _L( "Cae: CCaeEngineImp::MvruoPrepareComplete() entering, aError=%d" ), aError ); + + #ifdef CAE_TEST_VERSION + // For simulating errors when compiled as special "test version". + CaeMvruoPrepareCompleteError( aError ); + #endif + + if ( iVideoOpened && ( aError == KErrNone ) ) + { + iVideoPrepared = ETrue; // Later errors with settings after + // do not change the value. + } + + if ( iPrepPars ) + { + iPrepPars = EFalse; + // If no error, then fresh parameters are valid. + // Otherwise, old parameters are kept. + if ( aError == KErrNone ) + { + *iVideoFrameSize = *iVideoFrameSizePrep; + iVideoFrameRate = iVideoFrameRatePrep; + iVideoBitRate = iVideoBitRatePrep; + iVideoAudioEnabled = iVideoAudioEnabledPrep; + iVideoAudioBitRate = iVideoAudioBitRatePrep; + iMaxClipSizeInBytes = iMaxClipSizeInBytesPrep; + } + else + { + *iVideoFrameSizePrep = *iVideoFrameSize; + iVideoFrameRatePrep = iVideoFrameRate; + iVideoBitRatePrep = iVideoBitRate; + iVideoAudioEnabledPrep = iVideoAudioEnabled; + iVideoAudioBitRatePrep = iVideoAudioBitRate; + iMaxClipSizeInBytesPrep = iMaxClipSizeInBytes; + } + } + + OstTrace0( CAMERASRV_PERFORMANCE, CCAEENGINEIMP_MVRUOPREPARECOMPLETE, "e_CAM_CAE_MCAEOVIDEOPREPARECOMPLETE 1" ); + iCaeObserver->McaeoVideoPrepareComplete( aError ); + OstTrace0( CAMERASRV_PERFORMANCE, DUP1_CCAEENGINEIMP_MVRUOPREPARECOMPLETE, "e_CAM_CAE_MCAEOVIDEOPREPARECOMPLETE 0" ); + + LOGTEXT( _L( "Cae: CCaeEngineImp::MvruoPrepareComplete() returning" ) ); + } + + +// ----------------------------------------------------------------------------- +// CCaeEngineImp::MvruoRecordComplete +// Notification that video recording has completed. This is not called if +// recording is explicitly stopped by calling Stop. +// ----------------------------------------------------------------------------- +// +void CCaeEngineImp::MvruoRecordComplete( + TInt aError ) + { + LOGTEXT3( _L( "Cae: CCaeEngineImp::MvruoRecordComplete() entering, aError=%d, iVideoRecordingRunning=%d" ), aError, iVideoRecordingRunning ); + + // Stop generating video recording time information for the client. + iVideoTimes->Cancel(); + // Recording stopped: can't be paused anymore. + iVideoRecordingPaused = EFalse; + + // Reset previous time information + iPrevTimeElapsed = 0; + iPrevTimeRemaining = 0; + + if ( iVideoRecordingRunning || iAsyncVideoStopEnabled ) // To ensure that McaeoVideoRecordingComplete + { // gets called just once per recording. + iVideoRecordingRunning = EFalse; + + #ifdef CAE_TEST_VERSION + // For simulating errors when compiled as special "test version". + CaeMvruoRecordCompleteError( aError ); + #endif + + // Close video recording always in error case. Otherwise the camcorder plugin would + // be in indeterminated state. + // The code KErrCompletion means that video reocording has been completed by timer + if ( aError && aError != KErrCompletion && aError != KErrDiskFull ) + { + CloseVideoRecording(); + } + + // In async stop mode call also the other call-back to play stop sound + if ( iAsyncVideoStopEnabled ) + { + OstTrace0( CAMERASRV_PERFORMANCE, CCAEENGINEIMP_MVRUORECORDCOMPLETE, "e_CAM_CAE_MCAEOVIDEORECORDINGSTOPPED 1" ); + iCaeObserver->McaeoVideoRecordingStopped(); + OstTrace0( CAMERASRV_PERFORMANCE, DUP1_CCAEENGINEIMP_MVRUORECORDCOMPLETE, "e_CAM_CAE_MCAEOVIDEORECORDINGSTOPPED 0" ); + } + OstTrace0( CAMERASRV_PERFORMANCE, DUP2_CCAEENGINEIMP_MVRUORECORDCOMPLETE, "e_CAM_CAE_MCAEOVIDEORECORDINGCOMPLETE 1" ); + iCaeObserver->McaeoVideoRecordingComplete( aError ); + OstTrace0( CAMERASRV_PERFORMANCE, DUP3_CCAEENGINEIMP_MVRUORECORDCOMPLETE, "e_CAM_CAE_MCAEOVIDEORECORDINGCOMPLETE 0" ); + } + + LOGTEXT( _L( "Cae: CCaeEngineImp::MvruoRecordComplete() returning" ) ); + } + + +// ----------------------------------------------------------------------------- +// CCaeEngineImp::MvruoEvent +// Event Notification from controller +// ----------------------------------------------------------------------------- +// + +void CCaeEngineImp::MvruoEvent( + const TMMFEvent& aEvent ) + { + LOGTEXT3( _L( "Cae: CCaeEngineImp::MvruoEvent() entering, uid=%x, err=%d" ), aEvent.iEventType.iUid, aEvent.iErrorCode ); + + if ( aEvent.iEventType.iUid == KCamCControllerCCVideoRecordStopped.iUid ) + { + OstTrace0( CAMERASRV_PERFORMANCE, CCAEENGINEIMP_MVRUOEVENT, "e_CAM_CAE_MCAEOVIDEORECORDINGSTOPPED 1" ); + iCaeObserver->McaeoVideoRecordingStopped(); + OstTrace0( CAMERASRV_PERFORMANCE, DUP3_CCAEENGINEIMP_MVRUOEVENT, "e_CAM_CAE_MCAEOVIDEORECORDINGSTOPPED 0" ); + } + else if ( aEvent.iEventType.iUid == KCamCControllerCCVideoFileComposed.iUid ) + { + OstTrace0( CAMERASRV_PERFORMANCE, DUP1_CCAEENGINEIMP_MVRUOEVENT, "e_CAM_CAE_MCAEOVIDEORECORDINGCOMPLETE 1" ); + iCaeObserver->McaeoVideoRecordingComplete( aEvent.iErrorCode ); + OstTrace0( CAMERASRV_PERFORMANCE, DUP2_CCAEENGINEIMP_MVRUOEVENT, "e_CAM_CAE_MCAEOVIDEORECORDINGCOMPLETE 0" ); + } + else + { + // Send others events as error to UI + iVideoPrepared = EFalse; // mark that re-preparation is needed + OstTrace0( CAMERASRV_PERFORMANCE, DUP4_CCAEENGINEIMP_MVRUOEVENT, "e_CAM_CAE_MCAEOVIDEOPREPARECOMPLETE 1" ); + iCaeObserver->McaeoVideoPrepareComplete( aEvent.iErrorCode ); + OstTrace0( CAMERASRV_PERFORMANCE, DUP5_CCAEENGINEIMP_MVRUOEVENT, "e_CAM_CAE_MCAEOVIDEOPREPARECOMPLETE 0" ); + } + + LOGTEXT( _L( "Cae: CCaeEngineImp::MvruoEvent() returning" ) ); + } + + + +// ----------------------------------------------------------------------------- +// CCaeEngineImp::CancelVideoRecording +// Calls Video Recorder API Stop(). +// ----------------------------------------------------------------------------- +// +void CCaeEngineImp::CancelVideoRecording() + { + LOGTEXT( _L( "Cae: CCaeEngineImp::CancelVideoRecording() entering" ) ); + + if ( iVideoRecordingRunning ) + { + // This also prevents McaeoVideoRecordingComplete() call from MvruoRecordComplete() + // and McaeoVideoRecordingTimes() call from VideoRecordingTimesCallback(). + iVideoRecordingRunning = EFalse; + // Stop generating video recording time information for the client. + iVideoTimes->Cancel(); + + // Reset previous time information + iPrevTimeElapsed = 0; + iPrevTimeRemaining = 0; + + // Stop video recording. Do not call McaeoVideoRecordingComplete() + OstTrace0( CAMERASRV_PERFORMANCE, CCAEENGINEIMP_CANCELVIDEORECORDING, "e_CAM_CAE_VIDEORECORDER_STOP 1" ); + (void) iVideoRecorder->Stop(); + OstTrace0( CAMERASRV_PERFORMANCE, DUP1_CCAEENGINEIMP_CANCELVIDEORECORDING, "e_CAM_CAE_VIDEORECORDER_STOP 0" ); + iVideoRecordingPaused = EFalse; + } + + LOGTEXT( _L( "Cae: CCaeEngineImp::CancelVideoRecording() returning" ) ); + } + + +// ----------------------------------------------------------------------------- +// CCaeEngineImp::PrepareVideoSettingsL +// Calls Video Recorder API setting methods to set video recording paramaters. +// ----------------------------------------------------------------------------- +// +void CCaeEngineImp::PrepareVideoSettingsL() + { + OstTrace0( CAMERASRV_PERFORMANCE, CCAEENGINEIMP_PREPAREVIDEOSETTINGSL, "e_CAM_CAE_PREPAREVIDEOSETTINGS 1" ); + LOGTEXT( _L( "Cae: CCaeEngineImp::PrepareVideoSettingsL() entering" ) ); + + #ifdef CAE_TEST_VERSION + // For simulating errors when compiled as special "test version". + CaePrepareVideoSettingsErrorL(); + #endif + + iVideoRecorder->SetVideoFrameSizeL( *iVideoFrameSizePrep ); + iVideoRecorder->SetVideoFrameRateL( iVideoFrameRatePrep ); + iVideoRecorder->SetVideoBitRateL( iVideoBitRatePrep ); + iVideoRecorder->SetAudioEnabledL( iVideoAudioEnabledPrep ); + if ( iPrepareVideoAudioBitRate ) + { + iVideoRecorder->SetAudioBitRateL( iVideoAudioBitRatePrep ); + iPrepareVideoAudioBitRate = EFalse; + } + iVideoRecorder->SetMaxClipSizeL( iMaxClipSizeInBytesPrep ); + + // Set the recording gain to the maximum + TInt gain = iVideoRecorder->GainL(); + LOGTEXT2( _L( "Cae: CCaeEngineImp::PrepareVideoSettingsL() GainL was %d" ), gain ); + gain = iVideoRecorder->MaxGainL(); + LOGTEXT2( _L( "Cae: CCaeEngineImp::PrepareVideoSettingsL() MaxGainL is %d" ), gain ); + iVideoRecorder->SetGainL( gain ); + gain = iVideoRecorder->GainL(); + LOGTEXT2( _L( "Cae: CCaeEngineImp::PrepareVideoSettingsL() GainL set to %d" ), gain ); + + iPrepPars = ETrue; + OstTrace0( CAMERASRV_PERFORMANCE, DUP2_CCAEENGINEIMP_PREPAREVIDEOSETTINGSL, "e_CAM_CAE_VIDEORECORDER_PREPARE 1" ); + iVideoRecorder->Prepare(); + OstTrace0( CAMERASRV_PERFORMANCE, DUP3_CCAEENGINEIMP_PREPAREVIDEOSETTINGSL, "e_CAM_CAE_VIDEORECORDER_PREPARE 0" ); + + LOGTEXT( _L( "Cae: CCaeEngineImp::PrepareVideoSettingsL() returning" ) ); + OstTrace0( CAMERASRV_PERFORMANCE, DUP1_CCAEENGINEIMP_PREPAREVIDEOSETTINGSL, "e_CAM_CAE_PREPAREVIDEOSETTINGS 0" ); + } + + +// ----------------------------------------------------------------------------- +// CCaeEngineImp::FindVideoUidsL +// Finds UIDs for opening video recording. Uses ECOM. +// ----------------------------------------------------------------------------- +// +void CCaeEngineImp::FindVideoUidsL( + const TDesC8& aMimeType, + const TDesC& aPreferredSupplier ) + { + LOGTEXT( _L( "Cae: CCaeEngineImp::FindVideoUidsL() entering" ) ); + + iVideoControllerUid.iUid = 0; + iVideoFormatUid.iUid = 0; + + // Retrieve a list of possible controllers from ECOM. + // + // Controller must support recording the requested mime type. + // Controller must be provided by preferred supplier. + + CMMFControllerPluginSelectionParameters* cSelect = + CMMFControllerPluginSelectionParameters::NewLC(); + CMMFFormatSelectionParameters* fSelect = + CMMFFormatSelectionParameters::NewLC(); + + fSelect->SetMatchToMimeTypeL( aMimeType ); + cSelect->SetRequiredRecordFormatSupportL( *fSelect ); + cSelect->SetPreferredSupplierL( aPreferredSupplier, + CMMFPluginSelectionParameters::EOnlyPreferredSupplierPluginsReturned ); + + RMMFControllerImplInfoArray controllers; + CleanupResetAndDestroyPushL( controllers ); + cSelect->ListImplementationsL( controllers ); + + if ( controllers.Count() < 1 ) + { + // No appropriate controllers found. + LOGTEXT( _L( "Cae: CCaeEngineImp::FindVideoUidsL() leaving KErrNotSupported (no controllers found)" ) ); + User::Leave( KErrNotSupported ); + } + + TBool found( EFalse ); + for ( TInt contInd = 0; contInd < controllers.Count() && !found; contInd++ ) // there can be more than one controller, search from all of them + { + // Get the controller UID. + iVideoControllerUid = controllers[contInd]->Uid(); + LOGTEXT3( _L("Cae: CCaeEngineImp::FindVideoUidsL() contInd=%d, Uid=%x"), contInd, iVideoControllerUid.iUid ); + + // Inquires the controller about supported formats. + RMMFFormatImplInfoArray formats = controllers[contInd]->RecordFormats(); + + // Get the first format that supports our mime type. + for ( TInt i = 0; i < formats.Count(); i++ ) + { + if ( formats[i]->SupportsMimeType( aMimeType ) ) + { + iVideoFormatUid = formats[i]->Uid(); // set the UID + found = ETrue; + LOGTEXT3( _L("Cae: CCaeEngineImp::FindVideoUidsL() Found iVideoFormatUid=%x, index=%d"), iVideoFormatUid.iUid, i ); + break; + } + } + } + if ( !found ) + { + // No appropriate video format found. + LOGTEXT( _L( "Cae: CCaeEngineImp::FindVideoUidsL() leaving KErrNotSupported (no video format found)" ) ); + User::Leave( KErrNotSupported ); + } + + CleanupStack::PopAndDestroy( 3, cSelect ); // cselect, fselect, controllers + + LOGTEXT( _L( "Cae: CCaeEngineImp::FindVideoUidsL() returning" ) ); + } + + +// ----------------------------------------------------------------------------- +// CCaeEngineImp::ConvertAndSetVideoAudioTypeL +// Convert audio type from TDesC8 to TFourCC, set to iVideoAudioType. +// ----------------------------------------------------------------------------- +// +TFourCC CCaeEngineImp::ConvertAndSetVideoAudioTypeL( + const TDesC8& aAudioType ) + { + if ( aAudioType == KNullDesC8 ) + { + return KMMFFourCCCodeNULL; + } + else + { + if ( aAudioType.Length() != 4 ) + { + User::Leave( KErrArgument ); + } + return TFourCC( aAudioType[0], aAudioType[1], aAudioType[2], aAudioType[3] ); + } + } + + +// ----------------------------------------------------------------------------- +// CCaeEngineImp::VideoRecordingTimesCallback +// Calls Video Recorder API DurationL() and RecordTimeAvailable(). +// Finally calls McaeoVideoRecordingTimes(). +// ----------------------------------------------------------------------------- +// +TInt CCaeEngineImp::VideoRecordingTimesCallback( + TAny* aEngineImp ) + { + LOGTEXT( _L( "Cae: CCaeEngineImp::VideoRecordingTimesCallback() entering" ) ); + + CCaeEngineImp* thisEngineImp = static_cast( aEngineImp ); + + if ( thisEngineImp->iVideoRecordingRunning && !thisEngineImp->iVideoRecordingPaused ) + { + // Query elapsed recording time. + TTimeIntervalMicroSeconds timeElapsed( 0 ); + TRAPD( error, { timeElapsed = thisEngineImp->iVideoRecorder->DurationL(); } ); + + // Query remaining recording time. + TTimeIntervalMicroSeconds timeRemaining = thisEngineImp->iVideoRecorder->RecordTimeAvailable(); + + // The elapsed time could have been reseted to zero by the video recorder + // if there is stopping ongoing in video recorder, even if we do + // not have had the notification yet. In that case McaeoVideoRecordingTimes + // should be called with previous valid values. + if ( ( timeElapsed == 0 ) && ( thisEngineImp->iPrevTimeElapsed != 0 ) ) + { + // Invalid time. Use previous time information + LOGTEXT2( _L( "Cae: CCaeEngineImp::VideoRecordingTimesCallback(). Got invalid elapsed time from the video recorder: %f s." ), + I64LOW( timeElapsed.Int64() ) * 1.0 / KOneSecond); + LOGTEXT3( _L( "Cae: CCaeEngineImp::VideoRecordingTimesCallback(). Use previous valid elapsed time %f s. and remaining time %f s." ), + I64LOW( thisEngineImp->iPrevTimeElapsed.Int64() ) * 1.0 / KOneSecond, + I64LOW( thisEngineImp->iPrevTimeRemaining.Int64() ) * 1.0 / KOneSecond ); + timeElapsed = thisEngineImp->iPrevTimeElapsed; + timeRemaining = thisEngineImp->iPrevTimeRemaining; + } + else + { + // Store current time information + thisEngineImp->iPrevTimeElapsed = timeElapsed; + thisEngineImp->iPrevTimeRemaining = timeRemaining; + } + + // Deliver video recording times information. + thisEngineImp->iCaeObserver->McaeoVideoRecordingTimes( timeElapsed, timeRemaining, error ); + } + + LOGTEXT( _L( "Cae: CCaeEngineImp::VideoRecordingTimesCallback() returning" ) ); + + return ETrue; + } + +// --------------------------------------------------------- +// CCaeEngineImp::EnumerateVideoFrameSizeL +// Checks that camera HW supports given framesize +// --------------------------------------------------------- +// +TInt CCaeEngineImp::EnumerateVideoFrameSizeL(const TSize& aSize) + { + + LOGTEXT3( _L("Cae: CCaeEngineImp::EnumerateVideoFrameSizeL(), In, size: %dx%d"), aSize.iWidth, aSize.iHeight ); + + TCameraInfo cameraInfo; + iCamera->CameraInfo( cameraInfo ); + + TSize size; + TInt i = 0; + TInt j = 0; + TInt sizeIndex = -1; + + if ( cameraInfo.iVideoFrameFormatsSupported & CCamera::EFormatYUV420Planar ) + { + // check YUV420 planar + for ( i = 0; i < cameraInfo.iNumVideoFrameSizesSupported; i++ ) + { + iCamera->EnumerateVideoFrameSizes(size, i, CCamera::EFormatYUV420Planar); + LOGTEXT3(_L("Cae: CCaeEngineImp::EnumerateVideoFrameSizeL() Camera EFormatYUV420Planar %d x %d found from camera"), size.iWidth, size.iHeight ); + + if ( size == aSize ) + { + LOGTEXT3(_L("Cae: CCaeEngineImp::EnumerateVideoFrameSizeL() Camera EFormatYUV420Planar %d x %d Matched."), size.iWidth, size.iHeight ); + sizeIndex = i; + break; + } + } + } + else + { + LOGTEXT(_L("Cae: CCaeEngineImp::EnumerateVideoFrameSizeL() Camera doesn't support EFormatYUV420Planar")); + } + + if ( cameraInfo.iVideoFrameFormatsSupported & CCamera::EFormatYUV422 ) + { + // check YUV422 interleaved + for ( j = 0; j < cameraInfo.iNumVideoFrameSizesSupported; j++ ) + { + iCamera->EnumerateVideoFrameSizes(size, j, CCamera::EFormatYUV422 ); + LOGTEXT3(_L("Cae: CCaeEngineImp::EnumerateVideoFrameSizeL() Camera EFormatYUV422 %d x %d found from camera"), size.iWidth, size.iHeight ); + + if ( size == aSize ) + { + LOGTEXT3(_L("Cae: CCaeEngineImp::EnumerateVideoFrameSizeL() Camera EFormatYUV422 %d x %d Matched."), size.iWidth, size.iHeight ); + sizeIndex = j; + break; + } + } + } + else + { + LOGTEXT(_L("Cae: CCaeEngineImp::EnumerateVideoFrameSizeL() Camera doesn't support EFormatYUV422")); + } + + if ( sizeIndex == -1 ) + { + LOGTEXT(_L("Cae: CCaeEngineImp::EnumerateVideoFrameSizeL(), Camera does not support this resolution")); + } + + + LOGTEXT(_L("Cae: CCaeEngineImp::EnumerateVideoFrameSizeL(), Out")); + return ( sizeIndex ); + } + +// --------------------------------------------------------- +// CCaeEngineImp::SetAsyncVideoStopMode +// Enables/disables async stopping +// --------------------------------------------------------- +// +TInt CCaeEngineImp::SetAsyncVideoStopMode( TBool aAsyncVideoStopEnabled ) + { + LOGTEXT2( _L("Cae: CCaeEngineImp::SetAsyncVideoStop(%d) entering"), aAsyncVideoStopEnabled ); + TInt err; + + // Check if async stopping is supported + if ( iVideoControllerUid == KCamCControllerImplementationUid ) + { + iAsyncVideoStopEnabled = aAsyncVideoStopEnabled; + err = KErrNone; + } + else + { + err = KErrNotSupported; + } + + LOGTEXT2(_L("Cae: CCaeEngineImp::SetAsyncVideoStop() err=%d, returning"), err); + return ( err ); + } + + +// End of File