/*

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