/*

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

* This is a source file, which is required for Mp4DecHwDevice.

*

*/

//User includes

#include "arimpeg4aspdechwdevice.h"

#include "aristatemachine.h"

#include "ariprint.h"

//manufacturer name

_LIT( KManufacturer, "Aricent" );

_LIT( KIdentifier, "MPEG4/H263 Video Decoder" );

//supported mime types for mp4

_LIT8( KMPEG4SupportedMimeType, "video/mp4v-es" );

// profile level 0

_LIT8( KMPEG4SupportedProfileLevel_0, "video/mp4v-es; profile-level-id=8" );

// profile level 0b / 11

_LIT8( KMPEG4SupportedProfileLevel_0b, "video/mp4v-es; profile-level-id=9" );

// profile level 1

_LIT8( KMPEG4SupportedProfileLevel_1, "video/mp4v-es; profile-level-id=1" );

// profile level 2

_LIT8( KMPEG4SupportedProfileLevel_2, "video/mp4v-es; profile-level-id=2" );

// profile level 3

_LIT8( KMPEG4SupportedProfileLevel_3, "video/mp4v-es; profile-level-id=3" );

// profile level 4

_LIT8( KMPEG4SupportedProfileLevel_4, "video/mp4v-es; profile-level-id=4" );

// profile level 5

_LIT8( KMPEG4SupportedProfileLevel_5, "video/mp4v-es; profile-level-id=5" );

//supported mime types for h263

_LIT8( KH263SupportedMimeType, "video/h263-2000" );

_LIT8( KH26398SupportedMimeType, "video/h263-1998" );

// h263 profile level 10

_LIT8( KH263SupportedProfileLevel_10, "video/h263-2000;profile=0;level=10" );

// h263 profile level 20

_LIT8( KH263SupportedProfileLevel_20, "video/h263-2000;profile=0;level=20" );

// h263 profile level 30

_LIT8( KH263SupportedProfileLevel_30, "video/h263-2000;profile=0;level=30" );

// h263 profile level 45

_LIT8( KH263SupportedProfileLevel_45, "video/h263-2000;profile=0;level=45" );

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

//1st phase constructor of CAriMpeg4aspdecHwDevice

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

//

CMMFVideoDecodeHwDevice* CAriMpeg4aspdecHwDevice::NewL()

	{

	PRINT_ENTRY;

	CAriMpeg4aspdecHwDevice* self = new ( ELeave ) CAriMpeg4aspdecHwDevice;

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	PRINT_EXIT;

	return self;

	}

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

//Destructor

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

//

CAriMpeg4aspdecHwDevice::~CAriMpeg4aspdecHwDevice()

	{

	PRINT_ENTRY;

	delete iInputFormat;

	delete iEngine;

	delete iCodec;

	delete iState;

    delete iVideoPictureHeader;

	// This is required becoz user may say exit before start at that point

	// OutputFreeBuffer is not created

	if ( iOutputFreeBuffer )

		{

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

			{

            if ( ( iOutputFreeBuffer + i )->iHeader )

                {

			    delete ( iOutputFreeBuffer + i )->iHeader;

                }

			if ( ( iOutputFreeBuffer + i )->iData.iRawData )

				{

				delete

				( TUint8* )( iOutputFreeBuffer + i )->iData.iRawData->Ptr();

				}

            if ( ( iOutputFreeBuffer + i )->iData.iRawData )

                {

			    delete ( iOutputFreeBuffer + i )->iData.iRawData;

                }

			}

		delete [] iOutputFreeBuffer;

		}

	if ( iInputFreeBuffers )

		{

		TInt i;

		for ( i = 0 ; i < TInt( iBufferOptions.iMinNumInputBuffers ); i++ )

			{

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

			delete iInputFreeBuffers[i].iUser;

			}

		delete [] iInputFreeBuffers;

		}

	if ( iCustomBufferOptions )

		{

		delete iCustomBufferOptions;

		}

    iOutputFreeBufferQueue.Close();

	iInputFreeBufferQueue.Close();

	iMaxPictureRates.Reset();

	iMaxPictureRates.Close();

	iSupportedFormats.Reset();

	iSupportedFormats.Close();

    iOutputDevice = NULL;

    iMMFDevVideoPlayProxy = NULL;

    iCustomBufferHandle = NULL;

    PRINT_EXIT;

	}

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

//Retrieves a custom interface to the device.

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

//

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

	{

	PRINT_ENTRY;

	PRINT_EXIT;

	return NULL;

	}

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

//Retrieves decoder information about this hardware device. The device

//creates a CVideoDecoderInfo structure, fills it with correct data,

//pushes it to the cleanup stack and returns it. The client will delete the

//object when it is no longer needed.

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

//

CVideoDecoderInfo* CAriMpeg4aspdecHwDevice::VideoDecoderInfoLC()

    {

    PRINT_ENTRY;

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

		{

		// construct the video types for iVidTypes

		CCompressedVideoFormat* format = NULL;

		TPtrC8 mimeType = KDecoderInfoMimeArray[i];

		format = CCompressedVideoFormat::NewL( mimeType );

		CleanupStack::PushL(format);

		TInt status = iSupportedFormats.Append( format );

		if ( status != KErrNone )

			{

			PRINT_MSG( LEVEL_LOW, ( " Format support is not done, retval of "

					"append = %d \n", status ) );

			}

		CleanupStack::Pop( format );

		// max picture rates

		TPictureRateAndSize pictureRateAndSize;

		pictureRateAndSize.iPictureSize = TSize( KMaxFrameWidth,

				                                KMaxFrameHeight );

		pictureRateAndSize.iPictureRate = KPicRate;

		status = iMaxPictureRates.Append(pictureRateAndSize);

		if ( status != KErrNone )

			{

			PRINT_MSG( LEVEL_LOW, ( " error in appendng picturerates = %d \n",

					status ) );

			}

		}

    TUint maxBitRate = KMaxBitRate;

    CVideoDecoderInfo* videoDecoderInfo = CVideoDecoderInfo::NewL(

        	KUidMp4H263DecoderHwDevice,

        	KManufacturer,

        	KIdentifier,

         	TVersion( 1, 0, 0 ),

        	iSupportedFormats.Array(),

        	EFalse,

        	EFalse,

			TSize( KMaxFrameWidth, KMaxFrameHeight ),

			maxBitRate,

			iMaxPictureRates.Array(),

			ETrue,

			ETrue );

    CleanupStack::PushL( videoDecoderInfo );

    PRINT_MSG( LEVEL_LOW, ( "Closing maxPictureRates&supportedFormats\n" ) );

    PRINT_EXIT;

    return videoDecoderInfo;

}

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

//Reads header information from a coded data unit.

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

//

TVideoPictureHeader* CAriMpeg4aspdecHwDevice::GetHeaderInformationL(

								TVideoDataUnitType /*aDataUnitType*/,

								TVideoDataUnitEncapsulation aEncapsulation,

								TVideoInputBuffer* aDataUnit )

	{

	PRINT_ENTRY;

    if ( !aDataUnit )

	    {

	    PRINT_ERR( "Input argument is not proper, aDataUnit is null \n" );

		User::Leave( KErrArgument );

		}

    if ( aEncapsulation != EDuElementaryStream )

    	{

    	PRINT_ERR( "aEncapsulation is not supported type \n" );

        User::Leave( KErrNotSupported );

    	}

    iVideoPictureHeader = new ( ELeave ) TVideoPictureHeader;

	TRAPD( err, CAriMpeg4aspdecWrapper::GetHeaderInfoL(  *aDataUnit,

												  *iVideoPictureHeader ) );

    if ( err == KErrNone )

		{

		PRINT_EXIT;

        return ( iVideoPictureHeader );

    	}

    delete iVideoPictureHeader;

    iVideoPictureHeader = NULL;

    switch ( err )

        {

        case KErrCorrupt:

        case KErrNoMemory:

        case KErrArgument:

        case KErrNotSupported:

            {

            PRINT_ERR( "GetHeaderInfoL is returned with error \n" );

            User::Leave( err );

            break;

            }

        case KErrUnderflow:

            {

            PRINT_ERR( "GetHeaderInfoL returnd with error KErrUnderflow\n" );

            break;

            }

        default:

            {

            PRINT_ERR( "GetHeaderInfoL is returned with error \n" );

            User::Leave( KErrGeneral );

            }

        };

    PRINT_EXIT;

	return NULL;

	}

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

//Returns a header from GetHeaderInformationL() back to the decoder so that

//the memory can be freed.

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

//

void CAriMpeg4aspdecHwDevice::ReturnHeader( TVideoPictureHeader* aHeader )

	{

	PRINT_ENTRY;

	if ( !iState->IsInitialized() )

		{

		if ( iVideoPictureHeader == aHeader )

			{

			delete iVideoPictureHeader;

            iVideoPictureHeader = NULL;

			}

		else

			{

			iMMFDevVideoPlayProxy->MdvppFatalError( this, KErrArgument );

			}

		}

	else

		{

		iMMFDevVideoPlayProxy->MdvppFatalError( this, KErrNotReady );

		}

	PRINT_EXIT;

	}

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

//Sets the device input format to a compressed video format.

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

//

void CAriMpeg4aspdecHwDevice::SetInputFormatL(

								   const CCompressedVideoFormat& aFormat,

								   TVideoDataUnitType aDataUnitType,

								   TVideoDataUnitEncapsulation aEncapsulation,

								   TBool aDataInOrder )

	{

	PRINT_ENTRY;

	if ( !iState->IsInitialized() )

		{

		if ( ( !aDataInOrder ) ||

             ( aEncapsulation == EDuGenericPayload ) ||

             ( aEncapsulation == EDuRtpPayload ) ||

             ( aDataUnitType == EDuArbitraryStreamSection ) )

             User::Leave( KErrNotSupported );

		if ( ( aFormat.MimeType().FindF( KMPEG4SupportedMimeType ) !=

															KErrNotFound ) ||

			( aFormat.MimeType().FindF( KH263SupportedMimeType ) !=

														    KErrNotFound ) ||

			( aFormat.MimeType().FindF( KH26398SupportedMimeType ) !=

														    KErrNotFound ) )

			{

			iInputFormat = CCompressedVideoFormat::NewL( aFormat );

			iDataUnitType  = aDataUnitType;

			iEncapsulation = aEncapsulation;

			}

		else

			{

			PRINT_ERR( "aFormat is not supported \n" );

			User::Leave( KErrNotSupported );

			}

		}

	else

		{

		PRINT_ERR( "istate is not initialized yet\n" );

		User::Leave( KErrNotReady );

		}

	PRINT_EXIT;

	}

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

//Sets whether decoding should be synchronized to the current clock source,

//if any, or if pictures should instead be decoded as soon as possible.

//If decoding is synchronized, decoding timestamps are used if available,

//presentation timestamps are used if not. When decoding is not synchronized,

//pictures are decoded as soon as source data is available for them, and the

//decoder has a free output buffer. If a clock source is not available,

//decoding will not be synchronized.

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

//

void CAriMpeg4aspdecHwDevice::SynchronizeDecoding( TBool /*aSynchronize*/ )

	{

	PRINT_ENTRY;

	PRINT_EXIT;

	return;

	}

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

//Sets the Buffer Options as specified by the client.

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

//

void CAriMpeg4aspdecHwDevice::SetBufferOptionsL(

						const CMMFDevVideoPlay::TBufferOptions& aOptions )

	{

	PRINT_ENTRY;

	if ( !iState->IsInitialized() )

		{

		TTimeIntervalMicroSeconds zerotime( 0 );

        if ( ( aOptions.iMinNumInputBuffers < KMinInputBuffers ) ||

             ( aOptions.iPreDecodeBufferSize != 0 ) ||

             ( aOptions.iMaxPostDecodeBufferSize != 0 ) ||

             ( aOptions.iPreDecoderBufferPeriod != zerotime ) ||

             ( aOptions.iPostDecoderBufferPeriod != zerotime ) )

        	{

            User::Leave( KErrArgument );

        	}

		if ( ( aOptions.iMinNumInputBuffers > KMaxInputBuffers ) ||

               ( aOptions.iMaxInputBufferSize > KMaxInputBufferSize ) )

			{

		    User::Leave( KErrNotSupported );

			}

		iBufferOptions = aOptions;

		}

	else

		{

		PRINT_ERR( "istate is not initialized yet\n" );

		User::Leave( KErrNotReady );

		}

	PRINT_EXIT;

	}

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

//Gets the video decoder buffer options actually in use.

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

//

void CAriMpeg4aspdecHwDevice::GetBufferOptions(

								CMMFDevVideoPlay::TBufferOptions& aOptions )

	{

	PRINT_ENTRY;

	if ( !iState->IsInitialized() )

		{

		aOptions = iBufferOptions;

		}

	else

		{

		iMMFDevVideoPlayProxy->MdvppFatalError( this, KErrNotReady );

		}

	PRINT_EXIT;

	}

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

//Indicates which HRD/VBV specification is fulfilled in the input stream and

//any related parameters.

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

//

void CAriMpeg4aspdecHwDevice::SetHrdVbvSpec(

								THrdVbvSpecification /*aHrdVbvSpec*/,

								const TDesC8& /*aHrdVbvParams*/ )

	{

	PRINT_ENTRY;

	iMMFDevVideoPlayProxy->MdvppFatalError( this, KErrNotSupported );

	PRINT_EXIT;

	}

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

//Sets the output post-processor device to use.

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

//

void CAriMpeg4aspdecHwDevice::SetOutputDevice(

										CMMFVideoPostProcHwDevice* aDevice )

	{

	PRINT_ENTRY;

	if ( !iState->IsInitialized() )

		{

		if ( !aDevice )

			{

			iMMFDevVideoPlayProxy->MdvppFatalError( this, KErrArgument );

			}

		else

			{

			iOutputDevice = aDevice;

			// checks whether customBuffer supported by o/p device

            iCustomBufferHandle =

             ( MMmfVideoBufferManagement* )( iOutputDevice->CustomInterface(

										KMmfVideoBuffermanagementUid ) );

			}

		}

	else

		{

		PRINT_ERR( "istate is not initialized yet, "

				"calling MdvppFatalError on iMMFDevVideoPlayProxy\n" );

		iMMFDevVideoPlayProxy->MdvppFatalError( this, KErrNotReady );

		}

	PRINT_EXIT;

	}

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

//Returns the current decoding position, i.e.

//the timestamp for the most recently decoded picture.

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

//

TTimeIntervalMicroSeconds CAriMpeg4aspdecHwDevice::DecodingPosition()

	{

	PRINT_ENTRY;

	if ( iState->IsInitialized() )

		{

		PRINT_EXIT;

		return iDecodingPosition;

		}

	else

		{

		PRINT_ERR( "iState is not initialised, calling  MdvppFatalError\n" );

		iMMFDevVideoPlayProxy->MdvppFatalError( this, KErrNotReady );

		PRINT_EXIT;

		return ( TTimeIntervalMicroSeconds( 0 ) );

		}

	}

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

//Returns the current pre-decoder buffer size.

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

//

TUint CAriMpeg4aspdecHwDevice::PreDecoderBufferBytes()

	{

	PRINT_ENTRY;

    if ( !( iState->IsInitialized() ) )

        {

        iMMFDevVideoPlayProxy->MdvppFatalError( this, KErrNotReady );

        PRINT_EXIT;

		return ( 0 );

        }

    PRINT_EXIT;

    return 0;

	}

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

//Reads various counters related to the received input bitstream

//and coded data units.

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

//

void CAriMpeg4aspdecHwDevice::GetBitstreamCounters(

							CMMFDevVideoPlay::TBitstreamCounters& aCounters )

	{

	PRINT_ENTRY;

	if ( iState->IsInitialized() )

		{

		aCounters = iBitstreamCounters;

		//Reset the counters to Zero

		iBitstreamCounters.iLostPackets = 0;

		iBitstreamCounters.iTotalPackets = 0;

		}