/*

* 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()));

    }