--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/videoeditorengine/vedengine/src/VedVideoClip.cpp Fri Jan 29 14:08:33 2010 +0200
@@ -0,0 +1,523 @@
+/*
+* 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 "VedVideoClip.h"
+#include "VedMovieImp.h"
+#include "VedVideoClipInfoGeneratedImp.h"
+#include "VedVideoClipInfoImp.h"
+#include "AudClip.h"
+#include "AudObservers.h"
+
+CVedVideoClip* CVedVideoClip::NewL(CVedMovieImp* aMovie, const TDesC& aFileName,
+ TInt aIndex, CAudClip* aAudioClip,
+ MVedVideoClipInfoObserver& aObserver)
+ {
+ CVedVideoClip* self = new (ELeave) CVedVideoClip(aMovie, aAudioClip);
+ CleanupStack::PushL(self);
+ self->ConstructL(aFileName, aIndex, aObserver);
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+
+CVedVideoClip* CVedVideoClip::NewL(CVedMovieImp* aMovie, CVedVideoClipGenerator& aGenerator,
+ TInt aIndex, MVedVideoClipInfoObserver& aObserver, TBool aIsOwnedByVideoClip)
+ {
+ CVedVideoClip* self = new (ELeave) CVedVideoClip(aMovie, NULL /*CAudClip*/);
+ CleanupStack::PushL(self);
+ self->ConstructL(aGenerator, aIndex, aObserver, aIsOwnedByVideoClip);
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+CVedVideoClip* CVedVideoClip::NewL(CVedMovieImp* aMovie, RFile* aFileHandle,
+ TInt aIndex, CAudClip* aAudioClip,
+ MVedVideoClipInfoObserver& aObserver)
+ {
+ CVedVideoClip* self = new (ELeave) CVedVideoClip(aMovie, aAudioClip);
+ CleanupStack::PushL(self);
+ self->ConstructL(aFileHandle, aIndex, aObserver);
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+
+CVedVideoClip::CVedVideoClip(CVedMovieImp* aMovie, CAudClip* aAudioClip)
+ : iMovie(aMovie), iSpeed(KVedNormalSpeed), iColorEffect(EVedColorEffectNone),
+ iCutInTime(0), iAudClip(aAudioClip)
+ {
+ }
+
+
+void CVedVideoClip::ConstructL(const TDesC& aFileName, TInt aIndex,
+ MVedVideoClipInfoObserver& aObserver)
+ {
+ __ASSERT_ALWAYS(aIndex >= 0,
+ TVedPanic::Panic(TVedPanic::EVideoClipIllegalIndex));
+ __ASSERT_ALWAYS(aIndex <= iMovie->VideoClipCount(),
+ TVedPanic::Panic(TVedPanic::EVideoClipIllegalIndex));
+ iIndex = aIndex;
+
+ if (iMovie->iFs) // lock file against writing
+ {
+
+ TInt error = iLockFile.Open(*iMovie->iFs, aFileName, EFileShareReadersOnly | EFileStream | EFileRead);
+
+ if (error != KErrNone)
+ {
+ User::LeaveIfError(iLockFile.Open(*iMovie->iFs, aFileName,
+ EFileShareAny | EFileStream | EFileRead));
+ }
+ iLockFileOpened = ETrue;
+ }
+
+ if (iAudClip)
+ {
+ iInfo = CVedVideoClipInfoImp::NewL(iAudClip->Info(), aFileName, aObserver);
+ }
+ else
+ {
+ iInfo = CVedVideoClipInfoImp::NewL(NULL, aFileName, aObserver);
+ }
+ }
+
+
+void CVedVideoClip::ConstructL(CVedVideoClipGenerator& aGenerator, TInt aIndex,
+ MVedVideoClipInfoObserver& aObserver, TBool aIsOwnedByVideoClip)
+ {
+ __ASSERT_ALWAYS(aIndex >= 0,
+ TVedPanic::Panic(TVedPanic::EVideoClipIllegalIndex));
+ __ASSERT_ALWAYS(aIndex <= iMovie->VideoClipCount(),
+ TVedPanic::Panic(TVedPanic::EVideoClipIllegalIndex));
+ iIndex = aIndex;
+
+ iInfo = new (ELeave) CVedVideoClipInfoGeneratedImp(aGenerator, aIsOwnedByVideoClip);
+ ((CVedVideoClipInfoGeneratedImp*) iInfo)->ConstructL(aObserver);
+ }
+
+
+void CVedVideoClip::ConstructL(RFile* aFileHandle, TInt aIndex,
+ MVedVideoClipInfoObserver& aObserver)
+ {
+ __ASSERT_ALWAYS(aIndex >= 0,
+ TVedPanic::Panic(TVedPanic::EVideoClipIllegalIndex));
+ __ASSERT_ALWAYS(aIndex <= iMovie->VideoClipCount(),
+ TVedPanic::Panic(TVedPanic::EVideoClipIllegalIndex));
+ iIndex = aIndex;
+
+ if (iAudClip)
+ {
+ iInfo = CVedVideoClipInfoImp::NewL(iAudClip->Info(), aFileHandle, aObserver);
+ }
+ else
+ {
+ iInfo = CVedVideoClipInfoImp::NewL(NULL, aFileHandle, aObserver);
+ }
+ }
+
+
+CVedVideoClip::~CVedVideoClip()
+ {
+ delete iInfo;
+
+ if (iLockFileOpened)
+ iLockFile.Close();
+
+ }
+
+
+void CVedVideoClip::SetIndex(TInt aIndex)
+ {
+ __ASSERT_ALWAYS(aIndex >= 0,
+ TVedPanic::Panic(TVedPanic::EVideoClipIllegalIndex));
+ __ASSERT_ALWAYS(aIndex < iMovie->VideoClipCount(),
+ TVedPanic::Panic(TVedPanic::EVideoClipIllegalIndex));
+
+ if (aIndex != iIndex)
+ {
+ TInt oldIndex = iIndex;
+ iIndex = aIndex;
+
+ iMovie->iVideoClipArray.Remove(oldIndex);
+ TInt err = iMovie->iVideoClipArray.Insert(this, iIndex);
+ __ASSERT_DEBUG(err == KErrNone,
+ TVedPanic::Panic(TVedPanic::EInternal));
+
+ if (oldIndex < iIndex)
+ {
+ CVedVideoClip* clip = iMovie->iVideoClipArray[oldIndex];
+ clip->iIndex = oldIndex;
+ iMovie->RecalculateVideoClipTimings(clip);
+ }
+ else
+ {
+ iMovie->RecalculateVideoClipTimings(this);
+ }
+
+ iMovie->FireVideoClipIndicesChanged(iMovie, oldIndex, iIndex);
+ }
+ }
+
+
+void CVedVideoClip::SetSpeed(TInt aSpeed)
+ {
+ __ASSERT_ALWAYS((aSpeed >= KVedMinSpeed) && (aSpeed <= KVedMaxSpeed),
+ TVedPanic::Panic(TVedPanic::EVideoClipIllegalSpeed));
+
+ if (aSpeed != KVedNormalSpeed )
+ {
+ // slow motion, mute the audio track
+ if (iAudClip)
+ {
+ iAudClip->SetMuting(ETrue);
+ iMovie->FireVideoClipAudioSettingsChanged(iMovie, this);
+ }
+ }
+ else
+ {
+ // normal speed
+ if ( !iUserMuted )
+ {
+ // unmute the audio track unless user has muted the clip
+ if (iAudClip)
+ {
+ iAudClip->SetMuting(EFalse);
+ iMovie->FireVideoClipAudioSettingsChanged(iMovie, this);
+ }
+ }
+ }
+
+ if (aSpeed != iSpeed)
+ {
+ iSpeed = aSpeed;
+ iMovie->RecalculateVideoClipTimings(this);
+ iMovie->FireVideoClipTimingsChanged(iMovie, this);
+ }
+ }
+
+
+void CVedVideoClip::SetColorEffect(TVedColorEffect aColorEffect)
+ {
+ __ASSERT_ALWAYS((aColorEffect >= EVedColorEffectNone)
+ && (aColorEffect < EVedColorEffectLast),
+ TVedPanic::Panic(TVedPanic::EVideoClipIllegalColorEffect));
+
+ if (aColorEffect != iColorEffect)
+ {
+ iColorEffect = aColorEffect;
+ iMovie->FireVideoClipColorEffectChanged(iMovie, this);
+ }
+ }
+
+TRgb CVedVideoClip::ColorTone() const
+ {
+ return iColorTone;
+ }
+
+void CVedVideoClip::SetColorTone(TRgb aColorTone)
+ {
+ if (aColorTone != iColorTone)
+ {
+ // any checks needed?
+ iColorTone = aColorTone;
+ // reuses the observer callback from color effect, since essentially it is about the same thing
+ iMovie->FireVideoClipColorEffectChanged(iMovie, this);
+ }
+ }
+
+void CVedVideoClip::SetMuted(TBool aMuted)
+ {
+ if (!iAudClip)
+ {
+ return;
+ }
+ iUserMuted = aMuted; // store the mute-value (true/false) to be able to differentiate user and automatic mute
+ iAudClip->SetMuting(aMuted);
+ iMovie->FireVideoClipAudioSettingsChanged(iMovie, this);
+ }
+
+TInt CVedVideoClip::InsertDynamicLevelMarkL(const TVedDynamicLevelMark& aMark)
+ {
+ __ASSERT_ALWAYS(aMark.iTime.Int64() >= 0,
+ TVedPanic::Panic(TVedPanic::EIllegalDynamicLevelMark));
+ __ASSERT_ALWAYS(aMark.iTime.Int64() <= CutOutTime().Int64(),
+ TVedPanic::Panic(TVedPanic::EIllegalDynamicLevelMark));
+
+ if ( iAudClip )
+ {
+ return iAudClip->InsertDynamicLevelMarkL(TAudDynamicLevelMark(aMark.iTime, aMark.iLevel));
+ }
+ else
+ {
+ User::Leave(KErrNotFound);
+ return -1;//to make compiler happy
+ }
+ }
+
+TBool CVedVideoClip::RemoveDynamicLevelMark(TInt aIndex)
+ {
+ __ASSERT_ALWAYS(aIndex >= 0,
+ TVedPanic::Panic(TVedPanic::EIllegalDynamicLevelMarkIndex));
+ __ASSERT_ALWAYS(aIndex < DynamicLevelMarkCount(),
+ TVedPanic::Panic(TVedPanic::EIllegalDynamicLevelMarkIndex));
+ if ( iAudClip )
+ {
+ return iAudClip->RemoveDynamicLevelMark(aIndex);
+ }
+ else
+ {
+ return EFalse;
+ }
+ }
+
+TVedDynamicLevelMark CVedVideoClip::DynamicLevelMark(TInt aIndex) const
+ {
+ __ASSERT_ALWAYS(aIndex >= 0,
+ TVedPanic::Panic(TVedPanic::EIllegalDynamicLevelMarkIndex));
+ __ASSERT_ALWAYS(aIndex < DynamicLevelMarkCount(),
+ TVedPanic::Panic(TVedPanic::EIllegalDynamicLevelMarkIndex));
+
+ if ( iAudClip )
+ {
+ TAudDynamicLevelMark mark = iAudClip->DynamicLevelMark(aIndex);
+ return TVedDynamicLevelMark(mark.iTime, mark.iLevel);
+ }
+ else
+ {
+ return TVedDynamicLevelMark(TTimeIntervalMicroSeconds(0), 0);
+ }
+ }
+
+TInt CVedVideoClip::DynamicLevelMarkCount() const
+ {
+ if ( iAudClip )
+ {
+ return iAudClip->DynamicLevelMarkCount();
+ }
+ else
+ {
+ return 0;
+ }
+ }
+
+void CVedVideoClip::SetVolumeGain(TInt aVolumeGain)
+ {
+ if ( iAudClip )
+ {
+ iAudClip->SetVolumeGain(aVolumeGain);
+ }
+ }
+
+TInt CVedVideoClip::GetVolumeGain()
+ {
+ if ( iAudClip )
+ {
+ return iAudClip->GetVolumeGain();
+ }
+ else
+ {
+ return 0;
+ }
+ }
+
+
+void CVedVideoClip::SetCutInTime(TTimeIntervalMicroSeconds aCutInTime)
+ {
+ __ASSERT_ALWAYS(aCutInTime >= TTimeIntervalMicroSeconds(0),
+ TVedPanic::Panic(TVedPanic::EVideoClipIllegalCutInTime));
+ __ASSERT_ALWAYS(aCutInTime <= iCutOutTime,
+ TVedPanic::Panic(TVedPanic::EVideoClipIllegalCutInTime));
+ __ASSERT_ALWAYS(iInfo->Class() == EVedVideoClipClassFile,
+ TVedPanic::Panic(TVedPanic::EVideoClipNoFileAssociated));
+
+ if (aCutInTime != iCutInTime)
+ {
+ iCutInTime = aCutInTime;
+ iMovie->RecalculateVideoClipTimings(this);
+ iMovie->FireVideoClipTimingsChanged(iMovie, this);
+ }
+ }
+
+
+void CVedVideoClip::SetCutOutTime(TTimeIntervalMicroSeconds aCutOutTime)
+ {
+ __ASSERT_ALWAYS(aCutOutTime >= iCutInTime,
+ TVedPanic::Panic(TVedPanic::EVideoClipIllegalCutOutTime));
+ __ASSERT_ALWAYS(iInfo->Class() == EVedVideoClipClassFile,
+ TVedPanic::Panic(TVedPanic::EVideoClipNoFileAssociated));
+
+ if ( aCutOutTime > iInfo->Duration() )
+ {
+ aCutOutTime = iInfo->Duration();
+ }
+
+ if (aCutOutTime != iCutOutTime)
+ {
+ iCutOutTime = aCutOutTime;
+ iMovie->RecalculateVideoClipTimings(this);
+ iMovie->FireVideoClipTimingsChanged(iMovie, this);
+ }
+ }
+
+void CVedVideoClip::UpdateAudioClip()
+ {
+ if (!iAudClip)
+ {
+ return;
+ }
+ iAudClip->SetStartTime(iStartTime);
+ iAudClip->SetCutInTime(iCutInTime);
+ iAudClip->SetCutOutTime(iCutOutTime);
+ }
+
+
+
+CVedVideoClipInfo* CVedVideoClip::Info()
+ {
+ return iInfo;
+ }
+
+
+TBool CVedVideoClip::EditedHasAudio() const
+ {
+ TInt speed = Speed();
+ TBool isMuted = IsMuted();
+ TBool hasAudio = iInfo->HasAudio();
+ TBool ret = hasAudio && (speed == KVedNormalSpeed);
+ ret = ret && !isMuted;
+ return ret;
+ }
+
+
+CVedMovieImp* CVedVideoClip::Movie()
+ {
+ return iMovie;
+ }
+
+
+TInt CVedVideoClip::Index() const
+ {
+ return iIndex;
+ }
+
+
+TInt CVedVideoClip::Speed() const
+ {
+ return iSpeed;
+ }
+
+
+TVedColorEffect CVedVideoClip::ColorEffect() const
+ {
+ return iColorEffect;
+ }
+
+
+TBool CVedVideoClip::IsMuteable() const
+ {
+ return (iInfo->HasAudio() && (Speed() == KVedNormalSpeed));
+ }
+
+
+TBool CVedVideoClip::Muting() const
+ {
+ if (!iAudClip)
+ {
+ return ETrue;
+ }
+ return iAudClip->Muting();
+ }
+
+TBool CVedVideoClip::IsMuted() const
+ {
+ if (!iAudClip)
+ {
+ return ETrue;
+ }
+ if ( iUserMuted )
+ {
+ return ETrue;
+ }
+ else
+ {
+ // automatic mute due to slow motion is not informed to client as muted
+ // since it can cause some conflicts
+ return EFalse;
+ }
+ }
+
+void CVedVideoClip::SetNormalizing(TBool aNormalizing)
+ {
+ if (iAudClip)
+ {
+ iAudClip->SetNormalizing(aNormalizing);
+ }
+ }
+
+TBool CVedVideoClip::Normalizing() const
+ {
+ return (iAudClip && iAudClip->Normalizing());
+ }
+
+TTimeIntervalMicroSeconds CVedVideoClip::CutInTime() const
+ {
+ if (iInfo->Class() == EVedVideoClipClassFile)
+ {
+ return iCutInTime;
+ }
+ else
+ {
+ return TTimeIntervalMicroSeconds(0);
+ }
+ }
+
+
+TTimeIntervalMicroSeconds CVedVideoClip::CutOutTime() const
+ {
+ if (iInfo->Class() == EVedVideoClipClassFile)
+ {
+ return iCutOutTime;
+ }
+ else
+ {
+ return iInfo->Duration();
+ }
+ }
+
+
+TTimeIntervalMicroSeconds CVedVideoClip::StartTime() const
+ {
+ return iStartTime;
+ }
+
+
+TTimeIntervalMicroSeconds CVedVideoClip::EndTime() const
+ {
+ return TTimeIntervalMicroSeconds(iStartTime.Int64() + EditedDuration().Int64());
+ }
+
+
+TTimeIntervalMicroSeconds CVedVideoClip::EditedDuration() const
+ {
+ TInt64 editedDuration = CutOutTime().Int64() - CutInTime().Int64();
+ return TTimeIntervalMicroSeconds((TInt64(1000) * editedDuration) / TInt64(Speed()));
+ }
+