/*

* 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 Mpeg4SP/H263 encoder plugin class -

* CAriMp4spencHwDeviceImpl.

*

*/

//Includes

#include "arimp4spenchwdeviceimpl.h"

#include "arimp4sphwdeviceconstants.h"

#include "aricommon.h"

#include <E32base.h>

#include <AVC.h>

#include <H263.h>

#include <Implementationproxy.h>

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

//  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 CAriMp4spencHwDeviceImpl

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

//

CAriMp4spencHwDeviceImpl* CAriMp4spencHwDeviceImpl::NewL()

	{

	PRINT_ENTRY;

	CAriMp4spencHwDeviceImpl* self =

			new ( ELeave ) CAriMp4spencHwDeviceImpl();

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	PRINT_EXIT;

	return self;

	}

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

//  Default constructor

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

//

CAriMp4spencHwDeviceImpl::CAriMp4spencHwDeviceImpl() :

			iMMFDevVideoRecordProxy( NULL ),

			iInputDevice( NULL ),

			iClockSource( NULL ),

			iInputBufReturnToPreProc( EFalse ),

			iPeriodicTimer( NULL ),

			iClockTimeWhenPaused( 0 ),

			//100 milli seconds

			iPollingInterval( TTimeIntervalMicroSeconds32( 100000 ) ),

			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 ), iPacketsPending( EFalse )

	{

	PRINT_ENTRY;

	iSupportedDataUnitTypes = EDuCodedPicture | EDuVideoSegment;

	iSupportedDataUnitEncapsulations = EDuElementaryStream;

	// Default values for Init params - full range

	TUncompressedVideoFormat inputFormat;

	inputFormat.iDataFormat = EYuvRawData;

	inputFormat.iYuvFormat.iCoefficients = EYuvBt709Range0;

	inputFormat.iYuvFormat.iPattern = EYuv420Chroma1;

	inputFormat.iYuvFormat.iDataLayout = EYuvDataPlanar;

	inputFormat.iYuvFormat.iYuv2RgbMatrix = NULL;

	inputFormat.iYuvFormat.iRgb2YuvMatrix = NULL;

	inputFormat.iYuvFormat.iAspectRatioNum = 1;

	inputFormat.iYuvFormat.iAspectRatioDenom = 1;

	iSetMpeg4H263HWParams.iInputFormat = inputFormat;

	iSetMpeg4H263HWParams.iLevel = KMPEG4_LEVEL_UNKNOWN;

	iSetMpeg4H263HWParams.iAfterInitialize = 0;

	iSetMpeg4H263HWParams.iOutputFormat = EH263;

	iSetMpeg4H263HWParams.iMinNumOutputBuffers

			= KMPEG4H263ENCIMPL_MAXNUM_OUTPUTBUFFERS;

	iSetMpeg4H263HWParams.iPacketSize = KMPEG4H263ENCIMPL_DEFAULT_SEGMENTSIZE;

	iSetMpeg4H263HWParams.iMaxPictureRate

			= KMPEG4H263ENCIMPL_DEFAULT_PICTURERATE;

	// initialize picture counters

	iPictureCounters.iPicturesSkippedBufferOverflow = 0;

	iPictureCounters.iPicturesSkippedProcPower = 0;

	iPictureCounters.iPicturesSkippedRateControl = 0;

	iPictureCounters.iPicturesProcessed = 0;

	iPictureCounters.iInputPictures = 0;

	iSetMpeg4H263HWParams.iDataEncapsulation = EDuElementaryStream;

	// default packet mode is off

	iSetMpeg4H263HWParams.iDataUnitType = EDuCodedPicture;

	iSetMpeg4H263HWParams.iBitRate = KH263ENCIMPL_DEFAULT_BITRATE;

	iSetMpeg4H263HWParams.iTargetPictureRate

			= KMPEG4H263ENCIMPL_DEFAULT_PICTURERATE;

	iSetMpeg4H263HWParams.iRandomAccessRate

			= KMPEG4H263ENCIMPL_DEFAULT_RANDOMACCESSRATE;

	 // scene detection is ON

	iSetMpeg4H263HWParams.iSceneCutDetection = 1;

	//preprocessing disabled by default

	iSetMpeg4H263HWParams.iPreprocessing = 0;

	iSetMpeg4H263HWParams.iRCModel = CBR;

	iSetMpeg4H263HWParams.iComplexityLevel = HIGH;

	iSetMpeg4H263HWParams.iSearchRange = 31;

	PRINT_EXIT;

	}

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

//  Destructor

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

//

CAriMp4spencHwDeviceImpl::~CAriMp4spencHwDeviceImpl()

	{

	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();

	iOutputFreeBufferQueue.Close();

	if ( iOutputBuffers )

		{

		if ( iSetMpeg4H263HWParams.iMinNumOutputBuffers )

			{

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

				 i++ )

				{

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

					{

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

					}

				}

			}

		delete[] iOutputBuffers;

		iOutputBuffers = NULL;

		}

	if ( iPeriodicTimer )

		{

		delete iPeriodicTimer;

		iPeriodicTimer = NULL;

		}

	if ( iPacketOffSetAndLengthInfoBuffers )

		{

		for ( TInt i = 0; i < KMPEG4H263ENCIMPL_MAXNUM_TEMPOUTPUTBUFFERS;

			 i++ )

			{

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

			}

		delete[] ( TUint* ) iPacketOffSetAndLengthInfoBuffers;

		iPacketOffSetAndLengthInfoBuffers = NULL;

		}

	//delete temp output buffers

	iInternalOutputBufferQueue.Reset();

	iInternalOutputBufferQueue.Close();

	if ( iInternalOutputBuffers )

		{

		for ( TInt i = 0; i < KMPEG4H263ENCIMPL_MAXNUM_TEMPOUTPUTBUFFERS;

			i++ )

			{

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

				{

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

				}

			}

		delete[] iInternalOutputBuffers;

		iInternalOutputBuffers = NULL;

		}

	iFreeBufferQueueForPacketOffsetInfo.Reset();

	iFilledBufferQueueForPacketOffsetInfo.Reset();

	if ( iConfigData )

		{

		delete iConfigData;

		iConfigData = NULL;

		}

	if ( iPacketOffsetBuf )

		{

		delete iPacketOffsetBuf;

		iPacketOffsetBuf = NULL;

		}

	if ( iEncStateMac )

		{

		delete iEncStateMac;

		iEncStateMac = NULL;

		}

	PRINT_EXIT;

	}

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

//  Custom Interface supported by the HwDevice plugin

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

//

TAny* CAriMp4spencHwDeviceImpl::CustomInterface( TUid /* aInterface */ )

	{

	PRINT_ENTRY;

	PRINT_EXIT;

	return NULL;

	}

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

//  Returns information about this Encoder HW Device

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

//

CVideoEncoderInfo* CAriMp4spencHwDeviceImpl::VideoEncoderInfoLC()

	{

	PRINT_ENTRY;

	TSize maxPictureSize = TSize( KMPEG4H263ENCIMPL_720P_WIDTH,

			KMPEG4H263ENCIMPL_720P_HEIGHT );

	TUint32 maxBitRate = KMaxSupportedBitRate;

	RArray<TPictureRateAndSize> maxPictureRatesAndSizes;

	CleanupClosePushL( maxPictureRatesAndSizes );

	TPictureRateAndSize pictureRateAndSize;

	TInt error = KErrNone;

	// Max frame rate in mpeg4 sp encoding for any resolution is 15 fps.

	// 30 fps is supported only in H263 encoding for SQCIF, QCIF, CIF only.

	pictureRateAndSize.iPictureRate = KPictureRate30;

	pictureRateAndSize.iPictureSize = TSize( KMPEG4H263ENCIMPL_SQCIF_WIDTH,

											KMPEG4H263ENCIMPL_SQCIF_HEIGHT );

	error = maxPictureRatesAndSizes.Append( pictureRateAndSize );

	if  ( error != KErrNone )

		{

		User::Leave( error );

		}

	pictureRateAndSize.iPictureRate = KPictureRate30;

	pictureRateAndSize.iPictureSize = TSize( KMPEG4H263ENCIMPL_QCIF_WIDTH,

											KMPEG4H263ENCIMPL_QCIF_HEIGHT );

	error = maxPictureRatesAndSizes.Append( pictureRateAndSize );

	if  ( error != KErrNone )

		{

		User::Leave( error );

		}

	pictureRateAndSize.iPictureRate = KPictureRate30;

	pictureRateAndSize.iPictureSize = TSize( KMPEG4H263ENCIMPL_CIF_WIDTH,

			KMPEG4H263ENCIMPL_CIF_HEIGHT );

	error = maxPictureRatesAndSizes.Append( pictureRateAndSize );

	if  ( error != KErrNone )

		{

		User::Leave( error );

		}

	pictureRateAndSize.iPictureRate = KPictureRate15;

	pictureRateAndSize.iPictureSize = TSize( KMPEG4H263ENCIMPL_QVGA_WIDTH,

											KMPEG4H263ENCIMPL_QVGA_HEIGHT );

	error = maxPictureRatesAndSizes.Append( pictureRateAndSize );

	if  ( error != KErrNone )

		{

			User::Leave( error );

		}

	pictureRateAndSize.iPictureRate = KPictureRate15;

	pictureRateAndSize.iPictureSize = TSize( KMPEG4H263ENCIMPL_VGA_WIDTH,

											KMPEG4H263ENCIMPL_VGA_HEIGHT );

	error = maxPictureRatesAndSizes.Append( pictureRateAndSize );

	if  ( error != KErrNone )

		{

			User::Leave( error );

		}

	pictureRateAndSize.iPictureRate = KPictureRate15;

	pictureRateAndSize.iPictureSize = TSize( KMPEG4H263ENCIMPL_720P_WIDTH,

											KMPEG4H263ENCIMPL_720P_HEIGHT );

	error = maxPictureRatesAndSizes.Append( pictureRateAndSize );

	if  ( error != KErrNone )

		{

		User::Leave( error );

		}

	TUint32 lSupportedPictureOptions = TVideoPicture::ETimestamp

			| TVideoPicture::EReqInstantRefresh | TVideoPicture::ESceneCut;

	TUint32 supportedDataUnitEncapsulations = EDuElementaryStream;

	TUint32 supportedDataUnitTypes = EDuCodedPicture | EDuVideoSegment;

	CVideoEncoderInfo* videoEncoderInfo = CVideoEncoderInfo::NewL( TUid::Uid(

								KUidMpeg4H263EncoderHwDeviceImplUid ),

								KMPEG4H263EncManufacturer,

								KMPEG4H263EncIdentifier,

								TVersion( KMPEG4H263ENCIMPL_MAJOR_VERSION,

										  KMPEG4H263ENCIMPL_MINOR_VERSION,

										  KMPEG4H263ENCIMPL_BUILD_VERSION ),

								// Accelerated

								EFalse,

								// Enc doesnt support direct capture

								EFalse,

								iSupportedInputFormats.Array(),

								iSupportedOutputFormats.Array(),

								maxPictureSize,

								supportedDataUnitTypes,

								// Max bitrate layers

								supportedDataUnitEncapsulations, 1,

								//aSupportsSupplementalEnhancementInfo

								EFalse,

								//aMaxUnequalErrorProtectionLevels

								1,

								maxBitRate, maxPictureRatesAndSizes.Array(),

								1,

								//aSupportsPictureLoss

								lSupportedPictureOptions,

								ETrue,

								//aSupportsSliceLoss

								ETrue,

								//aCodingStandardSpecificInfo

								KNullDesC8,

								//aImplementationSpecificInfo

								KNullDesC8 );

	CleanupStack::PopAndDestroy();

	CleanupStack::PushL( videoEncoderInfo );

	PRINT_EXIT;

	return videoEncoderInfo;

	}

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

//  Sets the encoder output format

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

//

void CAriMp4spencHwDeviceImpl::SetOutputFormatL(

		const CCompressedVideoFormat& aFormat,

		TVideoDataUnitType aDataUnitType,

		TVideoDataUnitEncapsulation aDataEncapsulation,

		TBool aSegmentationAllowed )

	{

	PRINT_ENTRY;

	if ( iEncStateMac->IsInitialized() )

		{

		PRINT_ERR( "SetOutputFormatL () called before Initialize ()" );

		User::Leave( KErrPermissionDenied );

		}

	TInt error = KErrNotFound;

	TPtrC8 mimeType( aFormat.MimeType() );

	TInt i;

	for ( i = 0; i < iSupportedOutputFormats.Count(); i++ )

		{

		CCompressedVideoFormat* format = iSupportedOutputFormats[i];

		if ( mimeType.CompareF( format->MimeType() ) == 0 )

			{

			iSetMpeg4H263HWParams.iLevel = iLevels[i];

			error = KErrNone;

			break;

			}

		}

	if ( error == KErrNotFound )

		{

		PRINT_ERR( "CAriMp4spencHwDeviceImpl::SetOutputFormatL() Leaving"

				   " because of unsupported output mimetype" );

		User::Leave( KErrNotSupported );

		return;

		}

	// Index values 0 - 10 contain MPEG4 mime types and 11-17 contain

	// H263 mime types

	if ( i >= 0 && i <= KMPEG4SUPPMIMEARRAYMAXINDEXVALUE )

		{

		iSetMpeg4H263HWParams.iOutputFormat = EMpeg4;

		}

	else if ( i >= KMPEG4SUPPMIMEARRAYMAXINDEXVALUE + 1 && i

			<= KH263SUPPMIMEARRAYMAXINDEXVALUE )

		{

		iSetMpeg4H263HWParams.iOutputFormat = EH263;

		}

		PRINT_MSG( LEVEL_HIGH, ( "level is set to %d"

						,(TInt)iSetMpeg4H263HWParams.iLevel ) );

	if ( ( ( aDataUnitType != EDuCodedPicture ) && ( aDataUnitType

		!= EDuVideoSegment) ) || ( aDataEncapsulation

		!= EDuElementaryStream ) || (aSegmentationAllowed ) )

		{

		PRINT_ERR( "CAriMp4spencHwDeviceImpl::SetOutputFormatL() Leaving"

			" because of unsupported data unit type or data unit"

			" encapsulation" );

		User::Leave( KErrNotSupported );

		}