/*

* 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 decoder wrapper

*

*/

// INCLUDE FILES

#include <devvideoconstants.h>

#include "TNEDecoderWrap.h"

#include "ctrsettings.h"

// MACROS

#define TRASSERT(x) __ASSERT_DEBUG(x, User::Panic(_L("CTRANSCODERVIDEODECODERCLIENT"), -10010))

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

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

// CTNEDecoderWrap::NewL

// Two-phased constructor.

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

//

CTNEDecoderWrap* CTNEDecoderWrap::NewL(MThumbnailObserver* aObserver)

{

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

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

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

    return self;

}

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

// CTNEDecoderWrap::CTNEDecoderWrap

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

// might leave.

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

//

CTNEDecoderWrap::CTNEDecoderWrap(MThumbnailObserver* aObserver)

{    

    iObserver = aObserver;

    iDevVideoPlay = NULL;

    iCompresedFormat = NULL;

    iClockSource = NULL;

    iUid = TUid::Null();

    iHwDeviceId = THwDeviceId(0);

    iInputBuffer = NULL;

    iCodedBuffer = NULL;

    iDecodedPicture = NULL;

    iFatalError = KErrNone;

    iDataUnitType = EDuCodedPicture;

    iStop = EFalse;

    iState = ETRNone;

    iLastTimestamp = -1;

}

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

// CTNEDecoderWrap::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CTNEDecoderWrap::ConstructL()

{

    iDevVideoPlay = CMMFDevVideoPlay::NewL(*this);

    // Support for AVC

   	iClockSource = CSystemClockSource::NewL();

   	iInputFrameNum = 1;	

}

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

// CTNEDecoderWrap::~CTNEDecoderWrap()

// Destructor

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

//

CTNEDecoderWrap::~CTNEDecoderWrap()

{

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

    if (iDevVideoPlay)

    {

        delete iDevVideoPlay;

        iDevVideoPlay = NULL;

    }

    iInputBuffer = NULL;

    if (iClockSource)

    {

    	delete iClockSource;

    	iClockSource = 0;

    }

    if (iCompresedFormat)

    {

        delete iCompresedFormat;

    }

    iAcceleratedDecoders.Reset();

    iAcceleratedDecoders.Close();

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

}

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

// CTNEDecoderWrap::SupportsCodec

// Checks whether this coded is supported

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

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

//

TBool CTNEDecoderWrap::SupportsCodec(const TDesC8& aFormat, const TDesC8& aShortFormat)

{

    TBool supports = EFalse;

    TBuf8<256> mime;

    if (iDevVideoPlay)

    {

        RArray<TUid> decoders;

        TRAPD( status, iDevVideoPlay->FindDecodersL(aShortFormat, 0/*aPreProcType*/, decoders, EFalse/*aExactMatch*/) );

        if( ( status != KErrNone ) || ( decoders.Count() <= 0 ) )

        {

            PRINT((_L("CTNEDecoderWrap::SupportsCodec(), status[%d]"), status))

            supports = EFalse;

        }

        else

        {

            // Keep mime type given by codec fo future use

            iMimeType = aFormat;

            iShortMimeType = aShortFormat;

            supports = ETrue;

        }

        decoders.Reset();

        decoders.Close();

    }

    return supports;

}

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

// CTNEDecoderWrap::SetDecoderParametersL

// Sets codec parameters

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

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

//

void CTNEDecoderWrap::SetDecoderParametersL(TInt aDecoderLevel, const TTRVideoFormat& aFormat)

{

    PRINT((_L("CTNEDecoderWrap::SetDecoderParametersL(), In")))

    RArray<TUid> decoders;

    TBool codecAcceleration = EFalse;

    TInt status = KErrNone;

    iCodecLevel = aDecoderLevel;

    iFormat = aFormat;

	// Find the list of decoders 

    iDevVideoPlay->FindDecodersL(iShortMimeType, 0/*aPreProcType*/, decoders, EFalse/*aExactMatch*/);

    // Input format

    if (!iCompresedFormat)

    {

        TRAP(status, iCompresedFormat = CCompressedVideoFormat::NewL( iMimeType ));

        if (status != KErrNone)

        {

            // Reset decoder's list

            decoders.Reset();

            decoders.Close();

            User::Leave(status);

        }

    }

    // get decoder info

    for ( TInt i = 0; i < decoders.Count(); i ++ )

    {

        TRAP( status, codecAcceleration = CheckDecoderInfoL(decoders[i]) );

        if (status == KErrNone)

        {

            if (codecAcceleration != KTRAccelerationPriorityDecoder) 

            {

                // Use the first available software decoder

                iUid = decoders[i];

                // Keep the list of non-checked codecs for future use

                i = i + 1;

                for (; i < decoders.Count(); i ++)

                {

                    iCheckDecoders.Insert(decoders[i], iCheckDecoders.Count() );

                }

                break;

            }

            else

            {

                // Keep track of accelerated decoder to the list of "good" decoders

                iAcceleratedDecoders.Insert( decoders[i], iAcceleratedDecoders.Count() );

            }

        }

    }

    decoders.Reset();

    decoders.Close();

    if (iUid == TUid::Null())

    {

        // Check others "good"

        if ( iAcceleratedDecoders.Count() <= 0 )

        {

            PRINT((_L("CTNEDecoderWrap::SetDecoderParametersL(), No suitable decoders found")))

            User::Leave(KErrNotSupported);

        }

        else

        {

            // Select the accelerated as no ARM decoder is available

            iUid = iAcceleratedDecoders[0];

            iAcceleratedDecoders.Remove(0);

        }

    }

    PRINT((_L("CTNEDecoderWrap::SetDecoderParametersL(), Out")))

}

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

// CTNEDecoderWrap::CheckDecoderInfoL

// Checks coded info

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

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

//

TBool CTNEDecoderWrap::CheckDecoderInfoL(TUid aUid)

{

    CVideoDecoderInfo* decoderInfo = NULL; // Decoder info for retrieving capabilities

    TInt status = KErrNone;

    TBool accelerated = EFalse;

    // Check decoder

    PRINT((_L("CTNEDecoderWrap::CheckDecoderInfoL(), getting info from [0x%x]"), aUid.iUid ))

    decoderInfo = iDevVideoPlay->VideoDecoderInfoLC( aUid );

    if (!decoderInfo)

	{

        PRINT((_L("CTNEDecoderWrap::CheckDecoderInfoL(), getting info from [0x%x] failed[%d]"), aUid.iUid, status ))

        User::Leave(KErrNotSupported);

	}

    else 

	{

        // Check max rate for requested image format

        TSize maxSize = decoderInfo->MaxPictureSize();

        if ( (iFormat.iSize.iWidth > maxSize.iWidth) || (iFormat.iSize.iHeight > maxSize.iHeight) )

        {

            PRINT((_L("CTNEDecoderWrap::CheckDecoderInfoL(), Picture size is not supported")))

            status = KErrNotSupported;

        }

	}

    accelerated = decoderInfo->Accelerated();

    // Delete codec info

    CleanupStack::PopAndDestroy(decoderInfo);

    if (status != KErrNone)

    {

        User::Leave(status);

    }

    return accelerated;

}

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

// CTNEDecoderWrap::InitializeL

// Initializes decoder

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

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

//

void CTNEDecoderWrap::InitializeL()

    {

    PRINT((_L("CTNEDecoderWrap::InitializeL(), In")))

    TUint maxBufferSize = 0;

    TInt status = KErrNone;

	iState = ETRInitializing;

    switch(iFormat.iDataType)

        {

        case ETRDuCodedPicture:

            {

            iDataUnitType = EDuCodedPicture;

            break;

            }

        case ETRDuVideoSegment:

            {

            iDataUnitType = EDuVideoSegment;

            break;

            }

        default:

            {

            // Should never happend. Decoder does not support uncompressed input format. 

            TRASSERT(0);

            }

        }

    iBufferOptions.iMinNumInputBuffers = KTRDecoderMinNumberOfBuffers;

    // Select decoder first

    this->SelectDecoderL();

    // Set now output format for this device    

    TRAP(status, iDevVideoPlay->SetOutputFormatL(iHwDeviceId, iUncompressedFormat));

    // 3. Buffer options

    iBufferOptions.iPreDecodeBufferSize = 0;            // "0" - use default decoder value

    iBufferOptions.iMaxPostDecodeBufferSize = 0;        // No limitations

    iBufferOptions.iPreDecoderBufferPeriod = 0;

    iBufferOptions.iPostDecoderBufferPeriod = 0;

    // Check max coded picture size for specified codec level

    switch(iCodecLevel)

        {

        case KTRH263CodecLevel10:

            {

            maxBufferSize = KTRMaxBufferSizeLevel10;

            break;

            }

        case KTRH263CodecLevel20:

            {

            maxBufferSize = KTRMaxBufferSizeLevel20;

            break;

            }

        case KTRH263CodecLevel30:

            {

            maxBufferSize = KTRMaxBufferSizeLevel30;

            break;

            }

        case KTRH263CodecLevel40:

            {

            maxBufferSize = KTRMaxBufferSizeLevel40;

            break;

            }

        case KTRH263CodecLevel50:

            {

            maxBufferSize = KTRMaxBufferSizeLevel50;

            break;

            }

        case KTRH263CodecLevel60:

            {

            maxBufferSize = KTRMaxBufferSizeLevel60;

            break;

            }

        case KTRH263CodecLevel70:

            {

            maxBufferSize = KTRMaxBufferSizeLevel70;

            break;

            }

        case KTRMPEG4CodecLevel0:

            {

            maxBufferSize = KTRMaxBufferSizeLevel0;

            break;

            }

        case KTRMPEG4CodecLevel1:

            {

            maxBufferSize = KTRMaxBufferSizeLevel1;

            break;

            }

        case KTRMPEG4CodecLevel2:

            {

            maxBufferSize = KTRMaxBufferSizeLevel2;

            break;

            }

        case KTRMPEG4CodecLevel3:

            {

            maxBufferSize = KTRMaxBufferSizeLevel3;

            break;

            }

        case KTRMPEG4CodecLevel0b:

            {

            maxBufferSize = KTRMaxBufferSizeLevel0b;

            break;

            }

        case KTRMPEG4CodecLevel4a:

            {

            maxBufferSize = KTRMaxBufferSizeLevel4a;

            break;

            }

        default:

            {

            maxBufferSize = KTRMaxBufferSizeLevel0;

            break;

            }

        }

    iBufferOptions.iMaxInputBufferSize = maxBufferSize;

    PRINT((_L("CTNEDecoderWrap::InitializeL(), InputBufferSize[%d], NumberOfBuffers[%d]"), 

               iBufferOptions.iMaxInputBufferSize, iBufferOptions.iMinNumInputBuffers ))

    iDevVideoPlay->SetBufferOptionsL(iBufferOptions);

    // Initialize devVideoPlay

    iDevVideoPlay->Initialize();

    PRINT((_L("CTNEDecoderWrap::InitializeL(), Out")))

    }

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

// CTNEDecoderWrap::SelectDecoderL

// Selects decoder

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

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

//

void CTNEDecoderWrap::SelectDecoderL()

{

    PRINT(( _L("CTNEDecoderWrap::SelectDecoderL(), In") ))

    TInt status = KErrNone;

    TBool accelerated = EFalse;

    TBool exit = EFalse;

    if (iUid != TUid::Null())

	{

        TRAP( status, iHwDeviceId = iDevVideoPlay->SelectDecoderL(iUid) );

	}

    else

	{

        // Most likely an error exists, if iUid == NULL; 

        status = KErrAlreadyExists;

	}

    while ( !exit )

	{

        if (status == KErrNone)

		{

            // To get Output format list devvideoplay requires to define output format first. 

            iDevVideoPlay->SetInputFormatL(iHwDeviceId, *iCompresedFormat, iDataUnitType, EDuElementaryStream, ETrue);

            // It's time to check input format support (since the plugin is loaded to the memory)

            iUncompressedFormat.iDataFormat = EYuvRawData;

            TUncompressedVideoFormat uncFormat;

            TBool found = EFalse;

            TInt pattern1, pattern2;

            pattern1 = EYuv420Chroma1;

            pattern2 = EYuv420Chroma2;

            RArray<TUncompressedVideoFormat> supportedOutputFormats; 

            TRAP(status, iDevVideoPlay->GetOutputFormatListL( iHwDeviceId, supportedOutputFormats ));

            TInt formatCount = 0;

            if (status == KErrNone)

            {

                formatCount = supportedOutputFormats.Count();

                PRINT((_L("CTNEDecoderWrap::InitializeL(), formatCount[%d]"), formatCount ))

            }

            if (formatCount <= 0)

            {

                supportedOutputFormats.Close();

                status = KErrAlreadyExists;

                PRINT((_L("CTNEDecoderWrap::InitializeL(), There are no supported output formats") ))

                //User::Leave(KErrNotSupported);

            }

            else

            {

                // Check the most important paramers

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

                {

                    uncFormat = supportedOutputFormats[i];

                    PRINT((_L("CTNEDecoderWrap::InitializeL(), pattern[%d]"), uncFormat.iYuvFormat.iPattern ))

                    if ( (uncFormat.iDataFormat == iUncompressedFormat.iDataFormat) && 

                         ( (uncFormat.iYuvFormat.iPattern == pattern1) || 

                           (uncFormat.iYuvFormat.iPattern == pattern2) ) )

                        {

                        // Assign the rest of parameters

                        iUncompressedFormat = uncFormat;

                        found = ETrue;

                        exit = ETrue;

                        supportedOutputFormats.Close();

                        break;

                        }

                }

                if (!found)

                {

                    supportedOutputFormats.Close();

                    PRINT((_L("CTNEDecoderWrap::InitializeL(), Supported format is not found") ))

                    //User::Leave(KErrNotSupported);

                }