/*

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

* Interface of the arih264dechwdevice.

*

*/

#ifndef ARIH264DECHWDEVICE_H

#define ARIH264DECHWDEVICE_H

//System includes

#include <videoplayhwdevice.h>

#include <ImplementationProxy.h>

#include <buffermanagementci.h>

//User includes

#include "aribaseengine.h"

#include "arih264dechwdeviceuid.hrh"

// CONSTANTS

const TInt KMaxAllowPicLoss		= 75;

const TInt KMaxInputBufferSize  = ( 248 * 2048 );

const TInt KMaxOutputBuffers    = 2;

const TInt KMaxInputBuffers		= 2;

const TInt KMinInputBuffers		= 2;

// Implementatin id for the hwdevice

const TUid KUidH264DecoderHwDevice = {KUidH264DecoderHwDeviceImplUid};

const TUint KMaxBitRate = 15*1024*1024;

const TInt KDecoderInfoCount = 14;

//const TInt KMaxFrameWidth			= 1280;

//const TInt KMaxFrameHeight		= 720;

const TInt KPicRate					= 30;

// FORWARD DECLARTIONS

class CAriH264decWrapper;

class CStateMachine;

//CLASS DECLARATIONS

/**

 * This class is part of Aricent's H264 decoder HwDevice plugin used for

 * decoding H264 content to yuv420.

 * Provides implementation for standard MDF HwDevice plugin APIs as well as private functions

 * used internal to this class for .This class also implements callback APIs from

 * MMmfVideoBufferManagementObserver and MProcessEngineObserver which are called from CBaseEngine.

 */

class CAriH264decHwDevice: public CMMFVideoDecodeHwDevice,

						   public MProcessEngineObserver,

						   public MMmfVideoBufferManagementObserver

{

public:	//Constructors and destructor

	/**

	 * Two-phased constructor.

	 * @return pointer to an instance of CMMFVideoDecodeHwDevice

	 */

	static CMMFVideoDecodeHwDevice* NewL();

	/**

	 * Function to destroy resources allocated by this object

	 */

	virtual ~CAriH264decHwDevice();

public:	//CMMFVideoHwDevice Functions

   /**

	* Retrieves a custom interface to the specified hardware device

	* @param	aInteface	Interface UID, defined with the custom interface

	* @return	Pointer to the interface implementation, or NULL if the

	*           device does not implement the interface requested.

	*       	The return value must be cast to the correct type by the user.

	*/

	virtual TAny* CustomInterface( TUid aInterface );

public:	//CMMFVideoDecodeHwDevice Functions

    /**

	 * Retrieves decoder information about this hardware device.

	 * The device creates a CVideoDecoderInfo structure,

	 * fills it with correct data, pushes it to cleanup stack and returns it.

	 * The client will delete the object when it is no longer needed

	 * @return	Decoder information as a CVideoDecoderInfo object.

	 * The object is pushed to the cleanup stack, and must be deallocated by

	 * the caller.

	 * @leave	The method will leave if an error occurs.

	 */

	virtual CVideoDecoderInfo* VideoDecoderInfoLC();

   /**

	* Reads header information from a coded data unit.

	* @param aDataUnitType   The type of the coded data unit that is contained

	*                        in aDataUnit.

	*						 If the data is a simple piece of bitstream, use

	*						 EDuArbitraryStreamSection.

	* @param aEncapsulation  The encapsulation type used for the coded data.

	*                        If the data is a simple piece of bitstream, use

	*                        EDuElementaryStream.

	* @param aDataUnit	     The coded data unit, contained in a

	*                        TVideoInputBuffer.

	* @return				 Header information for the data unit, or NULL if

	*                        the coded data unit did not contain enough data

	*                        to parse the header.The header data must be

	* 						 returned to device using ReturnHeader() before

	*                        Initialize() is called or decoder is destroyed.

	* 						 The data remains valid until it is returned.

	* @leave				 This method may leave with one of the standard

	*                        error codes.

	* @pre					 This method can only be called before hwdevice

	*                        has been initialized with Initialize()

	*/

	virtual TVideoPictureHeader* GetHeaderInformationL(

			                       TVideoDataUnitType aDataUnitType,

		                           TVideoDataUnitEncapsulation aEncapsulation,

		                           TVideoInputBuffer* aDataUnit );

   /**

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

	* that the memory can be freed.

	* @param aHeader	The header to return

	* @pre				This method can only be called before the hwdevice

	*                    has been initialized with Initialize()

	*/

	virtual void ReturnHeader( TVideoPictureHeader* aHeader );

   /**

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

	* @param aFormat		  The input format to use

	* @param aDataUnitType	  The encapsulation type used for the coded data

	* @param aEncapsulation   The encapsulation type used for the coded data

	* @param aDataInOrder	  True if the input data is written in correct

	*                         decoding order, false if will be written in

	*                         arbitrary order.

	* @leave				  This method may leave with one of the standard

	*                         error codes.

	* @pre					  This method can only be called before hwdevice

	*                          has been initialized with Initialize()

	*/

	virtual void SetInputFormatL( const CCompressedVideoFormat& aFormat,

								   TVideoDataUnitType aDataUnitType,

								   TVideoDataUnitEncapsulation aEncapsulation,

								   TBool aDataInOrder );

   /**

	* Sets whether decoding should be synchronzed 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.

	* @param aSynchronize	True if decoding should be synchronized to a clock

	*                       source.

	* @pre					This method can only be called before the hwdevice

	*                       has been initialized with Initialize()

	*/

	virtual void SynchronizeDecoding( TBool aSynchronize );

   /**

	* Sets decoder buffering options

	* @param aOptions   Buffering options

	* @leave			This method may leave with one of the standard error

	*                   codes.

	* @pre				This method can only be called before the hwdevice has

	*                   been initialized with Initialize()

	*/

	virtual void SetBufferOptionsL(

			               const CMMFDevVideoPlay::TBufferOptions& aOptions );

   /**

	* Gets the video decoder buffer options actually in use. This can be used

	* before calling SetBufferOptions() to determine the default options, or

	* afterwards to check the values actually in use ( if some default values

	* were used ).

	* @param aOptions  Buffering options structure to fill.

	* @pre			   This method can only be called before the hwdevice has

	*                  been initialized with Initialize()

	*/

	virtual void GetBufferOptions(

			                     CMMFDevVideoPlay::TBufferOptions& aOptions );

   /**

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

	* and any related parameters.

	* @param aHrdVbvSpec	The HRD/VBV specification fulfilled

	* @param aHrdVbvParams	HRD/VBV parameters. The data format depends on the

	*                       parameters chosen. For 3GPP TS 26.234. parameters

	*                       aHrdVbvSpec=EHrdVbv3GPP, data in the descriptor

	*                       is a package of type TPckC<T3gppHrdVbvParams>

	* 						If no HRD/VBV parameters are used, the descriptor

	*                       is empty.

	* @pre					This method can only be called before the hwdevice

	*                       has been initialized with Initialize()

	*/

	virtual void SetHrdVbvSpec( THrdVbvSpecification aHrdVbvSpec,

			                   const TDesC8& aHrdVbvParams );

   /**

	* Sets the output post-procesor device to use. If an output device is set,

	* all decoded pictures are delivered to that device, and not drawn on

	* screen or returned to the client. Pictures are written using

	* CMMDVideoPostProcDevice::WritePictureL() or a custom interface after

	* they have been decoded. The post-processor must then synchronize

	* rendering to the clock source if necessary.

	*

	* @param aDevice	 The output post-processor device to use.

	* @pre				 This method can only be called before the hwdevice

	*                     has been initialized with Initialize()

	*/

	virtual void SetOutputDevice( CMMFVideoPostProcHwDevice* aDevice );

   /**

	* Returns the current decoding position, i.e. the timestamp for the most

	* recently decoded picture.

	* @return		Current decoding position.

	* @pre			This method can only be called before the hwdevice has

	*                been initialized with Initialize()

	*/

	virtual TTimeIntervalMicroSeconds DecodingPosition();

   /**

	* Returns the current pre-decoder buffer size

	* @return		The number of bytes of data in the pre-decoder buffer.

	* @pre			This method can only be called after the hwdevice has been

	*               initialized with Initialize().

	*/

	virtual TUint PreDecoderBufferBytes();

   /**

	* Reads various counters related to the received input bitstream and coded

	* data units.

	* @param aCounters     The counter structure to fill.

	* @pre				   This method can only be called after the hwdevice

	*                      has been initialized with Initialize().

	*/

	virtual void GetBitstreamCounters(

			                CMMFDevVideoPlay::TBitstreamCounters& aCounters );

   /**

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

	* @return	Number of free input buffers the decoder has available.

	* @leave	This method may leave with one of the standard error codes.

	* @pre		This method can only be called after the hwdevice has been

	*            initialized with Initialize().

	*/

	virtual TUint NumFreeBuffers();

   /**

	* Retrieves an empty video input buffer from the decoder. After input data

	* has been written to the buffer, it can be written to the decoder using

	* WriteCodedDataL(). The number of buffers the decoder must be able

	* to provide before expecting any back, and the maximum size for each

	* buffer, are specified in the buffer options.The decoder maintains

	* ownership of the buffers even while they have been retrieved by client,

	* and will take care of deallocating them.

	* @param aBufferSize	Required buffer size, in bytes. The resulting

	*                        buffer can be larger than this, but not smaller

	* @return				A new input data buffer. The buffer is at least

	*                        as large as requested, but it may be larger.

	* 						If no free buffers are available, the return value

	*                       is NULL.

	* @leave				This method may leave with one of the standard

	*                        error codes.

	* @pre					This method can only be called after the hwdevice

	*                        has been initialized with Initialize().

	*/

	virtual TVideoInputBuffer* GetBufferL( TUint aBufferSize );

   /**

	* Writes a piece of coded video data to the decoder. The data buffer must

	* be retrieved from the decoder with GetBufferL().

	* @param aBuffer	The coded data unit to write.

	* @leave				This method may leave with one of the standard

	*                        error codes.

	* @pre				This method can only be called after the hwdevice has

	*                    been initialized with Initialize().

	*/

	virtual void WriteCodedDataL( TVideoInputBuffer* aBuffer );

#ifdef SYMBIAN_MDF_API_V2

   /**

	* Configures the Decoder using header information known by the client.

	* @param	aVideoPictureHeader	Header information to configure the

	*                                    decoder with

	* @leave	The method will leave if an error occurs. Running out of data

	*            is not considered an error,

	* 		as described above.

	* @pre	This method can only be called before the hwdevice has been

	*        initialized with Initialize().

	*/

    virtual void ConfigureDecoderL(

    		                 const TVideoPictureHeader& aVideoPictureHeader );

#endif

public:	//Inherited from CMMFVideoPlayHwDevice

   /**

	* Retrieves post-processing information about this hardware device. The

	* device creates a CPostProcessorInfo structure ( defined in [3] ), 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.

	* @return		Post-processor information as a CPostProcessorInfo object.

	* 				The object is pushed to the cleanup stack, and must be

	*               deallocated by the caller.

	* @leave		This method may leave with one of the standard error codes

	*/

	virtual CPostProcessorInfo* PostProcessorInfoLC();

   /**

	* Retrieves the list of the output formats that the device supports. The

	* list is ordered in plug-in preference order, with the preferred formats

	* at the beginning of the list. The list can depend on the device source

	* format, and therefore SetSourceFormatL() must be called before calling

	* this method.

	* @param aFormats		An array for the result format list. The array

	*                       must be created and destroyed by the caller.

	* @leave				This method may leave with one of the standard

	*                       error codes.

	* @pre					This method can only be called after the hwdevice

	*                       has been initialized with Initialize().

	*/

	virtual void GetOutputFormatListL(

			                     RArray<TUncompressedVideoFormat>& aFormats );

   /**

	* Sets the device output format.

	* @param aDataUnit	    The format to use.

	* @leave				This method may leave with one of the standard

	*                       error codes.

	* @pre					This method can only be called after the hwdevice

	*                       has been initialized with Initialize().

	*/

	virtual void SetOutputFormatL( const TUncompressedVideoFormat &aFormat );

   /**

	* Sets the clock source to use for video timing. See [3] for a discussion

	* about audio/video synchronization. If no clock source is set. video

	* playback will not be synchronized, but will proceed as fast as possible,

	* depending on input data and output buffer availability.

	* @param aDataUnitType  The clock source to use.

	* @pre					This method can only be called after the hwdevice

	*                       has been initialized with Initialize().

	*/

	virtual void SetClockSource( MMMFClockSource* aClock );

   /**

	* Sets the device video output destination. The destination can be the

	* screen ( using direct screen access ) or memory buffers. By default

	* memory buffers are used. If data is written to another device, this

	* method is ignored, and suitable memory buffers are always used.

	* @param aScreen  True if video output destination is the screen, false

	*                 if memory buffers.

	* @leave		  This method may leave with one of the standard error

	*                 codes.

	* @pre			  This method can only be called after the hwdevice has

	*                 been initialized with Initialize().

	*/

	virtual void SetVideoDestScreenL( TBool aScreen );

   /**

	* Sets the post-processing types to be used.

	* @param aPostProcCombination   The post-processing steps to perform, a

	*                               bitwise or of values from TPostProcessType

	* @leave						This method may leave with one of the

	*                               standard error codes.

	* @pre							This method can be called either before

	*                               or after the hwdevice has been initialized

	*								with Initialize(). If called after

	*								with initialization, the change will only

	*								with be committed once CommitL() is called

	*/

	virtual void SetPostProcessTypesL( TUint32 aPostProcCombination );

   /**

	* Sets post-processing options for input ( pan-scan ) cropping.

	* @param aRect  The type of the coded data unit that is contained in

	*               aDataUnit.

	* @leave		This method may leave with one of the standard error codes

	* @pre			This method can be called either before or after the

	*               hwdevice has been initialized with Initialize(). If called

	*               after initialization, the change will only be committed

	*               once CommitL() is called.

	*/

	virtual void SetInputCropOptionsL( const TRect& aRect );

   /**

	* Sets post-processing options for YUV to RGB color space conversion. The

	* first variant specifies the input YUV and output RGB formats to use

	* explicitly, while the second variant uses the device input and output

	* formats. For decoder devices the default YUV format used is the format

	* specified in the input bitstream. SetSourceFormatL(), SetOutputFormatL()

	* and SetPostProcessTypesL() must be called before this method is used

	* @param aOptions	 The conversion options to use

	* @param aYuvFormat	 Conversion source YUV format, if specified.

	* @param aRgbFormat	 Conversion target RGB format, if specified..

	* @leave			 This method may leave with one of the standard error

	*                    codes.

	* @pre				 This method can be called either before or after the

	*                    hwdevice has been initialized with Initialize(). If

	*                    called after initialization, the change will only be

	*					 committed once CommitL() is called.

	*/

	virtual void SetYuvToRgbOptionsL( const TYuvToRgbOptions& aOptions,

									 const TYuvFormat& aYuvFormat,

									 TRgbFormat aRgbFormat );

   /**

	* Sets post-processing options for YUV to RGB color space conversion. The

	* first variant specifies the input YUV and output RGB formats to use

	* explicitly, while the second variant uses the device input and output

	* formats. For decoder devices the default YUV format used is the format

	* specified in the input bitstream. SetSourceFormatL(), SetOutputFormatL()

	* and SetPostProcessTypesL() must be called before this method is used

	* @param aOptions	 The conversion options to use

	* @leave			 This method may leave with one of the standard error

	*                    codes.

	* @pre				 This method can be called either before or after the

	*                    hwdevice has been initialized

	*					 with Initialize(). If called after initialization,

	*					 the change will only be committed once CommitL() is

	*					 called

	*/

	virtual void SetYuvToRgbOptionsL( const TYuvToRgbOptions& aOptions );

   /**

	* Sets post-processing options for YUV to RGB color space conversion. The

	* first variant specifies the input YUV and output RGB formats to use

	* explicitly, while the second variant uses the device input and output

	* formats. For decoder devices the default YUV format used is the format

	* specified in the input bitstream. SetSourceFormatL(), SetOutputFormatL()

	* and SetPostProcessTypesL() must be called before this method is used

	* @param aRotationType The rotation to perform.

	* @leave			  This method may leave with one of the standard

	*                     error codes.

	* @pre				  This method can be called either before or after

	*                     the hwdevice has been initialized with Initialize().

	*                     If called after initialization, the change will only

	*                     be committed once CommitL() is called.

	*/

	virtual void SetRotateOptionsL( TRotationType aRotationType );

   /**

	* @param aRotationType The rotation to perform.

	* @leave			  This method may leave with one of the standard

	*                     error codes.

	* @pre				  This method can be called either before or after

	*                     the hwdevice has been initialized with Initialize().

	*                     If called after initialization, the change will

	*                     only be committed once CommitL() is called.

	*/

	virtual void SetScaleOptionsL( const TSize& aTargetSize,