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

#define __DEVVIDEORECORD_H__

#include <e32std.h>

#include <mmf/devvideo/devvideobase.h>

class MMMFDevVideoRecordObserver;

class CMMFVideoRecordHwDevice;

class CMMFVideoEncodeHwDevice;

class CMMFVideoPreProcHwDevice;

class TVideoOutputBuffer;

/**

MMMFDevVideoRecordProxy is the interface the CDevVideoRecord implementation provides for video recording 

hardware devices. The hardware devices use this interface to report events and send used pictures and 

new buffers to the client.

@publishedAll

@released

*/

class MMMFDevVideoRecordProxy

	{

public:

	/**

	Delivers a new coded data unit to the client. The CDevVideoRecord implementation will maintain a list 

	of buffers and implement NumDataBuffers() and NextBufferL() based on those. The buffers will be returned

	back to the device using ReturnBuffer().

	@param	"aBuffer"	"The buffer containing the data to send."

	*/

	virtual void MdvrpNewBuffer(TVideoOutputBuffer* aBuffer) = 0;

	/**

	Returns a used input picture back to the client. Called by the encoder hardware device after the picture

	has been encoded.

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

	*/

	virtual void MdvrpReturnPicture(TVideoPicture* aPicture) = 0;

	/**

	Sends a notification to the client that the current supplemental info send request has completed.

	*/

	virtual void MdvrpSupplementalInfoSent() = 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 reports the error."

	@param	"aError"	"The error code."

	*/

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

	/**

	Reports that an asynchronous Initialize() method has completed. The device is now ready for recording.

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

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

	*/

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

	/**

	Reports that the input video data 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 MdvrpStreamEnd() = 0;

	};

/**

A video output buffer for a single output coded data unit from the encoder. In practice the encoder is 

likely to inherit its own buffer class from this class, adding its own internal bookkeeping data.

@publishedAll

@released

*/

class TVideoOutputBuffer

	{

public:

	/**

	Coded video data for this data unit.

	*/

	TPtrC8 iData;

	/**

	Capture timestamp for this data unit. If a single picture is divided into multiple data units, 

	all data units have the same timestamp.

	*/

	TTimeIntervalMicroSeconds iCaptureTimestamp;

	/**

	Identification number indicating the start of the spatial coverage of the data in the output buffer, 

	for example the first macroblock number. 

	*/

	TUint iCoverageStartPosition;

	/**

	End of the spatial coverage of the data in the buffer, for example the last macroblock number. 

	The idenfication numbers can be used to match data partitions with each other.

	*/

	TUint iCoverageEndPosition;

	/**

	Order number of the output buffer having the same spatial coverage as an earlier output buffer 

	of the same picture. Used with video pictures or segments that do not fit into an output buffer. 

	The order number of the first output buffer of a particular spatial coverage area is 0. The order 

	number shall be incremented by 1 for each subsequent output buffer having the same coverage in the 

	same coded picture.

	*/

	TUint iOrderNumber;

	/**

	Lowest unequal error protection level present in the buffer. Level 0 indicates that the buffer can 

	be discarded without causing temporal error propagation in the decoder, higher values indicate more 

	important buffers. If unequal error protection is not used, the value is set to 1.

	*/

	TUint iMinErrorProtectionLevel;

	/**

	Highest unequal error protection level present in the buffer. If unequal error protection is not 

	used, the value is set to 1.

	*/

	TUint iMaxErrorProtectionLevel;

	/**

	True if this buffer contains data that is required for decoding several pictures, for example the 

	only copy of a sequence header. A picture needed for motion compensated prediction is not considered

	"required for decoding several pictures".

	*/

	TBool iRequiredSeveralPictures;

	/**

	True if this buffer contains data that is required for decoding other parts of the same picture, 

	for example the only copy of the picture header.

	*/

	TBool iRequiredThisPicture;

	/**

	The layer number for this picture if layered bit-rate scalability is used. If layers are not used, 

	the layer number is always zero.

	*/

	TUint iLayer;

	/**

	Sub-sequence identifier of the output picture. A sub-sequence is a set of coded pictures within a 

	bit-rate scalability layer. A picture shall reside in one scalability layer and in one sub-sequence 

	only. A sub-sequence shall not depend on any other sub-sequence in the same or in a higher layer. 

	A sub-sequence in layer 0 can be decoded independently of any other sub-sequences. A sub-sequence 

	identifier labels the sub-sequence within a layer. Consecutive sub-sequences within a particular 

	layer in decoding order shall have a different sub-sequence identifier from each other. See Annex D 

	of H.264 | MPEG-4 AVC for further details.

	*/

	TUint iSubSeqId;

	/**

	The in-layer scalability step for the data in the buffer if in-layer scalability is used. 

	If in-layer scalability is not in use, the step is set to zero.

	*/

	TUint iInLayerScalabilityStep;

	/**

	iDataPartitionNumber equal to 0 indicates that data partitioning is not in use. Values of 

	iDataPartitionNumber greater than 0 indicate the data partition number in descending order of 

	importance, i.e. data partition 1 is the most important data partition subjectively. Data 

	partitioning can be used with multiple unequal error protection levels.

	*/

	TUint iDataPartitionNumber;

	/**

	True if this buffer contains data for a random access point. 

	*/

	TBool iRandomAccessPoint;

	/**

	Updated HRD/VBV parameters, valid if HRD/VBV is in use and iRandomAccessPoint is true.

	*/

	TPtrC8 iHrdVbvParams;

	/**

	Coding-standard specific data.

	*/

	TPtrC8 iCodingStandardSpecificData;

	/**

	Implementation-specific data.

	*/

	TPtrC8 iImplementationSpecificData;

	/**

	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;

	};

/**

This class contains information about the pre-processing capabilities that an encoder or a pre-processor 

hardware 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 pre-processor or encoder devices, and used by the MSL video client code.

@publishedAll

@released

*/

class CPreProcessorInfo : public CBase

	{

public:

	/**

	Creates and returns a new CPreProcessorInfo object. All data passed into this method is copied.

	@param "aUid"							"The uid of the pre-processor."

	@param "aManufacturer"					"The manufacturer of the pre-processor."

	@param "aIdentifier"					"The manufacturer-specific identifier of the pre-processor."

	@param "aVersion"						"The version of the pre-processor."

	@param "aAccelerated"					"Whether the pre-processor is hw accelerated or not."

	@param "aSupportsDirectCapture"			"Whether the pre-processor supports direct capture."

	@param "aInputFormats"					"An array of the supported input formats."

	@param "aOutputFormats"					"An array of the supported output formats."

	@param "aSupportedCombinations"			"An array of the supported combinations."

	@param "aSupportsArbitraryScaling"		"Whether the pre-processor supports arbitrary scaling."

	@param "aSupportsAntiAliasedScaling"	"Whether the pre-processor supports anti-alias filtering on scaling.""

	@param "aSupportedScaleFactors"			"An array of the supported scale factors if arbitrary scaling isn't suported"

	@param "aYuvToYuvCapabilities"			"The yuv to yuv conversion capabilities of the pre-processor."

	@param "aSupportedRgbRanges"			"The supported rgb ranges."

	@param "aSupportedRotations"			"The supported rotations."

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

	@return"The newly created CPreProcessorInfo object."

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

	*/

	IMPORT_C static CPreProcessorInfo* NewL(TUid aUid,

											const TDesC& aManufacturer,

											const TDesC& aIdentifier,

											TVersion aVersion,

											TBool aAccelerated,

											TBool aSupportsDirectCapture,

											const TArray<TUncompressedVideoFormat>& aInputFormats,

											const TArray<TUncompressedVideoFormat>& aOutputFormats,

											const TArray<TUint32>& aSupportedCombinations,

											TBool aSupportsArbitraryScaling,

											TBool aSupportsAntiAliasedScaling,

											const TArray<TScaleFactor>& aSupportedScaleFactors,

											const TYuvToYuvCapabilities& aYuvToYuvCapabilities,

											TUint32 aSupportedRgbRanges,

											TUint32 aSupportedRotations,

											const TDesC8& aImplementationSpecificInfo);

	/**

	Destructor.

	*/

	IMPORT_C ~CPreProcessorInfo();

	/**

	Returns the pre-processor UID.

	@return "Pre-processor UID."

	*/

	IMPORT_C TUid Uid() const;

	/**

	Returns the hardware device manufacturer.

	@return "The hardware device manufacturer. The reference is valid until this is destroyed."

	*/

	IMPORT_C const TDesC& Manufacturer() const;

	/**

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

	and identifier uniquely identifies the plug-in.

	@return "The hardware device identifier. The reference is valid until this object is destroyed."

	*/

	IMPORT_C const TDesC& Identifier() const;

	/**

	Returns the pre-processor version.

	@return "Pre-processor version."

	*/

	IMPORT_C TVersion Version() const;

	/**

	Returns whether the plug-in is hardware-accelerated. Hardware-accelerated pre-processors can run on 

	an application DSP or dedicated hardware.

	@return "True if the pre-processor is hardware-accelerated." 

	*/

	IMPORT_C TBool Accelerated() const;

	/**

	Returns whether the hardware device supports direct capture. Pre-processors supporting direct capture 

	can get the input pictures directly from a camera, possibly using an efficient hardware-dependent data 

	path.

	@return "True if the pre-processor supports direct capture."

	*/

	IMPORT_C TBool SupportsDirectCapture() const;

	/**

	Returns whether the pre-processor supports the given input format.

	@param	"aFormat"	"The format to be checked."

	@return "True if the pre-processor supports the given input format."

	*/

	IMPORT_C TBool SupportsInputFormat(const TUncompressedVideoFormat& aFormat) const;

	/**

	Returns the input formats that the pre-processor supports.

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

			until the CPreProcessorInfo object is destroyed."

	*/

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

	/**

	Returns whether the pre-processor supports the given output format.

	@param	"aFormat"	"The format to be checked."

	@return "True if the pre-processor supports the given input format."

	*/

	IMPORT_C TBool SupportsOutputFormat(const TUncompressedVideoFormat& aFormat) const;

	/**

	Returns the output formats that the pre-processor supports.

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

			until the CPreProcessorInfo object is destroyed."

	*/

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

	/**

	Returns whether the pre-processor supports the given pre-processing combination.

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

	@return "True if the pre-processing combination is supported."

	*/

	IMPORT_C TBool SupportsCombination(TUint32 aCombination) const;

	/**

	Lists all supported pre-processing combinations.

	@return "An RArray table of pre-processing combinations. Each value is a bitwise OR of values from 

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

	*/

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

	/**

	Returns whether the pre-processor supports arbitrary scaling.

	@return "True if arbitrary scaling is supported. If arbitrary scaling is not supported, some specific 

			scale factors can still be available."

	*/

	IMPORT_C TBool SupportsArbitraryScaling() const;

	/**

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

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

	*/

	IMPORT_C TBool SupportsAntiAliasedScaling() const;

	/**

	Returns the scaling factors the plug-in supports. If the plug-in supports arbitrary scaling the list 

	is empty - use SupportsArbitraryScaling() first.

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

			CPreProcessorInfo object is destroyed. If the pre-processor supports arbitrary scaling or 

			no scaling at all, the list is empty."

	*/

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

	/**

	Returns the YUV to YUV conversion capabilities for the pre-processor.

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

			until the CPreProcessorInfo object is destroyed."

	*/

	IMPORT_C const TYuvToYuvCapabilities& YuvToYuvCapabilities() const;

	/**

	Returns RGB value ranges the hardware device supports for RGB to YUV conversion.

	@return "The supported RGB ranges as a bitwise OR of TRgbRange values."

	*/

	IMPORT_C TUint32 SupportedRgbRanges() const;

	/**

	Returns the rotation types the plug-in supports.

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

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

	*/

	IMPORT_C TUint32 SupportedRotations() const;

	/**

	Returns implementation-specific information about the pre-processor.

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

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

			is valid until the CPreProcessorInfo object is destroyed."

	*/

	IMPORT_C const TDesC8& ImplementationSpecificInfo() const;

private:

	CPreProcessorInfo(TUid aUid,

					  TVersion aVersion,

					  TBool aAccelerated,

					  TBool aSupportsDirectCapture,

					  TBool aSupportsArbitraryScaling,

					  TBool aSupportsAntiAliasedScaling,

					  const TYuvToYuvCapabilities& aYuvToYuvCapabilities,

					  TUint32 aSupportedRgbRanges,

					  TUint32 aSupportedRotations);

	void ConstructL(const TDesC& aManufacturer,

					const TDesC& aIdentifier,

					const TArray<TUncompressedVideoFormat>& aInputFormats,

					const TArray<TUncompressedVideoFormat>& aOutputFormats,

					const TArray<TUint32>& aSupportedCombinations,

					const TArray<TScaleFactor>& aSupportedScaleFactors,

					const TDesC8& aImplementationSpecificInfo);

private:

	TUid iUid;

	HBufC* iManufacturer;

	HBufC* iIdentifier;

	TVersion iVersion;

	TBool iAccelerated;

	TBool iSupportsDirectCapture;

	RArray<TUncompressedVideoFormat> iInputFormats;

	RArray<TUncompressedVideoFormat> iOutputFormats;

	RArray<TUint32> iSupportedCombinations;

	TBool iSupportsArbitraryScaling;

	TBool iSupportsAntiAliasedScaling;

	RArray<TScaleFactor> iSupportedScaleFactors;

	TYuvToYuvCapabilities iYuvToYuvCapabilities;

	TUint32 iSupportedRgbRanges;

	TUint32 iSupportedRotations;

	HBufC8* iImplementationSpecificInfo;

	};

/**

This class contains information about a video encoder hardware device and its capabilities. 

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 encoder devices, and used by the MSL video client code.

@publishedAll

@released

*/

class CVideoEncoderInfo : public CBase

	{

public:

	/**

	Creates and returns a new CVideoEncoderInfo object. 

	All data passed in is copied on construction of the object.

	@param  aUid

	        The uid of the encoder.

	@param  aManufacturer

	        The video encoder manufacturer.

	@param  aIdentifier

	        The manufacturer-specific identifier for this encoder.

	@param  aVersion

	        The version of this encoder.

	@param  aAccelerated

	        Whether this encoder is accelerated.

	@param  aSupportsDirectCapture

	        Whether this encoder supports direct capture.

	@param  aSupportedInputFormats

	        An array of the supported input formats.

	@param  aSupportedOutputFormats

	        An array of the supported output formats.

	@param  aMaxPictureSize

	        The maximum supported picture size.

	@param  aSupportedDataUnitTypes

	        The supported data unit types.

	@param  aSupportedDataUnitEncapsulations

	        The supported data unit encapsulations.

	@param  aMaxBitrateLayers

	        The maximum number of bitrate layers supported.

	@param  aSupportsSupplementalEnhancementInfo

	        Whether supplemental enhancement info is supported.

	@param  aMaxUnequalErrorProtectionLevels

	        The maximum unequal error protection level supported.

	@param  aMaxBitRate

	        The maximum bit rate supported.

	@param  aMaxPictureRates

	        An array of the maximum picture size/rates supported.

	@param  aMaxInLayerScalabilitySteps

	        The maximum in-layer scalability steps supported.

	@param  aSupportedPictureOptions

	        The picture options supported.

	@param  aCodingStandardSpecificInfo

	        Coding standard specific info.

	@param  aImplementationSpecificInfo

	        Implementation specific info.

	@return A new CVideoEncoderInfo object.

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

	*/

	IMPORT_C static CVideoEncoderInfo* NewL(TUid aUid,

											const TDesC& aManufacturer,

											const TDesC& aIdentifier,

											TVersion aVersion,

											TBool aAccelerated,

											TBool aSupportsDirectCapture,

											const TArray<TUncompressedVideoFormat>& aSupportedInputFormats,

											const TArray<CCompressedVideoFormat*>& aSupportedOutputFormats,

											const TSize& aMaxPictureSize,

											TUint32 aSupportedDataUnitTypes,

											TUint32 aSupportedDataUnitEncapsulations,

											TUint aMaxBitrateLayers,

											TBool aSupportsSupplementalEnhancementInfo,

											TUint aMaxUnequalErrorProtectionLevels,

											TUint aMaxBitRate,

											const TArray<TPictureRateAndSize>& aMaxPictureRates,

											TUint aMaxInLayerScalabilitySteps,

											TUint32 aSupportedPictureOptions,

											TBool aSupportsPictureLoss,

											TBool aSupportsSliceLoss,

											const TDesC8& aCodingStandardSpecificInfo,

											const TDesC8& aImplementationSpecificInfo);

	/**

	Destructor.

	*/

	IMPORT_C ~CVideoEncoderInfo();

	/**

	Returns the encoder UID.

	@return "The encoder UID."

	*/

	IMPORT_C TUid Uid() const;

	/**

	Returns the encoder version.

	@return "The encoder version."

	*/

	IMPORT_C TVersion Version() const;

	/**

	Returns the encoder hardware device manufacturer.

	@return "The manufacturer name. The reference is valid until the CVideoEncoderInfo object is destroyed."

	*/

	IMPORT_C const TDesC& Manufacturer() const;

	/**

	Returns the encoder hardware device manufacturer-specific identifier. The combination of the 

	manufacturer and identifier uniquely identifies the plug-in.

	@return "The identifier. The reference is valid until the CVideoEncoderInfo object is destroyed."

	*/

	IMPORT_C const TDesC& Identifier() const;

	/**

	Returns whether the encoder is hardware-accelerated. Hardware-accelerated encoders can run on an 

	application DSP or dedicated hardware.

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

	*/

	IMPORT_C TBool Accelerated() const;

	/**

	Returns whether the encoder supports direct capture. Encoders supporting direct capture can get the 

	input pictures directly from a camera, possibly using an efficient hardware-dependent data path.

	@return "True if the encoder supports direct capture."

	*/

	IMPORT_C TBool SupportsDirectCapture() const;

	/**

	Returns whether the encoder supports the given input format.

	@param  "aFormat" "The format to check."

	@return "True if the encoder supports the given input format."

	*/

	IMPORT_C TBool SupportsInputFormat(const TUncompressedVideoFormat& aFormat) const;

	/**

	Returns the input formats that the encoder supports.

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

			valid until the CVideoEncoderInfo object is destroyed."

	*/

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

	/**

	Returns whether the encoder supports the given output format.

	@param	"aFormat" "The format to check."

	@return "True if the encoder supports the given output format."

	*/

	IMPORT_C TBool SupportsOutputFormat(const CCompressedVideoFormat& aFormat) const;

	/**

	Returns the output formats that the encoder supports.

	@return "An RArray table of supported video formats (CCompressedVideoFormat). The reference is 

			valid until the CVideoEncoderInfo object is destroyed."

	*/

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

	/**

	Returns the maximum picture size the encoder supports.

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

			object is destroyed."

	*/

	IMPORT_C const TSize& MaxPictureSize() const;

	/**

	Returns the data unit types supported by the encoder.

	@return "Supported data unit types. The value is a binary OR of values from TVideoDataUnitType."

	*/

	IMPORT_C TUint32 SupportedDataUnitTypes() const;

	/**

	Returns the data unit encapsulation types that the encoder supports.

	@return "Supported data unit encapsulation types. The value is a binary OR of values from 

			TVideoDataUnitEncapsulation."

	*/

	IMPORT_C TUint32 SupportedDataUnitEncapsulations() const;

	/**

	Returns the maximum number of bit-rate scalability layers supported.

	@return "Maximum number of bit-rate scalability layers supported, one (1) if layered scalability 

			is not supported."

	*/

	IMPORT_C TUint MaxBitrateLayers() const;

	/**

	Returns whether the encoder implements SendSupplementalInfoL(). If SendSupplementalInfoL() is 

	implemented, the client can send supplemental enhancement information messages as binary strings

	using that method. If SendSupplementalInfoL() is not implemented, this is not possible, but the 

	encoder can still generate and send coding standard or implementation specific supplemental 

	enhancement information automatically.

	@return "True if the encoder supports supplemental enhancement information."

	*/

	IMPORT_C TBool SupportsSupplementalEnhancementInfo() const;

	/**

	Returns the maximum number of unequal error protection levels supported.

	@return "Maximum number of unequal error protection levels supported, one (1) if unequal error 

			protection is not supported."

	*/

	IMPORT_C TUint MaxUnequalErrorProtectionLevels() const;

	/**

	Returns the maximum bit-rate supported by the encoder.

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

			bit-rate restrictions."

	*/

	IMPORT_C TUint MaxBitrate() const;

	/**

	Returns the maximum picture size/rate combinations supported by the encoder.  Video encoders can have

	different maximum picture rate limitations depending on the picture size used.

	@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 the maximum number of in-layer scalability steps supported.

	@return "Maximum number of in-layer scalability steps supported, one (1) if in-layer scalability is 

			not supported."

	*/

	IMPORT_C TUint MaxInLayerScalabilitySteps() const;

	/**

	Returns the input picture options that the encoder supports.

	@return "Supported input picture options, a bitwise OR of values from TVideoPicture::TVideoPictureOptions."

	*/

	IMPORT_C TUint32 SupportedPictureOptions() const;

	/**

	Returns whether the encoder supports picture loss indications. If true, the encoder implements

	PictureLoss(), and recovers lost picture contents when it receives the indication.

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

	*/

	IMPORT_C TBool SupportsPictureLoss() const;

	/**

	Returns whether the encoder supports slice loss indications. If true, the encoder implements

	SliceLoss(), and recovers lost or damaged macroblocks when it receives the indication.

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

	*/

	IMPORT_C TBool SupportsSliceLoss() const;

	/**

	Returns coding-standard specific information about the encoder.

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

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

			is destroyed."

	*/

	IMPORT_C const TDesC8& CodingStandardSpecificInfo() const;

	/**

	Returns implementation-specific information about the encoder.

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

	implementation-specific, and defined separately by the encoder supplier. The reference is valid until 

	the CVideoEncoderInfo object is destroyed."

	*/

	IMPORT_C const TDesC8& ImplementationSpecificInfo() const;

private:

	CVideoEncoderInfo(TUid aUid,

					  TVersion aVersion,

					  TBool aAccelerated,

					  TBool aSupportsDirectCapture,

				 	  const TSize& aMaxPictureSize,

					  TUint32 aSupportedDataUnitTypes,

					  TUint32 aSupportedDataUnitEncapsulations,

					  TUint aMaxBitrateLayers,

					  TBool aSupportsSupplementalEnhancementInfo,

					  TUint aMaxUnequalErrorProtectionLevels,

					  TUint aMaxBitRate,

					  TUint aMaxInLayerScalabilitySteps,

					  TUint32 aSupportedPictureOptions,

					  TBool aSupportsPictureLoss,

					  TBool aSupportsSliceLoss);

	void ConstructL(const TDesC& aManufacturer,

					const TDesC& aIdentifier,

					const TArray<TUncompressedVideoFormat>& aSupportedInputFormats,

					const TArray<CCompressedVideoFormat*>& aSupportedOutputFormats,

					const TArray<TPictureRateAndSize>& aMaxPictureRates,

					const TDesC8& aCodingStandardSpecificInfo,

					const TDesC8& aImplementationSpecificInfo);

private:

	TUid iUid;

	TVersion iVersion;

	HBufC* iManufacturer;

	HBufC* iIdentifier;

	TBool iAccelerated;

	TBool iSupportsDirectCapture;

	RArray<TUncompressedVideoFormat> iSupportedInputFormats;

	RPointerArray<CCompressedVideoFormat> iSupportedOutputFormats;

	TSize iMaxPictureSize;

	TUint32 iSupportedDataUnitTypes;

	TUint32 iSupportedDataUnitEncapsulations;

	TUint iMaxBitrateLayers;

	TBool iSupportsSupplementalEnhancementInfo;

	TUint iMaxUnequalErrorProtectionLevels;

	TUint iMaxBitRate;

	RArray<TPictureRateAndSize> iMaxPictureRates;

	TUint iMaxInLayerScalabilitySteps;

	TUint32 iSupportedPictureOptions;

	TBool iSupportsPictureLoss;

	TBool iSupportsSliceLoss;

	HBufC8* iCodingStandardSpecificInfo;

	HBufC8* iImplementationSpecificInfo;

	};

/**

CMMFDevVideoRecord is the main client class of DevVideoRecord.

@publishedAll

@released

*/

class CMMFDevVideoRecord : public CBase, private MMMFDevVideoRecordProxy

	{

public:

	/**

	Class to define the picture counters available through GetPictureCounters.

	@publishedAll

	@released

	*/

	class TPictureCounters

		{

 	public:

		/**

		Default constructor.  Zeros all members.

		*/

		inline TPictureCounters();

   public:

		/** The number of pictures skipped due to lack of output buffers. */

		TUint iPicturesSkippedBufferOverflow;

		/** The number of pictures skipped due to lack of processing power. */

		TUint iPicturesSkippedProcPower;

		/** The number of pictures skipped for bit-rate control purposes. */

		TUint iPicturesSkippedRateControl;

		/** The number of processed (i.e. pre-processed and encoded) input pictures. */

		TUint iPicturesProcessed;

		/** The total number of input pictures. When using direct capture, this is the total number of 

			pictures captured, otherwise it is the total number of input pictures written by the client. */

		TUint iInputPictures;

		};

public:

	/**

	Creates a new CMMFDevVideoRecord object.

	@param	"aObserver"	"The observer object to use. The observer callbacks are used to return input buffers 

						back to the client."

	@return "A new CMMFDevVideoRecord object.

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

				- KErrHardwareNotAvailable - Not enough free video processing hardware resources

				- KErrNoMemory - Not enough free memory available"

	*/

	IMPORT_C static CMMFDevVideoRecord* NewL(MMMFDevVideoRecordObserver& aObserver);

	/**

	Destructor.

	*/

	IMPORT_C ~CMMFDevVideoRecord();

	/**

	Finds all available encoders for a given video type with support for certain pre-processing operations. 

	The video type is specified using its MIME type, which may include parameters specifying the supported 

	level, version, and other information. Encoder hardware devices can use wildcards when listing the 

	supported video types in the ECom registration information, so it is possible that all the encoders 

	returned do not support the specified submode, e.g. profile and level, unless aExactMatch is set.

	The encoder capabilities can be checked with VideoEncoderInfoLC().

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

	@param	"aPreProcType"	"The pre-processing types that the encoder has to support, a binary OR of 

							TPrePostProcessType values. If no pre-processing support is needed, set this 

							value to zero."

	@param	"aEncoders"		"An array for the result encoder UIDs. The array must be created and destroyed 

							by the caller."

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

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

							loading the encoders 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	"The method will leave if an error occurs. Typical error codes used:

				-KErrNotFound - No encoders were found matching the search parameters."

	*/

	IMPORT_C void FindEncodersL(const TDesC8& aMimeType, 

								TUint32 aPreProcType, 

								RArray<TUid>& aEncoders, 

								TBool aExactMatch=ETrue);

	/**

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

	@param	"aPreProcType"		"The pre-processing types that the device has to support, a binary OR of 

								TPrePostProcessType values."

	@param	"aPreProcessors"	"An array for the result pre-processor UIDs. The array must be created and 

								destroyed by the caller."

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

				- KErrNotFound - No pre-processors were found matching the search parameters."

	*/

	IMPORT_C void FindPreProcessorsL(TUint32 aPreProcType, RArray<TUid>& aPreProcessors);

	/**

	Retrieves a list of available video encoders in the system.

	@param	"aEncoders"	"An array for the result encoder UIDs. The array must be created and destroyed by 

						the caller."

	@leave	"The method will leave if an error occurs. Not finding any encoders is not treated as an error 

			condition: in this situation, aEncoders will be empty."

	*/

	IMPORT_C void GetEncoderListL(RArray<TUid>& aEncoders);

	/**

	Retrieves a list of available video pre-processor hardware devices in the system.

	@param	"aPreProcessors"	"An array for the result pre-processor UIDs. The array must be created and 

								destroyed by the caller."

	@leave	"The method will leave if an error occurs. Not finding any pre-processors is not treated as an 

			error condition: in this situation, aPreProcessors will be empty."

	*/

	IMPORT_C void GetPreProcessorListL(RArray<TUid>& aPreProcessors);

	/**

	Retrieves information about an installed video encoder. Note that this method will need to load the 

	encoder hardware device into memory, and can thus be relatively expensive.

	@param	"aVideoEncoder"	"The video encoder device to query."

	@return	"Encoder information as a CVideoEncoderInfo object. The object is pushed to the cleanup stack, 

			and must be deallocated by the caller."

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

				- KErrNotFound - No encoder was found with the given UID"

	*/

	IMPORT_C CVideoEncoderInfo* VideoEncoderInfoLC(TUid aVideoEncoder);

	/**

	Retrieves information about the pre-processing capabilities of an installed pre-processor or encoder 

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

	relatively expensive.

	@param	"aPreProcessor"	"The device to query."

	@return	"Pre-processor information as a CPreProcessorInfo object. The object is pushed to the cleanupstack, 

			and must be deallocated by the caller."

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

				- KErrNotFound - No pre-processor was found with the given UID"

	*/

	IMPORT_C CPreProcessorInfo* PreProcessorInfoLC(TUid aPreProcessor);

	/**

	Selects the video encoder to be used. This method must be called before any other video encoder related 

	methods are used. The encoder can be changed by calling this method again before the system has been 

	initialized with Initialize().

	All video encoder settings are reset to their default values. By default no pre-processing is performed.

	@param	"aEncoder"	"The video encoder to use."

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

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

				- KErrNotFound - No encoder was found with the given UID"

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

	*/

	IMPORT_C THwDeviceId SelectEncoderL(TUid aEncoder);

	/**

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

	related methods are used. The pre-processor to use can be changed by calling this method again before 

	the API has been initialized with Initialize().

	All pre-processor settings are reset to their default values. By default no pre-processing is performed.

	@param	"aPreProcessor"	"The pre-processor to use."

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

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

				- KErrNotFound - No pre-processor was found with the given UID"

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

	*/

	IMPORT_C THwDeviceId SelectPreProcessorL(TUid aPreProcessor);

	/**

	Sets the input format for a hardware device. If both a pre-processor and an encoder are used, the 

	pre-processor output format and the encoder input format must be the same. The input format for the 

	first device in the system is the input format for video input data.

	The method has to be called for both direct capture as well as memory buffer input. The camera API 

	must be initialized by the device using it for capture, since there is no way to query the current 

	format from the camera API.

	@param	"aHwDevice"		"The hardware device to configure. The value is returned from SelectEncoderL() 

							or SelectPreProcessorL() when the device is selected."

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

	@param	"aPictureSize"	"The input picture size in pixels."

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

				- KErrNotSupported - The input format specified is not supported."

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

	*/

	IMPORT_C void SetInputFormatL(THwDeviceId aHwDevice, 

								  const TUncompressedVideoFormat& aFormat, 

								  const TSize& aPictureSize);

	/**

	Sets the data source to be a camera, and sets the system to use direct capture for input. The first 

	hardware device (pre-processor if both encoder and pre-processor are used, encoder otherwise) must 

	support direct capture.

	@param	"aCameraHandle"	"A camera handle for the camera to use. The handle is passed to 

							CCamera::NewDuplicateL() in the camera API."

	@param	"aPictureRate"	"Video capture picture rate."

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

				- KErrNotSupported - Direct capture is not supported or the picture rate specified is not 

				  supported."

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

	*/

	IMPORT_C void SetSourceCameraL(TInt aCameraHandle, TReal aPictureRate);

	/**

	Sets the data source to be memory buffers.

	@param	"aMaxPictureRate"		"The maximum picture rate for input pictures."

	@param	"aConstantPictureRate"	"True if the input picture rate is constant. In that case, 

									aMaxPictureRate specifies the picture rate. If pictures may be skipped 

									in the input data due to performance reasons, this flag cannot be set."

	@param	"aProcessRealtime"		"True if real-time processing is needed, false if not. Real-time 

									processing is typically needed for video recording applications, while 

									video conversion and off-line processing applications do not require it."

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

				- KErrNotSupported - The picture rate specified is not supported."

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

	*/

	IMPORT_C void SetSourceMemoryL(TReal aMaxPictureRate, TBool aConstantPictureRate, TBool aProcessRealtime);

	/**

	Sets the output format for a hardware device to a compressed video format. Only applicable for encoder 

	devices. The picture size depends on the input data format and possible scaling performed.

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

									SelectEncoderL()when the device is selected."

	@param	"aFormat"				"The video format to use."

	@param	"aDataUnitType"			"The type of output coded data units."

	@param	"aDataEncapsulation"	"Data encapsulation type for output encoded data units."

	@param	"aSegmentationAllowed"	"True if a coded data unit can be segmented into multiple output buffers 

									if a single buffer is not large enough."

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

				- KErrNotSupported - The format specified is not supported."

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

	*/

	IMPORT_C void SetOutputFormatL(THwDeviceId aHwDevice, 

								   const CCompressedVideoFormat& aFormat, 

								   TVideoDataUnitType aDataUnitType, 

								   TVideoDataUnitEncapsulation aDataEncapsulation,

								   TBool aSegmentationAllowed=EFalse);

	/**

	Sets the output format for a hardware device to an uncompressed video format. Only applicable for 

	pre-processor devices. The picture size depends on the input data format and possible scaling performed.

	@param	"aHwDevice"	"The hardware device to configure. The value is returned from SelectPreProcessorL()

						when the device is selected."

	@param	"aFormat"	"The video format to use."

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

				- KErrNotSupported - The format specified is not supported."