/*

* 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 encoder client.

*

*/

// INCLUDE FILES

#include <devvideorecord.h>

#include <devvideobase.h>

#include <devvideoconstants.h>

#include <H263.h>

#include <AVC.h>

#include <Mpeg4Visual.h>

#include "ctrtranscoder.h"

#include "ctrvideoencoderclient.h"

#include "ctrdevvideoclientobserver.h"

#include "ctrsettings.h"

#include "ctrhwsettings.h"

// MACROS

#define TRASSERT(x) __ASSERT_DEBUG(x, User::Panic(_L("CTRANSCODERVIDEOENCODERCLIENT"), -10000))

// CONSTANTS

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

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

// CTRVideoEncoderClient::NewL

// Two-phased constructor.

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

//

CTRVideoEncoderClient* CTRVideoEncoderClient::NewL(MTRDevVideoClientObserver& aObserver)

    {

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

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

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

    return self;

    }

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

// CTRVideoEncoderClient::CTRVideoEncoderClient

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

// might leave.

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

//

CTRVideoEncoderClient::CTRVideoEncoderClient(MTRDevVideoClientObserver& aObserver) :

    iObserver(aObserver)

    {

    iDevVideoRecord = NULL;

    iOutputMediaBuffer = NULL;

    iCompresedFormat = NULL;

    iUid = TUid::Null();

    iFallbackUid = TUid::Null();

    iRealTime = EFalse;

    iState = ETRNone;

    iCodingOptions.iSyncIntervalInPicture = 0;

    iCodingOptions.iHeaderExtension = 0;

    iCodingOptions.iDataPartitioning = EFalse;

    iCodingOptions.iReversibleVLC = EFalse;

    iSrcRate = 0.0;

    iVolHeaderSent = EFalse;

    iRemoveHeader = EFalse;

    iVolLength = 0;

    iRateOptions.iControl = EBrControlStream;

    iRateOptions.iPictureRate = KTRTargetFrameRateDefault;

    iRateOptions.iBitrate = KTRMaxBitRateH263Level10;

    iBitRateSetting = EFalse;

    iFatalError = KErrNone;

    iErrorRate = 0.0;

    iVolHeader = KNullDesC8;

    iVideoBufferManagementCI = NULL;

    iLastTimestamp = -1;

    iAcceleratedCodecSelected = EFalse;

    iSetRandomAccessPoint = EFalse;

    iNumH264SPSPPS = 0;

    }

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

// CTRVideoEncoderClient::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CTRVideoEncoderClient::ConstructL()

    {

    iDevVideoRecord = CMMFDevVideoRecord::NewL(*this);

    iOutputMediaBuffer = new(ELeave)CCMRMediaBuffer;

    }

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

// CTRVideoEncoderClient::~CTRVideoEncoderClient()

// Destructor

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

//

CTRVideoEncoderClient::~CTRVideoEncoderClient()

    {

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

    if (iDevVideoRecord)

        {

        delete iDevVideoRecord;

        iDevVideoRecord = NULL;

        }

    if (iCompresedFormat)

        {

        delete iCompresedFormat;

        }

    if (iOutputMediaBuffer)

        {

        delete iOutputMediaBuffer;

        }

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

    }

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

// CTRVideoEncoderClient::SupportsInputFormat

// Checks whether given input format is supported

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

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

//

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

    {

    TBool supports = EFalse;

    TBool preferredFound = EFalse;

    TBool fallbackFound = EFalse;

    if (iDevVideoRecord)

        {

        RArray<TUid> encoders;

        TRAPD( status, iDevVideoRecord->FindEncodersL(aShortFormat, 0/*aPreProcType*/, encoders, EFalse/*aExactMatch*/) );

        if( status != KErrNone  )

            {

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

            supports = EFalse;

            }

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

            {

            PRINT((_L("CTRVideoEncoderClient::SupportsCodec(), No encoders found")))

            supports = EFalse;

            }

        else

            {

            PRINT((_L("CTRVideoEncoderClient::SupportsCodec(), %d encoders found"), encoders.Count() ))

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

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

                {

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

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

                    {

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

                    iUid = encoders[i];

                    preferredFound = ETrue;

                    }

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

                    {

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

                    iFallbackUid = encoders[i];

                    fallbackFound = ETrue;

                    }

                if( preferredFound && fallbackFound )

                    {

                    // No need to search anymore

                    break;

                    }

                }

            }

        encoders.Reset();

        encoders.Close();

        }

#if !( defined (__WINS__) || defined (__WINSCW__) )

    if( !preferredFound )

#else

    if( !preferredFound && !fallbackFound )

#endif

        {

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

        PRINT((_L("CTRVideoEncoderClient::SupportsCodec(), No supported encoders found")))

        supports = EFalse;

        }

    else

        {

        PRINT((_L("CTRVideoEncoderClient::SupportsCodec(), Supported encoder found: 0x%x"), iUid.iUid))

        iMimeType = aFormat;

        iShortMimeType = aShortFormat;

        supports = ETrue;

        }

    return supports;

    }

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

// CTRVideoEncoderClient::SetCodecParametersL

// Sets codec parameters

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

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

//

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

                                                const TTRVideoFormat& aOutputFormat)

    {

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

    TInt status = KErrNone;

    iCodecType = aCodecType;

    iCodecLevel = aCodecLevel;

    iPictureSize = aOutputFormat.iSize;

    iOutputDataType = aOutputFormat.iDataType;

    // RAW YUV

    iUncompressedFormat.iDataFormat = EYuvRawData;

    // U & V samples are taken from the middle of four luminance samples

    // (as specified in H.263 spec)

    switch ( aInputFormat.iDataType )

        {

        case CTRTranscoder::ETRYuvRawData420:

            {

            iUncompressedFormat.iYuvFormat.iPattern = EYuv420Chroma2;

            break;

            }

        case CTRTranscoder::ETRYuvRawData422:

            {

            iUncompressedFormat.iYuvFormat.iPattern = EYuv422Chroma2;

            break;

            }

        default:

            {

            iUncompressedFormat.iYuvFormat.iPattern = EYuv420Chroma2;

            break;

            }

        }

    // Output format

    if (!iCompresedFormat)

        {

        iCompresedFormat = CCompressedVideoFormat::NewL( iMimeType );

        }

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

    if (status != KErrNone)

        {

        // Try again with the fallback encoder if one exists

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

            {

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

            if (status != KErrNone)

                {

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

                User::Leave(KErrNotSupported);

                }

            PRINT((_L("CTRVideoEncoderClient::SetCodecParametersL(), Reverting to fallback encoder")))

            // Fallback ok, take it   

            iUid = iFallbackUid;

            }

        else

            {

            PRINT((_L("CTRVideoEncoderClient::SetCodecParametersL(), No suitable encoders found")))

            User::Leave(KErrNotSupported);

            }

        }          

    //  AA Set codec here (final hwdevice Uid should be known before checking CI buffermanag support)

    // Select encoder first

    this->SelectEncoderL();

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

    }

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

// CTRVideoEncoderClient::CheckCodecInfoL

// Checks codec info

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

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

//

TBool CTRVideoEncoderClient::CheckCodecInfoL(TUid aUid)

    {

    CVideoEncoderInfo* encoderInfo = NULL; // Encoder info for retrieving capabilities

    iMaxFrameRate = 0;

    TInt status = KErrNone;

    TUint32 dataUnitType = 0;

    TBool accelerated = EFalse;

    switch(iOutputDataType)

        {

        case CTRTranscoder::ETRDuCodedPicture:

            {

            dataUnitType = EDuCodedPicture;

            break;

            }

        case CTRTranscoder::ETRDuVideoSegment:

            {

            dataUnitType = EDuVideoSegment;

            break;

            }

        default:

            {

            PRINT((_L("CTRVideoEncoderClient::CheckCodecInfoL(), should leave at the earlier stage, panic")))

            TRASSERT(0);

            }

        }

    // Check encoder

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

    encoderInfo = iDevVideoRecord->VideoEncoderInfoLC( aUid );

    PRINT((_L("CTRVideoEncoderClient::CheckCodecInfoL(), info [0x%x]"), encoderInfo ))

    if (!encoderInfo)

        {

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

        User::Leave(KErrNotSupported);

        }

    else

        {

        // Check input format

        // 1. retrieve supported formats from encoder hwdevice (since exact options are unknown)

        RArray<TUncompressedVideoFormat> supportedInputFormats = encoderInfo->SupportedInputFormats();

        TInt formatCount = supportedInputFormats.Count();

        if (formatCount <= 0)

            {

            supportedInputFormats.Close();

            PRINT((_L("CTRVideoEncoderClient::CheckCodecInfoL(), There are no supported input formats") ))

            User::Leave(KErrNotSupported);

            }

        else

            {

            TUncompressedVideoFormat uncFormat;

            TBool found = EFalse;

            TInt pattern1, pattern2;

            TInt dataLayout;

            if (iUncompressedFormat.iYuvFormat.iPattern == EYuv420Chroma2)

                {

                pattern1 = EYuv420Chroma1;

                pattern2 = EYuv420Chroma2;

                dataLayout = EYuvDataPlanar;

                }

            else

                {

                pattern1 = EYuv422Chroma1;

                pattern2 = EYuv422Chroma2;

                dataLayout = EYuvDataInterleavedBE;

                }

            // Check the most important paramers

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

                {

                uncFormat = supportedInputFormats[i];

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

                     (uncFormat.iYuvFormat.iDataLayout == dataLayout) &&

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

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

                    {

                    // Assign the rest of parameters

                    iUncompressedFormat = uncFormat;

                    if ( iCodecType != EH263 )

                        {

                        // Set aspect ratio to 1:1 (square)

                        iUncompressedFormat.iYuvFormat.iAspectRatioNum = 1;

                        iUncompressedFormat.iYuvFormat.iAspectRatioDenom = 1;

                        }

                    found = ETrue;

                    break;

                    }

                }

            if (!found)

                {

                supportedInputFormats.Close();

                PRINT((_L("CTRVideoEncoderClient::CheckCodecInfoL(), Supported format is not found") ))

                User::Leave(KErrNotSupported);

                }

            }

        /*if ( !encoderInfo->SupportsOutputFormat(*iCompresedFormat) ) // comment until symbian error is fixed

            {

            PRINT((_L("CTRVideoEncoderClient::CheckCodecInfoL(), Output format is not supported")))

            status = KErrNotSupported;

            }

        else */

        if ( (encoderInfo->SupportedDataUnitTypes() & dataUnitType) != dataUnitType ) 

            {

            PRINT((_L("CTRVideoEncoderClient::CheckCodecInfoL(), There's no support for this DUType")))

            status = KErrNotSupported;

            }

        else

            {

            // Get max rate for requested image format

            RArray<TPictureRateAndSize> rateAndSize = encoderInfo->MaxPictureRates();

            TUint rates = rateAndSize.Count();

            TSize picSize = iPictureSize;

            if ( picSize == TSize(640, 352) )  // Use VGA max frame rate for VGA 16:9

                picSize = TSize(640, 480);

            for ( TUint i = 0; i < rates; i++ )

                {

                if ( rateAndSize[i].iPictureSize == picSize )

                    {

                    status = KErrNone;

                    iMaxFrameRate = rateAndSize[i].iPictureRate;

                    PRINT((_L("CTRVideoEncoderClient::CheckCodecInfoL(), Needed picture size found!")))

                    break;

                    }

                status = KErrNotSupported;

                }

            }

        }

    accelerated = encoderInfo->Accelerated();

    // Delete codec info

    CleanupStack::PopAndDestroy(encoderInfo);

    if (status != KErrNone)

        {

        User::Leave(status);

        }

    return accelerated;

    }

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

// CTRVideoEncoderClient::SetBitRate

// Sets video bitrate

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

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

//

void CTRVideoEncoderClient::SetBitRate(TUint aBitRate)

    {

    if ( (iState == ETRInitialized) || (iState == ETRRunning) || (iState == ETRPaused) )

        {

        iRateOptions.iBitrate = aBitRate;

        iRateOptions.iPictureQuality = KTRPictureQuality;

        iRateOptions.iQualityTemporalTradeoff = KTRQualityTemporalTradeoff;

        if (iRealTime)

            {

            iRateOptions.iLatencyQualityTradeoff = KTRLatencyQualityTradeoffRT;

            }

        else

            {

            iRateOptions.iLatencyQualityTradeoff = KTRLatencyQualityTradeoffNonRT;

            }

        // Set bit rate to Encoder

        iDevVideoRecord->SetRateControlOptions(0/*Layer 0 is supported*/, iRateOptions);

        iBitRateSetting = ETrue;

        }

    else

        {

        // Keep bit rate and set it later

        iRateOptions.iBitrate = aBitRate;

        }

    }

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

// CTRVideoEncoderClient::SetRealTime

// Sets encoder mode to operate real-time

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

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

//

void CTRVideoEncoderClient::SetRealTime(TBool aRealTime)

    {

    iRealTime = aRealTime;

    }

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

// CTRVideoEncoderClient::SetFrameRate

// Sets frame rate

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

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

//

void CTRVideoEncoderClient::SetFrameRate(TReal& aFrameRate)