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

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #ifndef __DEVVIDEOPLAY_H__

    17 #define __DEVVIDEOPLAY_H__

    18 

    19 #include <e32std.h>

    20 #include <mmf/devvideo/devvideobase.h>

    21 

    22 class MMMFDevVideoPlayObserver;

    23 class CMMFVideoPlayHwDevice;

    24 class CMMFVideoDecodeHwDevice;

    25 class CMMFVideoPostProcHwDevice;

    26 

    27 

    28 /**

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

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

    31 @publishedAll

    32 @released

    33 */

    34 class MMMFDevVideoPlayProxy

    35 	{

    36 public:

    37 	/**

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

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

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

    41 

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

    43 	*/

    44 	virtual void MdvppNewPicture(TVideoPicture* aPicture) = 0;

    45 

    46 	/**

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

    48 	hardware device.

    49 	*/

    50 	virtual void MdvppNewBuffers() = 0;

    51 

    52 	/**

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

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

    55 

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

    57 	*/

    58 	virtual void MdvppReturnPicture(TVideoPicture* aPicture) = 0;

    59 

    60 	/**

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

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

    63 	MMMFDevVideoPlayObserver::MdvppSupplementalInformation() method is called immediately, 

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

    65 

    66 	@param "aData"		"The supplemental data."

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

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

    69 						aPictureId.iIdType is set to ENone."

    70 	*/

    71 	virtual void MdvppSupplementalInformation(const TDesC8& aData, 

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

    73 

    74 	/**

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

    76 	*/

    77 	virtual void MdvppPictureLoss() = 0;

    78 

    79 	/**

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

    81 	

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

    83 						until the method returns."

    84 	*/

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

    86 

    87 	/**

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

    89 

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

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

    92 								considered macroblock number 1 and the number for each macroblock increases 

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

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

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

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

    97 								reference is only valid until the method returns."

    98 	*/

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

   100 

   101 	/**

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

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

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

   105 	pictures have been lost.

   106 	

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

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

   109 							valid until the method returns."

   110 	*/

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

   112 

   113 	/**

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

   115 	can no longer be used in the device.

   116 

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

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

   119 									but the memory can still be freed."

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

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

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

   123 									available, aPictureId.iIdType is set to ENone."

   124 	*/

   125 	virtual void MdvppTimedSnapshotComplete(TInt aError, TPictureData* aPictureData, 

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

   127 

   128 	/**

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

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

   131 	been deleted and re-created.

   132 

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

   134 	@param "aError"	 "The error code."	

   135 	*/

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

   137 

   138 	/**

   139 	Reports that an asynchronous Initialize() method has completed. 

   140 	The device is now ready for playback.

   141 

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

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

   144 	*/

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

   146 

   147 	/**

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

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

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

   151 	hardware devices have called this method.

   152 	*/

   153 	virtual void MdvppStreamEnd() = 0;

   154 	};

   155 

   156 

   157 /**

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

   159 video data to the API.

   160 

   161 @publishedAll

   162 @released

   163 */

   164 class TVideoInputBuffer

   165 	{

   166 public:

   167 	/**

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

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

   170 	*/

   171 	IMPORT_C TVideoInputBuffer();

   172 

   173 public:

   174 	/**

   175 	 */

   176 	enum TVideoBufferOptions

   177 		{

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

   179 		ESequenceNumber	 = 0x00000001,

   180 		/** The decoding timestamp field is valid */

   181 		EDecodingTimestamp  = 0x00000002,

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

   183 		EPresentationTimestamp = 0x00000004,

   184 		/** Content protected pictures cannot be displayed on unprotected 

   185 		    external displays such as TV-out.

   186 		*/

   187 		EContentProtected = 0x00000008

   188 		};

   189 

   190 	/**

   191 	Pointer to the video data.

   192 	*/

   193 	TPtr8 iData;

   194 

   195 	/**

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

   197 	@see TVideoBufferOptions

   198 	*/

   199 	TUint32 iOptions;

   200 

   201 	/**

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

   203 	*/

   204 	TTimeIntervalMicroSeconds iDecodingTimestamp;

   205 

   206 	/**

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

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

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

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

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

   212 	*/

   213 	TTimeIntervalMicroSeconds iPresentationTimestamp;

   214 

   215 	/**

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

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

   218 	frame.

   219 	*/

   220 	TBool iPreRoll;

   221 

   222 	/**

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

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

   225 	data.

   226 	*/

   227 	TUint iSequenceNumber;

   228 

   229 	/**

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

   231 	*/

   232 	TBool iError;

   233 

   234 	/**

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

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

   237 	buffer has been returned.

   238 	*/

   239 	TDblQueLink iLink;

   240 

   241 	/**

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

   243 	is usually used for memory management purposes.

   244 	*/

   245 	TAny* iUser;

   246 	};

   247 

   248 

   249 /**

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

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

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

   253 

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

   255 @publishedAll

   256 @released

   257 */

   258 class CPostProcessorInfo : public CBase

   259 	{

   260 public:

   261 	/**

   262 	Creates and returns a new CPostProcessorInfo object.

   263 

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

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

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

   267 											identifier."

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

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

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

   271 											values created by the bitwise OR-ing of values from 

   272 											TPrePostProcessType."

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

   274 											Accelerated post-processors can run on an application DSP 

   275 											or dedicated hardware."

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

   277 											screen."

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

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

   280 											supported rotation types."

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

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

   283 											post-processor supports arbitrary scaling, this list should

   284 											be left zero-length."

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

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

   287 

   288 	@return "A new CPostProcessorInfo object."

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

   290 	*/

   291 	IMPORT_C static CPostProcessorInfo* NewL(TUid aUid,

   292 											 const TDesC& aManufacturer,

   293 											 const TDesC& aIdentifier,

   294 											 TVersion aVersion,

   295 											 const TArray<TUncompressedVideoFormat>& aSupportedFormats,

   296 											 const TArray<TUint32>& aSupportedCombinations,

   297 											 TBool aAccelerated,

   298 											 TBool aSupportsDirectDisplay,

   299 											 const TYuvToRgbCapabilities& aYuvToRgbCapabilities,

   300 											 TUint32 aSupportedRotations,

   301 											 TBool aSupportArbitraryScaling,

   302 											 const TArray<TScaleFactor>& aSupportedScaleFactors,

   303 											 TBool aAntiAliasedScaling,

   304 											 const TDesC8& aImplementationSpecificInfo = KNullDesC8);

   305 

   306 	/**

   307 	Destructor

   308 	*/

   309 	IMPORT_C ~CPostProcessorInfo();

   310 

   311 	/**

   312 	Returns the post-processor UID.

   313 	@return "Post-processor UID"

   314 	*/

   315 	IMPORT_C TUid Uid() const;

   316 

   317 	/**

   318 	Returns the post-processor hardware device manufacturer.

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

   320 			CPostProcessorInfo object is destroyed."

   321 	*/

   322 	IMPORT_C const TDesC& Manufacturer() const;

   323 

   324 	/**

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

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

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

   328 			CPostProcessorInfo object is destroyed."

   329 	*/

   330 	IMPORT_C const TDesC& Identifier() const;

   331 

   332 	/**

   333 	Returns the post-processor version.

   334 	@return "Post-processor version."

   335 	*/

   336 	IMPORT_C TVersion Version() const;

   337 

   338 	/**

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

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

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

   342 	*/

   343 	IMPORT_C TBool SupportsFormat(const TUncompressedVideoFormat& aFormat) const;

   344 

   345 	/**

   346 	Lists the source formats supported by the post-processor.

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

   348 			valid until the CPostProcessorInfo object is destroyed."

   349 	*/

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

   351 

   352 	/**

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

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

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

   356 	*/

   357 	IMPORT_C TBool SupportsCombination(TUint32 aCombination) const;

   358 

   359 	/**

   360 	Lists all supported post-processing combinations.

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

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

   363 	*/

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

   365 

   366 	/**

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

   368 	can run on an application DSP or dedicated hardware.

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

   370 	*/

   371 	IMPORT_C TBool Accelerated() const;

   372 

   373 	/**

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

   375 	is always supported.

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

   377 	*/

   378 	IMPORT_C TBool SupportsDirectDisplay() const;

   379 

   380 	/**

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

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

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

   384 			YUV to RGB conversion, the contents are undefined."

   385 	*/

   386 	IMPORT_C const TYuvToRgbCapabilities& YuvToRgbCapabilities() const;

   387 

   388 	/**

   389 	Returns the rotation types the post-processor supports.

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

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

   392 	*/

   393 	IMPORT_C TUint32 SupportedRotations() const;

   394 

   395 	/**

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

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

   398 	SupportedScaleFactors() to retrieve those.

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

   400 	*/

   401 	IMPORT_C TBool SupportsArbitraryScaling() const;

   402 

   403 	/**

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

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

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

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

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

   409 	*/

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

   411 

   412 	/**

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

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

   415 	*/

   416 	IMPORT_C TBool AntiAliasedScaling() const;

   417 

   418 	/**

   419 	Returns implementation-specific information about the post-processor.

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

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

   422 			reference is valid until the CPostProcessorInfo object is destroyed."

   423 	*/

   424 	IMPORT_C const TDesC8& ImplementationSpecificInfo() const;

   425 	

   426 	/**

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

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

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

   430 	*/

   431 	IMPORT_C void AddSupportedScreenL(TInt aScreenNo);

   432 	

   433 	/**

   434 	Lists the screens supported by the post processor.

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

   436 									 This method resets	the array before adding elements to it. 

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

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

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

   440 	*/

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

   442 	

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

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

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

   446 	 @See TVideoPicture::TVideoPictureOptions::EContentProtected 

   447 	 @See TVideoInputBuffer::TVideoBufferOptions::EContentProtected 

   448 	*/

   449 	IMPORT_C void SetSupportsContentProtected(const TBool aSetting);

   450 		

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

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

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

   454 	 @See TVideoPicture::TVideoPictureOptions::EContentProtected

   455 	 @See TVideoInputBuffer::TVideoBufferOptions::EContentProtected

   456 	*/

   457 	IMPORT_C TBool SupportsContentProtected() const;

   458 	

   459 private:

   460 	CPostProcessorInfo(TUid aUid,

   461 					   TVersion aVersion,

   462 					   TBool aAccelerated,

   463 					   TBool aSupportDirectDisplay,

   464 					   const TYuvToRgbCapabilities& aYuvToRgbCapabilities,

   465 					   TUint32 aSupportedRotations,

   466 					   TBool aSupportArbitraryScaling,

   467 					   TBool aAntiAliasedScaling);

   468 

   469 	void ConstructL(const TDesC& aManufacturer,

   470 					const TDesC& aIdentifier,

   471 					const TArray<TUncompressedVideoFormat>& aSupportedFormats,

   472 					const TArray<TUint32>& aSupportedCombinations,

   473 					const TArray<TScaleFactor>& aSupportedScaleFactors,

   474 					const TDesC8& aImplementationSpecificInfo);

   475 private:

   476 	TUid iUid;

   477 	TVersion iVersion;

   478 	TBool iAccelerated;

   479 	TBool iSupportDirectDisplay;

   480 	TYuvToRgbCapabilities iYuvToRgbCapabilities;

   481 	TUint32 iSupportedRotations;

   482 	TBool iSupportArbitraryScaling;

   483 	TBool iAntiAliasedScaling;

   484 	HBufC* iManufacturer;

   485 	HBufC* iIdentifier;

   486 	HBufC8* iImplementationSpecificInfo;

   487  	RArray<TUncompressedVideoFormat> iSupportedFormats;

   488 	RArray<TUint32> iSupportedCombinations;

   489 	RArray<TScaleFactor> iSupportedScaleFactors;

   490 	RArray<TInt> iSupportedScreens;

   491 	TBool iSupportsContentProtected;

   492 	};

   493 

   494 

   495 /**

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

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

   498 management is necessary.

   499 

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

   501 @publishedAll

   502 @released

   503 */

   504 class CVideoDecoderInfo : public CBase

   505 	{

   506 public:

   507 	/**

   508 	Creates and returns a new CVideoDecoderInfo object.

   509 

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

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

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

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

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

   515 											A copy will be taken of the array and the referenced 

   516 											CCompressedVideoFormat objects"

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

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

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

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

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

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

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

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

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

   526 

   527 	@return "A new CVideoDecoderInfo object."

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

   529 	*/

   530 	IMPORT_C static CVideoDecoderInfo* NewL(TUid aUid,

   531 											const TDesC& aManufacturer,

   532 											const TDesC& aIdentifier,

   533 											TVersion aVersion,

   534 											const TArray<CCompressedVideoFormat*>& aSupportedFormats,

   535 											TBool aAccelerated,

   536 											TBool aSupportsDirectDisplay,

   537 											const TSize& aMaxPictureSize,

   538 											TUint aMaxBitrate,

   539 											const TArray<TPictureRateAndSize>& aMaxPictureRates,

   540 											TBool aSupportsPictureLoss,

   541 											TBool aSupportsSliceLoss,

   542 											const TDesC8& aCodingStandardSpecificInfo = KNullDesC8,

   543 											const TDesC8& aImplementationSpecificInfo = KNullDesC8);

   544 

   545 	/**

   546 	Destructor.

   547 	*/

   548 	IMPORT_C ~CVideoDecoderInfo();

   549 

   550 	/**

   551 	Checks if the decoder supports the given format.

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

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

   554 	*/

   555 	IMPORT_C TBool SupportsFormat(const CCompressedVideoFormat& aFormat) const;

   556 

   557 	/**

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

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

   560 			is valid until the CVideoDecoderInfo object is destroyed."

   561 	*/

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

   563 

   564 	/**

   565 	Returns the codec device manufacturer.

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

   567 	CVideoDecoderInfo object is destroyed."

   568 	*/

   569 	IMPORT_C const TDesC& Manufacturer() const;

   570 

   571 	/**

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

   573 	and identifier uniquely identifies the hardware device.

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

   575 			CVideoDecoderInfo object is destroyed."

   576 	*/

   577 	IMPORT_C const TDesC& Identifier() const;

   578 

   579 	/**

   580 	Returns the decoder version.

   581 	@return "Decoder version."

   582 	*/

   583 	IMPORT_C TVersion Version() const;

   584 

   585 	/**

   586 	Returns the decoder UID.

   587 	@return "Decoder UID."

   588 	*/

   589 	IMPORT_C TUid Uid() const;

   590 

   591 	/**

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

   593 	an application DSP or dedicated hardware.

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

   595 	*/

   596 	IMPORT_C TBool Accelerated() const;

   597 

   598 	/**

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

   600 	buffers is always supported.

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

   602 	*/

   603 	IMPORT_C TBool SupportsDirectDisplay() const;

   604 

   605 	/**

   606 	Returns the maximum picture size the decoder supports.

   607 

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

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

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

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

   612 	bitstream).

   613 

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

   615 			object is destroyed."

   616 	*/

   617 	IMPORT_C const TSize& MaxPictureSize() const;

   618 

   619 	/**

   620 	Returns the maximum bit-rate supported by the decoder.

   621 

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

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

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

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

   626 	bitstream).

   627 

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

   629 			has no bit-rate restrictions."

   630 	*/

   631 	IMPORT_C TUint MaxBitrate() const;

   632 

   633 	/**

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

   635 	

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

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

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

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

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

   641 

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

   643 			until this object is deleted."

   644 	*/

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

   646 

   647 	/**

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

   649 	lost pictures by calling MdvpoPictureLoss().

   650 

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

   652 	*/

   653 	IMPORT_C TBool SupportsPictureLoss() const;

   654 

   655 	/**

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

   657 	lost macroblocks by calling MdvpoSliceLoss().

   658 

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

   660 	*/

   661 	IMPORT_C TBool SupportsSliceLoss() const;

   662 

   663 	/**

   664 	Returns coding-standard specific information about the decoder.

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

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

   667 			is destroyed."

   668 	*/

   669 	IMPORT_C const TDesC8& CodingStandardSpecificInfo() const;

   670 

   671 	/**

   672 	Returns implementation-specific information about the decoder.

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

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

   675 			is valid until the CVideoDecoderInfo object is destroyed."

   676 	*/

   677 	IMPORT_C const TDesC8& ImplementationSpecificInfo() const;

   678 	

   679 	/**

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

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

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

   683 	*/

   684 	IMPORT_C void AddSupportedScreenL(TInt aScreenNo);

   685 	

   686 	/**

   687 	Lists the screens supported by the decoder.

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

   689 									 This method resets	the array before adding elements to it. 

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

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

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

   693 	*/

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

   695 

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

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

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

   699 	 @See TVideoPicture::TVideoPictureOptions::EContentProtected 

   700 	 @See TVideoInputBuffer::TVideoBufferOptions::EContentProtected 

   701 	*/

   702 	IMPORT_C void SetSupportsContentProtected(const TBool aSetting);

   703 		

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

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

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

   707 	 @See TVideoPicture::TVideoPictureOptions::EContentProtected

   708 	 @See TVideoInputBuffer::TVideoBufferOptions::EContentProtected

   709 	*/

   710 	IMPORT_C TBool SupportsContentProtected() const;

   711 

   712 private:

   713 	CVideoDecoderInfo(TUid aUid,

   714 					  TVersion aVersion,

   715 					  TBool aAccelerated,

   716 					  TBool aSupportsDirectDisplay,

   717 					  const TSize& aMaxPictureSize,

   718 					  TUint aMaxBitrate,

   719 					  TBool aSupportsPictureLoss,

   720 					  TBool aSupportsSliceLoss);

   721 

   722 	void ConstructL(const TDesC& aManufacturer,

   723 					const TDesC& aIdentifier,

   724 					const TArray<CCompressedVideoFormat*>& aSupportedFormats,

   725 					const TArray<TPictureRateAndSize>& aMaxPictureRates,

   726 					const TDesC8& aCodingStandardSpecificInfo,

   727 					const TDesC8& aImplementationSpecificInfo);

   728 private:

   729 	TUid iUid;

   730 	TVersion iVersion;

   731 	TBool iAccelerated;

   732 	TBool iSupportsDirectDisplay;

   733 	TSize iMaxPictureSize;

   734 	TUint iMaxBitrate;

   735 	TBool iSupportsPictureLoss;

   736 	TBool iSupportsSliceLoss;

   737 	HBufC* iManufacturer;

   738 	HBufC* iIdentifier;

   739 	RPointerArray<CCompressedVideoFormat> iSupportedFormats;

   740 	RArray<TPictureRateAndSize> iMaxPictureRates;

   741 	HBufC8* iCodingStandardSpecificInfo;

   742 	HBufC8* iImplementationSpecificInfo;

   743 	RArray<TInt> iSupportedScreens;

   744 	TBool iSupportsContentProtected;

   745 	};

   746 

   747 

   748 

   749 

   750 /**

   751 CMMFDevVideoPlay is the main client API for DevVideoPlay.

   752 @publishedAll

   753 @released

   754 */

   755 class CMMFDevVideoPlay : public CBase, private MMMFDevVideoPlayProxy

   756 	{

   757 public:

   758 	/**

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

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

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

   762 	*/

   763 	class TPictureCounters

   764 		{

   765 	public:

   766 		/**

   767 		Default constructor.  Zeros all members.

   768 		*/

   769 		inline TPictureCounters();

   770 	public:

   771 		/**

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

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

   774 		picture decoding, post-processing and rendering phase.

   775 		*/

   776 		TUint iPicturesSkipped;

   777 

   778 		/**

   779 		The number of pictures decoded.

   780 		*/

   781 		TUint iPicturesDecoded;

   782 

   783 		/**

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

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

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

   787 		*/

   788 		TUint iPicturesDisplayed;

   789 

   790 		/**

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

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

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

   794 		to buffer overflows or other reasons.

   795 		*/

   796 		TUint iTotalPictures;

   797 		};

   798 

   799 	/**

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

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

   802 	cumulative values for counters itself if necessary.

   803 	*/

   804 	class TBitstreamCounters

   805 		{

   806 	public:

   807 		/**

   808 		Default constructor.  Zeros all members.

   809 		*/

   810 		inline TBitstreamCounters();

   811 	public:

   812 		/**

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

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

   815 		*/

   816 		TUint iLostPackets;

   817 

   818 		/**

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

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

   821 		*/

   822 		TUint iTotalPackets;

   823 		};

   824 

   825 	/**

   826 	Buffer options used with SetBufferOptionsL().

   827 	*/

   828 	class TBufferOptions

   829 		{

   830 	public:

   831 		/**

   832 		Default constructor.  Zeros all members.

   833 		*/

   834 		inline TBufferOptions();

   835 

   836 	public:

   837 		/**

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

   839 		*/

   840 		TUint iPreDecodeBufferSize;

   841 

   842 		/**

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

   844 		*/

   845 		TUint iMaxPostDecodeBufferSize;

   846 

   847 		/**

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

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

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

   851 		*/

   852 		TTimeIntervalMicroSeconds iPreDecoderBufferPeriod;

   853 

   854 		/**

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

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

   857 		*/

   858 		TTimeIntervalMicroSeconds iPostDecoderBufferPeriod;

   859 

   860 		/**

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

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

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

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

   865 		are explicitly requested.

   866 		*/

   867 		TUint iMaxInputBufferSize;

   868 

   869 		/**

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

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

   872 		WriteCodedDataL().

   873 		*/

   874 		TUint iMinNumInputBuffers;

   875 		};

   876 

   877 	/**

   878 	Information about a single computational complexity level.

   879 	*/

   880 	class TComplexityLevelInfo

   881 		{

   882 	public:

   883 		enum TOptions

   884 			{

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

   886 			EAvgPictureRate	   = 0x00000001,

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

   888 			EPictureSize		  = 0x00000002,

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

   890 			ERelativeImageQuality = 0x00000004,

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

   892 			ERequiredMIPS		 = 0x00000008,

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

   894 			ERelativeProcessTime  = 0x00000010

   895 			};

   896 		/**

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

   898 		*/

   899 		TUint32 iOptions;

   900 

   901 		/**

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

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

   904 		bitstream has not been read.

   905 		*/

   906 		TReal iAvgPictureRate;

   907 

   908 		/**

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

   910 		*/

   911 		TSize iPictureSize;

   912 

   913 		/**

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

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

   916 		*/

   917 		TReal iRelativeImageQuality;

   918 

   919 		/**

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

   921 		the options.

   922 		*/

   923 		TUint iRequiredMIPS;

   924 

   925 		/**

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

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

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

   929 		*/

   930 		TReal iRelativeProcessTime;

   931 		};

   932 

   933 public:

   934 

   935 	/**

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

   937 

   938 	@param  aObserver

   939 	        The observer object to use.

   940 

   941 	@return A pointer to a new CMMFDevVideoPlay object.

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

   943 	*/

   944 	IMPORT_C static CMMFDevVideoPlay* NewL(MMMFDevVideoPlayObserver& aObserver);

   945 

   946 	/**

   947 	Destructor.

   948 	*/

   949 	IMPORT_C ~CMMFDevVideoPlay();

   950 

   951 	/**

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

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

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

   955 	is equal to its position in the input array.

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

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

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

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

   960 			aCommonFormat is not modified."

   961 	*/

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

   963 										   const TArray<TUncompressedVideoFormat>& aFormats2, 

   964 										   TUncompressedVideoFormat& aCommonFormat);

   965 

   966 	/**

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

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

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

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

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

   972 	level, unless aExactMatch is set.

   973 	The decoder capabilities can be checked with VideoCodecInfoLC().

   974  

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

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

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

   978 							set this value to zero."

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

   980 							destroyed by the caller."

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

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

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

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

   985 							any case this parameter should be set to EFalse."

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

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

   988 	*/

   989 	IMPORT_C void FindDecodersL(const TDesC8& aMimeType, 

   990 								TUint32 aPostProcType, 

   991 								RArray<TUid>& aDecoders, 

   992 								TBool aExactMatch=ETrue);

   993 

   994 	/**

   995 	Finds all available post-processors for a given set of post-processing operations.

   996 	@param	"aPostProcType"		"The post-processing types that the hardware device has to support, 

   997 								a binary OR of TPrePostProcessType values."

   998 	@param	"aPostProcessors"	"An array for the result post-processor UIDs. The array must be 

   999 								created and destroyed by the caller."

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

  1001 				* KErrNotFound:	No post-processors were found matching the search parameters."

  1002 	*/

  1003 	IMPORT_C void FindPostProcessorsL(TUint32 aPostProcType, RArray<TUid>& aPostProcessors);

  1004 

  1005 	/**

  1006 	Retrieves a list of available video decoders in the system.

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

  1008 						destroyed by the caller."

  1009 	@leave	"This method may leave with one of the system-wide error codes.  Not finding any decoders 

  1010 			is not treated as an error condition: in this situation, aDecoders will be empty."

  1011 	*/

  1012 	IMPORT_C void GetDecoderListL(RArray<TUid>& aDecoders);

  1013 

  1014 	/**

  1015 	Retrieves a list of available video post-processors in the system.

  1016 

  1017 	@param  aPostProcessors

  1018 	        An array for the result post-processor UIDs. The array must be created and

  1019 	        destroyed by the caller.

  1020 

  1021 	@leave  This method may leave with one of the system-wide error codes.  Not finding any post-processors

  1022 	        is not treated as an error condition: in this situation, aDecoders will be empty.

  1023 	*/

  1024 	IMPORT_C void GetPostProcessorListL(RArray<TUid>& aPostProcessors);

  1025 

  1026 	/**

  1027 	Retrieves information about an installed video decoder. Note that this method will need to load 

  1028 	the codec hardware device into memory, and can thus be relatively expensive.

  1029 	@param	"aVideoDecoder"	"The video decoder to query."

  1030 	@return "Decoder information as a CVideoDecoderInfo object. The object is pushed to the cleanup

  1031 			stack, and must be deallocated by the caller."

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

  1033 	*/

  1034 	IMPORT_C CVideoDecoderInfo* VideoDecoderInfoLC(TUid aVideoDecoder);

  1035 

  1036 	/**

  1037 	Retrieves information about the post-processing capabilities of an installed post-processor or 

  1038 	decoder hardware device. Note that this method will need to load the device into memory, and can 

  1039 	thus be relatively expensive.

  1040 	@param	"aPostProcessor"	"The post-processor to query."

  1041 	@return "Post-processor information as a CPostProcessorInfo object. The object is pushed to the 

  1042 			cleanup stack, and must be deallocated by the caller."

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

  1044 	*/

  1045 	IMPORT_C CPostProcessorInfo* PostProcessorInfoLC(TUid aPostProcessor);

  1046 

  1047 	/**

  1048 	Selects the video decoder to be used. This method must be called before any other video decoder 

  1049 	related methods are used. The decoder to use can be changed by calling this method again before 

  1050 	the API has been initialized with Initialize().

  1051 	All video decoder settings are reset to their default values, which are up to the implementation 

  1052 	to decide if not specified in any of the MSL specifications. By default no post-processing is 

  1053 	performed.

  1054 

  1055 	@param  "aDecoder" "The video decoder to use."

  1056 	@return "Hardware device ID, used in other methods for configuring the decoder."

  1057 	@leave  "The method will leave if an error occurs. Typical error codes used:

  1058 			* KErrNotFound - No decoder was found with the given UID"

  1059 	@pre	"This method can only be called before the API has been initialized with Initialize()."

  1060 	*/

  1061 	IMPORT_C THwDeviceId SelectDecoderL(TUid aDecoder);

  1062 

  1063 	/**

  1064 	Selects the video post-processor to be used. This method must be called before any other 

  1065 	post-processor related methods are used. The post-processor to use can be changed by calling

  1066 	this method again before the API has been initialized with Initialize().

  1067 	All post-processor settings are reset to their default values, which are up to the implementation

  1068 	to decide if not specified in any of the MSL specifications.

  1069 

  1070 	@param  "aPostProcessor" "The post-processor to use."

  1071 	@return "Hardware device ID, used in other methods for configuring the post-processor."

  1072 	@leave  "The method will leave if an error occurs. Typical error codes used:

  1073 				* KErrNotFound - No post-processor was found with the given UID"

  1074 	@pre	"This method can only be called before the API has been initialized with Initialize()."

  1075 	*/

  1076 	IMPORT_C THwDeviceId SelectPostProcessorL(TUid aPostProcessor);

  1077 

  1078 	/**

  1079 	Reads header information from a coded data unit. [1 #59] This method can be called only after 

  1080 	SelectDecoderL().

  1081 	@param	"aDataUnitType"				"The type of coded data unit that is contained in aDataUnit. If the 

  1082 										data is a simple piece of bitstream, use 

  1083 										EDuArbitraryStreamSection."

  1084 	@param	"aDataUnitEncapsulation"	"The encapsulation type used for the coded data. If the data 

  1085 										is a simple piece of bitstream, use EDuElementaryStream."

  1086 	@param	"aDataUnit"					"The coded data unit, contained in a TVideoInputBuffer."

  1087 	@return "Header information for the data unit, or NULL if the coded data unit did not contain 

  1088 			enough data to parse the header. The header data must be returned to the API using 

  1089 			ReturnHeader() before the API is shut down or the decoder is changed. The data remains 

  1090 			valid until it is returned."

  1091 	@leave	"The method will leave if an error occurs. Running out of data is not considered an error, 

  1092 			as described above. Typical error codes used:

  1093 				* KErrNotSupported - The data is not in a supported format.

  1094 				* KErrCorrupt - The data appears to be in a supported format, but is corrupted."

  1095 	*/

  1096 	IMPORT_C TVideoPictureHeader* GetHeaderInformationL(TVideoDataUnitType aDataUnitType, 

  1097 														TVideoDataUnitEncapsulation aDataUnitEncapsulation, 

  1098 														TVideoInputBuffer* aDataUnit);

  1099 

  1100 	IMPORT_C void ConfigureDecoderL(const TVideoPictureHeader& aVideoPictureHeader);

  1101 

  1102 	/**

  1103 	Returns a header from GetHeaderInformationL() back to the decoder so that the memory can be freed.

  1104 	@param	"aHeader"	"The header to return."

  1105 	@pre	"This method can only be called before the API has been initialized with Initialize()."

  1106 	*/

  1107 	IMPORT_C void ReturnHeader(TVideoPictureHeader* aHeader);

  1108 

  1109 	/**

  1110 	Sets a hardware device input format to an uncompressed video format. Only post-processors support 

  1111 	uncompressed video input.

  1112 	@param	"aHwDevice"	"The hardware device to configure. The value is returned from

  1113 						SelectPostProcessorL() when the device is selected."

  1114 	@param	"aFormat"	"The input format to use."

  1115 	@leave	"The method will leave if an error occurs. Typical error codes used:

  1116 				* KErrNotSupported - The input format is not supported."

  1117 	@pre	"This method can only be called before the API has been initialized with Initialize()."

  1118 	*/

  1119 	IMPORT_C void SetInputFormatL(THwDeviceId aHwDevice, const TUncompressedVideoFormat& aFormat);

  1120 

  1121 	/**

  1122 	Sets a hardware device Input format to a compressed video format. Only decoders support compressed 

  1123 	video input.

  1124 	@param	"aHwDevice"			"The hardware device to configure. The value is returned from 

  1125 								SelectDecoderL() when the device is selected."

  1126 	@param	"aFormat"			"The input format to use."

  1127 	@param	"aDataUnitType"		"The data unit type for input data."

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

  1129 	@param	"aDataInOrder"		"True if the input data is written in correct decoding order, false if 

  1130 								the input data may be written in arbitrary order."

  1131 	@leave	"The method will leave if an error occurs. Typical error codes used:

  1132 				* KErrNotSupported - The input format is not supported."

  1133 	@pre	"This method can only be called before the API has been initialized with Initialize()."

  1134 	*/

  1135 	IMPORT_C void SetInputFormatL(THwDeviceId aHwDevice,