/*

* 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, required for arih264dechwdevice

*

*/

//User includes

#include "arih264dechwdevice.h"

#include "arih264decwrapper.h"

#include "aristatemachine.h"

#include "ariprint.h"

//

//CAriH264decHwDevice

//

_LIT( KManufacturer, "Aricent" );

_LIT( KIdentifier, "H264 Video Decoder" );

//supported h264 mime types

_LIT8( KH264SupportedMimeType, "video/H264" );

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

//1st phase constructor of CAriH264decHwDevice

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

//

CMMFVideoDecodeHwDevice* CAriH264decHwDevice::NewL()

	{

	PRINT_ENTRY;

	CAriH264decHwDevice* self = new ( ELeave ) CAriH264decHwDevice;

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop();

	PRINT_EXIT;

	return self;

	}

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

//Destructor

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

//

CAriH264decHwDevice::~CAriH264decHwDevice()

	{

	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 )

		{

		for ( TInt i = 0 ; i < 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* CAriH264decHwDevice::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* CAriH264decHwDevice::VideoDecoderInfoLC()

	{

    PRINT_ENTRY;

    // construct the video types for iVidTypes

	CCompressedVideoFormat* format = NULL;

	format = CCompressedVideoFormat::NewL( KH264SupportedMimeType );

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

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

		{

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

            KUidH264DecoderHwDevice,

            KManufacturer,

            KIdentifier,

            TVersion( 1, 0, 0 ),

            iSupportedFormats.Array(),

            // Non-Accelerated

            EFalse,

            // Doesnt support Direct Display

            EFalse,

            TSize( KMaxFrameWidth, KMaxFrameHeight ),

            maxBitRate,

            iMaxPictureRates.Array(),

            //decoder supports picture loss indications

            ETrue,

            //decoder supports slice loss indications

            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* CAriH264decHwDevice::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, CAriH264decWrapper::GetHeaderInfoL( *aDataUnit,

													*iVideoPictureHeader ) );

    if ( err == KErrNone )

    	{

    	PRINT_EXIT;

        return ( iVideoPictureHeader );

    	}

    // An error has occured

    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 CAriH264decHwDevice::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 CAriH264decHwDevice::SetInputFormatL(

								const CCompressedVideoFormat& aFormat,

								TVideoDataUnitType aDataUnitType,

								TVideoDataUnitEncapsulation aEncapsulation,

								TBool aDataInOrder )

	{

	PRINT_ENTRY;

	if ( !iState->IsInitialized() )

		{

		if ( ( !aDataInOrder ) ||

             ( aEncapsulation == EDuGenericPayload ) ||

             ( aEncapsulation == EDuRtpPayload ) )

             User::Leave( KErrNotSupported );

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

															 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 CAriH264decHwDevice::SynchronizeDecoding( TBool /*aSynchronize*/ )

	{

	PRINT_ENTRY;

	PRINT_EXIT;

	return;

	}

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

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

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

//

void CAriH264decHwDevice::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 CAriH264decHwDevice::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 CAriH264decHwDevice::SetHrdVbvSpec(

										THrdVbvSpecification /*aHrdVbvSpec*/,

										const TDesC8& /*aHrdVbvParams*/ )

	{

	PRINT_ENTRY;

	PRINT_EXIT;

	iMMFDevVideoPlayProxy->MdvppFatalError( this, KErrNotSupported );

	}

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

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

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

//

void CAriH264decHwDevice::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 CAriH264decHwDevice::DecodingPosition()

	{

	PRINT_ENTRY;

	if ( iState->IsInitialized() )

		{

		PRINT_EXIT;

		return iDecodingPosition;

		}

	else

		{

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

		iMMFDevVideoPlayProxy->MdvppFatalError( this, KErrNotReady );

		return ( TTimeIntervalMicroSeconds( 0 ) );

		}

	}

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

//Returns the current pre-decoder buffer size.

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

//

TUint CAriH264decHwDevice::PreDecoderBufferBytes()

	{

	PRINT_ENTRY;

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

        {

        iMMFDevVideoPlayProxy->MdvppFatalError( this, KErrNotReady );

		return ( 0 );

        }

    PRINT_EXIT;

    return 0;

	}

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

//Reads various counters related to the received input bitstream

//and coded data units.

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

//

void CAriH264decHwDevice::GetBitstreamCounters(

							CMMFDevVideoPlay::TBitstreamCounters& aCounters )

	{

	PRINT_ENTRY;

	if ( iState->IsInitialized() )

		{

		aCounters = iBitstreamCounters;

		//Reset the counters to Zero

		iBitstreamCounters.iLostPackets = 0;

		iBitstreamCounters.iTotalPackets = 0;

		}

	else

		{

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

		iMMFDevVideoPlayProxy->MdvppFatalError( this, KErrNotReady );

		}

	PRINT_EXIT;

	}

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

//Retrieves the number of free input buffers the decoder has available

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

//

TUint CAriH264decHwDevice::NumFreeBuffers()

	{

	PRINT_ENTRY;

	if ( iState->IsInitialized() )

		{

		if ( iNumberOfInputBuffersAllocated == 0 )

		    {

		    PRINT_EXIT;

		    return ( iBufferOptions.iMinNumInputBuffers );

		    }

		else

		    {

		    PRINT_EXIT;

		    return  ( iInputFreeBufferQueue.Count() );

		    }

		}

	else

		{

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

		iMMFDevVideoPlayProxy->MdvppFatalError( this, KErrNotReady );