diff -r 000000000000 -r bb31fbe78861 h264_dec/arih264dechwdevice/inc/arih264dechwdevice.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/h264_dec/arih264dechwdevice/inc/arih264dechwdevice.h Fri Jul 23 16:58:44 2010 +0100 @@ -0,0 +1,1177 @@ +/* +* Copyright (c) 2009 Aricent and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Aricent - initial contribution. +* +* Contributors: +* +* Description: +* Interface of the arih264dechwdevice. +* +*/ + +#ifndef ARIH264DECHWDEVICE_H +#define ARIH264DECHWDEVICE_H + +//System includes +#include +#include +#include + +//User includes +#include "aribaseengine.h" +#include "arih264dechwdeviceuid.hrh" + +// CONSTANTS +const TInt KMaxAllowPicLoss = 75; +const TInt KMaxInputBufferSize = ( 248 * 2048 ); +const TInt KMaxOutputBuffers = 2; +const TInt KMaxInputBuffers = 2; +const TInt KMinInputBuffers = 2; +// Implementatin id for the hwdevice +const TUid KUidH264DecoderHwDevice = {KUidH264DecoderHwDeviceImplUid}; + +const TUint KMaxBitRate = 15*1024*1024; +const TInt KDecoderInfoCount = 14; + +//const TInt KMaxFrameWidth = 1280; +//const TInt KMaxFrameHeight = 720; +const TInt KPicRate = 30; + +// FORWARD DECLARTIONS +class CAriH264decWrapper; +class CStateMachine; +//CLASS DECLARATIONS + +/** + * This class is part of Aricent's H264 decoder HwDevice plugin used for + * decoding H264 content to yuv420. + * Provides implementation for standard MDF HwDevice plugin APIs as well as private functions + * used internal to this class for .This class also implements callback APIs from + * MMmfVideoBufferManagementObserver and MProcessEngineObserver which are called from CBaseEngine. + */ +class CAriH264decHwDevice: public CMMFVideoDecodeHwDevice, + public MProcessEngineObserver, + public MMmfVideoBufferManagementObserver +{ +public: //Constructors and destructor + + /** + * Two-phased constructor. + * @return pointer to an instance of CMMFVideoDecodeHwDevice + */ + static CMMFVideoDecodeHwDevice* NewL(); + + /** + * Function to destroy resources allocated by this object + */ + virtual ~CAriH264decHwDevice(); + +public: //CMMFVideoHwDevice Functions + + /** + * Retrieves a custom interface to the specified hardware device + + * @param aInteface Interface UID, defined with the custom interface + * @return Pointer to the interface implementation, or NULL if the + * device does not implement the interface requested. + * The return value must be cast to the correct type by the user. + */ + virtual TAny* CustomInterface( TUid aInterface ); + +public: //CMMFVideoDecodeHwDevice Functions + + /** + * Retrieves decoder information about this hardware device. + * The device creates a CVideoDecoderInfo structure, + * fills it with correct data, pushes it to cleanup stack and returns it. + * The client will delete the object when it is no longer needed + + * @return Decoder information as a CVideoDecoderInfo object. + * The object is pushed to the cleanup stack, and must be deallocated by + * the caller. + + * @leave The method will leave if an error occurs. + */ + virtual CVideoDecoderInfo* VideoDecoderInfoLC(); + + /** + * Reads header information from a coded data unit. + + * @param aDataUnitType The type of the coded data unit that is contained + * in aDataUnit. + * If the data is a simple piece of bitstream, use + * EDuArbitraryStreamSection. + * @param aEncapsulation The encapsulation type used for the coded data. + * If the data is a simple piece of bitstream, use + * EDuElementaryStream. + * @param aDataUnit The coded data unit, contained in a + * TVideoInputBuffer. + + * @return Header information for the data unit, or NULL if + * the coded data unit did not contain enough data + * to parse the header.The header data must be + * returned to device using ReturnHeader() before + * Initialize() is called or decoder is destroyed. + * The data remains valid until it is returned. + + * @leave This method may leave with one of the standard + * error codes. + + * @pre This method can only be called before hwdevice + * has been initialized with Initialize() + */ + virtual TVideoPictureHeader* GetHeaderInformationL( + TVideoDataUnitType aDataUnitType, + TVideoDataUnitEncapsulation aEncapsulation, + TVideoInputBuffer* aDataUnit ); + + /** + * Returns a header from GetHeaderInformationL() back to the decoder so + * that the memory can be freed. + + * @param aHeader The header to return + + * @pre This method can only be called before the hwdevice + * has been initialized with Initialize() + */ + virtual void ReturnHeader( TVideoPictureHeader* aHeader ); + + /** + * Sets the device input format to a compressed video format. + + * @param aFormat The input format to use + * @param aDataUnitType The encapsulation type used for the coded data + * @param aEncapsulation The encapsulation type used for the coded data + * @param aDataInOrder True if the input data is written in correct + * decoding order, false if will be written in + * arbitrary order. + + * @leave This method may leave with one of the standard + * error codes. + + * @pre This method can only be called before hwdevice + * has been initialized with Initialize() + */ + virtual void SetInputFormatL( const CCompressedVideoFormat& aFormat, + TVideoDataUnitType aDataUnitType, + TVideoDataUnitEncapsulation aEncapsulation, + TBool aDataInOrder ); + + /** + * Sets whether decoding should be synchronzed to the current clock source, + * if any, or if pictures should instead be decoded as soon as possible. + * If decoding is synchronized, decoding timestamps are used if available, + * presentation timestamps are used if not. When decoding is not + * synchronized, pictures are decoded as soon as source data is available + * for them, and the decoder has a free output buffer. If a clock source is + * not available, decoding will not be synchronized. + + * @param aSynchronize True if decoding should be synchronized to a clock + * source. + + * @pre This method can only be called before the hwdevice + * has been initialized with Initialize() + */ + virtual void SynchronizeDecoding( TBool aSynchronize ); + + /** + * Sets decoder buffering options + + * @param aOptions Buffering options + + * @leave This method may leave with one of the standard error + * codes. + + * @pre This method can only be called before the hwdevice has + * been initialized with Initialize() + */ + virtual void SetBufferOptionsL( + const CMMFDevVideoPlay::TBufferOptions& aOptions ); + + /** + * Gets the video decoder buffer options actually in use. This can be used + * before calling SetBufferOptions() to determine the default options, or + * afterwards to check the values actually in use ( if some default values + * were used ). + + * @param aOptions Buffering options structure to fill. + + * @pre This method can only be called before the hwdevice has + * been initialized with Initialize() + */ + virtual void GetBufferOptions( + CMMFDevVideoPlay::TBufferOptions& aOptions ); + + /** + * Indicates which HRD/VBV specification is fulfilled in the input stream + * and any related parameters. + + * @param aHrdVbvSpec The HRD/VBV specification fulfilled + * @param aHrdVbvParams HRD/VBV parameters. The data format depends on the + * parameters chosen. For 3GPP TS 26.234. parameters + * aHrdVbvSpec=EHrdVbv3GPP, data in the descriptor + * is a package of type TPckC + * If no HRD/VBV parameters are used, the descriptor + * is empty. + + * @pre This method can only be called before the hwdevice + * has been initialized with Initialize() + */ + virtual void SetHrdVbvSpec( THrdVbvSpecification aHrdVbvSpec, + const TDesC8& aHrdVbvParams ); + + /** + * Sets the output post-procesor device to use. If an output device is set, + * all decoded pictures are delivered to that device, and not drawn on + * screen or returned to the client. Pictures are written using + * CMMDVideoPostProcDevice::WritePictureL() or a custom interface after + * they have been decoded. The post-processor must then synchronize + * rendering to the clock source if necessary. + * + * @param aDevice The output post-processor device to use. + + * @pre This method can only be called before the hwdevice + * has been initialized with Initialize() + */ + virtual void SetOutputDevice( CMMFVideoPostProcHwDevice* aDevice ); + + /** + * Returns the current decoding position, i.e. the timestamp for the most + * recently decoded picture. + + * @return Current decoding position. + + * @pre This method can only be called before the hwdevice has + * been initialized with Initialize() + */ + virtual TTimeIntervalMicroSeconds DecodingPosition(); + + /** + * Returns the current pre-decoder buffer size + + * @return The number of bytes of data in the pre-decoder buffer. + + * @pre This method can only be called after the hwdevice has been + * initialized with Initialize(). + */ + virtual TUint PreDecoderBufferBytes(); + + /** + * Reads various counters related to the received input bitstream and coded + * data units. + + * @param aCounters The counter structure to fill. + + * @pre This method can only be called after the hwdevice + * has been initialized with Initialize(). + */ + virtual void GetBitstreamCounters( + CMMFDevVideoPlay::TBitstreamCounters& aCounters ); + + /** + * Retrieves the number of free input buffers the decoder has available + + * @return Number of free input buffers the decoder has available. + + * @leave This method may leave with one of the standard error codes. + + * @pre This method can only be called after the hwdevice has been + * initialized with Initialize(). + */ + virtual TUint NumFreeBuffers(); + + /** + * Retrieves an empty video input buffer from the decoder. After input data + * has been written to the buffer, it can be written to the decoder using + * WriteCodedDataL(). The number of buffers the decoder must be able + * to provide before expecting any back, and the maximum size for each + * buffer, are specified in the buffer options.The decoder maintains + * ownership of the buffers even while they have been retrieved by client, + * and will take care of deallocating them. + + * @param aBufferSize Required buffer size, in bytes. The resulting + * buffer can be larger than this, but not smaller + + * @return A new input data buffer. The buffer is at least + * as large as requested, but it may be larger. + * If no free buffers are available, the return value + * is NULL. + + * @leave This method may leave with one of the standard + * error codes. + + * @pre This method can only be called after the hwdevice + * has been initialized with Initialize(). + */ + virtual TVideoInputBuffer* GetBufferL( TUint aBufferSize ); + + /** + * Writes a piece of coded video data to the decoder. The data buffer must + * be retrieved from the decoder with GetBufferL(). + + * @param aBuffer The coded data unit to write. + + * @leave This method may leave with one of the standard + * error codes. + + * @pre This method can only be called after the hwdevice has + * been initialized with Initialize(). + */ + virtual void WriteCodedDataL( TVideoInputBuffer* aBuffer ); + +#ifdef SYMBIAN_MDF_API_V2 + /** + * Configures the Decoder using header information known by the client. + * @param aVideoPictureHeader Header information to configure the + * decoder with + * @leave The method will leave if an error occurs. Running out of data + * is not considered an error, + * as described above. + * @pre This method can only be called before the hwdevice has been + * initialized with Initialize(). + */ + virtual void ConfigureDecoderL( + const TVideoPictureHeader& aVideoPictureHeader ); + +#endif + +public: //Inherited from CMMFVideoPlayHwDevice + + /** + * Retrieves post-processing information about this hardware device. The + * device creates a CPostProcessorInfo structure ( defined in [3] ), fills + * it with correct data, pushes it to the cleanup stack and returns it. The + * client will delete the object when it is no longer needed. + + * @return Post-processor information as a CPostProcessorInfo object. + * The object is pushed to the cleanup stack, and must be + * deallocated by the caller. + + * @leave This method may leave with one of the standard error codes + */ + virtual CPostProcessorInfo* PostProcessorInfoLC(); + + /** + * Retrieves the list of the output formats that the device supports. The + * list is ordered in plug-in preference order, with the preferred formats + * at the beginning of the list. The list can depend on the device source + * format, and therefore SetSourceFormatL() must be called before calling + * this method. + + * @param aFormats An array for the result format list. The array + * must be created and destroyed by the caller. + + * @leave This method may leave with one of the standard + * error codes. + + * @pre This method can only be called after the hwdevice + * has been initialized with Initialize(). + */ + virtual void GetOutputFormatListL( + RArray& aFormats ); + + /** + * Sets the device output format. + + * @param aDataUnit The format to use. + + * @leave This method may leave with one of the standard + * error codes. + + * @pre This method can only be called after the hwdevice + * has been initialized with Initialize(). + */ + virtual void SetOutputFormatL( const TUncompressedVideoFormat &aFormat ); + + /** + * Sets the clock source to use for video timing. See [3] for a discussion + * about audio/video synchronization. If no clock source is set. video + * playback will not be synchronized, but will proceed as fast as possible, + * depending on input data and output buffer availability. + + * @param aDataUnitType The clock source to use. + + * @pre This method can only be called after the hwdevice + * has been initialized with Initialize(). + */ + virtual void SetClockSource( MMMFClockSource* aClock ); + + /** + * Sets the device video output destination. The destination can be the + * screen ( using direct screen access ) or memory buffers. By default + * memory buffers are used. If data is written to another device, this + * method is ignored, and suitable memory buffers are always used. + + * @param aScreen True if video output destination is the screen, false + * if memory buffers. + + * @leave This method may leave with one of the standard error + * codes. + + * @pre This method can only be called after the hwdevice has + * been initialized with Initialize(). + */ + virtual void SetVideoDestScreenL( TBool aScreen ); + + /** + * Sets the post-processing types to be used. + + * @param aPostProcCombination The post-processing steps to perform, a + * bitwise or of values from TPostProcessType + * @leave This method may leave with one of the + * standard error codes. + + * @pre This method can be called either before + * or after the hwdevice has been initialized + * with Initialize(). If called after + * with initialization, the change will only + * with be committed once CommitL() is called + */ + virtual void SetPostProcessTypesL( TUint32 aPostProcCombination ); + + /** + * Sets post-processing options for input ( pan-scan ) cropping. + + * @param aRect The type of the coded data unit that is contained in + * aDataUnit. + + * @leave This method may leave with one of the standard error codes + + * @pre This method can be called either before or after the + * hwdevice has been initialized with Initialize(). If called + * after initialization, the change will only be committed + * once CommitL() is called. + */ + virtual void SetInputCropOptionsL( const TRect& aRect ); + + /** + * Sets post-processing options for YUV to RGB color space conversion. The + * first variant specifies the input YUV and output RGB formats to use + * explicitly, while the second variant uses the device input and output + * formats. For decoder devices the default YUV format used is the format + * specified in the input bitstream. SetSourceFormatL(), SetOutputFormatL() + * and SetPostProcessTypesL() must be called before this method is used + + * @param aOptions The conversion options to use + * @param aYuvFormat Conversion source YUV format, if specified. + * @param aRgbFormat Conversion target RGB format, if specified.. + + * @leave This method may leave with one of the standard error + * codes. + + * @pre This method can be called either before or after the + * hwdevice has been initialized with Initialize(). If + * called after initialization, the change will only be + * committed once CommitL() is called. + */ + virtual void SetYuvToRgbOptionsL( const TYuvToRgbOptions& aOptions, + const TYuvFormat& aYuvFormat, + TRgbFormat aRgbFormat ); + /** + * Sets post-processing options for YUV to RGB color space conversion. The + * first variant specifies the input YUV and output RGB formats to use + * explicitly, while the second variant uses the device input and output + * formats. For decoder devices the default YUV format used is the format + * specified in the input bitstream. SetSourceFormatL(), SetOutputFormatL() + * and SetPostProcessTypesL() must be called before this method is used + + * @param aOptions The conversion options to use + + * @leave This method may leave with one of the standard error + * codes. + + * @pre This method can be called either before or after the + * hwdevice has been initialized + * with Initialize(). If called after initialization, + * the change will only be committed once CommitL() is + * called + */ + virtual void SetYuvToRgbOptionsL( const TYuvToRgbOptions& aOptions ); + + /** + * Sets post-processing options for YUV to RGB color space conversion. The + * first variant specifies the input YUV and output RGB formats to use + * explicitly, while the second variant uses the device input and output + * formats. For decoder devices the default YUV format used is the format + * specified in the input bitstream. SetSourceFormatL(), SetOutputFormatL() + * and SetPostProcessTypesL() must be called before this method is used + + * @param aRotationType The rotation to perform. + + * @leave This method may leave with one of the standard + * error codes. + + * @pre This method can be called either before or after + * the hwdevice has been initialized with Initialize(). + * If called after initialization, the change will only + * be committed once CommitL() is called. + */ + virtual void SetRotateOptionsL( TRotationType aRotationType ); + + /** + * @param aRotationType The rotation to perform. + + * @leave This method may leave with one of the standard + * error codes. + + * @pre This method can be called either before or after + * the hwdevice has been initialized with Initialize(). + * If called after initialization, the change will + * only be committed once CommitL() is called. + */ + virtual void SetScaleOptionsL( const TSize& aTargetSize, + TBool aAntiAliasFiltering ); + + /** + * Sets post-processing options for output cropping. SetPostProcessTypesL() + * must be called before this method is used. + + * @param aRect Output cropping area + + * @leave This method may leave with one of the standard error codes. + + * @pre This method can be called either before or after the + * hwdevice has been initialized with Initialize(). If called + * after initialization, the change will only be committed + * once CommitL() is called. + */ + virtual void SetOutputCropOptionsL( const TRect& aRect ); + + /** + * Sets post-processing plug-in specific options. SetPostProcessTypesL() + * must be called before this method is used. + + * @param aOptions The format is plug-in specific + + * @leave This method may leave with one of the standard error + * codes. + + * @pre This method can be called either before or after the + * hwdevice has been initialized with Initialize(). If + * called after initialization, the change will only be + * committed once CommitL() is called. + */ + virtual void SetPostProcSpecificOptionsL( const TDesC8& aOptions ); + + /** + * Initializes the device. This method is asynchronous, the device will + * call MMFVideoPlayProxy::MdvppInitializeComplete() after initialization + * has completed. After this method has successfully completed, further + * configuration changes are not possible except where separately noted + + * @leave This method may leave with one of the standard error codes. + */ + virtual void Initialize(); + + /** + * Commit all configuration changes since the last CommitL(), Revert() or + * Initialize(). This only applies to methods that can be called both + * before AND after the hwdevice has been initialized. + + @leave This method may leave with one of the standard error codes. + */ + virtual void CommitL(); + + /** + * Revert any configuration changes that have not yet been committed using + * CommitL(). This only applies to methods that can be called both before + * AND after the hwdevice has been initialized. + + * @leave This method may leave with one of the standard error codes. + + * @pre This method can only be called after the hwdevice has been + * initialized with Initialize(). + */ + virtual void Revert(); + + /** + * Starts writing output directly to the display frame buffer using Direct + * Screen Access. + + * @param aVideoRect The video output rectangle on screen. + * @param aScreenDevice The screen device to use. The screen device object + * must be valid in the current thread. + * @param aClipRegion Initial clipping region to use. + + * @leave This method may leave with one of the standard + * error codes. + + * @pre This method can only be called after the hwdevice + * has been initialized with Initialize(). + */ + virtual void StartDirectScreenAccessL( const TRect& aVideoRect, + CFbsScreenDevice& aScreenDevice, + const TRegion& aClipRegion ); + + /** + * Sets a new clipping region for Direct Screen Access. After the method + * returns, no video will be drawn outside of the region. If clipping is + * not supported, or the clipping region is too complex, either playback + * will pause or will resume without video display, depending on the + * current setting of SetPauseOnClipFail(), and the result can be verified + * with IsPlaying(). Clipping can be disabled by setting a new clipping + * region that includes the whole video window. + + * @param aRegion The new clipping region. After the method returns, + * no video will be drawn outside the region. + + * @pre This method can only be called after the hwdevice + * has been initialized with Initialize(). + */ + virtual void SetScreenClipRegion( const TRegion& aRegion ); + + + /** + * Sets whether the system should pause playback when it gets a clipping + * region it cannot handle, or Direct Screen Access is aborted completely. + * If not, processing will proceed normally, but no video will be drawn. + * By default, playback is paused. + + * @param aPause True if playback should be paused when clipping fails, + * false if not. + * If playback is not paused, it will be continued + * If without video display + * + * @pre This method can only be called after the hwdevice has + * been initialized with Initialize(). + */ + virtual void SetPauseOnClipFail( TBool aPause ); + + /** + * Aborts Direct Screen Access completely, to be called from + * MAbortDirectScreenAccess::AbortNow() and similar methods. DSA can be + * resumed by calling StartDirectScreenAccessL(). + + * @pre This method can only be called after the hwdevice has been + * initialized with Initialize(). + */ + virtual void AbortDirectScreenAccess(); + + /** + * Indicates Whether playback is proceeding + * @return ETrue if video is still being played ( even if not + * necessarily displayed ) + + * @pre This method can only be called after the hwdevice has been + * initialized with Initialize(). + */ + virtual TBool IsPlaying(); + + /** + * Re-draws the latest video picture.Only available when DSA is being used. + * If DSA is aborted or a non-supported clipping region has been set, the + * request may be ignored. + + * @pre This method can only be called after the hwdevice has been + * initialized with Initialize(). + */ + virtual void Redraw(); + + /** + * Starts video playback, including decoding, post-processing, and + * rendering. Playback will proceed until it has been stopped or paused, or + * the end of the bitstream is reached. + + * @pre This method can only be called after the hwdevice has been + * initialized with Initialize(). + */ + virtual void Start(); + + /** + * Stops video playback. No new pictures will be decoded, post-processed, + * or rendered. + + * @pre This method can only be called after the hwdevice has been + * initialized with Initialize(). + */ + virtual void Stop(); + + /** + * Pauses video playback, including decoding, post-processing, and + * rendering. No pictures will be decoded, post-processed, or rendered + * until playback has been resumed. + + * @pre This method can only be called after the hwdevice has been + * initialized with Initialize(). + */ + virtual void Pause(); + + /** + * Resumes video playback after a pause. + + * @pre This method can only be called after the hwdevice has been + * initialized with Initialize(). + */ + virtual void Resume(); + + /** + * Changes to a new decoding and playback position, used for randomly + * accessing ( seeking ) the input stream. The position change flushes all + * input and output buffers, pre-decoder and post-decoder buffering are + * handled as if a new bitstream was. If the device still has buffered + * pictures that precede the new playback position, they will be discarded. + * If playback is synchronized to a clock source, the client is responsible + * for setting the clock source to the new position. + + * @param aPlaybackPositio The new playback position in the video stream. + + * @pre This method can only be called after the hwdevice + * has been initialized with Initialize(). + */ + virtual void SetPosition( + const TTimeIntervalMicroSeconds& aPlaybackPosition ); + + /** + * Freezes a picture on the screen. After the picture has been frozen, no + * new pictures are displayed until the freeze is released with + * ReleaseFreeze(). If the device output is being written to memory buffers + * or to another plug-in, instead of the screen, no decoded pictures will + * be delivered while the freeze is active, and they are simply discarded. + + * @param aTimestamp The presentation timestamp of the picture to + * freeze. The frozen picture will be the first + * picture with a timestamp greater than or equal to + * this parameter + + * @pre This method can only be called after the hwdevice + * has been initialized with Initialize(). + */ + virtual void FreezePicture( const TTimeIntervalMicroSeconds& aTimestamp ); + + /** + * Releases a picture frozen with FreezePicture() + + * @param aTimestamp The presentation timestamp of the picture to + * release. The first picture displayed after the + * release will be the first picture with a timestamp + * greater than or equal to this parameter. To + * greater release the freeze immediately, set the + * greater timestamp to zero. + + * @pre This method can only be called after the hwdevice + * has been initialized with Initialize(). + */ + virtual void ReleaseFreeze( const TTimeIntervalMicroSeconds& aTimestamp ); + + /** + * Returns the current playback position, i.e. the timestamp for the most + * recently displayed or virtually displayed picture. If the device output + * is written to another device, the most recent output picture is used. + + * @return Current playback position + + * @pre This method can only be called after the hwdevice has been + * initialized with Initialize(). + */ + virtual TTimeIntervalMicroSeconds PlaybackPosition(); + + /** + * Returns the total amount of memory allocated for uncompressed pictures. + * This figure only includes the pictures actually allocated by the plug-in + * itself, so that the total number of bytes allocated in the system can be + * calculated by taking the sum of the values from all plug-ins. + + * @return Total number of bytes of memory allocated for uncompressed + * pictures. + + * @pre This method can only be called after the hwdevice has been + * initialized with Initialize(). + */ + virtual TUint PictureBufferBytes(); + + /** + * Reads various counters related to decoded pictures. See the definition + * of TPictureCounters for a description of the counters. The counters are + * reset when Initialize() or this method is called, and thus they only + * include pictures processed since the last call. + + * @param aCounters The counter structure to fill + * @pre This method can only be called after the hwdevice has + * been initialized with Initialize(). + */ + virtual void GetPictureCounters( + CMMFDevVideoPlay::TPictureCounters& aCounters ); + + /** + * Sets the computational complexity level to use. If separate complexity + * levels are not available, the method call is ignored. If the level + * specified is not available, the results are undefined. Typically the + * device will either ignore the request or use the nearest suitable level. + + * @param aLevel The computational complexity level to use. Level zero (0) + * is the most complex one, with the highest quality. Higher + * level numbers require less processing and may have lower + * quality + + * @pre This method can only be called after the hwdevice has been + * initialized with Initialize(). + */ + virtual void SetComplexityLevel( TUint aLevel ); + + /** + * Gets the number of complexity levels available. + + * @return The number of complexity control levels available, or zero if + * the information is not available yet. The information may not + * be available if the number of levels depends on the input + * data, and enough input data has not been read yet. In that + * case, using level zero is safe. + + * @pre This method can only be called after the hwdevice has been + * initialized with Initialize(). + */ + virtual TUint NumComplexityLevels(); + + /** + * Gets information about a computational complexity level. This method can + * be called after NumComplexityLevels() has returned a non-zero value - at + * that point the information is guaranteed to be available. Some hardware + * device implementations may not be able to provide all values, in that + * case the values will be approximated. + + * @param aLevel The computational complexity level to query. The level + * numbers range from zero ( the most complex ) to + * NumComplexityLevels()-1. + * @param aInfo The information structure to fill + + * @pre This method can only be called after the hwdevice has + * been initialized with Initialize(). + */ + virtual void GetComplexityLevelInfo( TUint aLevel, + CMMFDevVideoPlay::TComplexityLevelInfo& aInfo ); + + /** + * Returns a picture back to the device. This method is called by + * CDevVideoPlay to return pictures from the client ( after they have been + * written with NewPicture() ), or by the output device when it has + * finished using a picture. + + * @param aPicture The picture to return. The device can re-use the + * memory for the picture. + + * @pre This method can only be called after the hwdevice has + * been initialized with Initialize(). + */ + virtual void ReturnPicture( TVideoPicture* aPicture ); + + /** + * Gets a copy of the latest picture sent to output + + * @param aPictureData Target picture. The memory for the picture + * must be allocated by the caller, and + * initialized properly. The data formats must + * match the snapshot format requested. + * @param aFormat The picture format to use for the snapshot. + + * @return ETrue if the snapshot was taken, EFalse if a + * picture is not available. The picture may not + * be available if decoding has not progressed + * far enough yet. + + * @leave The method will leave if an error occurs. + + * @pre This method can only be called after the + * hwdevice has been initialized with Initialize(). + */ + virtual TBool GetSnapshotL( TPictureData& aPictureData, + const TUncompressedVideoFormat& aFormat ); + + /** + * Gets a copy of a specified picture.When the snapshot is available, it + * will be returned to the client using the TimedSnapshotComplete() + * callback. To cancel a timed snapshot request, use CancelTimedSnapshot(). + * Only one timed snapshot request can be active at a time. + + * @param aPictureData Target picture. The memory for the picture + * must be allocated by the caller, and + * initialized properly. The data formats + * must match the snapshot format requested. + * The picture must remain valid until + * the snapshot has been taken or until the + * the request has been cancelled with + * the CancelTimedSnapshot(). + * @param aFormat The picture format to use for the snapshot + * @param aPresentationTimestamp Presentation timestamp for the picture to + * copy. The timestamp + * must match the timestamp in the picture + * must exactly, so the same clock frequency + * must should be used. Used for the first + * must method variant + + * @leave The method will leave if an error occurs. + + * @pre This method can only be called after the + * hwdevice has been initialized with + * Initialize(). + */ + virtual void GetTimedSnapshotL( TPictureData* aPictureData, + const TUncompressedVideoFormat& aFormat, + const TTimeIntervalMicroSeconds& aPresentationTimestamp ); + + /** + * Gets a copy of a specified picture.When the snapshot is available, it + * will be returned to the client using the TimedSnapshotComplete() + * callback. To cancel a timed snapshot request, use CancelTimedSnapshot(). + * Only one timed snapshot request can be active at a time. + + * @param aPictureData Target picture. The memory for the picture must be + * allocated by the caller, and initialized properly. + * The data formats must match the snapshot format + * requested. The picture must remain valid until + the snapshot has been taken or until the request + has been cancelled with CancelTimedSnapshot(). + * @param aFormat The picture format to use for the snapshot. + * @param aPictureId Picture identifier for the picture to copy. Used + * for the second method variant + + * @leave The method will leave if an error occurs. + + * @pre This method can only be called after the hwdevice + * has been initialized with Initialize(). + */ + virtual void GetTimedSnapshotL( TPictureData* aPictureData, + const TUncompressedVideoFormat& aFormat, + const TPictureId& aPictureId ); + /** + * Cancels a timed snapshot request + + * @pre This method can only be called after the hwdevice has been + * initialized with Initialize(). + */ + virtual void CancelTimedSnapshot(); + + /** + * Gets a list of the supported snapshot picture formats. + + * @param aFormats An array for the result format list. The array + * must be created and destroyed by the caller + + * @leave The method will leave if an error occurs. + + * @pre This method can only be called after the hwdevice + * has been initialized with Initialize(). + */ + virtual void GetSupportedSnapshotFormatsL( + RArray& aFormats ); + + /** + * Notifies the hardware device that the end of input data has been reached + * and no more input data will be written. The hardware device can use this + * signal to ensure that the remaining data gets processed, without waiting + * for new data. After the remaining data has been processed, the hardware + * device must notify call the proxy MdvppStreamEnd() callback.This method + * is mainly useful for file-to-file conversions and other non-realtime + * processing. For real-time playback all video pictures are processed or + * discarded according to their timestamps. + + * @pre This method can only be called after the hwdevice has been + * initialized with Initialize(). + */ + virtual void InputEnd(); + +public: // MProcessEngineObserver Function + + /** + * Callback from Engine to represent buffer has been consumed + * @param : aInp and aError + * @return : TInt: KErrNone or KErrCancel + */ + virtual TInt InputBufferConsumed ( TAny* aInp, TInt aError ); + + /** + * Callback to reprsent that output buffer is ready + * @param : aInp and aError + * @return : TInt: KErrNone or KErrCancel + */ + virtual TInt OutputBufferReady ( TAny* aOup, TInt aError ); + + /** + * CallBack to handle error + * @return : None + */ + virtual void FatalErrorFromProcessEngine ( TInt aError ); + /** + * added as a dummy function, to make compatibility with the + * encoder for the utility-processengine + */ + // Callback to indicate the completion of callback + void CommandProcessed ( TInt aCmd, TAny* aCmdData, TInt aError ); + +public : // MMmfVideoBufferManagementObserver Functions + + /** + * Notifies the observer that one or more new input buffers are available. + * The client can then use MmvbmGetBufferL() to get a buffer. + */ + virtual void MmvbmoNewBuffers() ; + + /** + * Notifies the observer all outstanding input buffers must be + * released immediately + */ + virtual void MmvbmoReleaseBuffers(); + +protected: + + /** + * Set the proxy implementation to be used. Called just after the object is + * constructed. + + * @param aProxy The proxy to use. + */ + virtual void SetProxy( MMMFDevVideoPlayProxy& aProxy ); + +private: + /** + * C++ default constructor. + */ + CAriH264decHwDevice(); + + /** + * Symbian 2nd phase constructor . + */ + void ConstructL(); + + /** + *Creates o/p buffers based on the o/p formats supported + *@param : None + */ + void CreateOutputBuffersL(); + + /** + * Gives call backs to clinet regarding slice and picture loss + * @param : None + */ + + void SliceAndPictureLoss(); + + /** + * Allcotion and reallocation of input buffers + * @param : None + */ + + void CreateInputBufferL( TUint aBufferSize, TBool aReallocate ); + + /** + * HandleInputEndInStopping + * @param : None + */ + void HandleInputEndInStopping(); + +private : //Data + + // Reference to Input Free Buffer Queue + RArray iInputFreeBufferQueue; + + // Free Input Buffers + TVideoInputBuffer* iInputFreeBuffers; + + // Reference to Output Device + CMMFVideoPostProcHwDevice* iOutputDevice; + + // Reference to Proxy Object + MMMFDevVideoPlayProxy* iMMFDevVideoPlayProxy; + + // Represents the state of the Decoder Hw Device + CStateMachine *iState; + + // Reference to Video Picture Header + TVideoPictureHeader* iVideoPictureHeader; + + // Current Decoding Position + TTimeIntervalMicroSeconds iDecodingPosition; + + // Handle to the Compressed video format + CCompressedVideoFormat* iInputFormat; + + // Uncompressed Output format + TUncompressedVideoFormat iOutputFormat; + + // Buffer Options Set by the Client + CMMFDevVideoPlay::TBufferOptions iBufferOptions; + + // Current Picture Counter value + CMMFDevVideoPlay::TPictureCounters iPictureCounters; + + // Current Bit Stream Counter value + CMMFDevVideoPlay::TBitstreamCounters iBitstreamCounters; + + // Codec Reference + CAriH264decWrapper* iCodec; + + // Base Process Engine Reference + CBaseEngine* iEngine; + + // To Check whether inputend is called or not + TBool iInputEndCalled; + + // OutPut Buffers + TVideoPicture* iOutputFreeBuffer; + + // Free OutPut Buffer Queue + RArray iOutputFreeBufferQueue; + + // counter to keep track of the no of buffers added to the engine + TInt iFilledBufferCounter; + + // data unit type set by the client + TVideoDataUnitType iDataUnitType; + + // Encapulation set by the client + TVideoDataUnitEncapsulation iEncapsulation; + + // represents the o/p buffer size + TInt iOutputBufferSize; + + // flag to whether o/p buffers created or not + TBool iOutputBuffersCreated; + + // Picture Number + TUint iPictureNumber; + + // represents the number of inputbuffers created so avoids reallocation + TUint iNumberOfInputBuffersAllocated; + + // Reference to the custom buffer interface + MMmfVideoBufferManagement* iCustomBufferHandle; + + // buffer options for the custom interface + MMmfVideoBufferManagement::TBufferOptions *iCustomBufferOptions; + + // represents whether the o/p buffers should be added to engine or not + TBool iBufferAdded; + + // flag to indciate that ConfigureDecoderL is called + TBool iConfigureDecoderCalled; + + // flag to indciate that decoder has been configured + TBool iDecoderConfigured; + + // the width of the source file + TInt iWidthSource; + + // the height of the source file + TInt iHeightSource; + + // type of the input stream + TInt iStreamType; + + // length of the NAL hdr + TUint iLenOfNalLenFld, iLenOfHdrLen; + + // array which holds the list of supported formats + RArray iSupportedFormats; + + // array which holds the max value of the picture rates + RArray iMaxPictureRates; + +}; + +#endif //ARIH264DECHWDEVICE_H