--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/videoeditorengine/vedengine/src/VedVideoClipInfoImp.cpp Fri Jan 29 14:08:33 2010 +0200
@@ -0,0 +1,911 @@
+/*
+* Copyright (c) 2010 Ixonos Plc.
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the "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:
+* Ixonos Plc
+*
+* Description:
+*
+*/
+
+
+
+
+#include "VedVideoClipInfoImp.h"
+#include "movieprocessor.h"
+#include <fbs.h>
+#include <ecom/ecom.h>
+#include "audclipinfo.h"
+#include "audcommon.h"
+#include "VedVideoClip.h"
+
+// Print macro
+#ifdef _DEBUG
+#include <e32svr.h>
+#define PRINT(x) RDebug::Print x
+#else
+#define PRINT(x)
+#endif
+
+
+EXPORT_C CVedVideoClipInfo* CVedVideoClipInfo::NewL(const TDesC& aFileName,
+ MVedVideoClipInfoObserver& aObserver)
+ {
+ PRINT(_L("CVedVideoClipInfo::NewL"));
+
+ CVedVideoClipInfoImp* self = (CVedVideoClipInfoImp*)NewLC(aFileName, aObserver);
+ self->iVideoClipIsStandalone = ETrue;
+ CleanupStack::Pop(self);
+ PRINT(_L("CVedVideoClipInfo::NewL out"));
+ return self;
+ }
+
+EXPORT_C CVedVideoClipInfo* CVedVideoClipInfo::NewLC(const TDesC& aFileName,
+ MVedVideoClipInfoObserver& aObserver)
+ {
+ PRINT(_L("CVedVideoClipInfo::NewLC in"));
+
+ CVedVideoClipInfoImp* self = new (ELeave) CVedVideoClipInfoImp(NULL);
+ CleanupStack::PushL(self);
+ self->ConstructL(aFileName, aObserver);
+
+ PRINT(_L("CVedVideoClipInfo::NewLC out"));
+ return self;
+ }
+
+EXPORT_C CVedVideoClipInfo* CVedVideoClipInfo::NewL(RFile* aFileHandle,
+ MVedVideoClipInfoObserver& aObserver)
+ {
+ PRINT(_L("CVedVideoClipInfo::NewL"));
+
+ CVedVideoClipInfoImp* self = (CVedVideoClipInfoImp*)NewLC(aFileHandle, aObserver);
+ self->iVideoClipIsStandalone = ETrue;
+ CleanupStack::Pop(self);
+ PRINT(_L("CVedVideoClipInfo::NewL out"));
+ return self;
+ }
+
+EXPORT_C CVedVideoClipInfo* CVedVideoClipInfo::NewLC(RFile* aFileHandle,
+ MVedVideoClipInfoObserver& aObserver)
+ {
+ PRINT(_L("CVedVideoClipInfo::NewLC in"));
+
+ CVedVideoClipInfoImp* self = new (ELeave) CVedVideoClipInfoImp(NULL);
+ CleanupStack::PushL(self);
+ self->ConstructL(aFileHandle, aObserver);
+
+ PRINT(_L("CVedVideoClipInfo::NewLC out"));
+ return self;
+ }
+
+
+CVedVideoClipInfo* CVedVideoClipInfoImp::NewL(CAudClipInfo* aAudClipInfo,
+ const TDesC& aFileName, MVedVideoClipInfoObserver& aObserver)
+ {
+ CVedVideoClipInfoImp* self = new (ELeave) CVedVideoClipInfoImp(aAudClipInfo);
+ CleanupStack::PushL(self);
+ if (aAudClipInfo)
+ {
+ self->ConstructL(aAudClipInfo->FileName(), aObserver);
+ }
+ else
+ {
+ self->ConstructL(aFileName, aObserver);
+ }
+ self->iVideoClipIsStandalone = EFalse;
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+CVedVideoClipInfo* CVedVideoClipInfoImp::NewL(CAudClipInfo* aAudClipInfo,
+ RFile* aFileHandle, MVedVideoClipInfoObserver& aObserver)
+ {
+ CVedVideoClipInfoImp* self = new (ELeave) CVedVideoClipInfoImp(aAudClipInfo);
+ CleanupStack::PushL(self);
+ if (aAudClipInfo)
+ {
+ self->ConstructL(aAudClipInfo->FileHandle(), aObserver);
+ }
+ else
+ {
+ self->ConstructL(aFileHandle, aObserver);
+ }
+ self->iVideoClipIsStandalone = EFalse;
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+
+CVedVideoClipInfoImp::CVedVideoClipInfoImp(CAudClipInfo* aAudClipInfo)
+ : iReady(EFalse), iAudClipInfoOwnedByVideoClipInfo(EFalse), iAudClipInfo(aAudClipInfo)
+ {
+ }
+
+
+void CVedVideoClipInfoImp::ConstructL(const TDesC& aFileName,
+ MVedVideoClipInfoObserver& aObserver)
+ {
+ PRINT(_L("CVedVideoClipInfo::ConstructL in"));
+
+ iFileName = HBufC::NewL(aFileName.Length());
+ *iFileName = aFileName;
+
+ iFrameOperation = CVedVideoClipFrameOperation::NewL(this);
+
+ iInfoOperation = CVedVideoClipInfoOperation::NewL(this, aObserver);
+
+ PRINT(_L("CVedVideoClipInfo::ConstructL out"));
+ }
+
+void CVedVideoClipInfoImp::ConstructL(RFile* aFileHandle,
+ MVedVideoClipInfoObserver& aObserver)
+ {
+ PRINT(_L("CVedVideoClipInfo::ConstructL in"));
+
+ iFileName = HBufC::NewL(1);
+ iFileHandle = aFileHandle;
+
+ iFrameOperation = CVedVideoClipFrameOperation::NewL(this);
+
+ iInfoOperation = CVedVideoClipInfoOperation::NewL(this, aObserver);
+
+ PRINT(_L("CVedVideoClipInfo::ConstructL out"));
+ }
+
+
+CVedVideoClipInfoImp::~CVedVideoClipInfoImp()
+ {
+ PRINT(_L("CVedVideoClipInfo::~CVedVideoClipInfoImp in"));
+
+ delete iInfoOperation;
+ delete iFrameOperation;
+
+ User::Free(iVideoFrameInfoArray);
+ delete iFileName;
+
+ REComSession::FinalClose();
+
+ if (iAudClipInfoOwnedByVideoClipInfo)
+ {
+ delete iAudClipInfo;
+ }
+
+ PRINT(_L("CVedVideoClipInfo::~CVedVideoClipInfoImp out"));
+ }
+
+
+TPtrC CVedVideoClipInfoImp::DescriptiveName() const
+ {
+ return *iFileName;
+ }
+
+CVedVideoClipGenerator* CVedVideoClipInfoImp::Generator() const
+ {
+ // Always panic
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoNoGeneratorAssociated);
+
+ // This will never be reached.
+ return NULL;
+ }
+
+
+TVedVideoClipClass CVedVideoClipInfoImp::Class() const
+ {
+ return EVedVideoClipClassFile;
+ }
+
+
+TInt CVedVideoClipInfoImp::GenerateVideoFrameInfoArrayL()
+ {
+ PRINT(_L("CVedVideoClipInfoImp::GenerateVideoFrameInfoArrayL in"));
+
+ __ASSERT_ALWAYS(iReady,
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));
+
+ TInt error = KErrNone;
+
+ if ( !iVideoFrameInfoArrayReady )
+ {
+ CMovieProcessor* processor = CMovieProcessor::NewL();
+ CleanupStack::PushL(processor);
+ TRAP( error, processor->GenerateVideoFrameInfoArrayL(*iFileName, iFileHandle, iVideoFrameInfoArray));
+ CleanupStack::PopAndDestroy(processor);
+
+ if ( (error == KErrNone) && iVideoFrameInfoArray )
+ {
+ iVideoFrameInfoArrayReady = ETrue;
+ }
+ else
+ {
+ PRINT((_L("CVedVideoClipInfoImp::GenerateVideoFrameInfoArrayL Error=%d"), error));
+ }
+ }
+
+ PRINT(_L("CVedVideoClipInfoImp::GenerateVideoFrameInfoArrayL out"));
+ return error;
+ }
+
+
+TInt CVedVideoClipInfoImp::GetVideoFrameIndexL(TTimeIntervalMicroSeconds aTime)
+ {
+ PRINT(_L("CVedVideoClipInfoImp::GetVideoFrameIndex in"));
+
+ __ASSERT_ALWAYS(iReady,
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));
+ __ASSERT_ALWAYS((aTime >= TTimeIntervalMicroSeconds(0)) && (aTime <= Duration()),
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoIllegalVideoFrameTime));
+
+ /* Use binary search to find the right frame. */
+
+ TInt start = 0;
+ TInt end = iVideoFrameCount - 1;
+ TInt index = -1;
+ TBool always = ETrue;
+
+ while( always )
+ {
+ index = start + ((end - start) / 2);
+
+ TTimeIntervalMicroSeconds startTime = VideoFrameStartTimeL(index);
+ TTimeIntervalMicroSeconds endTime = VideoFrameEndTimeL(index);
+ if (index < (VideoFrameCount() - 1))
+ {
+ endTime = TTimeIntervalMicroSeconds(endTime.Int64() - 1);
+ }
+
+ if (aTime < startTime)
+ {
+ end = index - 1;
+ }
+ else if (aTime > endTime)
+ {
+ start = index + 1;
+ }
+ else
+ {
+ always = EFalse;
+ }
+ }
+
+ PRINT(_L("CVedVideoClipInfoImp::GetVideoFrameIndex out"));
+ return index;
+ }
+
+
+void CVedVideoClipInfoImp::GetFrameL(MVedVideoClipFrameObserver& aObserver,
+ TInt aIndex,
+ TSize* const aResolution,
+ TDisplayMode aDisplayMode,
+ TBool aEnhance,
+ TInt aPriority)
+ {
+ PRINT(_L("CVedVideoClipInfoImp::GetFrameL in"));
+
+ __ASSERT_ALWAYS(iReady,
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));
+
+ iFrameOperation->StartL(aObserver, aIndex, aResolution, aDisplayMode, aEnhance, aPriority);
+
+ PRINT(_L("CVedVideoClipInfoImp::GetFrameL out"));
+ }
+
+
+void CVedVideoClipInfoImp::CancelFrame()
+ {
+ PRINT(_L("CVedVideoClipInfoImp::CancelFrame in"));
+
+ if ( !iReady )
+ {
+ PRINT(_L("CVedVideoClipInfoImp::CancelFrame not even info ready yet, cancel it and get out"));
+ iInfoOperation->Cancel();
+ return;
+ }
+
+ iFrameOperation->Cancel();
+
+ PRINT(_L("CVedVideoClipInfoImp::CancelFrame out"));
+ }
+
+
+
+
+TPtrC CVedVideoClipInfoImp::FileName() const
+ {
+ __ASSERT_ALWAYS(iReady,
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));
+
+ return *iFileName;
+ }
+
+RFile* CVedVideoClipInfoImp::FileHandle() const
+ {
+ __ASSERT_ALWAYS(iReady,
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));
+
+ return iFileHandle;
+ }
+
+
+TVedVideoFormat CVedVideoClipInfoImp::Format() const
+ {
+ __ASSERT_ALWAYS(iReady,
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));
+
+ return iFormat;
+ }
+
+
+TVedVideoType CVedVideoClipInfoImp::VideoType() const
+ {
+ __ASSERT_ALWAYS(iReady,
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));
+
+ return iVideoType;
+ }
+
+
+TSize CVedVideoClipInfoImp::Resolution() const
+ {
+ __ASSERT_ALWAYS(iReady,
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));
+
+ return iResolution;
+ }
+
+
+TBool CVedVideoClipInfoImp::HasAudio() const
+ {
+
+ if (!iReady)
+ {
+ if (iVideoClipIsStandalone)
+ return EFalse;
+ }
+
+ if (iAudClipInfo == 0)
+ {
+ return EFalse;
+ }
+ return ((iAudClipInfo->Properties().iAudioType != EAudTypeUnrecognized)
+ && (iAudClipInfo->Properties().iAudioType != EAudNoAudio));
+ }
+
+
+TVedAudioType CVedVideoClipInfoImp::AudioType() const
+ {
+ __ASSERT_ALWAYS(iReady,
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));
+
+ if (iAudClipInfo == 0)
+ {
+ return EVedAudioTypeNoAudio;
+ }
+
+ TVedAudioType vedAudioType = EVedAudioTypeUnrecognized;
+ if (iAudClipInfo->Properties().iAudioType == EAudAMR)
+ {
+ vedAudioType = EVedAudioTypeAMR;
+ }
+ else if (iAudClipInfo->Properties().iAudioType == EAudAMRWB)
+ {
+ vedAudioType = EVedAudioTypeAMRWB;
+ }
+ else if (iAudClipInfo->Properties().iAudioType == EAudMP3)
+ {
+ vedAudioType = EVedAudioTypeMP3;
+ }
+ else if (iAudClipInfo->Properties().iAudioType == EAudAAC_MPEG4 )
+ {
+ vedAudioType = EVedAudioTypeAAC_LC;
+ }
+ else if (iAudClipInfo->Properties().iAudioType == EAudWAV)
+ {
+ vedAudioType = EVedAudioTypeWAV;
+ }
+ else if (iAudClipInfo->Properties().iAudioType == EAudNoAudio)
+ {
+ vedAudioType = EVedAudioTypeNoAudio;
+ }
+
+ return vedAudioType;
+ }
+
+TVedAudioChannelMode CVedVideoClipInfoImp::AudioChannelMode() const
+ {
+ __ASSERT_ALWAYS(iReady,
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));
+
+ if (iAudClipInfo == 0)
+ {
+ return EVedAudioChannelModeUnrecognized;
+ }
+
+ TVedAudioChannelMode vedChannelMode = EVedAudioChannelModeUnrecognized;
+ if (iAudClipInfo->Properties().iChannelMode == EAudStereo)
+ {
+ vedChannelMode = EVedAudioChannelModeStereo;
+ }
+ else if (iAudClipInfo->Properties().iChannelMode == EAudSingleChannel)
+ {
+ vedChannelMode = EVedAudioChannelModeSingleChannel;
+ }
+ else if (iAudClipInfo->Properties().iChannelMode == EAudDualChannel)
+ {
+ vedChannelMode = EVedAudioChannelModeDualChannel;
+ }
+
+ return vedChannelMode;
+ }
+
+TInt CVedVideoClipInfoImp::AudioSamplingRate() const
+ {
+ __ASSERT_ALWAYS(iReady,
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));
+
+ if (iAudClipInfo == 0)
+ {
+ return 0;
+ }
+
+ return iAudClipInfo->Properties().iSamplingRate;
+ }
+
+
+TTimeIntervalMicroSeconds CVedVideoClipInfoImp::Duration() const
+ {
+ __ASSERT_ALWAYS(iReady,
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));
+
+ return iDuration;
+ }
+
+
+TInt CVedVideoClipInfoImp::VideoFrameCount() const
+ {
+ __ASSERT_ALWAYS(iReady,
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));
+
+ return iVideoFrameCount;
+ }
+
+
+TTimeIntervalMicroSeconds CVedVideoClipInfoImp::VideoFrameStartTimeL(TInt aIndex)
+ {
+ __ASSERT_ALWAYS(iReady,
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));
+ __ASSERT_ALWAYS(((aIndex >= 0) && (aIndex < iVideoFrameCount)),
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoIllegalVideoFrameIndex));
+
+ if ( !iVideoFrameInfoArrayReady )
+ {
+ User::LeaveIfError(GenerateVideoFrameInfoArrayL());
+ }
+
+ TInt64 startTime = TInt64(iVideoFrameInfoArray[aIndex].iStartTime) * TInt64(1000);
+ return TTimeIntervalMicroSeconds(startTime);
+ }
+
+
+TTimeIntervalMicroSeconds CVedVideoClipInfoImp::VideoFrameEndTimeL(TInt aIndex)
+ {
+ __ASSERT_ALWAYS(iReady,
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));
+ __ASSERT_ALWAYS(((aIndex >= 0) && (aIndex < iVideoFrameCount)),
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoIllegalVideoFrameIndex));
+
+ if ( !iVideoFrameInfoArrayReady )
+ {
+ User::LeaveIfError(GenerateVideoFrameInfoArrayL());
+ }
+
+ if (aIndex < (iVideoFrameCount - 1))
+ {
+ return (TInt64(iVideoFrameInfoArray[aIndex + 1].iStartTime) * TInt64(1000));
+ }
+ else
+ {
+ return iDuration;
+ }
+ }
+
+
+TTimeIntervalMicroSeconds CVedVideoClipInfoImp::VideoFrameDurationL(TInt aIndex)
+ {
+ __ASSERT_ALWAYS(iReady,
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));
+ __ASSERT_ALWAYS(((aIndex >= 0) && (aIndex < iVideoFrameCount)),
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoIllegalVideoFrameIndex));
+
+ if ( !iVideoFrameInfoArrayReady )
+ {
+ User::LeaveIfError(GenerateVideoFrameInfoArrayL());
+ }
+
+
+ TInt64 duration = - (TInt64(iVideoFrameInfoArray[aIndex].iStartTime) * TInt64(1000));
+ if (aIndex < (iVideoFrameCount - 1))
+ {
+ duration += TInt64(iVideoFrameInfoArray[aIndex + 1].iStartTime) * TInt64(1000);
+ }
+ else
+ {
+ duration += iDuration.Int64();
+ }
+
+ return TTimeIntervalMicroSeconds(duration);
+ }
+
+
+TInt CVedVideoClipInfoImp::VideoFrameSizeL(TInt aIndex)
+ {
+ __ASSERT_ALWAYS(iReady,
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));
+ __ASSERT_ALWAYS(((aIndex >= 0) && (aIndex < iVideoFrameCount)),
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoIllegalVideoFrameIndex));
+
+ if ( !iVideoFrameInfoArrayReady )
+ {
+ User::LeaveIfError(GenerateVideoFrameInfoArrayL());
+ }
+
+
+ return iVideoFrameInfoArray[aIndex].iSize;
+ }
+
+
+TBool CVedVideoClipInfoImp::VideoFrameIsIntraL(TInt aIndex)
+ {
+ __ASSERT_ALWAYS(iReady,
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));
+ __ASSERT_ALWAYS(((aIndex >= 0) && (aIndex < iVideoFrameCount)),
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoIllegalVideoFrameIndex));
+
+ if ( !iVideoFrameInfoArrayReady )
+ {
+ User::LeaveIfError(GenerateVideoFrameInfoArrayL());
+ }
+
+ if (iVideoFrameInfoArray[aIndex].iFlags & KVedVideoFrameInfoFlagIntra)
+ {
+ return ETrue;
+ }
+ else
+ {
+ return EFalse;
+ }
+ }
+
+void CVedVideoClipInfoImp::SetTranscodeFactor(TVedTranscodeFactor aFactor)
+ {
+ iTimeFactor.iStreamType = aFactor.iStreamType;
+ iTimeFactor.iTRes = aFactor.iTRes;
+ }
+
+TVedTranscodeFactor CVedVideoClipInfoImp::TranscodeFactor()
+ {
+ return iTimeFactor;
+ }
+
+TBool CVedVideoClipInfoImp::IsMMSCompatible()
+ {
+ __ASSERT_ALWAYS(iReady,
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));
+
+ TAudType audioType;
+ if (iAudClipInfo == 0)
+ {
+ audioType = EAudNoAudio;
+ }
+ else
+ {
+ audioType = iAudClipInfo->Properties().iAudioType;
+ }
+
+ return ( ( iFormat == EVedVideoFormat3GPP ) &&
+ ( iVideoType == EVedVideoTypeH263Profile0Level10 ) &&
+ ( audioType == EAudAMR ) );
+ }
+
+
+CVedVideoClipInfoOperation* CVedVideoClipInfoOperation::NewL(CVedVideoClipInfoImp* aInfo,
+ MVedVideoClipInfoObserver& aObserver)
+ {
+ PRINT(_L("CVedVideoClipInfoOperation::NewL in"));
+
+ CVedVideoClipInfoOperation* self =
+ new (ELeave) CVedVideoClipInfoOperation(aInfo, aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+
+ PRINT(_L("CVedVideoClipInfoOperation::NewL out"));
+ return self;
+ }
+
+
+CVedVideoClipInfoOperation::CVedVideoClipInfoOperation(CVedVideoClipInfoImp* aInfo,
+ MVedVideoClipInfoObserver& aObserver)
+ : CActive(EPriorityStandard), iInfo(aInfo), iMovieProcessorError(KErrNone)
+ {
+ PRINT(_L("CVedVideoClipInfoOperation::CVedVideoClipInfoOperation in"));
+
+ iObserver = &aObserver;
+ CActiveScheduler::Add(this);
+
+ PRINT(_L("CVedVideoClipInfoOperation::CVedVideoClipInfoOperation out"));
+ }
+
+
+void CVedVideoClipInfoOperation::ConstructL()
+ {
+ PRINT(_L("CVedVideoClipInfoOperation::ConstructL in"));
+
+ iGettingAudio = EFalse;
+
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete(status, KErrNone);
+
+ PRINT(_L("CVedVideoClipInfoOperation::ConstructL out"));
+ }
+
+
+CVedVideoClipInfoOperation::~CVedVideoClipInfoOperation()
+ {
+ Cancel();
+ }
+
+
+void CVedVideoClipInfoOperation::RunL()
+ {
+ PRINT(_L("CVedVideoClipInfoOperation::RunL in"));
+
+ if (iGettingAudio)
+ {
+ if (iMovieProcessorError == KErrNone || iMovieProcessorError == KErrNoAudio)
+ {
+ iInfo->iReady = ETrue;
+ iMovieProcessorError = KErrNone;
+ }
+ iObserver->NotifyVideoClipInfoReady(*iInfo, iMovieProcessorError);
+ }
+ else
+ {
+ CMovieProcessor* processor = CMovieProcessor::NewL();
+ TVedAudioType audioType = EVedAudioTypeUnrecognized;
+ TVedAudioChannelMode audioChannelMode = EVedAudioChannelModeUnrecognized;
+ TInt audioSamplingRate;
+ TRAP(iMovieProcessorError,
+ processor->GetVideoClipPropertiesL(*iInfo->iFileName,
+ iInfo->iFileHandle,
+ iInfo->iFormat,
+ iInfo->iVideoType,
+ iInfo->iResolution,
+ audioType,
+ iInfo->iDuration,
+ iInfo->iVideoFrameCount,
+ audioSamplingRate,
+ audioChannelMode));
+ delete processor;
+ processor = 0;
+
+ if (iMovieProcessorError != KErrNone)
+ {
+ iObserver->NotifyVideoClipInfoReady(*iInfo, iMovieProcessorError);
+ }
+ else if (iInfo->iAudClipInfo || !iInfo->iVideoClipIsStandalone)
+ {
+ if (iMovieProcessorError == KErrNone)
+ {
+ iInfo->iReady = ETrue;
+ }
+ iObserver->NotifyVideoClipInfoReady(*iInfo, iMovieProcessorError);
+ }
+ else
+ {
+
+ if (iInfo->iFileHandle)
+ iInfo->iAudClipInfo = CAudClipInfo::NewL(iInfo->iFileHandle, *this);
+ else
+ iInfo->iAudClipInfo = CAudClipInfo::NewL(*iInfo->iFileName, *this);
+
+ iInfo->iAudClipInfoOwnedByVideoClipInfo = ETrue;
+ iGettingAudio = ETrue;
+ }
+ }
+ PRINT(_L("CVedVideoClipInfoOperation::RunL out"));
+ }
+
+void CVedVideoClipInfoOperation::NotifyClipInfoReady(CAudClipInfo& /*aInfo*/, TInt aError)
+ {
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete(status, KErrNone);
+
+ iMovieProcessorError = aError;
+ }
+
+void CVedVideoClipInfoOperation::DoCancel()
+ {
+ }
+
+
+CVedVideoClipFrameOperation* CVedVideoClipFrameOperation::NewL(CVedVideoClipInfoImp* aInfo)
+ {
+ PRINT(_L("CVedVideoClipFrameOperation::NewL in"));
+
+ CVedVideoClipFrameOperation* self =
+ new (ELeave) CVedVideoClipFrameOperation(aInfo);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+
+ PRINT(_L("CVedVideoClipFrameOperation::NewL out"));
+ return self;
+ }
+
+
+CVedVideoClipFrameOperation::CVedVideoClipFrameOperation(CVedVideoClipInfoImp* aInfo)
+ : CActive(EPriorityIdle), iInfo(aInfo)
+ {
+ PRINT(_L("CVedVideoClipFrameOperation::CVedVideoClipFrameOperation in"));
+ CActiveScheduler::Add(this);
+ PRINT(_L("CVedVideoClipFrameOperation::CVedVideoClipFrameOperation out"));
+ }
+
+
+void CVedVideoClipFrameOperation::ConstructL()
+ {
+ }
+
+
+CVedVideoClipFrameOperation::~CVedVideoClipFrameOperation()
+ {
+ Cancel();
+ }
+
+
+void CVedVideoClipFrameOperation::StartL(MVedVideoClipFrameObserver& aObserver,
+ TInt aIndex,
+ TSize* const aResolution,
+ TDisplayMode aDisplayMode,
+ TBool aEnhance,
+ TInt aPriority)
+ {
+ PRINT(_L("CVedVideoClipFrameOperation::StartL in"));
+
+ __ASSERT_ALWAYS(!IsActive(),
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoFrameOperationAlreadyRunning));
+ __ASSERT_DEBUG(iProcessor == 0, TVedPanic::Panic(TVedPanic::EInternal));
+
+ TSize resolution;
+ if (aResolution != 0)
+ {
+ __ASSERT_ALWAYS(aResolution->iWidth > 0,
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoIllegalFrameResolution));
+ __ASSERT_ALWAYS(aResolution->iHeight > 0,
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoIllegalFrameResolution));
+
+ resolution = *aResolution;
+ }
+ else
+ {
+ resolution = iInfo->Resolution();
+ }
+
+ __ASSERT_ALWAYS(((aIndex >= 0) && (iInfo->VideoFrameCount() == 0) ||
+ (aIndex < iInfo->VideoFrameCount()) ||
+ (aIndex == KFrameIndexBestThumb) ),
+ TVedPanic::Panic(TVedPanic::EVideoClipInfoIllegalVideoFrameIndex));
+
+ iIndex = aIndex;
+
+ iFactor.iStreamType = EVedVideoBitstreamModeUnknown;
+ iFactor.iTRes = 0;
+
+ CMovieProcessor* processor = CMovieProcessor::NewLC();
+
+ processor->StartThumbL(iInfo->FileName(), iInfo->FileHandle(), aIndex, resolution, aDisplayMode,
+ aEnhance);
+
+ /* Initialization OK. This method cannot leave any more. Start processing. */
+
+ CleanupStack::Pop(processor);
+
+ iProcessor = processor;
+ iObserver = &aObserver;
+
+ SetPriority(aPriority);
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete(status, KErrNone);
+
+ PRINT(_L("CVedVideoClipFrameOperation::StartL out"));
+ }
+
+
+void CVedVideoClipFrameOperation::RunL()
+ {
+ PRINT(_L("CVedVideoClipFrameOperation::RunL in"));
+
+ __ASSERT_DEBUG(iProcessor != 0, TVedPanic::Panic(TVedPanic::EInternal));
+ __ASSERT_DEBUG(iObserver != 0, TVedPanic::Panic(TVedPanic::EInternal));
+
+ TInt err = KErrNone;
+
+ if (!iThumbRequestPending)
+ TRAP(err, iProcessor->ProcessThumbL(iStatus, &iFactor));
+
+ if (err != KErrNone)
+ {
+ delete iProcessor;
+ iProcessor = 0;
+
+ MVedVideoClipFrameObserver* observer = iObserver;
+ iObserver = 0;
+ observer->NotifyVideoClipFrameCompleted(*iInfo, err, NULL);
+ return;
+ }
+
+ if (!iThumbRequestPending)
+ {
+ iInfo->SetTranscodeFactor(iFactor);
+ iThumbRequestPending = ETrue;
+ iStatus = KRequestPending;
+ SetActive();
+ return;
+ }
+ else
+ {
+ MVedVideoClipFrameObserver* observer = iObserver;
+ iObserver = 0;
+
+ if (iStatus == KErrNone)
+ {
+ CFbsBitmap* frame = 0;
+ iProcessor->FetchThumb(frame);
+ observer->NotifyVideoClipFrameCompleted(*iInfo, KErrNone, frame);
+ }
+ else
+ {
+ observer->NotifyVideoClipFrameCompleted(*iInfo, iStatus.Int(), NULL);
+ }
+ iThumbRequestPending = EFalse;
+ delete iProcessor;
+ iProcessor = 0;
+ }
+
+ PRINT(_L("CVedVideoClipFrameOperation::RunL out"));
+ }
+
+
+void CVedVideoClipFrameOperation::DoCancel()
+ {
+ if (iProcessor != 0)
+ {
+ delete iProcessor;
+ iProcessor = 0;
+
+ // Cancel our internal request
+ if ( iStatus == KRequestPending )
+ {
+ PRINT((_L("CVedVideoClipFrameOperation::DoCancel() cancel request")));
+ TRequestStatus *status = &iStatus;
+ User::RequestComplete(status, KErrCancel);
+ }
+ iThumbRequestPending = EFalse;
+
+ MVedVideoClipFrameObserver* observer = iObserver;
+ iObserver = 0;
+ observer->NotifyVideoClipFrameCompleted(*iInfo, KErrCancel, NULL);
+ }
+ }
+