/*

* 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 "VedVideoClipInfoGeneratedImp.h"

#include "VedMovieImp.h"

#include "VedVideoClip.h"

#include "VedVideoClipGenerator.h"

#include <fbs.h>

// Print macro

#ifdef _DEBUG

#include <e32svr.h>

#define PRINT(x) RDebug::Print x

#else

#define PRINT(x)

#endif

CVedVideoClipInfoGeneratedImp::CVedVideoClipInfoGeneratedImp(CVedVideoClipGenerator& aGenerator, TBool aOwnsGenerator)

        : iGenerator(&aGenerator), iOwnsGenerator(aOwnsGenerator)

    {

    }

void CVedVideoClipInfoGeneratedImp::ConstructL(MVedVideoClipInfoObserver& aObserver)

    {

    PRINT(_L("CVedVideoClipInfoGeneratedImp::ConstructL in"));

    iInfoOperation = CVedVideoClipInfoGeneratedOperation::NewL(this, aObserver);

    iAdapter = new (ELeave) CVedVideoClipGeneratedFrameToFrameAdapter(*this);

    PRINT(_L("CVedVideoClipInfoGeneratedImp::ConstructL out"));

    }

CVedVideoClipInfoGeneratedImp::~CVedVideoClipInfoGeneratedImp()

    {

    PRINT(_L("CVedVideoClipInfoGeneratedImp::~CVedVideoClipInfoGeneratedImp in"));

    if ( iGenerator )

        {

        if ( (TInt)iOwnsGenerator == (TInt)ETrue )

            {

            delete iGenerator;

            }

        iGenerator = 0;

        }

    delete iInfoOperation;

    delete iAdapter;

    PRINT(_L("CVedVideoClipInfoGeneratedImp::~CVedVideoClipInfoGeneratedImp out"));

    }

TPtrC CVedVideoClipInfoGeneratedImp::DescriptiveName() const 

    {

    __ASSERT_ALWAYS(iReady, 

                    TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));

    return iGenerator->DescriptiveName();

    }

CVedVideoClipGenerator* CVedVideoClipInfoGeneratedImp::Generator() const

    {

    __ASSERT_ALWAYS(iReady, 

                    TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));

    return iGenerator;

    }

TVedVideoClipClass CVedVideoClipInfoGeneratedImp::Class() const 

    {

    __ASSERT_ALWAYS(iReady, 

                    TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));

    return EVedVideoClipClassGenerated;

    }

TInt CVedVideoClipInfoGeneratedImp::GetVideoFrameIndexL(TTimeIntervalMicroSeconds aTime)

    {

    __ASSERT_ALWAYS(iReady, 

                    TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));

    return iGenerator->GetVideoFrameIndex(aTime);

    }

void CVedVideoClipInfoGeneratedImp::GetFrameL(MVedVideoClipFrameObserver& aObserver, 

                                     TInt aIndex,

                                     TSize* const aResolution,

                                     TDisplayMode aDisplayMode,

                                     TBool aEnhance,

                                     TInt aPriority)

    {

    PRINT(_L("CVedVideoClipInfoGeneratedImp::GetFrameL in"));

    __ASSERT_ALWAYS(iReady, 

                    TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));

    iAdapter->iFrameObserver = &aObserver;

    iGenerator->GetFrameL(*iAdapter, aIndex, aResolution, aDisplayMode, aEnhance, aPriority);

    PRINT(_L("CVedVideoClipInfoGeneratedImp::GetFrameL out"));

    }

void CVedVideoClipInfoGeneratedImp::CancelFrame()

    {

    PRINT(_L("CVedVideoClipInfoGeneratedImp::CancelFrame in"));

    __ASSERT_ALWAYS(iReady, 

                    TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));

    iGenerator->CancelFrame();

    PRINT(_L("CVedVideoClipInfoGeneratedImp::CancelFrame out"));

    }

TPtrC CVedVideoClipInfoGeneratedImp::FileName() const

    {

    // Always panic

    TVedPanic::Panic(TVedPanic::EVideoClipInfoNoFileAssociated);

    // This will never be reached.

    return NULL;

    }

RFile* CVedVideoClipInfoGeneratedImp::FileHandle() const

    {

    // Always panic

    TVedPanic::Panic(TVedPanic::EVideoClipInfoNoFileAssociated);

    // This will never be reached.

    return NULL;

    }

TVedVideoFormat CVedVideoClipInfoGeneratedImp::Format() const

    {

    // Always panic

    TVedPanic::Panic(TVedPanic::EVideoClipInfoNoFileAssociated);

    // This will never be reached.

    return EVedVideoFormatUnrecognized;

    }

TVedVideoType CVedVideoClipInfoGeneratedImp::VideoType() const

    {

    // Always panic

    TVedPanic::Panic(TVedPanic::EVideoClipInfoNoFileAssociated);

    // This will never be reached.

    return EVedVideoTypeUnrecognized;

    }

TSize CVedVideoClipInfoGeneratedImp::Resolution() const

    {

    __ASSERT_ALWAYS(iReady, 

                    TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));

    return iGenerator->Movie()->Resolution();

    }

TBool CVedVideoClipInfoGeneratedImp::HasAudio() const

    {

    __ASSERT_ALWAYS(iReady, 

                    TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));

    return EFalse;  

    }

TVedAudioType CVedVideoClipInfoGeneratedImp::AudioType() const

    {

    // Always panic

    TVedPanic::Panic(TVedPanic::EVideoClipInfoNoFileAssociated);

    // This will never be reached.

    return EVedAudioTypeUnrecognized;

    }

TVedAudioChannelMode CVedVideoClipInfoGeneratedImp::AudioChannelMode() const

    {

    // Always panic

    TVedPanic::Panic(TVedPanic::EVideoClipInfoNoFileAssociated);

    // This will never be reached.

    return EVedAudioChannelModeUnrecognized;

    }

TInt CVedVideoClipInfoGeneratedImp::AudioSamplingRate() const

    {

    // Always panic

    TVedPanic::Panic(TVedPanic::EVideoClipInfoNoFileAssociated);

    // This will never be reached.

    return -1;

    }

TTimeIntervalMicroSeconds CVedVideoClipInfoGeneratedImp::Duration() const

    {

    __ASSERT_ALWAYS(iReady, 

                    TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));

    return iGenerator->Duration();

    }

TInt CVedVideoClipInfoGeneratedImp::VideoFrameCount() const

    {

    __ASSERT_ALWAYS(iReady, 

                    TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));

    return iGenerator->VideoFrameCount();

    }

TTimeIntervalMicroSeconds CVedVideoClipInfoGeneratedImp::VideoFrameStartTimeL(TInt aIndex)

    {

    __ASSERT_ALWAYS(iReady, 

                    TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));

    return iGenerator->VideoFrameStartTime(aIndex);

    }

TTimeIntervalMicroSeconds CVedVideoClipInfoGeneratedImp::VideoFrameEndTimeL(TInt aIndex)

    {

    __ASSERT_ALWAYS(iReady, 

                    TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));

    return iGenerator->VideoFrameEndTime(aIndex);

    }

TTimeIntervalMicroSeconds CVedVideoClipInfoGeneratedImp::VideoFrameDurationL(TInt aIndex)

    {

    __ASSERT_ALWAYS(iReady, 

                    TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));

    return iGenerator->VideoFrameDuration(aIndex);

    }

TInt CVedVideoClipInfoGeneratedImp::VideoFrameSizeL(TInt /*aIndex*/) 

    {

    __ASSERT_ALWAYS(iReady, 

                    TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));

    // always panic

    TVedPanic::Panic(TVedPanic::EVideoClipInfoNoFileAssociated);

    // will never be reached

    return 0;

    }

TBool CVedVideoClipInfoGeneratedImp::VideoFrameIsIntraL(TInt aIndex) 

    {

    __ASSERT_ALWAYS(iReady, 

                    TVedPanic::Panic(TVedPanic::EVideoClipInfoNotReady));

    if (aIndex == 0) 

        {

        return ETrue;

        }

    return EFalse;

    }

void CVedVideoClipInfoGeneratedImp::SetTranscodeFactor(TVedTranscodeFactor aFactor)

    {

    iTFactor.iStreamType =aFactor.iStreamType;

    iTFactor.iTRes = aFactor.iTRes;

    }

TVedTranscodeFactor CVedVideoClipInfoGeneratedImp::TranscodeFactor()

    {

    return iTFactor;

    }

TBool CVedVideoClipInfoGeneratedImp::IsMMSCompatible()

    {

    // Always panic

    TVedPanic::Panic(TVedPanic::EVideoClipInfoNoFileAssociated);

    // This will never be reached.

    return ETrue;;

    }

CVedVideoClipInfoGeneratedOperation* CVedVideoClipInfoGeneratedOperation::NewL(CVedVideoClipInfoGeneratedImp* aInfo,

                                                                               MVedVideoClipInfoObserver& aObserver)

    {

    PRINT(_L("CVedVideoClipInfoGeneratedOperation::NewL in"));

    CVedVideoClipInfoGeneratedOperation* self = 

        new (ELeave) CVedVideoClipInfoGeneratedOperation(aInfo, aObserver);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    PRINT(_L("CVedVideoClipInfoGeneratedOperation::NewL out"));

    return self;

    }

CVedVideoClipInfoGeneratedOperation::CVedVideoClipInfoGeneratedOperation(CVedVideoClipInfoGeneratedImp* aInfo,

                                                                         MVedVideoClipInfoObserver& aObserver)

        : CActive(EPriorityStandard), iInfo(aInfo)

    {

    PRINT(_L("CVedVideoClipInfoGeneratedOperation::CVedVideoClipInfoGeneratedOperation in"));

    iObserver = &aObserver;

    CActiveScheduler::Add(this);

    PRINT(_L("CVedVideoClipInfoGeneratedOperation::CVedVideoClipInfoGeneratedOperation out"));

    }

void CVedVideoClipInfoGeneratedOperation::ConstructL()

    {

    PRINT(_L("CVedVideoClipInfoGeneratedOperation::ConstructL in"));

    SetActive();

    TRequestStatus* status = &iStatus;

    User::RequestComplete(status, KErrNone);

    PRINT(_L("CVedVideoClipInfoGeneratedOperation::ConstructL out"));

    }

CVedVideoClipInfoGeneratedOperation::~CVedVideoClipInfoGeneratedOperation()

    {

    Cancel();

    }

void CVedVideoClipInfoGeneratedOperation::RunL()

    {

    PRINT(_L("CVedVideoClipInfoGeneratedOperation::RunL in"));

    iInfo->iReady = ETrue;

    iObserver->NotifyVideoClipInfoReady(*iInfo, KErrNone);

    PRINT(_L("CVedVideoClipInfoGeneratedOperation::RunL out"));

    }

void CVedVideoClipInfoGeneratedOperation::DoCancel()

    {

    }

CVedVideoClipGeneratedFrameToFrameAdapter::CVedVideoClipGeneratedFrameToFrameAdapter(CVedVideoClipInfo& aInfo)

: iInfo(aInfo)

    {

    }

void CVedVideoClipGeneratedFrameToFrameAdapter::NotifyVideoClipGeneratorFrameCompleted(

                        CVedVideoClipGenerator& /*aInfo*/, TInt aError, CFbsBitmap* aFrame)

    {

    iFrameObserver->NotifyVideoClipFrameCompleted(iInfo, aError, aFrame);

    }