/*

* Copyright (c) 2009 Aricent and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:

* Aricent - initial contribution.

*

* Contributors:

*

* Description:

* Implementation of member functions of H264 encoder plugin class -

* CAriH264encHwDeviceImpl.

*

*/

// System Includes

#include <e32base.h>

#include <avc.h>

#include <e32math.h>

// User Includes

#include "arih264enchwdeviceimpl.h"

#include "arih264hwdeviceconstants.h"

#include "arih264encwrapper.h"

// MACRO DEFINITIONS - start

// Uncomment this flag to enable instant rate calculations on-the-fly in urel

// builds. In UDEB it is enabled automatically

// By default it is commented

//#define CALCINSTANTBITRATE

// Uncomment to print additional debug information retrieved from

// core encoder

//#define DEBUG_INFO

// MACRO DEFINITIONS - end

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

//  Maps the num/denom from the MDF to the aspect_ratio_idc value supported

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

//

TInt32 MapAspectRatio( TUint32 aNumerator, TUint32 aDenominator )

	{

	PRINT_ENTRY;

	TInt32 aspectratio = -1;

	switch ( aDenominator )

		{

		case 1:

			if ( aNumerator == 1 )

				{

				aspectratio = 1;

				}

			break;

		case 11:

			switch ( aNumerator )

				{

				case 12:

					aspectratio = 2;

					break;

				case 10:

					aspectratio = 3;

					break;

				case 16:

					aspectratio = 4;

					break;

				case 24:

					aspectratio = 6;

					break;

				case 20:

					aspectratio = 7;

					break;

				case 32:

					aspectratio = 8;

					break;

				case 18:

					aspectratio = 10;

					break;

				case 15:

					aspectratio = 11;

					break;

				default:

					break;

				}

			break;

		case 33:

			switch ( aNumerator )

				{

				case 40:

					aspectratio = 5;

					break;

				case 80:

					aspectratio = 9;

					break;

				case 64:

					aspectratio = 12;

					break;

				default:

					break;

				}

			break;

		case 99:

			if ( aNumerator == 160 )

				{

				aspectratio = 13;

				}

			break;

		default:

			break;

		}

	PRINT_EXIT;

	return aspectratio;

	}

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

//  Two phase constructor for an object of CAriH264encHwDeviceImpl

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

//

CAriH264encHwDeviceImpl* CAriH264encHwDeviceImpl::NewL()

	{

	PRINT_ENTRY;

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

	PRINT_EXIT;

    return self;

	}

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

//  Default constructor

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

//

CAriH264encHwDeviceImpl::CAriH264encHwDeviceImpl()

    :iMMFDevVideoRecordProxy( NULL ),

     iInputDevice ( NULL ),

     iClockSource ( NULL ),

	 iInputBufReturnToPreProc( EFalse ),

     iPeriodicTimer ( NULL ),

	 iClockTimeWhenPaused( 0 ),

	 //100 milli seconds

     iPollingInterval(TTimeIntervalMicroSeconds32( KPOLLINGINTERVAL ) ),

     iCodec( NULL ),

     iEngine( NULL ),

	 iOutputBuffers( NULL ),

     iOutputBufferSize( 0 ),

     iPauseOffset( 0 ),

     iTotalTime( 0 ),

     iLastEncodedPictureTimestamp( 0 ),

	 iPictureLoss( EFalse ),

	 iInputEndCalled( EFalse ),

	 iFrozen( EFalse ),

	 iTotalLengthFilledSoFarInPacketMode( 0 ),

	 iTotalOutputBufferLengthInPacketMode( 0 ),

	 iPacketOffSetCurrentPosition( NULL ),

	 iPacketOffSetAndLengthInfoBuffers( NULL ),

	 iInternalOutputBuffers( NULL ),

	 iNumOfBuffersAtClientInPacketModeNeedReAllocation( 0 ),

	 iPacketsPending( EFalse ),

	 iNumOfOutBuffersAvailableInPacketModeChange( 0 ),

	 iNumofBuffersPendingFromClientInChangeToPacketMode( 0 ),

	 iNumOfOutBuffersBeforeChangeToPacketMode( 0 ),

	 iCodedBufferForPacketModeChange( NULL ),

	 iSegmentBuffers( NULL ),

	 iIsConfigDataFilledInFirstOutputBuffer( EFalse ),

	 iIsSliceEnabledInCodedPicture( EFalse ),

	 iNoOfOutputFramesPerSec( 0 ),

	 iSizePerFrame( 0 ),

	 iEncStateMac( NULL )

	{

	PRINT_ENTRY;

	iSupportedDataUnitTypes = EDuCodedPicture | EDuVideoSegment;

	iSupportedDataUnitEncapsulations = EDuElementaryStream

									   | EDuGenericPayload;

    // Default values for Init params - full range

    TUncompressedVideoFormat inputFormat;

    inputFormat.iDataFormat = EYuvRawData;

    inputFormat.iYuvFormat.iCoefficients = EYuvBt709Range1;

    inputFormat.iYuvFormat.iPattern = EYuv420Chroma1;

    inputFormat.iYuvFormat.iDataLayout = EYuvDataPlanar;

    inputFormat.iYuvFormat.iYuv2RgbMatrix = NULL;

    inputFormat.iYuvFormat.iRgb2YuvMatrix = NULL;

    inputFormat.iYuvFormat.iAspectRatioNum = 1;

    inputFormat.iYuvFormat.iAspectRatioDenom = 1;

    iH264EncInitParams.iInputFormat = inputFormat;

    iH264EncInitParams.iLevel = KH264ENCIMPL_LEVEL_UNKNOWN;

	iH264EncInitParams.iAfterInitialize = 0;

    iH264EncInitParams.iOutputFormat        = EH264;

    iH264EncInitParams.iMinNumOutputBuffers

		= KH264ENCIMPL_MAXNUM_OUTPUTBUFFERS;

	iH264EncInitParams.iMaxCodedSegmentSize

		= KH264ENCIMPL_DEFAULT_SEGMENTSIZE;

	iH264EncInitParams.iMaxPictureRate = KH264ENCIMPL_DEFAULT_PICTURERATE;

	// initialize picture counters

	iPictureCounters.iPicturesSkippedBufferOverflow = 0;

	iPictureCounters.iPicturesSkippedProcPower		= 0;

	iPictureCounters.iPicturesSkippedRateControl	= 0;

	iPictureCounters.iPicturesProcessed				= 0;

	iPictureCounters.iInputPictures					= 0;

	// default packet mode is off

	iH264EncInitParams.iDataEncapsulation 	= EDuElementaryStream;

    iH264EncInitParams.iDataUnitType		= EDuCodedPicture;

	iH264EncInitParams.iBitRate = KH264ENCIMPL_DEFAULT_BITRATE;

    iH264EncInitParams.iTargetPictureRate = KH264ENCIMPL_DEFAULT_PICTURERATE;

    iH264EncInitParams.iRandomAccessRate

		= KH264ENCIMPL_DEFAULT_RANDOMACCESSRATE;

    PRINT_EXIT;

	}

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

//  Destructor

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

//

CAriH264encHwDeviceImpl::~CAriH264encHwDeviceImpl()

	{

	PRINT_ENTRY;

	PRINT_MSG( LEVEL_LOW, ( "this is %x", this ) );

    iSupportedInputFormats.Close();

	iLevels.Close();

    //allocated formats should be deleted before closing

    while ( iSupportedOutputFormats.Count() > 0 )

		{

        CCompressedVideoFormat* lCompFormat =   iSupportedOutputFormats[0];

        iSupportedOutputFormats.Remove( 0 );

        delete lCompFormat;

		}

    iSupportedOutputFormats.Close();

	// Stop processing

	if( !iEncStateMac->IsStopped() && ( !iEncStateMac->IsInDeadState() ) )

		{

		if( iEncStateMac->IsInitialized() )

			{

			Stop();

			}

		}

	if( iEngine )

		{

		iEngine->Reset();

		delete iEngine;

		iEngine = NULL;

		}

	if( iCodec )

		{

		delete iCodec;

		iCodec = NULL;

		}

    //delete output buffers

    iOutputFreeBufferQueue.Reset();

    if( iOutputBuffers )

		{

		if( iNumOfOutBuffersBeforeChangeToPacketMode )

			{

			for ( TInt i = 0; i < iNumOfOutBuffersBeforeChangeToPacketMode

				; i++ )

				{

				if ( iOutputBuffers[i].iData.Ptr() )

					{

					delete ( TUint8* )iOutputBuffers[i].iData.Ptr();

					}

				}

			}

		else

			{

			for ( TInt i = 0; i < iH264EncInitParams.iMinNumOutputBuffers;

				i++ )

				{

				if ( iOutputBuffers[i].iData.Ptr() )

					{

					delete ( TUint8* )iOutputBuffers[i].iData.Ptr();

					}

				}

			}

		delete []iOutputBuffers;

        }

    delete iPeriodicTimer;

    iPeriodicTimer = NULL;

	if ( iPacketOffSetAndLengthInfoBuffers )

		{

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

			{

			delete [] ( TUint8* )iPacketOffSetAndLengthInfoBuffers[i];

			}

		delete []( TUint* )iPacketOffSetAndLengthInfoBuffers;

		}

    //delete temp output buffers

    iInternalOutputBufferQueue.Reset();

    if( iInternalOutputBuffers )

        {

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

            {

            if ( iInternalOutputBuffers[i].iData.Ptr() )

                {

                delete ( TUint8* )iInternalOutputBuffers[i].iData.Ptr();

                }

            }

		delete []iInternalOutputBuffers;

        }

	if ( iCodedBufferForPacketModeChange )

		{

		if ( iCodedBufferForPacketModeChange->iData.Ptr() )

			{

			delete iCodedBufferForPacketModeChange->iData.Ptr();

			}

		delete iCodedBufferForPacketModeChange;

		}

	iFreeBufferQueueForPacketOffsetInfo.Reset();

	iFilledBufferQueueForPacketOffsetInfo.Reset();

	//delete the segment buffers

    if( iSegmentBuffers )

        {

        for ( TInt i = 0; i < iH264EncInitParams.iMinNumOutputBuffers; i++ )

            {

            if ( iSegmentBuffers[i].iData.Ptr() )

                {

                delete ( TUint8* )iSegmentBuffers[i].iData.Ptr();

                }

            }

		delete []iSegmentBuffers;

        }

    if ( iConfigData )

    	{

    	delete iConfigData;

    	iConfigData = NULL;

    	}

    if ( iEncStateMac )

        {

    	delete iEncStateMac;

    	iEncStateMac = NULL;

        }

	PRINT_EXIT;

	}

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

//  Custom Interface supported by the HwDevice plugin

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

//

TAny* CAriH264encHwDeviceImpl::CustomInterface( TUid  aInterface )

	{

	PRINT_ENTRY;

	if( aInterface == KH324AnnexKDefinedEncoderConfigDataCIUid )

		{

		PRINT_EXIT;

		return ( ( MH324AnnexKDefinedEncoderConfigDataCI* ) this );

		}

	else

		{

		PRINT_EXIT;

		return NULL;

		}

	}

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

//  Returns information about this Encoder HW Device

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

//

CVideoEncoderInfo* CAriH264encHwDeviceImpl::VideoEncoderInfoLC()

	{

	PRINT_ENTRY;

    TSize maxPictureSize = TSize( KH264ENCIMPL_SDTV_WIDTH,

    		KH264ENCIMPL_SDTV_HEIGHT_PAL );

    TUint32 maxBitRate = KMAXSUPPBITRATE;

    RArray<TPictureRateAndSize> maxPictureRatesAndSizes;

    CleanupClosePushL( maxPictureRatesAndSizes );

    TPictureRateAndSize pictureRateAndSize;

    pictureRateAndSize.iPictureRate = KPictureRate30;

    pictureRateAndSize.iPictureSize = TSize( KH264ENCIMPL_QCIF_WIDTH,

											  KH264ENCIMPL_QCIF_HEIGHT );

	TInt error = KErrNone;

    error = maxPictureRatesAndSizes.Append( pictureRateAndSize );

	if( error != KErrNone )

		{

		PRINT_ERR( "Error while appending maximum picture rate and size" );

		User::Leave( error );

		}

    pictureRateAndSize.iPictureRate = KPictureRate30;

    pictureRateAndSize.iPictureSize = TSize( KH264ENCIMPL_VGA_WIDTH,

												KH264ENCIMPL_VGA_HEIGHT );

    error = maxPictureRatesAndSizes.Append( pictureRateAndSize );

	if( error != KErrNone )

		{

		PRINT_ERR( "Error while appending maximum picture rate and size" );

		User::Leave( error );

		}

    pictureRateAndSize.iPictureRate = KPictureRate30;

    pictureRateAndSize.iPictureSize = TSize( KH264ENCIMPL_CIF_WIDTH,

											  KH264ENCIMPL_CIF_HEIGHT );

    error = maxPictureRatesAndSizes.Append( pictureRateAndSize );

	if( error != KErrNone )

		{

		PRINT_ERR( "Error while appending maximum picture rate and size" );

		User::Leave( error );

		}

    pictureRateAndSize.iPictureRate = KPictureRate30;

    pictureRateAndSize.iPictureSize = TSize( KH264ENCIMPL_SQCIF_WIDTH,

											 KH264ENCIMPL_SQCIF_HEIGHT );

    error = maxPictureRatesAndSizes.Append( pictureRateAndSize );

	if( error != KErrNone )

		{

		PRINT_ERR( "Error while appending maximum picture rate and size" );

		User::Leave( error );

		}

    pictureRateAndSize.iPictureRate = KPictureRate30;

    pictureRateAndSize.iPictureSize = TSize( KH264ENCIMPL_QVGA_WIDTH,

											 KH264ENCIMPL_QVGA_HEIGHT );

    error = maxPictureRatesAndSizes.Append( pictureRateAndSize );

	if( error != KErrNone )

		{

		PRINT_ERR( "Error while appending maximum picture rate and size" );

		User::Leave( error );

		}

    pictureRateAndSize.iPictureRate = KPictureRate30;

    pictureRateAndSize.iPictureSize = TSize( KH264ENCIMPL_SDTV_WIDTH,

										 KH264ENCIMPL_HALFSDTV_HEIGHT_NTSC);

    error = maxPictureRatesAndSizes.Append( pictureRateAndSize );

	if( error != KErrNone )

		{

		PRINT_ERR( "Error while appending maximum picture rate and size" );

		User::Leave( error );

		}

    pictureRateAndSize.iPictureRate = KPictureRate30;

    pictureRateAndSize.iPictureSize = TSize( KH264ENCIMPL_SDTV_WIDTH,

										 KH264ENCIMPL_HALFSDTV_HEIGHT_PAL );

    error = maxPictureRatesAndSizes.Append( pictureRateAndSize );

	if( error != KErrNone )

		{

		PRINT_ERR( "Error while appending maximum picture rate and size" );

		User::Leave( error );

		}

    pictureRateAndSize.iPictureRate = KPictureRate30;

    pictureRateAndSize.iPictureSize = TSize( KH264ENCIMPL_SDTV_WIDTH,

											KH264ENCIMPL_SDTV_HEIGHT_NTSC );

    error = maxPictureRatesAndSizes.Append( pictureRateAndSize );

	if( error != KErrNone )

		{

		PRINT_ERR( "Error while appending maximum picture rate and size" );

		User::Leave( error );

		}

    pictureRateAndSize.iPictureRate = KH264ENCIMPL_PICTURERATE_25;

    pictureRateAndSize.iPictureSize = TSize( KH264ENCIMPL_SDTV_WIDTH,

											KH264ENCIMPL_SDTV_HEIGHT_PAL );

    error = maxPictureRatesAndSizes.Append( pictureRateAndSize );

	if( error != KErrNone )

		{

		PRINT_ERR( "Error while appending maximum picture rate and size" );

		User::Leave( error );

		}

    TUint32 supportedPictureOptions = TVideoPicture::ETimestamp |

										TVideoPicture::EReqInstantRefresh;

	TUint32 supportedDataUnitEncapsulations = EDuElementaryStream |

												EDuGenericPayload;

	TUint32 supportedDataUnitTypes			 = EDuCodedPicture |

												EDuVideoSegment;

    CVideoEncoderInfo* lVideoEncoderInfo = CVideoEncoderInfo::NewL( TUid::

										Uid( KUidH264EncoderHwDeviceImplUid ),

										KH264EncManufacturer,

										KH264EncIdentifier,

										TVersion( KH264ENCIMPL_MAJOR_VERSION,

										KH264ENCIMPL_MINOR_VERSION,