/*

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

#include "AudClip.h"

#include "AudClipInfo.h"

#include "movieprocessor.h"

// Print macro

#ifdef _DEBUG

#include <e32svr.h>

#define PRINT(x) RDebug::Print x

#else

#define PRINT(x)

#endif

// -----------------------------------------------------------------------------

// CVedAudioClipInfo::NewL

// Constructs a new CVedAudioClipInfo object

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

EXPORT_C CVedAudioClipInfo* CVedAudioClipInfo::NewL(const TDesC& aFileName,

                                                    MVedAudioClipInfoObserver& aObserver)

    {

    CVedAudioClipInfoImp* self = (CVedAudioClipInfoImp*)NewLC(aFileName, aObserver);

    CleanupStack::Pop(self);

    return self;

    }

EXPORT_C CVedAudioClipInfo* CVedAudioClipInfo::NewL(RFile* aFileHandle,

                                                    MVedAudioClipInfoObserver& aObserver)

    {

    CVedAudioClipInfoImp* self = (CVedAudioClipInfoImp*)NewLC(aFileHandle, aObserver);

    CleanupStack::Pop(self);

    return self;

    }

// -----------------------------------------------------------------------------

// CVedAudioClipInfo::NewLC

// Constructs a new CVedAudioClipInfo object, leaves it to cleanupstack

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

EXPORT_C CVedAudioClipInfo* CVedAudioClipInfo::NewLC(const TDesC& aFileName,

                                                     MVedAudioClipInfoObserver& aObserver)

    {

    CVedAudioClipInfoImp* self = new (ELeave) CVedAudioClipInfoImp();

    CleanupStack::PushL(self);

    self->ConstructL(aFileName, aObserver);

    return self;

    }

EXPORT_C CVedAudioClipInfo* CVedAudioClipInfo::NewLC(RFile* aFileHandle,

                                                     MVedAudioClipInfoObserver& aObserver)

    {

    CVedAudioClipInfoImp* self = new (ELeave) CVedAudioClipInfoImp();

    CleanupStack::PushL(self);

    self->ConstructL(aFileHandle, aObserver);

    return self;

    }

CVedAudioClipInfoImp* CVedAudioClipInfoImp::NewL(CAudClip* aAudClip,

                                                 MVedAudioClipInfoObserver& aObserver)

    {

    CVedAudioClipInfoImp* self = (CVedAudioClipInfoImp*)NewLC(aAudClip, aObserver);

    CleanupStack::Pop(self);

    return self;

    }

CVedAudioClipInfoImp* CVedAudioClipInfoImp::NewLC(CAudClip* aAudClip,

                                            MVedAudioClipInfoObserver& aObserver)

    {

    CVedAudioClipInfoImp* self = new (ELeave) CVedAudioClipInfoImp();

    CleanupStack::PushL(self);

    self->ConstructL(aAudClip, aObserver);

    return self;

    }

// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------

// CVedAudioClipInfo::CVedAudioClipInfoImp

// Constuctor 

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

CVedAudioClipInfoImp::CVedAudioClipInfoImp()

        : iReady(EFalse)

    {

    }

// -----------------------------------------------------------------------------

// CVedAudioClipInfoImp::ConstructL

// Symbian two phased constructor.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CVedAudioClipInfoImp::ConstructL(CAudClip* aAudClip, 

                                      MVedAudioClipInfoObserver& aObserver)

    {

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

    iAudClip = aAudClip;

    iAudClipInfo = iAudClip->Info();

    iAudioProperties = iAudClipInfo->Properties();

    iReady = ETrue;

    iObserver = &aObserver;

    iOperation = CVedAudioClipInfoOperation::NewL(this, aObserver);

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

    }

void CVedAudioClipInfoImp::ConstructL(const TDesC& aFileName, 

                                     MVedAudioClipInfoObserver& aObserver)

    {

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

    iReady = EFalse;

    iAudClipInfo = CAudClipInfo::NewL(aFileName, *this);

    iObserver = &aObserver;

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

    }

void CVedAudioClipInfoImp::ConstructL(RFile* aFileHandle, 

                                     MVedAudioClipInfoObserver& aObserver)

    {

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

    iReady = EFalse;

    iAudClipInfo = CAudClipInfo::NewL(aFileHandle, *this);

    iObserver = &aObserver;

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

    }

// -----------------------------------------------------------------------------

// CVedAudioClipInfoImp::~CVedAudioClipInfoImp

// Destroys the object and releases all resources.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

CVedAudioClipInfoImp::~CVedAudioClipInfoImp()

    {

    if (iAudClipInfo != 0 && !iAudClip) 

    {

    delete iAudClipInfo;

    }

    delete iOperation;    

    REComSession::FinalClose();

    }

void CVedAudioClipInfoImp::NotifyClipInfoReady(CAudClipInfo& aInfo, TInt aError)

    {

    if (aError == KErrNone)

        {

        iAudioProperties = aInfo.Properties();    

        iReady = ETrue;

        }

    iObserver->NotifyAudioClipInfoReady(*this, aError);

    }

// -----------------------------------------------------------------------------

// CVedAudioClipInfoImp::ChannelMode

// Returns the channel mode of the audio if applicable.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TVedAudioChannelMode CVedAudioClipInfoImp::ChannelMode() const

    {

    __ASSERT_ALWAYS(iReady, TVedPanic::Panic(TVedPanic::EAudioClipInfoNotReady));

    TVedAudioChannelMode vedChannelMode = EVedAudioChannelModeUnrecognized;

    if (iAudioProperties.iChannelMode == EAudStereo)

        {

        vedChannelMode = EVedAudioChannelModeStereo;

        }

    else if (iAudioProperties.iChannelMode == EAudSingleChannel)

        {

        vedChannelMode = EVedAudioChannelModeSingleChannel;

        }

    else if (iAudioProperties.iChannelMode == EAudDualChannel)

        {

        vedChannelMode = EVedAudioChannelModeDualChannel;

        }

    return vedChannelMode;   

    }

// -----------------------------------------------------------------------------

// CVedAudioClipInfoImp::SamplingRate

// Returns the sampling rate in hertz.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt CVedAudioClipInfoImp::SamplingRate() const

    {

    __ASSERT_ALWAYS(iReady, TVedPanic::Panic(TVedPanic::EAudioClipInfoNotReady));

    return iAudioProperties.iSamplingRate;

    }

// -----------------------------------------------------------------------------

// CVedAudioClipInfoImp::Format

// Returns the audio format

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//  

TVedAudioFormat CVedAudioClipInfoImp::Format() const 

    {

    __ASSERT_ALWAYS(iReady, 

                    TVedPanic::Panic(TVedPanic::EAudioClipInfoNotReady));

    TVedAudioFormat vedAudioFormat = EVedAudioFormatUnrecognized;

    switch(iAudioProperties.iFileFormat) 

        {

    case EAudFormat3GPP:

        vedAudioFormat = EVedAudioFormat3GPP;

        break;

    case EAudFormatMP4:

        vedAudioFormat = EVedAudioFormatMP4;

        break;

    case EAudFormatAMR:

        vedAudioFormat = EVedAudioFormatAMR;

        break;

    case EAudFormatAMRWB:

        vedAudioFormat = EVedAudioFormatAMRWB;

        break;

    case EAudFormatMP3:

        vedAudioFormat = EVedAudioFormatMP3;

        break;

    case EAudFormatAAC_ADIF:

        vedAudioFormat = EVedAudioFormatAAC_ADIF;

        break;

    case EAudFormatAAC_ADTS:

        vedAudioFormat = EVedAudioFormatAAC_ADTS;

        break;

    case EAudFormatWAV:

        vedAudioFormat = EVedAudioFormatWAV;

        break;

    default:

        TVedPanic::Panic(TVedPanic::EInternal);

        }

    return vedAudioFormat;

    }

// -----------------------------------------------------------------------------

// CVedAudioClipInfoImp::BitrateMode

// Returns the bitrate mode

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//  

TVedBitrateMode CVedAudioClipInfoImp::BitrateMode() const

    {

    __ASSERT_ALWAYS(iReady, 

                    TVedPanic::Panic(TVedPanic::EAudioClipInfoNotReady));

    TVedBitrateMode vedBitrateMode = EVedBitrateModeUnrecognized;

    switch(iAudioProperties.iBitrateMode) 

        {

    case EAudConstant:

        vedBitrateMode = EVedBitrateModeConstant;

        break;

    case EAudVariable:

        vedBitrateMode = EVedBitrateModeVariable;

        break;

    default:

        TVedPanic::Panic(TVedPanic::EInternal);

        }

    return vedBitrateMode;

    }

// -----------------------------------------------------------------------------

// CVedAudioClipInfoImp::Bitrate

// Returns the bitrate

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//  

TInt CVedAudioClipInfoImp::Bitrate() const

    {

    __ASSERT_ALWAYS(iReady, 

                    TVedPanic::Panic(TVedPanic::EAudioClipInfoNotReady));

    return iAudioProperties.iBitrate;

    }

// -----------------------------------------------------------------------------

// CVedAudioClipInfoImp::GetVisualizationL

// Generates a visualization of the audio clip

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//  

void CVedAudioClipInfoImp::GetVisualizationL(MVedAudioClipVisualizationObserver& aObserver, TInt aResolution, TInt aPriority)

    {

    __ASSERT_ALWAYS(iReady, 

                    TVedPanic::Panic(TVedPanic::EAudioClipInfoNotReady));

    iVisualizationObserver = &aObserver;

    iAudClipInfo->GetVisualizationL(*this, aResolution, aPriority);

    }

// -----------------------------------------------------------------------------

// CVedAudioClipInfoImp::CancelVisualizationL

// Cancels visualization generation

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//  

void CVedAudioClipInfoImp::CancelVisualizationL()

    {

    __ASSERT_ALWAYS(iReady, 

                    TVedPanic::Panic(TVedPanic::EAudioClipInfoNotReady));

    iAudClipInfo->CancelVisualization();

    }

// -----------------------------------------------------------------------------

// CVedAudioClipInfoImp::NotifyClipInfoVisualizationCompleted

// Callback for visualization complete

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//  

void CVedAudioClipInfoImp::NotifyClipInfoVisualizationCompleted(const CAudClipInfo& /*aClipInfo*/, TInt aError, TInt8* aVisualization, TInt aSize)

    {

    iVisualizationObserver->NotifyAudioClipVisualizationCompleted(*this, aError, aVisualization, aSize);

    iVisualizationObserver = 0;

    }

// -----------------------------------------------------------------------------

// CVedAudioClipInfoImp::NotifyClipInfoVisualizationStarted

// Callback for visualization started 

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//  

void CVedAudioClipInfoImp::NotifyClipInfoVisualizationStarted(const CAudClipInfo& /*aClipInfo*/, TInt aError)

    {

    if (aError != KErrNone) 

        {

        iVisualizationObserver->NotifyAudioClipVisualizationCompleted(*this, aError, NULL, 0);

        iVisualizationObserver = 0;

        }

    else

        {

        iVisualizationObserver->NotifyAudioClipVisualizationStarted(*this);

        }

    }

// -----------------------------------------------------------------------------

// CVedAudioClipInfoImp::NotifyClipInfoVisualizationProgressed

// Callback for visualization progress

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//  

void CVedAudioClipInfoImp::NotifyClipInfoVisualizationProgressed(const CAudClipInfo& /*aClipInfo*/, TInt aPercentage)

    {

    iVisualizationObserver->NotifyAudioClipVisualizationProgressed(*this, aPercentage);

    }

// -----------------------------------------------------------------------------

// CVedAudioClipInfoImp::

// Returns the audio clip filename

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//  

TPtrC CVedAudioClipInfoImp::FileName() const

    {

    __ASSERT_ALWAYS(iReady, 

                    TVedPanic::Panic(TVedPanic::EAudioClipInfoNotReady));

    return iAudClipInfo->FileName();

    }

RFile* CVedAudioClipInfoImp::FileHandle() const

    {

    __ASSERT_ALWAYS(iReady, 

                    TVedPanic::Panic(TVedPanic::EAudioClipInfoNotReady));

    return iAudClipInfo->FileHandle();

    }

// -----------------------------------------------------------------------------

// CVedAudioClipInfoImp::Type

// Returns the audio type

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//  

TVedAudioType CVedAudioClipInfoImp::Type() const

    {

    __ASSERT_ALWAYS(iReady, 

                    TVedPanic::Panic(TVedPanic::EAudioClipInfoNotReady));

    TVedAudioType vedAudioType = EVedAudioTypeUnrecognized;

    if (iAudioProperties.iAudioType == EAudAMR)

        {

        vedAudioType = EVedAudioTypeAMR;

        }

    else if (iAudioProperties.iAudioType == EAudAMRWB)

        {

        vedAudioType = EVedAudioTypeAMRWB;

        }

    else if (iAudioProperties.iAudioType == EAudMP3)

        {

        vedAudioType = EVedAudioTypeMP3;

        }

    else if (iAudioProperties.iAudioType == EAudAAC_MPEG2 || iAudioProperties.iAudioType == EAudAAC_MPEG4 )

        {

        vedAudioType = EVedAudioTypeAAC_LC;

        }

    else if (iAudioProperties.iAudioType == EAudWAV)

        {

        vedAudioType = EVedAudioTypeWAV;

        }

    return vedAudioType;

    }

// -----------------------------------------------------------------------------

// CVedAudioClipInfoImp::Duration

// Returns the audio clip duration

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//  

TTimeIntervalMicroSeconds CVedAudioClipInfoImp::Duration() const

    {

    __ASSERT_ALWAYS(iReady, 

                    TVedPanic::Panic(TVedPanic::EAudioClipInfoNotReady));

    return iAudioProperties.iDuration;

    }

// -----------------------------------------------------------------------------

// CVedAudioClipInfoImp::Compare

// Compares two audio clip info classes

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//  

TInt CVedAudioClipInfoImp::Compare(const CVedAudioClipInfoImp& c1, 

                                   const CVedAudioClipInfoImp& c2) 

    {

    if (c1.iAudClip == 0 || c2.iAudClip == 0)

        {

        return 0;

        }

    if (c1.iAudClip->StartTime() > c2.iAudClip->StartTime()) 

        {

        return 1;

        }

    else if (c1.iAudClip->StartTime() < c2.iAudClip->StartTime()) 

        {

        return -1;

        }

    else 

        {

        return 0;

        }

    }

//////////////////////////////////////////////////////////////////////////

// CVedAudioClipInfoOperation

// 

// -----------------------------------------------------------------------------

// CVedAudioClipInfoOperation::NewL

// Constructs a new CVedAudioClipInfoOperation object.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

CVedAudioClipInfoOperation* CVedAudioClipInfoOperation::NewL(CVedAudioClipInfoImp* aInfo,

                                                             MVedAudioClipInfoObserver& aObserver)

    {

    CVedAudioClipInfoOperation* self = 

        new (ELeave) CVedAudioClipInfoOperation(aInfo, aObserver);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// -----------------------------------------------------------------------------

// CVedAudioClipInfoOperation::CVedAudioClipInfoOperation

// Constructor.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

CVedAudioClipInfoOperation::CVedAudioClipInfoOperation(CVedAudioClipInfoImp* aInfo,

                                                       MVedAudioClipInfoObserver& aObserver)

        : CActive(EPriorityStandard), iObserver(aObserver), iInfo(aInfo)

    {