/*

* 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:  

* Transcoder Implementation.

*

*/

// INCLUDE FILES

#include <centralrepository.h>

#include "ctrvideopicturesink.h"

#include "ctrtranscoderobserver.h"

#include "ctrtranscoderimp.h"

#include "ctrsettings.h"

#include "ctrhwsettings.h"

#include "ctrvideodecoderclient.h"

#include "ctrvideoencoderclient.h"

#include "ctrscaler.h"

#include "ctrprivatecrkeys.h"

// MACROS

#define TRASSERT(x) __ASSERT_DEBUG(x, User::Panic(_L("CTRANSCODERIMP"), KErrAbort))

// ============================ MEMBER FUNCTIONS ===============================

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

// CTRTranscoderImp::NewL

// Two-phased constructor.

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

//

CTRTranscoderImp* CTRTranscoderImp::NewL(MTRTranscoderObserver& aObserver)

    {

    PRINT(_L("CTRTranscoderImp::NewL(), In"))

    CTRTranscoderImp* self = new (ELeave) CTRTranscoderImp(aObserver);

    CleanupStack::PushL( reinterpret_cast<CTRTranscoder*>(self) );

    self->ConstructL();

    CleanupStack::Pop();

    PRINT(_L("CTRTranscoderImp::NewL(), Out"))

    return self;

    }

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

// CTRTranscoderImp::CTRTranscoderImp

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CTRTranscoderImp::CTRTranscoderImp(MTRTranscoderObserver& aObserver) :

    CActive(EPriorityStandard), 

    iObserver(aObserver)

    {

    CActiveScheduler::Add(this);

    iVideoDecoderClient = NULL;

    iVideoEncoderClient = NULL;

    iRealTime = EFalse;

    iMediaSink = NULL;

    iScaler = NULL;

    iPictureSink = NULL;

    iPictureSinkTemp = NULL;

    iState = ETRNone;

    iEncoderInitStatus = KTRErrNotReady;    /*Internal error status*/

    iDecoderInitStatus = KTRErrNotReady;

    iEncoderStreamEnd = EFalse;

    iDecoderStreamEnd = EFalse;

    iDataArray = NULL;

    iVideoPictureArray = NULL;

    iDecodedPicture = NULL;

    iBitRateSetting = EFalse;

    iFatalError = KErrNone;

    iOptimizedDataTransfer = EFalse;

    iEncoderEnabled = ETrue;

    iPictureSinkEnabled = EFalse;

    iPictureSinkClientSetting = EFalse;

    iSetRandomAccessPoint = EFalse;

    iEncoderEnabledSettingChanged = EFalse;

    iPictureSinkSettingChanged = EFalse;

    iEncoderEnableClientSetting = ETrue;

    iWaitPictureFromClient = NULL;

    iWaitNewDecodedPicture = NULL;

    iNewEvent = NULL;

    iCurrentPictureSinkEnabled = EFalse;

    iCurrentAsyncPictureSinkEnabled = EFalse;

    iCurrentEncoderEnabled = ETrue;

    iCurrentAsyncEncoderEnabled = ETrue;

    iCurrentRandomAccess = EFalse;

    iAsyncStop = EFalse;

    iMaxFramesInProcessing = KTRMaxFramesInProcessingDefault;

    // Set offset for queues

    iTranscoderPictureQueue.SetOffset( static_cast<TInt>( _FOFF( TVideoPicture, iLink )));

    iEncoderPictureQueue.SetOffset( static_cast<TInt>( _FOFF( TVideoPicture, iLink )));

    iCIPictureBuffersQueue.SetOffset( static_cast<TInt>( _FOFF( TVideoPicture, iLink )));

    iTranscoderTRPictureQueue.SetOffset( static_cast<TInt>( _FOFF( TTRVideoPicture, iLink )));

    iContainerWaitQueue.SetOffset( static_cast<TInt>( _FOFF( TVideoPicture, iLink )));

    iTranscoderEventSrc.SetOffset( static_cast<TInt>( _FOFF( CTREventItem, iLink )));

    iTranscoderEventQueue.SetOffset( static_cast<TInt>( _FOFF( CTREventItem, iLink )));

    iTranscoderAsyncEventQueue.SetOffset( static_cast<TInt>( _FOFF( CTREventItem, iLink )));

    }

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

// CTRTranscoderImp::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CTRTranscoderImp::ConstructL()

    {

    PRINT((_L("CTRTranscoderImp::ConstructL(), In")))

    // Allocate ivent quque

    iEvents = NULL;

    iEvents = new (ELeave) CTREventItem[KNumberOfEvents];

    // Fill event's queue

    for (TInt i = 0; i < KNumberOfEvents; i ++)

        {

        iEvents[i].Reset();

        iTranscoderEventSrc.AddLast( iEvents[i] );

        }

    LoadCodecUids();

    PRINT((_L("CTRTranscoderImp::ConstructL(), Out")))

    }

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

// CTRTranscoderImp::~CTRTranscoderImp()

// Destructor

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

//

CTRTranscoderImp::~CTRTranscoderImp()

    {

    PRINT((_L("CTRTranscoderImp::~CTRTranscoderImp(), In")))

    TInt i = 0;

    if ( iState == ETRRunning )

        {

        TRAPD(status, this->StopL());

        PRINT((_L("CTRTranscoderImp::~CTRTranscoderImp(), StopL status[%d]"), status))

        if (status != KErrNone)

            {

            // Nothing to do, since destruction of the app

            }

        }

    Cancel();

    if (iVideoDecoderClient)

        {

        delete iVideoDecoderClient;

        iVideoDecoderClient = NULL;

        }

    if (iVideoEncoderClient)

        {

        delete iVideoEncoderClient;

        iVideoEncoderClient = NULL;

        }

    if (iScaler)

        {

        delete iScaler;

        iScaler = NULL;

        }

    if (iDataArray)

        {

        for (i = 0; i < KTRPictureBuffersNumber; i ++)

            {

            if ( iDataArray[i] )

                {

                delete[] iDataArray[i];

                iDataArray[i] = NULL;

                }

            }

        delete[] iDataArray;

        iDataArray = NULL;

        }

    if ( (iMode == EEncoding) && (iInputPictureSize == iOutputPictureSize) )

        {

        // Clean iRawData ptrs, since the actual memory was allocated by the client

        if (iVideoPictureArray)

            {

            for (i = 0; i < KTRPictureBuffersNumber; i ++)

                {

                if (iVideoPictureArray[i].iData.iRawData)

                    {

                    iVideoPictureArray[i].iData.iRawData = NULL;

                    }

                }

            }

        }

    if (iVideoPictureArray)

        {

        for (i = 0; i < KTRPictureBuffersNumber; i ++)

            {

            if (iVideoPictureArray[i].iData.iRawData)

                {

                delete iVideoPictureArray[i].iData.iRawData;

                iVideoPictureArray[i].iData.iRawData = NULL;

                }

            }

        delete[] iVideoPictureArray;

        iVideoPictureArray = NULL;

        }

    if (iTRVideoPictureArray)

        {

        delete[] iTRVideoPictureArray;

        iTRVideoPictureArray = NULL;

        }

    if (iEvents)

        {

        delete[] iEvents;

        }

    PRINT((_L("CTRTranscoderImp::~CTRTranscoderImp(), Out")))

    }

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

// CTRTranscoderImp::SupportsInputVideoFormat

// Checks whether given input format is supported

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

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

//

TBool CTRTranscoderImp::SupportsInputVideoFormat(const TDesC8& aMimeType)

    {

    PRINT((_L("CTRTranscoderImp::SupportsInputVideoFormat(), In")))

    TBool supports = EFalse;

    if ( aMimeType == KNullDesC8 )

        {

        PRINT((_L("CTRTranscoderImp::SupportsInputVideoFormat(), Mime type is undefined")))

        return EFalse;

        }

    // Check video decoder

    if (!iVideoDecoderClient)

        {

         // Parse MIME

        TRAPD(status, this->ParseMimeTypeL(aMimeType, ETrue));

        if (status != KErrNone)

            {

            PRINT((_L("CTRTranscoderImp::SupportsInputVideoFormat(), ParseMimeTypeL[%d]"), status))

            return EFalse;

            }

        // Create the decoder client first

        TRAP( status, iVideoDecoderClient = CTRVideoDecoderClient::NewL(*this) );

        if (status != KErrNone)

            {

            PRINT((_L("CTRTranscoderImp::SupportsInputVideoFormat(), VideoDecClient status[%d]"), status))

            iVideoDecoderClient = NULL;

            return EFalse;

            }

        }

    // Choose the correct codec Uids to use    

    TInt preferredUid = 0;

    TInt fallbackUid = 0;

    TInt resolutionUid = 0;

    if (iInputCodec == EH263)

        {

        preferredUid = iH263DecoderUid;

        fallbackUid = KTRFallbackDecoderUidH263;

        PRINT((_L("CTRTranscoderImp::SupportsInputVideoFormat() H.263, preferred = 0x%x"), preferredUid))

        PRINT((_L("CTRTranscoderImp::SupportsInputVideoFormat() H.263, fallback = 0x%x"), fallbackUid))

        if (iInputPictureSize.iWidth <= iH263DecoderLowResThreshold)

            {

            resolutionUid = iH263DecoderLowResUid;

            PRINT((_L("CTRTranscoderImp::SupportsInputVideoFormat() H.263, below, resolutions = 0x%x"), resolutionUid))

            }

        }

    else if (iInputCodec == EH264)

        {

        preferredUid = iH264DecoderUid;

        fallbackUid = KTRFallbackDecoderUidH264;

        PRINT((_L("CTRTranscoderImp::SupportsInputVideoFormat() AVC, preferred = 0x%x"), preferredUid))

        PRINT((_L("CTRTranscoderImp::SupportsInputVideoFormat() AVC, fallback = 0x%x"), fallbackUid))

        if (iInputPictureSize.iWidth <= iH264DecoderLowResThreshold)

            {

            resolutionUid = iH264DecoderLowResUid;

            PRINT((_L("CTRTranscoderImp::SupportsInputVideoFormat() AVC, below, resolutions = 0x%x"), resolutionUid))

            }

        }

    else

        {

        preferredUid = iMPEG4DecoderUid;

        fallbackUid = KTRFallbackDecoderUidMPEG4;

        PRINT((_L("CTRTranscoderImp::SupportsInputVideoFormat() MPEG-4, preferred = 0x%x"), preferredUid))

        PRINT((_L("CTRTranscoderImp::SupportsInputVideoFormat() MPEG-4, fallback = 0x%x"), fallbackUid))

        if (iInputPictureSize.iWidth <= iMPEG4DecoderLowResThreshold)

            {

            resolutionUid = iMPEG4DecoderLowResUid;

            PRINT((_L("CTRTranscoderImp::SupportsInputVideoFormat() MPEG-4, below, resolutions = 0x%x"), resolutionUid))

            }

        }

    if (resolutionUid != 0)

        {

        preferredUid = resolutionUid;

        }

    PRINT((_L("CTRTranscoderImp::SupportsInputVideoFormat() preferred = 0x%x"), preferredUid))    

    supports = iVideoDecoderClient->SupportsCodec(iInputMimeType, iInputShortMimeType, preferredUid, fallbackUid);

    PRINT((_L("CTRTranscoderImp::SupportsInputVideoFormat(), supports[%d] Out"), supports))

    return supports;

    }

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

// CTRTranscoderImp::SupportsOutputVideoFormat

// Checks whether given output format is supported

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

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

//

TBool CTRTranscoderImp::SupportsOutputVideoFormat(const TDesC8& aMimeType)

    {

    PRINT((_L("CTRTranscoderImp::SupportsOutputVideoFormat(), In")))

    TBool supports = EFalse;

    if ( aMimeType == KNullDesC8 )

        {

        PRINT((_L("CTRTranscoderImp::SupportsOutputVideoFormat(), Mime type is undefined")))

        return EFalse;

        }

    // Check video encoder

    if (!iVideoEncoderClient)

        {

        // Parse MIME

        TRAPD(status, this->ParseMimeTypeL(aMimeType, EFalse));

        if (status != KErrNone)

            {

            PRINT((_L("CTRTranscoderImp::SupportsInputVideoFormat(), ParseMimeTypeL[%d]"), status))

            return EFalse;

            }

        // Create the encoder client first

        TRAP(status, iVideoEncoderClient = CTRVideoEncoderClient::NewL(*this) );

        if (status != KErrNone)

            {

            PRINT((_L("CTRTranscoderImp::SupportsOutputVideoFormat(), VideoEncClient status[%d]"), status))

            iVideoEncoderClient = NULL;

            return EFalse;

            }

        }

    // Choose the correct codec Uids to use    

    TInt preferredUid = 0;

    TInt fallbackUid = 0;

    TInt resolutionUid = 0;

    if (iOutputCodec == EH263)

        {

        preferredUid = iH263EncoderUid;

        fallbackUid = KTRFallbackEncoderUidH263;

        PRINT((_L("CTRTranscoderImp::SupportsOutputVideoFormat() H.263, preferred = 0x%x"), preferredUid))

        PRINT((_L("CTRTranscoderImp::SupportsOutputVideoFormat() H.263, fallback = 0x%x"), fallbackUid))

        if (iOutputPictureSize.iWidth <= iH263EncoderLowResThreshold)

            {

            resolutionUid = iH263EncoderLowResUid;

            PRINT((_L("CTRTranscoderImp::SupportsOutputVideoFormat() H.263, below, resolutions = 0x%x"), resolutionUid))

            }

        }

    else if (iOutputCodec == EH264)

        {

        preferredUid = iH264EncoderUid;

        fallbackUid = KTRFallbackEncoderUidH264;

        PRINT((_L("CTRTranscoderImp::SupportsOutputVideoFormat() AVC, preferred = 0x%x"), preferredUid))

        PRINT((_L("CTRTranscoderImp::SupportsOutputVideoFormat() AVC, fallback = 0x%x"), fallbackUid))

        if (iOutputPictureSize.iWidth <= iH264EncoderLowResThreshold)

            {

            resolutionUid = iH264EncoderLowResUid;

            PRINT((_L("CTRTranscoderImp::SupportsOutputVideoFormat() AVC, below, resolutions = 0x%x"), resolutionUid))

            }

        }

    else

        {

        preferredUid = iMPEG4EncoderUid;

        fallbackUid = KTRFallbackEncoderUidMPEG4;

        PRINT((_L("CTRTranscoderImp::SupportsOutputVideoFormat() MPEG-4, preferred = 0x%x"), preferredUid))

        PRINT((_L("CTRTranscoderImp::SupportsOutputVideoFormat() MPEG-4, fallback = 0x%x"), fallbackUid))

        if (iOutputPictureSize.iWidth <= iMPEG4EncoderLowResThreshold)

            {

            resolutionUid = iMPEG4EncoderLowResUid;

            PRINT((_L("CTRTranscoderImp::SupportsOutputVideoFormat() MPEG-4, below, resolutions = 0x%x"), resolutionUid))

            }

        }

    if (resolutionUid != 0)

        {

        preferredUid = resolutionUid;

        }

    PRINT((_L("CTRTranscoderImp::SupportsOutputVideoFormat() preferred = 0x%x"), preferredUid))        

    supports = iVideoEncoderClient->SupportsCodec(iOutputMimeType, iOutputShortMimeType, preferredUid, fallbackUid);

    PRINT((_L("CTRTranscoderImp::SupportsOutputVideoFormat(), supports[%d] Out"), supports))

    return supports;

    }

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

// CTRTranscoderImp::LoadCodecUids

// Loads codec Uids from central repository

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

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

//    

void CTRTranscoderImp::LoadCodecUids()

    {

    PRINT((_L("CTRTranscoderImp::LoadCodecUids(), In")))

    CRepository* repository = NULL;

    TRAPD(error, repository = CRepository::NewL(KCRUidTranscoder));

    if (error != KErrNone)

        {

        PRINT((_L("CTRTranscoderImp::LoadCodecUids(), Error: %d, Out"), error))

        return;

        }

    if (repository->Get(KTRH263DecoderUid, iH263DecoderUid) != KErrNone)

        {

        iH263DecoderUid = 0;

        }

    if (repository->Get(KTRH264DecoderUid, iH264DecoderUid) != KErrNone)

        {

        iH264DecoderUid = 0;

        }

    if (repository->Get(KTRMPEG4DecoderUid, iMPEG4DecoderUid) != KErrNone)

        {

        iMPEG4DecoderUid = 0;

        }

    if (repository->Get(KTRH263EncoderUid, iH263EncoderUid) != KErrNone)

        {

        iH263EncoderUid = 0;

        }

    if (repository->Get(KTRH264EncoderUid, iH264EncoderUid) != KErrNone)

        {

        iH264EncoderUid = 0;

        }

    if (repository->Get(KTRMPEG4EncoderUid, iMPEG4EncoderUid) != KErrNone)

        {

        iMPEG4EncoderUid = 0;

        }

    if (repository->Get(KTRH263DecoderLowResUid, iH263DecoderLowResUid) != KErrNone)

        {

        iH263DecoderLowResUid = 0;

        }

    if (repository->Get(KTRH264DecoderLowResUid, iH264DecoderLowResUid) != KErrNone)

        {

        iH264DecoderLowResUid = 0;

        }

    if (repository->Get(KTRMPEG4DecoderLowResUid, iMPEG4DecoderLowResUid) != KErrNone)

        {

        iMPEG4DecoderLowResUid = 0;

        }

    if (repository->Get(KTRH263EncoderLowResUid, iH263EncoderLowResUid) != KErrNone)

        {

        iH263EncoderLowResUid = 0;

        }

    if (repository->Get(KTRH264EncoderLowResUid, iH264EncoderLowResUid) != KErrNone)

        {

        iH264EncoderLowResUid = 0;

        }

    if (repository->Get(KTRMPEG4EncoderLowResUid, iMPEG4EncoderLowResUid) != KErrNone)

        {

        iMPEG4EncoderLowResUid = 0;

        }

    if (repository->Get(KTRH263DecoderLowResThreshold, iH263DecoderLowResThreshold) != KErrNone)

        {

        iH263DecoderLowResThreshold = 0;