/*

* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:

*

* Description:   TNE Video Clip Implementation

*

*/

#include "TNEVideoClipInfoImp.h"

#include "TNEProcessor.h"

#include <fbs.h>

#include <coemain.h>

#include <ecom/ecom.h>

// Print macro

#ifdef _DEBUG

#include <e32svr.h>

#define PRINT(x) RDebug::Print x

#else

#define PRINT(x)

#endif

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

// CTNEVideoClipInfo::NewL

// API exposed by TNE to create TNEVideoClipInfo using RFile handle

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

EXPORT_C CTNEVideoClipInfo* CTNEVideoClipInfo::NewL(const RFile& aFileHandle,

                                                    MTNEVideoClipInfoObserver& aObserver)

{

    PRINT(_L("CTNEVideoClipInfo::NewL"));

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

    CleanupStack::Pop(self);

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

    return self;

}

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

// CTNEVideoClipInfo::NewL

// API exposed by TNE to create TNEVideoClipInfo using file name

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

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

                                                    MTNEVideoClipInfoObserver& aObserver)

{

    PRINT(_L("CTNEVideoClipInfo::NewL"));

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

    CleanupStack::Pop(self);

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

    return self;

}

EXPORT_C CTNEVideoClipInfo* CTNEVideoClipInfo::NewLC(const RFile& aFileHandle,

                                                     MTNEVideoClipInfoObserver& aObserver)

{

    PRINT(_L("CTNEVideoClipInfo::NewLC in"));

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

    CleanupStack::PushL(self);

    self->ConstructL(aFileHandle, aObserver);

    PRINT(_L("CTNEVideoClipInfo::NewLC out"));

    return self;

}

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

                                                     MTNEVideoClipInfoObserver& aObserver)

{

    PRINT(_L("CTNEVideoClipInfo::NewLC in"));

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

    CleanupStack::PushL(self);

    self->ConstructL(aFileName, aObserver);

    PRINT(_L("CTNEVideoClipInfo::NewLC out"));

    return self;

}

CTNEVideoClipInfo* CTNEVideoClipInfoImp::NewL(const RFile& aFileHandle, 

                                              MTNEVideoClipInfoObserver& aObserver)

{

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

    CleanupStack::PushL(self);

    self->ConstructL(aFileHandle, aObserver);

    CleanupStack::Pop(self);

    return self;

}

CTNEVideoClipInfoImp::CTNEVideoClipInfoImp()

        : iReady(EFalse)

{

	iFs = NULL;

}

TInt CTNEVideoClipInfoImp::VideoFrameCount() const

{

    __ASSERT_ALWAYS(iReady, 

                    TTNEPanic::Panic(TTNEPanic::EVideoClipInfoNotReady));

    return iVideoFrameCount;

}

void CTNEVideoClipInfoImp::ConstructL(const RFile& aFileHandle,

                                      MTNEVideoClipInfoObserver& aObserver)

{

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

	iFileHandle.Duplicate(aFileHandle);

    iThumbOperation = CTNEVideoClipThumbOperation::NewL(this);

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

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

}

void CTNEVideoClipInfoImp::ConstructL(const TDesC& aFileName,

                                      MTNEVideoClipInfoObserver& aObserver)

{

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

    // Get RFile Handle

    iFs = new (ELeave) RFs;

    User::LeaveIfError(iFs->Connect());

	TInt iError = iFileHandle.Open(*iFs, aFileName, EFileShareReadersOnly | EFileStream | EFileRead);

    iThumbOperation = CTNEVideoClipThumbOperation::NewL(this);

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

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

}

CTNEVideoClipInfoImp::~CTNEVideoClipInfoImp()

{

    PRINT(_L("CTNEVideoClipInfo::~CTNEVideoClipInfoImp in"));

    delete iInfoOperation;

    delete iThumbOperation;

	iFileHandle.Close();

    if(iFs)

    {

	    iFs->Close();

	    delete iFs;    	

    }

    REComSession::FinalClose();

    PRINT(_L("CTNEVideoClipInfo::~CTNEVideoClipInfoImp out"));

}

void CTNEVideoClipInfoImp::GetThumbL(MTNEVideoClipThumbObserver& aObserver, 

                                     TInt aIndex,

                                     TSize* const aResolution,

                                     TDisplayMode aDisplayMode,

                                     TBool aEnhance,

                                     TInt aPriority)

{

    PRINT(_L("CTNEVideoClipInfoImp::GetThumbL in"));

    __ASSERT_ALWAYS(iReady, 

                    TTNEPanic::Panic(TTNEPanic::EVideoClipInfoNotReady));

    iThumbOperation->StartL(aObserver, aIndex, aResolution, aDisplayMode, aEnhance, aPriority);

    PRINT(_L("CTNEVideoClipInfoImp::GetThumbL out"));

}

void CTNEVideoClipInfoImp::CancelThumb()

{

    PRINT(_L("CTNEVideoClipInfoImp::CancelThumb in"));

    if ( !iReady )

        {

        PRINT(_L("CTNEVideoClipInfoImp::CancelThumb not even info ready yet, cancel it and get out"));

        iInfoOperation->Cancel();

        return;

        }

    iThumbOperation->Cancel();

    PRINT(_L("CTNEVideoClipInfoImp::CancelThumb out"));

}

TPtrC CTNEVideoClipInfoImp::FileName() const

{

    __ASSERT_ALWAYS(iReady, 

                    TTNEPanic::Panic(TTNEPanic::EVideoClipInfoNotReady));

	TFileName fileName;

	iFileHandle.FullName(fileName);

    return fileName;

}

TSize CTNEVideoClipInfoImp::GetResolution() const

{

    __ASSERT_ALWAYS(iReady, 

                    TTNEPanic::Panic(TTNEPanic::EVideoClipInfoNotReady));

    return iResolution;

}

/**********************************************

***        Video Clip Info Operations        **

***                                          **

**********************************************/

CTNEVideoClipInfoOperation* CTNEVideoClipInfoOperation::NewL(CTNEVideoClipInfoImp* aInfo,

                                                             MTNEVideoClipInfoObserver& aObserver)

    {

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

    CTNEVideoClipInfoOperation* self = 

        new (ELeave) CTNEVideoClipInfoOperation(aInfo, aObserver);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

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

    return self;

    }

CTNEVideoClipInfoOperation::CTNEVideoClipInfoOperation(CTNEVideoClipInfoImp* aInfo,

                                                       MTNEVideoClipInfoObserver& aObserver)

        : CActive(EPriorityStandard), iInfo(aInfo), iTNEProcessorError(KErrNone)

    {

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

    iObserver = &aObserver;

    CActiveScheduler::Add(this);

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

    }

void CTNEVideoClipInfoOperation::ConstructL()

    {

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

    CTNEProcessor* processor = CTNEProcessor::NewL();

    TRAP(iTNEProcessorError,

         processor->GetVideoClipPropertiesL((iInfo->iFileHandle), 

                                            iInfo->iFormat,

                                            iInfo->iVideoType,

                                            iInfo->iResolution,

                                            iInfo->iVideoFrameCount

                                            ));    

    delete processor;

    processor = 0;

    PRINT((_L("CTNEVideoClipInfoOperation::ConstructL GetVideoClipInfo returned: %d "), iTNEProcessorError ));

    if ((iTNEProcessorError == KErrNone)

            || (iTNEProcessorError == KErrNotFound) 

            || (iTNEProcessorError == KErrPathNotFound)

            || (iTNEProcessorError == KErrNotSupported))

        {

        // Report also certain common error conditions to the observer instead of leaving

        SetActive();

        TRequestStatus* status = &iStatus;

        User::RequestComplete(status, KErrNone);

        }

    else

        {

        User::Leave(iTNEProcessorError);

        }

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

    }

CTNEVideoClipInfoOperation::~CTNEVideoClipInfoOperation()

    {

    Cancel();

    }

void CTNEVideoClipInfoOperation::RunL()

    {

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

    if (iTNEProcessorError != KErrNone) 

       {

         iObserver->NotifyVideoClipInfoReady(*iInfo, iTNEProcessorError);

       }

    else

       {

         if (iTNEProcessorError == KErrNone) 

            {

              iInfo->iReady = ETrue;

            }

         iObserver->NotifyVideoClipInfoReady(*iInfo, iTNEProcessorError);

       }

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

    }

// ***********************************************************************

// This function gets called by the Cancel operation of the Active object.

//  Standard implementation of the cancel operation on a active object

// ***********************************************************************

void CTNEVideoClipInfoOperation::DoCancel()

    {

    }

/**********************************

***      Thumb Operations        **

***                              **

***********************************/

CTNEVideoClipThumbOperation* CTNEVideoClipThumbOperation::NewL(CTNEVideoClipInfoImp* aInfo)

    {

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

    CTNEVideoClipThumbOperation* self = 

        new (ELeave) CTNEVideoClipThumbOperation(aInfo);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

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

    return self;

    }

CTNEVideoClipThumbOperation::CTNEVideoClipThumbOperation(CTNEVideoClipInfoImp* aInfo)

        : CActive(EPriorityIdle), iInfo(aInfo)

    {

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

    CActiveScheduler::Add(this);

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

    }

void CTNEVideoClipThumbOperation::ConstructL()

    {

    }

CTNEVideoClipThumbOperation::~CTNEVideoClipThumbOperation()

    {

    Cancel();

    }

void CTNEVideoClipThumbOperation::StartL(MTNEVideoClipThumbObserver& aObserver,

                                         TInt aIndex,

                                         TSize* const aResolution, 

                                         TDisplayMode aDisplayMode,

                                         TBool aEnhance,

                                         TInt aPriority)

    {

    PRINT(_L("CTNEVideoClipThumbOperation::StartL in"));

    __ASSERT_ALWAYS(!IsActive(), 

        TTNEPanic::Panic(TTNEPanic::EVideoClipInfoFrameOperationAlreadyRunning));

    __ASSERT_DEBUG(iTNEProcessor == 0, TTNEPanic::Panic(TTNEPanic::EInternal));

    TSize resolution;

    if (aResolution != 0)

        {

        __ASSERT_ALWAYS(aResolution->iWidth >= 0, 

            TTNEPanic::Panic(TTNEPanic::EVideoClipInfoIllegalFrameResolution));

        __ASSERT_ALWAYS(aResolution->iHeight >= 0, 

            TTNEPanic::Panic(TTNEPanic::EVideoClipInfoIllegalFrameResolution));

        resolution = *aResolution;

        }

    else

        {

        resolution = iInfo->GetResolution();

        // need check here to see if resolution retreived from the clip is bad

        if ((resolution.iHeight <=0) || (resolution.iWidth <=0 ))

          {

        resolution.iHeight = 96;

        resolution.iWidth = 128;

          }   

        }

    // Verify that IndexFrame is within limit

    __ASSERT_ALWAYS(((aIndex >= 0) && (iInfo->VideoFrameCount() == 0) || 

                                      (aIndex < iInfo->VideoFrameCount()) || 

                                      (aIndex == KBestThumbIndex) ), 

    TTNEPanic::Panic(TTNEPanic::EVideoClipInfoIllegalVideoFrameIndex));

    iIndex = aIndex;

    CTNEProcessor* processor = CTNEProcessor::NewLC();  

    processor->StartThumbL((iInfo->iFileHandle), aIndex, resolution, aDisplayMode,

                           aEnhance);

    /* Initialization OK. This method cannot leave any more. Start processing. */

    CleanupStack::Pop(processor);

    iTNEProcessor = processor;

    iObserver = &aObserver;

    SetPriority(aPriority);

    SetActive();

    TRequestStatus* status = &iStatus;

    User::RequestComplete(status, KErrNone);

    PRINT(_L("CTNEVideoClipThumbOperation::StartL out"));

    }

void CTNEVideoClipThumbOperation::RunL()

    {

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

    __ASSERT_DEBUG(iTNEProcessor != 0, TTNEPanic::Panic(TTNEPanic::EInternal));

    __ASSERT_DEBUG(iObserver != 0, TTNEPanic::Panic(TTNEPanic::EInternal));

    TInt err = KErrNone;

    if (!iThumbRequestPending)

        TRAP(err, iTNEProcessor->ProcessThumbL(iStatus));

    if (err != KErrNone)

        {

        delete iTNEProcessor;

        iTNEProcessor = 0;

        MTNEVideoClipThumbObserver* observer = iObserver;

        iObserver = 0;

        observer->NotifyVideoClipThumbCompleted(*iInfo, err, NULL);

        return;

        }

  // the control flows to ih263 decoder 

  // in the next loop it gets to this runl again

    if (!iThumbRequestPending)

    {        

        iThumbRequestPending = ETrue;

        iStatus = KRequestPending;

        SetActive();        

        return;

    }

    else

    {

        MTNEVideoClipThumbObserver* observer = iObserver;

        iObserver = 0;

        if (iStatus == KErrNone)

        {

            CFbsBitmap* frame = 0;

            iTNEProcessor->FetchThumb(frame);

            observer->NotifyVideoClipThumbCompleted(*iInfo, KErrNone, frame);            

        }

        else

        {

            observer->NotifyVideoClipThumbCompleted(*iInfo, iStatus.Int(), NULL);            

        }

        iThumbRequestPending = EFalse;

        delete iTNEProcessor;

        iTNEProcessor = 0;

    }      

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

    }

void CTNEVideoClipThumbOperation::DoCancel()

    {

    if (iTNEProcessor != 0)

        {

        delete iTNEProcessor;

        iTNEProcessor = 0;

        // Cancel our internal request

        if ( iStatus == KRequestPending )

        {

            PRINT((_L("CTNEVideoClipThumbOperation::DoCancel() cancel request")));

            TRequestStatus *status = &iStatus;

            User::RequestComplete(status, KErrCancel);

        }

        MTNEVideoClipThumbObserver* observer = iObserver;

        iObserver = 0;

        observer->NotifyVideoClipThumbCompleted(*iInfo, KErrCancel, NULL);

        }

    }