// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

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

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#ifndef __DEVVIDEOPLAY_H__

#define __DEVVIDEOPLAY_H__

#include <e32std.h>

#include <mmf/devvideo/devvideobase.h>

class MMMFDevVideoPlayObserver;

class CMMFVideoPlayHwDevice;

class CMMFVideoDecodeHwDevice;

class CMMFVideoPostProcHwDevice;

/**

MMMFDevVideoPlayProxy is the interface to the CMMFDevVideoPlay API implementation that the hardware devices 

use to deliver data back to the client and report their progress to the API implementation.

@publishedAll

@released

*/

class MMMFDevVideoPlayProxy

	{

public:

	/**

	Delivers a new decoded picture to the client. The CMMFDevVideoPlay implementation will maintain 

	a list of decoded pictures and implement GetNewPictureInfo() and NextPictureL() based on those. 

	The pictures will be returned back to the hardware device using ReturnPicture().

	@param "aPicture" "The newly processed picture."

	*/

	virtual void MdvppNewPicture(TVideoPicture* aPicture) = 0;

	/**

	Notifies the client that one or more new empty input buffers are available. Called by the decoder 

	hardware device.

	*/

	virtual void MdvppNewBuffers() = 0;

	/**

	Returns a used input video picture back to the caller. Called by a post-processor hardware device 

	after the picture has been processed and the picture source was the client, not another plug-in.

	@param "aPicture" "The picture to return."

	*/

	virtual void MdvppReturnPicture(TVideoPicture* aPicture) = 0;

	/**

	Delivers supplemental information from a decoder hardware device to the client. 

	The information is codec-dependent. The method is synchronous - the client 

	MMMFDevVideoPlayObserver::MdvppSupplementalInformation() method is called immediately, 

	and the memory for the supplemental information can be re-used when the call returns.

	@param "aData"		"The supplemental data."

	@param "aTimestamp" "The presentation timestamp for the picture that the supplemental data is part of."

	@param "aPictureId" "Picture identifier for the picture. If a picture ID is not available, 

						aPictureId.iIdType is set to ENone."

	*/

	virtual void MdvppSupplementalInformation(const TDesC8& aData, 

		const TTimeIntervalMicroSeconds& aTimestamp, const TPictureId& aPictureId) = 0;

	/**

	Back channel information, indicating a picture loss without specifying the lost picture.

	*/

	virtual void MdvppPictureLoss() = 0;

	/**

	Back channel information, indicating the pictures that have been lost.

	@param "aPictures"	"Picture identifiers for the lost pictures. The reference is only valid

						until the method returns."

	*/

	virtual void MdvppPictureLoss(const TArray<TPictureId>& aPictures) = 0;

	/**

	Back channel information, indicating the loss of consecutive macroblocks in raster scan order.

	@param "aFirstMacroblock"	"The first lost macroblock.  The macroblocks are numbered 

								such that the macroblock in the upper left corner of the picture is 

								considered macroblock number 1 and the number for each macroblock increases 

								from left to right and then from top to bottom in raster-scan order."

	@param "aNumMacroblocks"	"The number of lost macroblocks that are consecutive in raster-scan order."

	@param "aPicture"			"The picture identifier for the picture where the macroblocks were lost.  

								If the picture is not known, aPicture.iIdType is set to ENone.  The 

								reference is only valid until the method returns."

	*/

	virtual void MdvppSliceLoss(TUint aFirstMacroblock, TUint aNumMacroblocks, const TPictureId& aPicture)= 0;

	/**

	Back channel information from the decoder, indicating a reference picture selection request. 

	The request is delivered as a coding-standard specific binary message.  Reference picture selection

	can be used to select a pervious correctly transmitted picture to use as a reference in case later 

	pictures have been lost.

	@param "aSelectionData"	"The reference picture selection request message. The message format is 

							coding-standard specific, and defined separately. The reference is only 

							valid until the method returns."

	*/

	virtual void MdvppReferencePictureSelection(const TDesC8& aSelectionData)= 0;

	/**

	Delivers a timed snapshot result to the client. The memory reserved for the snapshot picture 

	can no longer be used in the device.

	@param "aError"					"An error code, KErrNone if no errors occurred. 

									If an error occurred, the data in the snapshot may not be valid, 

									but the memory can still be freed."

	@param "aPictureData"			"The snapshot picture data."

	@param "aPresentationTimestamp"	"The presentation timestamp for the snapshot picture."

	@param "aPictureId"				"Picture identifier for the picture. If a picture ID is not 

									available, aPictureId.iIdType is set to ENone."

	*/

	virtual void MdvppTimedSnapshotComplete(TInt aError, TPictureData* aPictureData, 

		const TTimeIntervalMicroSeconds& aPresentationTimestamp, const TPictureId& aPictureId) = 0;

	/**

	Reports a fatal error to the client. The device must automatically stop processing 

	video data when such errors occur, and may not do further processing before it has 

	been deleted and re-created.

	@param "aDevice" "The device that reported the error."

	@param "aError"	 "The error code."	

	*/

	virtual void MdvppFatalError(CMMFVideoHwDevice* aDevice, TInt aError) = 0;

	/**

	Reports that an asynchronous Initialize() method has completed. 

	The device is now ready for playback.

	@param "aDevice" "The device that was initialzied."

	@param "aError"	 "Initialization result error code, KErrNone if initialization was successful."	

	*/

	virtual void MdvppInitializeComplete(CMMFVideoHwDevice* aDevice, TInt aError) = 0;

	/**

	Reports that the input video stream end has been reached and all pictures have been processed. 

	Called by each hardware device after their InputEnd() methods have been called and all data has 

	been processed. The proxy implementation will notify the client about stream end when all 

	hardware devices have called this method.

	*/

	virtual void MdvppStreamEnd() = 0;

	};

/**

A buffer for compressed video data, contains one coded data unit. Video buffers are used for writing 

video data to the API.

@publishedAll

@released

*/

class TVideoInputBuffer

	{

public:

	/**

	Default constructor. Zeroes all members (including iData which will point to garbage until manually

	set to point to the real video buffer memory data area by the user).

	*/

	IMPORT_C TVideoInputBuffer();

public:

	/**

	 */

	enum TVideoBufferOptions

		{

		/** The sequence number field is valid. */

		ESequenceNumber	 = 0x00000001,

		/** The decoding timestamp field is valid */

		EDecodingTimestamp  = 0x00000002,

		/** The presentation timestamp field is valid.*/

		EPresentationTimestamp = 0x00000004,

		/** Content protected pictures cannot be displayed on unprotected 

		    external displays such as TV-out.

		*/

		EContentProtected = 0x00000008

		};

	/**

	Pointer to the video data.

	*/

	TPtr8 iData;

	/**

	Data unit options. The value is a bitfield combined from values from TVideoBufferOptions.

	@see TVideoBufferOptions

	*/

	TUint32 iOptions;

	/**

	Data unit decoding timestamp. Valid if EDecodingTimestamp is set in the options.

	*/

	TTimeIntervalMicroSeconds iDecodingTimestamp;

	/**

	Data unit presentation timestamp. Valid if EPresentationTimestamp is set in the options. 

	If the input bitstream does not contain timestamp information, this field should be valid, 

	otherwise pictures cannot be displayed at the correct time.   If the input bitstream contains 

	timestamp information (such as the TR syntax element of H.263 bitstreams) and valid 

	iPresentationTimestamp is provided, the value of iPresentationTimestamp is used in playback.

	*/

	TTimeIntervalMicroSeconds iPresentationTimestamp;

	/**

	True if the data is part of a pre-roll period and may not be drawn. The decoder may skip 

	display-related operations, but must still decode normally since pre-roll may not end in a key 

	frame.

	*/

	TBool iPreRoll;

	/**

	Data unit sequence number. Valid if ESequenceNumber is set in the options. If present, the 

	sequence number is incremented once per coded data unit, a gap in the numbers indicates missing 

	data.

	*/

	TUint iSequenceNumber;

	/**

	True if the data unit is known to contain erroneous data.

	*/

	TBool iError;

	/**

	A queue link used internally by the MSL API. The field must not be modified while the buffer is 

	in the MSL API, but can be used by the client before the buffer has been written and after the 

	buffer has been returned.

	*/

	TDblQueLink iLink;

	/**

	A pointer for free-form user data. The pointer is set by the module that created the buffer, and 

	is usually used for memory management purposes.

	*/

	TAny* iUser;

	};

/**

This class contains information about the post-processing functionality that a single post-processor 

or decoder hardware device has. Although it mainly contains static data, it is defined as a complete 

CBase-derived class since the data is relatively complex and proper memory management is necessary.

The objects are created by the post-processor or decoder devices, and used by the MSL video client code.

@publishedAll

@released

*/

class CPostProcessorInfo : public CBase

	{

public:

	/**

	Creates and returns a new CPostProcessorInfo object.

	@param	"aUid"							"The UID of the post-processor."

	@param	"aManufacturer"					"The manufacturer of the post-processor hw device."

	@param	"aIdentifier"					"The post-processor hw device manufacturer-specific 

											identifier."

	@param	"aVersion"						"The post-processor version."

	@param	"aSupportedFormats"				"The source formats supported by the post-processor."

	@param	"aSupportedCombinations"		"The supported post-processing combinations.  An array of 

											values created by the bitwise OR-ing of values from 

											TPrePostProcessType."

	@param	"aAccelerated"					"Whether the post processor is hardware-accelerated. 

											Accelerated post-processors can run on an application DSP 

											or dedicated hardware."

	@param	"aSupportsDirectDisplay"		"Whether the hw device supports output directly to the 

											screen."

	@param	"aYuvToRgbCapabilities"			"The post-processor YUV to RGB conversion capabilities."

	@param	"aSupportedRotations"			"A bitwise OR of values of TRotationType to indicate the 

											supported rotation types."

	@param	"aSupportArbitraryScaling"		"Whether the post-processor supports arbitrary scaling."

	@param	"aSupportedScaleFactors"		"A list of the discrete scaling factors supported. If the

											post-processor supports arbitrary scaling, this list should

											be left zero-length."

	@param	"aAntiAliasedScaling"			"Whether anti-aliasing filtering for scaling is supported."

	@param	"aImplementationSpecificInfo"	"Implementation-specific information."

	@return "A new CPostProcessorInfo object."

	@leave	"This method may leave with one of the system-wide error codes."

	*/

	IMPORT_C static CPostProcessorInfo* NewL(TUid aUid,

											 const TDesC& aManufacturer,

											 const TDesC& aIdentifier,

											 TVersion aVersion,

											 const TArray<TUncompressedVideoFormat>& aSupportedFormats,

											 const TArray<TUint32>& aSupportedCombinations,

											 TBool aAccelerated,

											 TBool aSupportsDirectDisplay,

											 const TYuvToRgbCapabilities& aYuvToRgbCapabilities,

											 TUint32 aSupportedRotations,

											 TBool aSupportArbitraryScaling,

											 const TArray<TScaleFactor>& aSupportedScaleFactors,

											 TBool aAntiAliasedScaling,

											 const TDesC8& aImplementationSpecificInfo = KNullDesC8);

	/**

	Destructor

	*/

	IMPORT_C ~CPostProcessorInfo();

	/**

	Returns the post-processor UID.

	@return "Post-processor UID"

	*/

	IMPORT_C TUid Uid() const;

	/**

	Returns the post-processor hardware device manufacturer.

	@return "The manufacturer name as a standard Symbian descriptor. The reference is valid until the 

			CPostProcessorInfo object is destroyed."

	*/

	IMPORT_C const TDesC& Manufacturer() const;

	/**

	Returns the post-processor hardware device manufacturer-specific identifier. 

	The combination of the manufacturer and identifier uniquely identifies the device.

	@return "The identifier as a standard Symbian descriptor. The reference is valid until the 

			CPostProcessorInfo object is destroyed."

	*/

	IMPORT_C const TDesC& Identifier() const;

	/**

	Returns the post-processor version.

	@return "Post-processor version."

	*/

	IMPORT_C TVersion Version() const;

	/**

	Checks if the post-processor supports the given format as a source format.

	@param	"aFormat"	"The format to check. The reference is not used after the method returns."

	@return "ETrue if the post-processor supports the given format, EFalse if not."

	*/

	IMPORT_C TBool SupportsFormat(const TUncompressedVideoFormat& aFormat) const;

	/**

	Lists the source formats supported by the post-processor.

	@return "A RArray table of supported video formats (TUncompressedVideoFormat). The reference is 

			valid until the CPostProcessorInfo object is destroyed."

	*/

	IMPORT_C const RArray<TUncompressedVideoFormat>& SupportedFormats() const;

	/**

	Checks if the post-processor supports the given post-processing combination.

	@param	"aCombination" "Post-processing combination, a bitwise OR of values from TPrePostProcessType."

	@return "ETrue if the post-processing combination is supported, EFalse if not."

	*/

	IMPORT_C TBool SupportsCombination(TUint32 aCombination) const;

	/**

	Lists all supported post-processing combinations.

	@return "A RArray table or post-processing combinations. Each value is a bitwise OR of values from 

			TPrePostProcessType. The reference is valid until the CPostProcessorInfo object is destroyed."

	*/

	IMPORT_C const RArray<TUint32>& SupportedCombinations() const;

	/**

	Returns whether the hardware device is hardware-accelerated. Hardware-accelerated post-processors 

	can run on an application DSP or dedicated hardware.

	@return "ETrue if the device is hardware-accelerated."

	*/

	IMPORT_C TBool Accelerated() const;

	/**

	Returns whether the hardware device supports output directly to the screen. Output to memory buffers 

	is always supported.

	@return "ETrue if the post-processor supports direct screen output."

	*/

	IMPORT_C TBool SupportsDirectDisplay() const;

	/**

	Returns the post-processor YUV to RGB color conversion capabilities.

	@return "The conversion capabilities as a TYuvToRgbCapabilities structure. The reference is valid 

			until the CPostProcessorInfo object is destroyed. If the post-processor does not support 

			YUV to RGB conversion, the contents are undefined."

	*/

	IMPORT_C const TYuvToRgbCapabilities& YuvToRgbCapabilities() const;

	/**

	Returns the rotation types the post-processor supports.

	@return "The supported rotation types as a bitwise OR of TRotationType values. If the 

			post-processor does not support rotation, the return value is zero."

	*/

	IMPORT_C TUint32 SupportedRotations() const;

	/**

	Returns whether the post-processor supports arbitrary scaling. If arbitrary scaling is not 

	supported, a limited selection of scaling factors may still be available, use 

	SupportedScaleFactors() to retrieve those.

	@return "ETrue if the post-processor supports arbitrary scaling, EFalse if not."

	*/

	IMPORT_C TBool SupportsArbitraryScaling() const;

	/**

	Returns the scaling factors the post-processor supports. If the post-processor supports arbitrary 

	scaling the list is empty - use SupportsArbitraryScaling() first.

	@return "A RArray list of supported scale factors (TScaleFactor). The reference is valid until the 

			CPostProcessorInfo object is destroyed. If the post-processor supports arbitrary scaling 

			or no scaling at all, the list is empty."

	*/

	IMPORT_C const RArray<TScaleFactor>& SupportedScaleFactors() const;

	/**

	Returns whether the hardware device supports anti-aliasing filtering for scaling.

	@return "True if anti-aliasing filtering is supported."

	*/

	IMPORT_C TBool AntiAliasedScaling() const;

	/**

	Returns implementation-specific information about the post-processor.

	@return "Implementation- specific information about the post-processor. The data format is 

			implementation-specific, and defined separately by the post-processor supplier. The 

			reference is valid until the CPostProcessorInfo object is destroyed."

	*/

	IMPORT_C const TDesC8& ImplementationSpecificInfo() const;

	/**

	Adds the screen number into the list of screens supported by the post processor.

	@leave	"KErrNoMemory when there is no memory to expand the list of supported screens. 

			 KErrNotSupported if the secondary screen display is not supported in Multimedia Framework."

	*/

	IMPORT_C void AddSupportedScreenL(TInt aScreenNo);

	/**

	Lists the screens supported by the post processor.

	@param	"aSupportedScreens"		"An array to retrieve the list of supported screens. 

									 This method resets	the array before adding elements to it. 

									 The array must be created and destroyed by the caller."

	@leave "KErrNotSupported if the secondary screen display is not supported in Multimedia Framework.

			KErrNoMemory when there is no memory to expand the list."

	*/

	IMPORT_C void GetSupportedScreensL(RArray<TInt>& aSupportedScreens) const;

	/** Sets a flag indicating whether the PostProcessor supports per picture content protection.

	    E.g. Where content protection within a video stream can alter.

	 @param "aSetting" "Set to TRUE to indicate PostProcessor supports content protection. 

	 @See TVideoPicture::TVideoPictureOptions::EContentProtected 

	 @See TVideoInputBuffer::TVideoBufferOptions::EContentProtected 

	*/

	IMPORT_C void SetSupportsContentProtected(const TBool aSetting);

	/** Returns whether the PostProcessor supports per picture content protection.

	    E.g. Where content protection within a video stream can alter.

	 @return "True if the PostProcessor supports Content Protection." 

	 @See TVideoPicture::TVideoPictureOptions::EContentProtected

	 @See TVideoInputBuffer::TVideoBufferOptions::EContentProtected

	*/

	IMPORT_C TBool SupportsContentProtected() const;

private:

	CPostProcessorInfo(TUid aUid,

					   TVersion aVersion,

					   TBool aAccelerated,

					   TBool aSupportDirectDisplay,

					   const TYuvToRgbCapabilities& aYuvToRgbCapabilities,

					   TUint32 aSupportedRotations,

					   TBool aSupportArbitraryScaling,

					   TBool aAntiAliasedScaling);

	void ConstructL(const TDesC& aManufacturer,

					const TDesC& aIdentifier,

					const TArray<TUncompressedVideoFormat>& aSupportedFormats,

					const TArray<TUint32>& aSupportedCombinations,

					const TArray<TScaleFactor>& aSupportedScaleFactors,

					const TDesC8& aImplementationSpecificInfo);

private:

	TUid iUid;

	TVersion iVersion;

	TBool iAccelerated;

	TBool iSupportDirectDisplay;

	TYuvToRgbCapabilities iYuvToRgbCapabilities;

	TUint32 iSupportedRotations;

	TBool iSupportArbitraryScaling;

	TBool iAntiAliasedScaling;

	HBufC* iManufacturer;

	HBufC* iIdentifier;

	HBufC8* iImplementationSpecificInfo;

 	RArray<TUncompressedVideoFormat> iSupportedFormats;

	RArray<TUint32> iSupportedCombinations;

	RArray<TScaleFactor> iSupportedScaleFactors;

	RArray<TInt> iSupportedScreens;

	TBool iSupportsContentProtected;

	};

/**

This class contains information about a single video decoder. Although it mainly contains static data, 

it is defined as a complete CBase-derived class since the data is relatively complex and proper memory 

management is necessary.

The objects are created by the video decoder hardware devices, and used by the MSL video client code.

@publishedAll

@released

*/

class CVideoDecoderInfo : public CBase

	{

public:

	/**

	Creates and returns a new CVideoDecoderInfo object.

	@param	"aUid"							"The uid of the decoder."

	@param	"aManufacturer"					"The video decoder manufacturer."

	@param	"aIdentifier"					"The manufacturer-specific identifier for this video decoder."

	@param	"aVersion"						"The version of this video decoder."

	@param	"aSupportedFormats"				"An array of the formats supported by the decoder. 

											A copy will be taken of the array and the referenced 

											CCompressedVideoFormat objects"

	@param	"aAccelerated"					"Whether this decoder is accelerated or not."

	@param	"aSupportsDirectDisplay"		"Whether this decoder supports direct display or not."

	@param	"aMaxPictureSize"				"The maximum picture size supported by the decoder."

	@param	"aMaxBitrate"					"The maximum bit rate supported by the decoder. Use KMaxTUint32 if there are no bit-rate restrictions."

	@param	"aMaxPictureRates"				"An array of the maximum picture size/rate combinations supported by the decoder."

	@param	"aSupportsPictureLoss"			"Whether the decoder supports picture loss indications."

	@param	"aSupportsSliceLoss"			"Whether the decoder supports slice loss indications."

	@param	"aCodingStandardSpecificInfo"	"Coding-standard specific information about the decoder."

	@param	"aImplementationSpecificInfo"	"Implementation-specific information about the decoder."

	@return "A new CVideoDecoderInfo object."

	@leave	"This method may leave with one of the system-wide error codes."

	*/

	IMPORT_C static CVideoDecoderInfo* NewL(TUid aUid,

											const TDesC& aManufacturer,

											const TDesC& aIdentifier,

											TVersion aVersion,

											const TArray<CCompressedVideoFormat*>& aSupportedFormats,

											TBool aAccelerated,

											TBool aSupportsDirectDisplay,

											const TSize& aMaxPictureSize,

											TUint aMaxBitrate,

											const TArray<TPictureRateAndSize>& aMaxPictureRates,

											TBool aSupportsPictureLoss,

											TBool aSupportsSliceLoss,

											const TDesC8& aCodingStandardSpecificInfo = KNullDesC8,

											const TDesC8& aImplementationSpecificInfo = KNullDesC8);

	/**

	Destructor.

	*/

	IMPORT_C ~CVideoDecoderInfo();

	/**

	Checks if the decoder supports the given format.

	@param	"aFormat"	"The format to check. The reference is not used after the method returns."

	@return "ETrue if the codec supports the given format, EFalse if not."

	*/

	IMPORT_C TBool SupportsFormat(const CCompressedVideoFormat& aFormat) const;

	/**

	Lists the video formats, including submodes, supported by the decoder.

	@return "A RPointerArray table of supported video formats (CCompressedVideoFormat). The reference 

			is valid until the CVideoDecoderInfo object is destroyed."

	*/

	IMPORT_C const RPointerArray<CCompressedVideoFormat>& SupportedFormats() const;

	/**

	Returns the codec device manufacturer.

	@return "The manufacturer name as a standard Symbian descriptor. The reference is valid until the 

	CVideoDecoderInfo object is destroyed."

	*/

	IMPORT_C const TDesC& Manufacturer() const;

	/**

	Returns the codec device manufacturer-specific identifier. The combination of the manufacturer 

	and identifier uniquely identifies the hardware device.

	@return "The identifier as a standard Symbian descriptor. The reference is valid until the 

			CVideoDecoderInfo object is destroyed."

	*/

	IMPORT_C const TDesC& Identifier() const;

	/**

	Returns the decoder version.

	@return "Decoder version."

	*/

	IMPORT_C TVersion Version() const;

	/**

	Returns the decoder UID.

	@return "Decoder UID."

	*/

	IMPORT_C TUid Uid() const;

	/**

	Returns whether the decoder is hardware-accelerated. A hardware-accelerated decoder can run on 

	an application DSP or dedicated hardware.

	@return "True if the decoder is hardware-accelerated."

	*/

	IMPORT_C TBool Accelerated() const;

	/**

	Returns whether the hardware device supports output directly to the screen. Output to memory 

	buffers is always supported.

	@return "True if the hardware device supports direct screen output."

	*/

	IMPORT_C TBool SupportsDirectDisplay() const;

	/**

	Returns the maximum picture size the decoder supports.

	Note that if the decoder reports that it supports a certain profile and level, then it 

	shall support all bitstreams corresponding to that profile/level.  This method can be used 

	to specify capabilities that are beyond the standard levels (for example some MPEG-4 bitstreams 

	are encoded with picture sizes that are larger than those specified by the profile/level of the 

	bitstream).

	@return "The maximum picture size supported. The reference is valid until the CVideoDecoderInfo 

			object is destroyed."

	*/

	IMPORT_C const TSize& MaxPictureSize() const;

	/**

	Returns the maximum bit-rate supported by the decoder.

	Note that if the decoder reports that it supports a certain profile and level, then it shall 

	support all bitstreams corresponding to that profile/level.  This method can be used to 

	specify capabilities that are beyond the standard levels (for example some MPEG-4 bitstreams 

	are encoded with bit rates that are higher than those specified by the profile/level of the

	bitstream).

	@return "Maximum bit-rate supported, in bits per second. KMaxTUint32 can be used if the decoder 

			has no bit-rate restrictions."

	*/

	IMPORT_C TUint MaxBitrate() const;

	/**

	Returns the maximum picture size/rate combinations supported by the decoder.  

	Video decoders can have different maximum picture rate limitations depending on the picture size used.

	Note that if the decoder reports that it supports a certain profile and level, then it shall 

	support all bitstreams corresponding to that profile/level.  This method can be used to specify 

	capabilities that are beyond the standard levels (for example some MPEG-4 bitstreams are encoded

	with picture rates that are beyond those specified by the profile/level of the bitstream).

	@return "A reference to an array of picture size/rate combinations.  The reference remains valid

			until this object is deleted."

	*/

	IMPORT_C const RArray<TPictureRateAndSize>& MaxPictureRates() const;

	/**

	Returns whether the decoder supports picture loss indications. If true, the decoder indicates

	lost pictures by calling MdvpoPictureLoss().

	@return "True if the decoder supports picture loss indications."

	*/

	IMPORT_C TBool SupportsPictureLoss() const;

	/**

	Returns whether the decoder supports slice loss indications. If true, the decoder indicates 

	lost macroblocks by calling MdvpoSliceLoss().

	@return "True if the decoder supports slice loss indications."

	*/

	IMPORT_C TBool SupportsSliceLoss() const;

	/**

	Returns coding-standard specific information about the decoder.

	@return "Coding-standard specific information about the decoder. The data format is coding-standard

			specific, and defined separately. The reference is valid until the CVideoDecoderInfo object

			is destroyed."

	*/

	IMPORT_C const TDesC8& CodingStandardSpecificInfo() const;

	/**

	Returns implementation-specific information about the decoder.

	@return "Implementation- specific information about the decoder. The data format is 

			implementation-specific, and defined separately by the decoder supplier. The reference 

			is valid until the CVideoDecoderInfo object is destroyed."

	*/

	IMPORT_C const TDesC8& ImplementationSpecificInfo() const;

	/**

	Adds the screen number into the list of screens supported by the decoder.

	@leave	"KErrNoMemory when there is no memory to expand the list of supported screens. 

			 KErrNotSupported if the secondary screen display is not supported in Multimedia Framework."

	*/

	IMPORT_C void AddSupportedScreenL(TInt aScreenNo);

	/**

	Lists the screens supported by the decoder.

	@param	"aSupportedScreens"		"An array to retrieve the list of supported screens. 

									 This method resets	the array before adding elements to it. 

									 The array must be created and destroyed by the caller."

	@leave "KErrNotSupported if the secondary screen display is not supported in Multimedia Framework.

			KErrNoMemory when there is no memory to expand the list."

	*/

	IMPORT_C void GetSupportedScreensL(RArray<TInt>& aSupportedScreens) const;

	/** Sets a flag indicating whether the Decoder supports per picture content protection.

	    E.g. Where content protection within a video stream can alter.

	 @param "aSetting" "Set to TRUE to indicate decoder supports content protection. 

	 @See TVideoPicture::TVideoPictureOptions::EContentProtected 

	 @See TVideoInputBuffer::TVideoBufferOptions::EContentProtected 

	*/

	IMPORT_C void SetSupportsContentProtected(const TBool aSetting);

	/** Returns whether the Decoder supports per picture content protection.

	    E.g. Where content protection within a video stream can alter.

	 @return "True if the Decoder supports Content Protection." 

	 @See TVideoPicture::TVideoPictureOptions::EContentProtected

	 @See TVideoInputBuffer::TVideoBufferOptions::EContentProtected

	*/

	IMPORT_C TBool SupportsContentProtected() const;

private:

	CVideoDecoderInfo(TUid aUid,

					  TVersion aVersion,

					  TBool aAccelerated,

					  TBool aSupportsDirectDisplay,

					  const TSize& aMaxPictureSize,

					  TUint aMaxBitrate,

					  TBool aSupportsPictureLoss,

					  TBool aSupportsSliceLoss);

	void ConstructL(const TDesC& aManufacturer,

					const TDesC& aIdentifier,

					const TArray<CCompressedVideoFormat*>& aSupportedFormats,

					const TArray<TPictureRateAndSize>& aMaxPictureRates,

					const TDesC8& aCodingStandardSpecificInfo,

					const TDesC8& aImplementationSpecificInfo);

private:

	TUid iUid;

	TVersion iVersion;

	TBool iAccelerated;

	TBool iSupportsDirectDisplay;

	TSize iMaxPictureSize;

	TUint iMaxBitrate;

	TBool iSupportsPictureLoss;

	TBool iSupportsSliceLoss;

	HBufC* iManufacturer;

	HBufC* iIdentifier;

	RPointerArray<CCompressedVideoFormat> iSupportedFormats;

	RArray<TPictureRateAndSize> iMaxPictureRates;

	HBufC8* iCodingStandardSpecificInfo;

	HBufC8* iImplementationSpecificInfo;

	RArray<TInt> iSupportedScreens;

	TBool iSupportsContentProtected;

	};

/**

CMMFDevVideoPlay is the main client API for DevVideoPlay.

@publishedAll

@released

*/

class CMMFDevVideoPlay : public CBase, private MMMFDevVideoPlayProxy

	{

public:

	/**

	Picture statistic counters. Used for following playback progress. The counters can be retrieved 

	using GetPictureCounters() and are reset after each call. The client must keep track of the 

	cumulative values for counters and picture processing rates itself if necessary.

	*/

	class TPictureCounters

		{

	public:

		/**

		Default constructor.  Zeros all members.

		*/

		inline TPictureCounters();

	public:

		/**

		The number of pictures skipped due to lack of processing power. This does not include pictures 

		inside data bytes discarded due to buffer overflows, but includes all pictures skipped at 

		picture decoding, post-processing and rendering phase.

		*/

		TUint iPicturesSkipped;

		/**

		The number of pictures decoded.

		*/

		TUint iPicturesDecoded;

		/**

		The number of pictures "virtually" displayed. "Virtually" displayed pictures are pictures 

		that have been drawn on the screen, when using direct rendering, or pictures that have been 

		decoded, processed, and delivered to the client when not using direct rendering.

		*/

		TUint iPicturesDisplayed;

		/**

		The total number of pictures in the input bitstream. This figure does not include pictures that 

		have been lost due to transmission errors, since those have not been processed by the MSL 

		hardware devices, but does include pictures that have been discarded by the HW devices due 

		to buffer overflows or other reasons.

		*/

		TUint iTotalPictures;

		};

	/**

	Bitstream statistic counters, used for following decoding progress. The counters can be retrieved 

	using GetBitstreamCounters() and are reset after each call. The client must keep track of the 

	cumulative values for counters itself if necessary.

	*/

	class TBitstreamCounters

		{

	public:

		/**

		Default constructor.  Zeros all members.

		*/

		inline TBitstreamCounters();

	public:

		/**

		Number of lost packets.  This figure includes all packets that have been dropped by the hardware 

		devices due to buffer overruns, but it does not include packets lost due to transmission errors.

		*/

		TUint iLostPackets;

		/**

		Total number of packets. This figure includes all the packets that have been received by the 

		decoder, including packets that have been dropped due to buffer overruns.

		*/

		TUint iTotalPackets;

		};

	/**

	Buffer options used with SetBufferOptionsL().

	*/

	class TBufferOptions

		{

	public:

		/**

		Default constructor.  Zeros all members.

		*/

		inline TBufferOptions();

	public:

		/**

		Pre-decoder buffer size in bytes. Set to zero to use decoder default value.

		*/

		TUint iPreDecodeBufferSize;

		/**

		Maximum post-decoder buffer size in bytes. Set to zero to remove limitations.

		*/

		TUint iMaxPostDecodeBufferSize;

		/**

		Initial pre-decoder buffering period, the amount of coded data to be buffered before decoding 

		starts. If the value is set to zero, decoding begins immediately when all data associated with 

		the first decoding timestamp is received. Default value is zero.

		*/

		TTimeIntervalMicroSeconds iPreDecoderBufferPeriod;

		/**

		The amount of data buffered after the decoding before playback starts. If the value is zero, 

		playback begins immediately when the first picture has been decoded. The default value is zero.

		*/

		TTimeIntervalMicroSeconds iPostDecoderBufferPeriod;

		/**

		The maximum input buffer size that the client will request. If the buffer options have been 

		set successfully, the decoder must be able to supply buffers of this size. If no information 

		is available about the bitstream, the client may have to set this value to a relatively large 

		value, and thus the decoder should not by default allocate buffers of this size before they 

		are explicitly requested.

		*/

		TUint iMaxInputBufferSize;

		/**

		The minimum number of input buffers the decoder needs to have available. This is the number of 

		buffers the client can request through GetBufferL() before writing any back using 

		WriteCodedDataL().

		*/

		TUint iMinNumInputBuffers;

		};

	/**

	Information about a single computational complexity level.

	*/

	class TComplexityLevelInfo

		{

	public:

		enum TOptions

			{

			/** The average picture rate field is valid. */

			EAvgPictureRate	   = 0x00000001,

			/** The picture size field is valid. */

			EPictureSize		  = 0x00000002,

			/** The relative image quality field is valid. */

			ERelativeImageQuality = 0x00000004,

			/** The required MIPS field is valid. */

			ERequiredMIPS		 = 0x00000008,

			/** The relative processing time field is valid. */

			ERelativeProcessTime  = 0x00000010

			};

		/**

		Structure options. The value is a bitfield combined from values from TOptions.

		*/

		TUint32 iOptions;

		/**

		The average picture rate, in pictures per second. Valid only if EAvgPictureRate is set in the

		options. This value depends on the input bitstream, and may not be available if enough 

		bitstream has not been read.

		*/

		TReal iAvgPictureRate;

		/**

		Picture size (spatial resolution), in pixels. Valid only if EPictureSize is set in the options.

		*/

		TSize iPictureSize;

		/**

		Relative image quality, compared to the best available level. 1.0 is the quality at the 

		maximum quality level (level zero). Valid only if ERelativeImageQuality is set in the options.

		*/

		TReal iRelativeImageQuality;

		/**

		The number of MIPS required to process the data. Valid only if ERequiredMIPS is set in 

		the options.

		*/

		TUint iRequiredMIPS;

		/**

		Relative amount of processing time needed compared to standard-compliant decoding of all data. 

		1.0 is the processing time required for full processing, which usually corresponds to 

		complexity level zero. Valid only if ERelativeProcessTime is set in the options.

		*/

		TReal iRelativeProcessTime;

		};

public:

	/**

	Constructs a new MSL video client instance. Each client instance supports a single video bitstream.

	@param  aObserver

	        The observer object to use.

	@return A pointer to a new CMMFDevVideoPlay object.

	@leave  This method may leave with one of the system-wide error codes.

	*/

	IMPORT_C static CMMFDevVideoPlay* NewL(MMMFDevVideoPlayObserver& aObserver);

	/**

	Destructor.

	*/

	IMPORT_C ~CMMFDevVideoPlay();

	/**

	Finds a common format from two lists of uncompressed video formats. Used typically to find a 

	suitable intermediate format between a video decoder and a post-processor. If multiple common 

	formats are available, the lowest-cost format is selected, assuming that the cost of each format 

	is equal to its position in the input array.

	@param	"aFormats1"		"The first format list."

	@param	"aFormats2"		"The second format list."

	@param	"aCommonFormat"	"The target variable where the common format found (if any) is stored."

	@return	"True if a common format was found, false if not. If no common format was found, 

			aCommonFormat is not modified."

	*/

	IMPORT_C static TBool FindCommonFormat(const TArray<TUncompressedVideoFormat>& aFormats1, 

										   const TArray<TUncompressedVideoFormat>& aFormats2, 

										   TUncompressedVideoFormat& aCommonFormat);

	/**

	Finds all available decoders for a given video type with support for certain post-processing 

	operations. The video type is specified using its MIME type, which may include parameters 

	specifying the supported level, version, and other information. Decoder HW devices can use 

	wildcards when listing the supported video types in the ECom registration information, so it is 

	possible that all the decoders returned do not support the specified submode, e.g. profile and 

	level, unless aExactMatch is set.

	The decoder capabilities can be checked with VideoCodecInfoLC().

	@param	"aMimeType"		"The video type that will be decoded."

	@param	"aPostProcType"	"The post-processing types that the decoder has to support, a binary OR 

							of TPrePostProcessType values. If no post-processing support is needed, 

							set this value to zero."

	@param	"aDecoders"		"An array for the result decoder UIDs. The array must be created and 

							destroyed by the caller."

	@param	"aExactMatch"	"True if exact matching should be used. In this only decoders that support 

							exactly the MIME-type given will be returned. Since verifying this may 

							require loading the decoders into memory, this can be a fairly expensive 

							operation, and if the user needs to verify their capabilities further in 

							any case this parameter should be set to EFalse."

	@leave	"This method may leave with one of the system-wide error codes. Typical error codes used:

				* KErrNotFound:	No decoders were found matching the search parameters."

	*/

	IMPORT_C void FindDecodersL(const TDesC8& aMimeType, 

								TUint32 aPostProcType, 

								RArray<TUid>& aDecoders, 

								TBool aExactMatch=ETrue);