/*

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

* Implementation for video encoder.

*

*/

#include "statusmonitor.h"

#include "videoencoder.h"

#include "vedvideosettings.h"

#include "vedvolreader.h"

#include "vedavcedit.h"

// Assertion macro wrapper for code cleanup

#define VEASSERT(x) __ASSERT_DEBUG(x, User::Panic(_L("CVIDEOENCODER"), EInternalAssertionFailure)) 

// Debug print macro

#ifdef _DEBUG

#include <e32svr.h>

#define PRINT(x) RDebug::Print x

#else

#define PRINT(x)

#endif

// Constants

// time increment resolution

const TUint KTimeIncrementResolutionHW = 30000;

//const TUint KTimeIncrementResolutionSW = 29;

const TReal KMinRandomAccessRate = 0.2;

//const TUint KPictureQuality = 50;

//const TReal KLatencyQyalityTradeoff = 1.0;

//const TReal KQualityTemporalTradeoff = 0.8;

//const TBool KEncodingRealTime = EFalse;

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

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

// CVideoEncoder::NewL

// Two-phased constructor.

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

//

CVideoEncoder* CVideoEncoder::NewL(CStatusMonitor *aMonitor, CVedAVCEdit* aAvcEdit, 

                                   const TPtrC8& aVideoMimeType)

{

	PRINT((_L("CVideoEncoder::NewL() : MDF"))); 

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

	CleanupStack::PushL( self );

	self->ConstructL(aMonitor, aAvcEdit, aVideoMimeType);

	CleanupStack::Pop();

	return self;    

}

CVideoEncoder::CVideoEncoder() : CActive(EPriorityStandard), iInputBuffer(0,0)

{    

    iPreviousTimeStamp = TTimeIntervalMicroSeconds(0);

    iKeyFrame = EFalse;

}

void CVideoEncoder::ConstructL(CStatusMonitor *aMonitor, CVedAVCEdit* aAvcEdit, 

                               const TPtrC8& aVideoMimeType)

{

	iTranscoder = NULL;	

	iMonitor = aMonitor;

	iAvcEdit = aAvcEdit;

	iFrameSize = KVedResolutionQCIF;

	iFrameRate = 15.0;	

	iInputFrameRate = 15.0;

	iRandomAccessRate = KMinRandomAccessRate;

    // interpret and store video codec MIME-type. Allocates also iDataBuffer

    SetVideoCodecL( aVideoMimeType );	

	iStatus = NULL;	

	iVolReader = CVedVolReader::NewL();

	// allocate input picture

	iInputPicture = new (ELeave) TTRVideoPicture;

	// Create a timer 

	User::LeaveIfError(iTimer.CreateLocal());

	iTimerCreated = ETrue;

	// Add us to active scheduler

	CActiveScheduler::Add(this);

}

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

// CVideoEncoder::~CVideoEncoder()

// Destructor

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

//

CVideoEncoder::~CVideoEncoder()

    {

    Cancel();

    if ( iInputPicture )

	{

        delete iInputPicture;

		iInputPicture = 0;

	}

	if ( iDataBuffer )

	{	        

	    delete iDataBuffer;

	    iDataBuffer = 0;

	}

    if ( iTranscoder )

	{

        delete iTranscoder;

		iTranscoder = 0;

	}

	if ( iVolReader )

	{

	    delete iVolReader;

	    iVolReader = 0;

	}

    if ( iTimerCreated )

	{

        iTimer.Close();

		iTimerCreated = EFalse;

	}

    }

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

// CVideoEncoder::SetVideoCodecL()

// Interpret and store video mime type

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

//

void CVideoEncoder::SetVideoCodecL(const TPtrC8& aMimeType)

    {

    TBuf8<256> string;

    TBuf8<256> newMimeType;

    string = KVedMimeTypeH263;

    string += _L8( "*" );

	TInt dataBufferSize = KMaxCodedPictureSizeQCIF;

    iMaxFrameRate = 15.0;

    iArbitrarySizeAllowed = EFalse;

    if ( aMimeType.MatchF( (const TDesC8& )string ) != KErrNotFound ) 

        {

        // H.263

        newMimeType = KVedMimeTypeH263;

        if ( aMimeType.MatchF( _L8("*profile*") ) != KErrNotFound )

            {

            // profile given, check if we support it

            if ( aMimeType.MatchF( _L8("*profile=0*")) != KErrNotFound )

                {

                // profile 0 requested

                newMimeType += _L8( "; profile=0" );

                }

            else

                {

                // no other profiles supported

                PRINT((_L("CVideoEncoder::SetVideoCodecL() unsupported profile")));

                User::Leave(KErrNotSupported);

                }

            }

        else

            {

            // no profile is given => assume 0

            newMimeType += _L8( "; profile=0" );

            }

        if ( aMimeType.MatchF( _L8("*level=10*") ) != KErrNotFound )

            {

    		iMaxBitRate = iBitRate = KVedBitRateH263Level10;

    		iMaxResolution = KVedResolutionQCIF;

    		dataBufferSize = KMaxCodedPictureSizeQCIF;

            newMimeType += _L8( "; level=10" );

            }

        else if ( aMimeType.MatchF( _L8("*level=45*") ) != KErrNotFound )

            {

    		iMaxBitRate = iBitRate = KVedBitRateH263Level45;

    		iMaxResolution = KVedResolutionQCIF;

    		dataBufferSize = KMaxCodedPictureSizeQCIF;

            newMimeType += _L8( "; level=45" );

            }

        else if ( aMimeType.MatchF( _L8("*level*") ) != KErrNotFound )

            {

            // no other levels supported

            PRINT((_L("CVideoEncoder::SetVideoCodecL() unsupported level")));

            User::Leave(KErrNotSupported);

            }

        else

            {

            // if no level is given assume 10

    		iMaxBitRate = iBitRate = KVedBitRateH263Level10;

    		iMaxResolution = KVedResolutionQCIF;

    		dataBufferSize = KMaxCodedPictureSizeQCIF;

            newMimeType += _L8( "; level=10" );

            }

        }

    else

        {

        string = KVedMimeTypeMPEG4Visual;

        string += _L8( "*" );

        if ( aMimeType.MatchF( string ) != KErrNotFound ) 

            {

            // MPEG-4 Visual

            newMimeType = KVedMimeTypeMPEG4Visual;

            if ( aMimeType.MatchF( _L8("*profile-level-id=8*") ) != KErrNotFound )

                {

                // simple profile level 0

        		iMaxBitRate = iBitRate = KVedBitRateMPEG4Level0;

        		iMaxResolution = KVedResolutionQCIF;

                // define max size 10K

                dataBufferSize = KMaxCodedPictureSizeMPEG4QCIF;

                newMimeType += _L8("; profile-level-id=8");

                }

            else if ( aMimeType.MatchF( _L8("*profile-level-id=9*") ) != KErrNotFound )

                {

                // simple profile level 0b

        		iMaxBitRate = iBitRate = KVedBitRateMPEG4Level0;

        		iMaxResolution = KVedResolutionQCIF;

                // define max size 10K

                dataBufferSize = KMaxCodedPictureSizeMPEG4QCIF;

                newMimeType += _L8("; profile-level-id=9");

                }

            else if ( aMimeType.MatchF( _L8("*profile-level-id=1*") ) != KErrNotFound )

                {

                // simple profile level 1

        		iMaxBitRate = iBitRate = KVedBitRateMPEG4Level0;

        		iMaxResolution = KVedResolutionQCIF;

                // define max size 10K

                dataBufferSize = KMaxCodedPictureSizeMPEG4QCIF;

                iArbitrarySizeAllowed = ETrue;                

                newMimeType += _L8("; profile-level-id=1");

                }

            else if ( aMimeType.MatchF( _L8("*profile-level-id=2*") ) != KErrNotFound )

                {

                // simple profile level 2

			    dataBufferSize = KMaxCodedPictureSizeMPEG4CIF;

        		iMaxResolution = KVedResolutionCIF;

			    iMaxBitRate = iBitRate = KVedBitRateMPEG4Level2;

                iArbitrarySizeAllowed = ETrue;                

                newMimeType += _L8("; profile-level-id=2");

                }

            else if ( aMimeType.MatchF( _L8("*profile-level-id=3*") ) != KErrNotFound )

                {

                // simple profile level 3

			    dataBufferSize = KMaxCodedPictureSizeMPEG4CIF;

			    iMaxBitRate = iBitRate = KVedBitRateMPEG4Level2;

        		iMaxResolution = KVedResolutionCIF;

			    iMaxFrameRate = 30.0;

                iArbitrarySizeAllowed = ETrue;                

                newMimeType += _L8("; profile-level-id=3");

                }

            else if ( aMimeType.MatchF( _L8("*profile-level-id=4*") ) != KErrNotFound )

                {

                // simple profile level 4a

			    iMaxBitRate = iBitRate = KVedBitRateMPEG4Level4A;	        	

			    dataBufferSize = KMaxCodedPictureSizeVGA;

        		iMaxResolution = KVedResolutionVGA;

			    iMaxFrameRate = 30.0;

                iArbitrarySizeAllowed = ETrue;                

                newMimeType += _L8("; profile-level-id=4");

                }

            else if ( aMimeType.MatchF( _L8("*profile-level-id=*") ) != KErrNotFound )

                {

                // no other profile-level ids supported

                PRINT((_L("CVideoEncoder::SetVideoCodecL() unsupported MPEG-4 profile-level")));

                User::Leave(KErrNotSupported);

                }

            else

                {

                // Default is level 0 in our case (normally probably level 1)

        		iMaxBitRate = iBitRate = KVedBitRateMPEG4Level0;

        		iMaxResolution = KVedResolutionQCIF;

                // define max size 10K

                dataBufferSize = KMaxCodedPictureSizeMPEG4QCIF;

                newMimeType += _L8("; profile-level-id=8");

                }

            }

        else

            {

#ifdef VIDEOEDITORENGINE_AVC_EDITING

            string = KVedMimeTypeAVC;

            string += _L8( "*" );                

            if ( aMimeType.MatchF( string ) != KErrNotFound ) 

                {

                // AVC

                newMimeType = KVedMimeTypeAVC;

                if ( aMimeType.MatchF( _L8("*profile-level-id=42800A*") ) != KErrNotFound )

                    {

                    // baseline profile level 1

            		iMaxBitRate = iBitRate = KVedBitRateAVCLevel1;

            		iMaxResolution = KVedResolutionQCIF;                        

                    dataBufferSize = KMaxCodedPictureSizeAVCLevel1;

                    iArbitrarySizeAllowed = ETrue;                

                    newMimeType += _L8("; profile-level-id=42800A");

                    }                    

                else if ( aMimeType.MatchF( _L8("*profile-level-id=42900B*") ) != KErrNotFound )

                    {                                                

                    // baseline profile level 1b

                    iMaxBitRate = iBitRate = KVedBitRateAVCLevel1b;

            		iMaxResolution = KVedResolutionQCIF;                        

                    dataBufferSize = KMaxCodedPictureSizeAVCLevel1B;

                    iArbitrarySizeAllowed = ETrue;                

                    newMimeType += _L8("; profile-level-id=42900B");

                    }

                else if ( aMimeType.MatchF( _L8("*profile-level-id=42800B*") ) != KErrNotFound )

                    {

                    // baseline profile level 1.1

                    iMaxBitRate = iBitRate = KVedBitRateAVCLevel1_1;

            		iMaxResolution = KVedResolutionCIF;                        

                    dataBufferSize = KMaxCodedPictureSizeAVCLevel1_1;

                    iArbitrarySizeAllowed = ETrue;                

                    newMimeType += _L8("; profile-level-id=42800B");

                    }

                else if ( aMimeType.MatchF( _L8("*profile-level-id=42800C*") ) != KErrNotFound )

                    {

                    // baseline profile level 1.2

                    iMaxBitRate = iBitRate = KVedBitRateAVCLevel1_2;

            		iMaxResolution = KVedResolutionCIF;                        

                    dataBufferSize = KMaxCodedPictureSizeAVCLevel1_2;

                    iArbitrarySizeAllowed = ETrue;                

                    newMimeType += _L8("; profile-level-id=42800C");                    

                    }      

                //WVGA task

                else if ( aMimeType.MatchF( _L8("*profile-level-id=42801F*") ) != KErrNotFound )

                    {

                    // baseline profile level 1.3

                    iMaxBitRate = iBitRate = KVedBitRateAVCLevel3_1;

            		iMaxResolution = KVedResolutionWVGA;                        

                    dataBufferSize = KMaxCodedPictureSizeAVCLevel3_1;

                    iArbitrarySizeAllowed = ETrue;                

                    newMimeType += _L8("; profile-level-id=42801F");                    

                    }

                else if ( aMimeType.MatchF( _L8("*profile-level-id=*") ) != KErrNotFound )

                    {

                    // no other profile-level ids supported

                    PRINT((_L("CVideoEncoder::SetVideoCodecL() unsupported AVC profile-level")));

                    User::Leave(KErrNotSupported);

                    }

                else

                    {

                        // Default is level 1 (?)

                        iMaxBitRate = iBitRate = KVedBitRateAVCLevel1;

                		iMaxResolution = KVedResolutionQCIF;                            

                        dataBufferSize = KMaxCodedPictureSizeAVCLevel1;

                        newMimeType += _L8("; profile-level-id=42800A");

                    }                

                }

            else

                {

                    // unknown mimetype

                    User::Leave( KErrNotSupported );

                }                                        

#else

                    // unknown mimetype

                    User::Leave( KErrNotSupported );

#endif

            }

        }

    // successfully interpreted the input mime type

    iMimeType = newMimeType;

    if ( iDataBuffer )

        {

        delete iDataBuffer;

        iDataBuffer = NULL;

        }

	iDataBuffer = (HBufC8*) HBufC8::NewL(dataBufferSize);    

    }

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

// CVideoEncoder::SetFrameSizeL

// Sets the used frame size

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

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

//

void CVideoEncoder::SetFrameSizeL(const TSize& aSize)

    {

    if (iFrameSize == aSize)

        return;

    if ( (aSize.iWidth > iMaxResolution.iWidth) || (aSize.iHeight > iMaxResolution.iHeight))

        {

        if ( iArbitrarySizeAllowed ) // This is for future-proofness. Currently the checking of standard sizes below overrules this one

            {

            if ( aSize.iWidth * aSize.iHeight > iMaxResolution.iWidth*iMaxResolution.iHeight )

                {

                PRINT((_L("CVideoEncoder::SetFrameSizeL() too high resolution requested")));

                User::Leave( KErrNotSupported );

                }

            }

        else

            {

            PRINT((_L("CVideoEncoder::SetFrameSizeL() incompatible or too high resolution requested")));

            User::Leave( KErrNotSupported );

            }

        }

	// check new size. For now only standard sizes are allowed

	if ( (aSize != KVedResolutionSubQCIF) && 

		 (aSize != KVedResolutionQCIF) &&

		 (aSize != KVedResolutionCIF) &&

		 (aSize != KVedResolutionQVGA) &&

		 (aSize != KVedResolutionVGA16By9) &&

		 (aSize != KVedResolutionVGA) &&

		 //WVGA task

		 (aSize != KVedResolutionWVGA) )

	{

		 User::Leave( KErrArgument );

	}

    iFrameSize = aSize;    

    }

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

// CVideoEncoder::GetFrameSize

// Gets the used frame size

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

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

//

void CVideoEncoder::FrameSize(TSize& aSize) const

    {

    aSize = iFrameSize;

    }

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

// CVideoEncoder::SetFrameRate

// Sets the used targt frame rate

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

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

//

TInt CVideoEncoder::SetFrameRate(const TReal aFrameRate)

{

    VEASSERT(aFrameRate > 0.0);

    if ( aFrameRate <= iMaxFrameRate )

        {

        iFrameRate = TReal32(aFrameRate);

        }

    else

        {

        iFrameRate = iMaxFrameRate;

        }

    // target framerate cannot be larger than source framerate

    if (iFrameRate > iInputFrameRate)

        iFrameRate = iInputFrameRate;

    return KErrNone;

}

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

// CVideoEncoder::SetInputFrameRate

// Sets the used input sequence frame rate

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

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

//

TInt CVideoEncoder::SetInputFrameRate(const TReal aFrameRate)

    {

    VEASSERT(aFrameRate > 0.0);

    iInputFrameRate = aFrameRate;

    // target framerate cannot be larger than source framerate

    if (iFrameRate > iInputFrameRate)

        iFrameRate = iInputFrameRate;

    return KErrNone;

    }

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

// CVideoEncoder::SetRandomAccessRate

// Sets the used target random access rate

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

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

//

TInt CVideoEncoder::SetRandomAccessRate(const TReal aRate)

{

    VEASSERT(aRate > 0.0);

    iRandomAccessRate = aRate;

    return KErrNone;

}

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

// CVideoEncoder::SetBitrate

// Sets the used target bitrate