/*

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

* Video decoder client.

*

*/

// INCLUDE FILES

#include <devvideoconstants.h>

#include "ctrvideodecoderclient.h"

#include "ctrtranscoder.h"

#include "ctrdevvideoclientobserver.h"

#include "ctrsettings.h"

#include "ctrhwsettings.h"

// MACROS

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

// CONSTANTS

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

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

// CTRVideoDecoderClient::NewL

// Two-phased constructor.

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

//

CTRVideoDecoderClient* CTRVideoDecoderClient::NewL(MTRDevVideoClientObserver& aObserver)

    {

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

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

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

    return self;

    }

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

// CTRVideoDecoderClient::CTRVideoDecoderClient

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

// might leave.

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

//

CTRVideoDecoderClient::CTRVideoDecoderClient(MTRDevVideoClientObserver& aObserver) :

    iObserver(aObserver)

    {

    iDevVideoPlay = NULL;

    iCompresedFormat = NULL;

    iUid = TUid::Null();

    iFallbackUid = TUid::Null();

    iHwDeviceId = THwDeviceId(0);

    iInputBuffer = NULL;

    iCodedBuffer = NULL;

    iDecodedPicture = NULL;

    iVideoResourceHandlerCI = NULL;   

    iFatalError = KErrNone;

    iDataUnitType = EDuCodedPicture;

    iStop = EFalse;

    iLastTimestamp = -1;

    iAcceleratedCodecSelected = EFalse;

    }

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

// CTRVideoDecoderClient::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CTRVideoDecoderClient::ConstructL()

    {

    iDevVideoPlay = CMMFDevVideoPlay::NewL(*this);

    }

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

// CTRVideoDecoderClient::~CTRVideoDecoderClient()

// Destructor

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

//

CTRVideoDecoderClient::~CTRVideoDecoderClient()

    {

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

    if (iDevVideoPlay)

        {

        delete iDevVideoPlay;

        iDevVideoPlay = NULL;

        }

    iInputBuffer = NULL;

    if (iCompresedFormat)

        {

        delete iCompresedFormat;

        }

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

    }

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

// CTRVideoDecoderClient::SupportsCodec

// Checks whether this coded is supported

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

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

//

TBool CTRVideoDecoderClient::SupportsCodec(const TDesC8& aFormat, const TDesC8& aShortFormat, TInt aUid, TInt aFallbackUid)

    {

    TBool supports = EFalse;

    TBool preferredFound = EFalse;

    TBool fallbackFound = EFalse;

    if (iDevVideoPlay)

        {

        RArray<TUid> decoders;

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

        if( status != KErrNone  )

            {

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

            supports = EFalse;

            }

        else if( decoders.Count() <= 0 )

            {

            PRINT((_L("CTRVideoDecoderClient::SupportsCodec(), No decoders found")))

            supports = EFalse;

            }

        else

            {

            PRINT((_L("CTRVideoDecoderClient::SupportsCodec(), %d decoders found"), decoders.Count() ))

            // Check if any of the found decoders matches with the given Uids

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

                {

                PRINT((_L("CTRVideoDecoderClient::SupportsCodec(), found codec 0x%x"), decoders[i].iUid))

                if( decoders[i].iUid == aUid )

                    {

                    PRINT((_L("CTRVideoDecoderClient::SupportsCodec(), preferred found")))

                    iUid = decoders[i];

                    preferredFound = ETrue;

                    }

                if( decoders[i].iUid == aFallbackUid )

                    {

                    PRINT((_L("CTRVideoDecoderClient::SupportsCodec(), fallback found")))

                    iFallbackUid = decoders[i];

                    fallbackFound = ETrue;

                    }

                if( preferredFound && fallbackFound )

                    {

                    // No need to search anymore

                    break;

                    }

                }

            }

        decoders.Reset();

        decoders.Close();

        }

    if( !preferredFound )

        {

        // Preferred decoder was not found => Probably the given decoder Uid is wrong

        PRINT((_L("CTRVideoDecoderClient::SupportsCodec(), No supported decoders found")))

        supports = EFalse;

        }

    else

        {

        PRINT((_L("CTRVideoDecoderClient::SupportsCodec(), Supported decoder found: 0x%x"), iUid.iUid))

        iMimeType = aFormat;

        iShortMimeType = aShortFormat;

        supports = ETrue;

        }

    return supports;

    }

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

// CTRVideoDecoderClient::SetCodecParametersL

// Sets codec parameters

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

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

//

void CTRVideoDecoderClient::SetCodecParametersL(TInt aCodecType, TInt aCodecLevel, const TTRVideoFormat& aInputFormat, 

                                                const TTRVideoFormat& aOutputFormat)

    {

    PRINT((_L("CTRVideoDecoderClient::SetCodecParametersL(), In")))

    TInt status = KErrNone;

    iCodecType = aCodecType;

    iCodecLevel = aCodecLevel;

    iInputFormat = aInputFormat;

    iOutputFormat = aOutputFormat;

    // Input format

    if (!iCompresedFormat)

        {

        iCompresedFormat = CCompressedVideoFormat::NewL( iMimeType );

        }

    TRAP( status, iAcceleratedCodecSelected = CheckCodecInfoL(iUid) );

    if (status != KErrNone)

        {

        // Try again with the fallback decoder if one exists

        if( (iFallbackUid != TUid::Null()) && (iFallbackUid.iUid != iUid.iUid) )

            {

            TRAP( status, iAcceleratedCodecSelected = CheckCodecInfoL(iFallbackUid) );

            if (status != KErrNone)

                {

                PRINT((_L("CTRVideoDecoderClient::SetCodecParametersL(), Failed to get codec info")))

                User::Leave(KErrNotSupported);

                }

            PRINT((_L("CTRVideoDecoderClient::SetCodecParametersL(), Reverting to fallback decoder")))

            // Fallback ok, take it    

            iUid = iFallbackUid;

            }

        else

            {

            PRINT((_L("CTRVideoDecoderClient::SetCodecParametersL(), No suitable decoders found")))

            User::Leave(KErrNotSupported);

            }

        }

    PRINT((_L("CTRVideoDecoderClient::SetCodecParametersL(), Out")))

    }

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

// CTRVideoDecoderClient::CheckCodecInfoL

// Checks coded info

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

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

//

TBool CTRVideoDecoderClient::CheckCodecInfoL(TUid aUid)

    {

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

    TInt status = KErrNone;

    TBool accelerated = EFalse;

    // Check decoder

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

    decoderInfo = iDevVideoPlay->VideoDecoderInfoLC( aUid );

    if (!decoderInfo)

        {

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

        User::Leave(KErrNotSupported);

        } //  AA skip info check before symbian fix

    else /* if ( !decoderInfo->SupportsFormat(*iCompresedFormat) ) // Check input format

        {

        PRINT((_L("CTRVideoDecoderClient::CheckCodecInfoL(), Input format is not supported")))

        status = KErrNotSupported;

        }

    else */

        {

        // Check max rate for requested image format

        TSize maxSize = decoderInfo->MaxPictureSize();

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

            {

            PRINT((_L("CTRVideoDecoderClient::CheckCodecInfoL(), Picture size is not supported")))

            status = KErrNotSupported;

            }

        }

    accelerated = decoderInfo->Accelerated();

    // Delete codec info

    CleanupStack::PopAndDestroy(decoderInfo);

    if (status != KErrNone)

        {

        User::Leave(status);

        }

    return accelerated;

    }

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

// CTRVideoDecoderClient::InitializeL

// Initializes encoder

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

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

//

void CTRVideoDecoderClient::InitializeL()

    {

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

    TUint maxBufferSize = 0;

    TInt status = KErrNone;

    switch(iInputFormat.iDataType)

        {

        case CTRTranscoder::ETRDuCodedPicture:

            {

            iDataUnitType = EDuCodedPicture;

            break;

            }

        case CTRTranscoder::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 KTRH264CodecLevel10:

            {

            maxBufferSize = KTRMaxBufferSizeH264Level10;

            break;

            }

        case KTRH264CodecLevel10b:

            {

            maxBufferSize = KTRMaxBufferSizeH264Level10b;

            break;

            }

        case KTRH264CodecLevel11:

            {

            maxBufferSize = KTRMaxBufferSizeH264Level11;

            break;

            }

        case KTRH264CodecLevel12:

            {

            maxBufferSize = KTRMaxBufferSizeH264Level12;

            break;

            }

        case KTRH264CodecLevel13:

            {

            maxBufferSize = KTRMaxBufferSizeH264Level13;

            break;

            }

        case KTRH264CodecLevel20:

            {

            maxBufferSize = KTRMaxBufferSizeH264Level20;

            break;

            }

        case KTRH264CodecLevel30:

            {

            maxBufferSize = KTRMaxBufferSizeH264Level30;

            break;

            }

        case KTRH264CodecLevel31:

            {

            maxBufferSize = KTRMaxBufferSizeH264Level31;

            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("CTRVideoDecoderClient::InitializeL(), InputBufferSize[%d], NumberOfBuffers[%d]"), 

               iBufferOptions.iMaxInputBufferSize, iBufferOptions.iMinNumInputBuffers ))

    iDevVideoPlay->SetBufferOptionsL(iBufferOptions);

    if (iScalingInUse)

        {

        PRINT((_L("CTRVideoDecoderClient::InitializeL(), Enabling scaling")))

        if (iScalingWithDeblocking)

            {

            // Enable scaling with deblocking

            iDevVideoPlay->SetPostProcessTypesL(iHwDeviceId, EPpScale | EPpDeblocking);

            }

        else

            {

            // Deblocking not supported, enable just scaling

            iDevVideoPlay->SetPostProcessTypesL(iHwDeviceId, EPpScale);

            }

        iDevVideoPlay->SetScaleOptionsL(iHwDeviceId, iScaledOutputSize, EFalse);

        }

    // Initialize devVideoPlay

    iDevVideoPlay->Initialize();

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

    }

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

// CTRVideoDecoderClient::SelectDecoderL

// Selects decoder

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