diff -r 1cbb0d5bf7f2 -r b6dbf97aba93 mdfdevvideoextensions/nga_mdf_postprocessor_shai/inc/NGAPostProcHwDevice.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mdfdevvideoextensions/nga_mdf_postprocessor_shai/inc/NGAPostProcHwDevice.h Thu Sep 16 18:57:38 2010 +0100 @@ -0,0 +1,1161 @@ +/* +* Copyright (c) 2008 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 __NGAPOSTPROCHWDEVICE_H__ +#define __NGAPOSTPROCHWDEVICE_H__ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include //RSurfaceManager +#include //TSurfaceId +#include //TVideoAspectRatio +//TBC++ +//#include +#include "devvideosurfacehandlecustominterface.h" +#include "postinitializeci.h" +//TBC-- +#include +#include +#include +#include +#include + +#include "fetchframecustominterface.h" +#include "MdfRDebug.h" +#include "NGAPostProcHwDevice_UID.hrh" +#include "NGAPostProcSessionManagerObserver.h" +#include "common.h" + +class CNGAPostProcSessionManager; +class CNGAPostProcSurfaceHandler; +class CNGAPostProcTimer; +class RWsSession; + +class CNGAPostProcHwDevice: public CMMFVideoPostProcHwDevice, + public MMmfVideoBufferManagement, + public MNGAPostProcSessionManagerObserver, + public MMMFVideoSurfaceSupport, + public MMmfVideoPropertiesObserver, + public MMmfVideoResourceObserver, + public MMmfVideoSurfaceHandleControl, + public MMmfVideoPropertiesNotifier, + public MMmfVideoPlayRateControl, + public MMmfVideoSecureOutput, + public MMmfAdvancedVideoSecureOutput, + public MMmfPostInitializeRequest +{ + +public: + // === Constructors and destructor === + /** + * Two-phased constructor. + * @return pointer to an instance of CMMFVideoPostProcHwDevice + */ + static CMMFVideoPostProcHwDevice* NewL(); + + /** + * Destructor. + */ + ~CNGAPostProcHwDevice(); + +public: + + // === CMMFVideoPostProcHwDevice === + + /** + Sets the device input format to an uncompressed video format. + + @param "aFormat" "The input format to use." + @leave "The method will leave if an error occurs. Typical error codes used: + * KErrNotSupported - The input format is not supported." + @pre "This method can only be called before the hwdevice has been initialized with Initialize()." + */ + void SetInputFormatL(const TUncompressedVideoFormat& aFormat); + + /** + Sets the decoder device that will write data to this post-processor. Decoded pictures will be + written with WritePictureL() or through a custom interface. After pictures have been processed, + they must be returned to the decoder using ReturnPicture(). + + @param "aDevice" "The decoder source plug-in to use." + @pre "This method can only be called before the hwdevice has been initialized with Initialize()." + */ + void SetInputDevice(CMMFVideoDecodeHwDevice* aDevice); + + /** + Writes an uncompressed video picture to the post-processor. The picture must be returned to the + client or source plug-in after it has been used. + + @param "aPicture" "The picture to write." + @leave "This method may leave with one of the system-wide error codes." + @pre "This method can only be called after the hwdevice has been initialized with Initialize()." + */ + void WritePictureL(TVideoPicture* aPicture); + + /** + Retrieves post-processing information about this hardware device. + The device creates a CPostProcessorInfo structure, 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 system-wide error codes. + */ + 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 system-wide error codes. + @pre "This method may only be called before the hwdevice has been initialized using Initialize()." + */ + void GetOutputFormatListL(RArray& aFormats); + + /** + Sets the device output format. + + @param "aFormat" "The format to use." + @leave "This method may leave with one of the system-wide error codes. + @pre "This method may only be called before the hwdevice has been initialized using Initialize()." + */ + void SetOutputFormatL(const TUncompressedVideoFormat &aFormat); + + /** + Sets the clock source to use for video timing. 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 "aClock" "The clock source to be used." + @pre "This method can only be called before the hwdevice has been initialized with Initialize()." + */ + 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 system-wide error codes. + @pre "This method can only be called before the hwdevice has been initialized with Initialize()." + */ + 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 system-wide 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 must only be committed when CommitL() is called." + */ + void SetPostProcessTypesL(TUint32 aPostProcCombination); + + /** + Sets post-processing options for input (pan-scan) cropping. + + @param "aRect" "The cropping rectangle to use." + @leave "This method may leave with one of the system-wide 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 must only be committed when CommitL() is called." + */ + void SetInputCropOptionsL(const TRect& aRect); + + /** + Sets post-processing options for YUV to RGB color space conversion. + Specifies the input YUV and output RGB formats to use explicitly. 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" + @param "aRgbFormat" "Conversion target RGB format" + @leave "This method may leave with one of the system-wide 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 must only be committed when CommitL() is called." + */ + void SetYuvToRgbOptionsL(const TYuvToRgbOptions& aOptions, const TYuvFormat& aYuvFormat, + TRgbFormat aRgbFormat); + + /** + Sets post-processing options for YUV to RGB color space conversion. + 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 system-wide 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 must only be committed when CommitL() is called." + */ + void SetYuvToRgbOptionsL(const TYuvToRgbOptions& aOptions); + + /** + Sets post-processing options for rotation. SetPostProcessTypesL() must be called before + this method is used. + + @param "aRotationType" "The rotation to perform." + @leave "This method may leave with one of the system-wide 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 must only be committed when CommitL() is called." + */ + void SetRotateOptionsL(TRotationType aRotationType); + + /** + Sets post-processing options for scaling. SetPostProcessTypesL() must be called before + this method is used. + + @param "aTargetSize" "Scaling target size. If a fixed scale factor size is used, + the new dimensions must be set to width=floor(factor*width), + height=floor(factor*height). For example, scaling a + QCIF (176x144) picture up by a factor of 4/3 yields a size + of 234x192." + @param "aAntiAliasFiltering" "True if anti-aliasing filtering should be used. + If the post-processor does not support anti-aliased scaling, + or supports anti-aliased scaling only, this argument is ignored." + @leave "This method may leave with one of the system-wide 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 must only be committed when CommitL() is called." + */ + 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 system-wide 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 must only be committed when CommitL() is called." + */ + void SetOutputCropOptionsL(const TRect& aRect); + + /** + Sets post-processing plug-in specific options. SetPostProcessTypesL() must be called before + this method is used. + + @param "aOptions" "The options. The format is plug-in specific." + @leave "This method may leave with one of the system-wide 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 must only be committed when CommitL() is called." + */ + 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. + */ + void Initialize(); + + /** + Commit all changes since the last CommitL(), Revert() or Initialize() + to the hardware device. This only applies to methods which can be called both + before AND after DevVideoPlay has been initialized. + + @see SetPostProcessTypesL + @see SetInputCropOptionsL + @see SetYuvToRgbOptionsL + @see SetRotateOptionsL + @see SetScaleOptionsL + @see SetOutputCropOptionsL + @see SetPostProcSpecificOptionsL + + @leave "The method will leave if an error occurs." + @pre "This method can only be called after the hwdevice has been initialized with Initialize()." + */ + void CommitL(); + + /** + Revert all changes since the last CommitL(), Revert() or Initialize() + back to their previous settings. This only applies to methods which can + be called both before AND after DevVideoPlay has been initialized. + + @see SetPostProcessTypesL + @see SetInputCropOptionsL + @see SetYuvToRgbOptionsL + @see SetRotateOptionsL + @see SetScaleOptionsL + @see SetOutputCropOptionsL + @see SetPostProcSpecificOptionsL + + @pre "This method can only be called after the hwdevice has been initialized with Initialize()." + */ + 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 system-wide error codes. + @pre "This method can only be called after the hwdevice has been initialized with Initialize()." + */ + 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()." + */ + 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 without video display." + @pre "This method can only be called after the hwdevice has been initialized with Initialize()." + */ + 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()." + */ + void AbortDirectScreenAccess(); + + /** + Indicates whether playback is proceeding. This method can be used to check whether playback was + paused or not in response to a new clipping region or DSA abort. + + @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()." + */ + 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()." + */ + 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()." + */ + 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()." + */ + 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()." + */ + void Pause(); + + /** + Resumes video playback after a pause. + @pre "This method can only be called after the hwdevice has been initialized with Initialize()." + */ + 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 being decoded. 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 "aPlaybackPosition" "The new playback position in the video stream." + @pre "This method can only be called after the hwdevice has been initialized with Initialize()." + */ + 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()." + */ + 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 release the freeze immediately, + set the timestamp to zero." + @pre "This method can only be called after the hwdevice has been initialized with Initialize()." + */ + 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()." + */ + 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()." + */ + TUint PictureBufferBytes(); + + /** + Reads various counters related to decoded pictures. The counters are reset when Initialize() + or this method is called, and thus they only include pictures processed since the last call. + + Post-processor devices return the number of input pictures in iPicturesDecoded and + iTotalPictures. If the decoded pictures are written to another plug-in, they are considered + to be "virtually displayed". + + @param "aCounters" "The counter structure to fill." + @pre "This method can only be called after the hwdevice has been initialized with Initialize()." + */ + 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. + + The complexity level can be changed at any point during playback. + + @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()." + */ + 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()." + */ + 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()." + */ + void GetComplexityLevelInfo(TUint aLevel, CMMFDevVideoPlay::TComplexityLevelInfo& aInfo); + + /** + Returns a picture back to the device. This method is called by CMMFDevVideoPlay 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()." + */ + 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. Typical error codes used: + * KErrNotSupported - The requested data format or picture size is not supported, or the + plug-in does not support snapshots." + @pre "This method can only be called after the hwdevice has been initialized with Initialize()." + */ +// TBool GetSnapshotL(TPictureData& aPictureData, const TUncompressedVideoFormat& aFormat) {return EFalse;}; + TBool GetSnapshotL(TPictureData& aPictureData, const TUncompressedVideoFormat& aFormat); + + /** + 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 "aPresentationTimestamp" "Presentation timestamp for the picture to copy." + + @leave "The method will leave if an error occurs. Typical error codes used: + * KErrNotSupported - The requested data format or picture size is not supported or + the plug-in does not support timed snapshots." + @pre "This method can only be called after the hwdevice has been initialized with Initialize()." + */ + //void GetTimedSnapshotL(TPictureData* aPictureData, const TUncompressedVideoFormat& aFormat, + // const TTimeIntervalMicroSeconds& aPresentationTimestamp){}; + void GetTimedSnapshotL(TPictureData*, const TUncompressedVideoFormat&, const TTimeIntervalMicroSeconds&){}; + + + /** + 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." + + @leave "The method will leave if an error occurs. Typical error codes used: + * KErrNotSupported - The requested data format or picture size is not supported or + the plug-in does not support timed snapshots." + @pre "This method can only be called after the hwdevice has been initialized with Initialize()." + */ +// void GetTimedSnapshotL(TPictureData* aPictureData, const TUncompressedVideoFormat& aFormat, +// const TPictureId& aPictureId){}; + void GetTimedSnapshotL(TPictureData*, const TUncompressedVideoFormat&, const TPictureId& ){}; + + /** + Cancels a timed snapshot request. + @pre "This method can only be called after the hwdevice has been initialized with Initialize()." + */ + 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 "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()." + */ + void GetSupportedSnapshotFormatsL(RArray&){}; + + + /** + + 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. For example when the data type is not EDuCodedPicture, + calling this method is necessary otherwise a hardware device implementation might be looking for + the start code for the next picture to ensure it has a complete picture before starting to decode + the previous one. + + + After the remaining data has been processed (and displayed, if applicable), the hardware + device must notify the proxy with the MdvppStreamEnd() callback. + + DevVideo clients are encouraged to call this method, but its use is not mandatory for synchronized + processing. For synchronized playback, all video pictures are processed or discarded according to + their timestamps, and so the client can easily infer when processing is complete. However, it + should be noted that the last picture might not be displayed if this method is not called and the + input data type is not EDuCodedPicture. + + For non-synchronized playback (e.g. file conversion), a client must call this method otherwise it + will never find out when the hardware device has finished processing the data. + + @pre "This method can only be called after the hwdevice has been initialized with Initialize()." + */ + void InputEnd(); + + /** + Retrieves a custom interface to the device. + @param "aInterface" "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." + */ + TAny* CustomInterface(TUid aInterface); + + // === MNGAPostProcSessionManagerObserver === + /** + Set the proxy implementation to be used. Called just after the object is constructed. + @param "aProxy" "The proxy to use." + */ + void BufferAvailable(TInt aBufId, TInt aStatus); + +public: + + // === MMmfVideoBufferManagement === + + /** + * Sets the observer object to use. The observer gets notified + * when new buffers are available and when buffers need to be + * released back to the media device. + * + * This method can only be called before the media device has + * been Initialized with InitializeL(). + * + * @param aObserver The observer object to use. + */ + void MmvbmSetObserver(MMmfVideoBufferManagementObserver* aObserver); + + /** + * Enables input buffer management mode. In buffer management mode + * the target media device allocates memory for input buffers and + * the client can only use input buffers allocated with + * MmvbmGetBufferL(). + * + * This method can only be called before the media device has been + * Initialized with InitializeL(). This method must be called if + * the client uses MmvbmGetBufferL(). + * + * @param aEnable ETrue if input buffer management mode is used. + */ + void MmvbmEnable(TBool aEnable); + + /** + * Sets the buffer options to use. The client can request the + * number of input buffers that should be available, but typically + * only few (one or two) buffers can be used. + * + * This method can only be called before the media device has been + * Initialized with InitializeL(). + * + * @param aOptions The buffer options to use, see TBufferOptions. + * + * @leave KErrNotSupported The requested buffer options are not + * supported. Typically the client has requested too many input + * buffers. + */ + void MmvbmSetBufferOptionsL(const TBufferOptions& aOptions); + + /** + * Gets the buffer options currently in use. + * + * This method can only be called before the media device has been + * Initialized with InitializeL(). + * + * @param aOptions Target buffer options data structure. + */ + void MmvbmGetBufferOptions(TBufferOptions& aOptions); + + /** + * Gets a new input picture buffer. The client can then write data + * into the buffer and write it back to the media device with + * WritePictureL(). + * + * This method can only be called after the media device has been + * Initialized with InitializeL(). This method can only be called + * in buffer management mode, i.e. if the client has called + * MmvbmEnable(ETrue). + * + * Note that target-allocated and client-allocated input buffers + * cannot be mixed. In buffer management mode only input buffers + * allocated with this method can be sent to the media device. + * + * If a client has retrieved buffers with MmvbmGetBufferL(), it + * must be prepated to release them synchronously at any point if + * MmmfBufferManagementObserver::MmvbmoReleaseBuffers() is + * called. This may happen if the target media device suddenly + * loses access to the buffers due to DSA abort, resource + * management conflict, or media device destruction. + * + * @param aSize The requested buffer size, in pixels. The buffer + * size should match the picture size set at initialisation phase, + * or otherwise suitable buffer may not be available. If the size + * is smaller than the size set at initialisation phase, the + * allocated buffer may be larger than requested. + * + * @return A new input picture buffer. If no free buffers are + * available, the return value is NULL. + * + * @leave General The method will leave if an error occurs. Lack + * of free buffers is not considered an error. + */ + TVideoPicture* MmvbmGetBufferL(const TSize& aSize); + + /** + * Releases an input buffer back to the media device without using + * it. This method is mainly used as a response to a + * MmvbmReleaseBuffers() callback. + * + * @param aBuffer The buffer to release. + */ + void MmvbmReleaseBuffer(TVideoPicture* aBuffer); + +public: + + // === MMMFVideoSurfaceSupport === + + /** + Requests the media device to use graphics surfaces for video rendering. + The client must call this method before Initialize() to ensure the media + device allocates the right types of resources for rendering. + */ + void MmvssUseSurfaces(); + + /** + Sets a new video surface support observer to receive surface management events + from the media device. + + @param aObserver New observer object to use. + */ + void MmvssSetObserver(MMMFVideoSurfaceObserver& aObserver); + + /** + Retrieves surface parameters for a display. The client typically calls this in response + to a MmvsoSurfaceCreated() or MmvsoSurfaceParametersUpdated() observer callback. + + @param aSurfaceId + Surface ID for the display. + @param aCropRect + Cropping rectangle within the surface. The crop rectangle identifies the area of + the surface that should be shown on the screen. + @param aPixelAspectRatio + Video picture pixel aspect ratio. + + @leave KErrNotReady if no surface is available for the display. + */ + + void MmvssGetSurfaceParametersL(TSurfaceId& aSurfaceId, TRect& aCropRect, + TVideoAspectRatio& aPixelAspectRatio); + /** + Indicates that the surface is no longer in use and can be destroyed. The client typically calls + this in response to MmvsoSurfaceCreated() (while old surface is already in use and the current + should be removed) or MmvsoRemoveSurface() observer callback. + + @param aSurfaceId Surface ID that is no longer in use + + @leave KErrNotFound if the surface does not exist + */ + void MmvssSurfaceRemovedL(const TSurfaceId& aSurfaceId); + +public: + + // === MMmfVideoPropertiesObserver === + + /** + Decoded video properties updated. The media device implementing the + MMmfVideoPropertiesNotifier extension will call this method immediately + before outputting a picture with the updated properties. + + When the extension is used between a decoder and a post-processor media + device, the post-processor can associate the changed properties with the + correct picture, since the next incoming picture after this call will + be the first updated one. + + When the extension is used between a DevVideoPlay client and a + post-processor media device, the client can synchronously reconfigure + video display options using SetScaleOptionsL() and related methods. This + lets the client reconfigure the display for the correct picture. + + @param aYuvFormat Updated YUV format parameters. The updated fields are + iAspectRatioDenom, iAspectRatioNum, and iCoefficients + @param aPictureSize Updated picture size. This size will be the true + picture display size, excluding any padding that + the codec might use. + */ + virtual void MmvpoUpdateVideoProperties(const TYuvFormat& aYuvFormat, const TSize& aPictureSize); + +public: + + // === MMmfVideoResourceObserver === + + /** + Indicates that a media device has lost its resources. The client must + synchronously pause or stop processing before returning from this method + so that the media device can release its resources to the system. If + the client does not pause or stop, resource loss will be handled as a + fatal error. + + The client may start again or resume after receiving a + MvroResourcesRestored() callback. + + @param aMediaDevice UID for the media device that lost resources. The + client can use this e.g. to determine whether the + decoder or the post-processor lost resources. This + is typically not required though since the client + must pause DevVideo entirely. + */ + virtual void MmvroResourcesLost(TUid aMediaDevice); + + /** + Indicates that a media device has regained its resources after a + previous resource loss. The client can restart or resume processing. + This can be done either synchronously or asynchronously. + + @param aMediaDevice UID for the media device that regained resources. + */ + virtual void MmvroResourcesRestored(TUid aMediaDevice); + + + // === MMmfVideoSurfaceHandleControl === + + /** + Sets an external surface ID. This should be called as soon as external surface is created. + + @param aSurfaceID external surface ID. + + */ + + virtual void MmvshcSetSurfaceHandle(const TSurfaceId& aSurfaceHandle); + + /** + Sets a redraw buffer to be used during resource loss. + + @param aRedrawBuffer redraw buffer. + + */ + virtual void MmvshcRedrawBufferToSurface(TPtrC8& aRedrawBuffer); + + /** + * Creates a surface and maps the surface with the chunk handle passed in. + * @param aAttributes + * @param aHandle is the Chunk handle for the data. + * @param aSurfaceId returns the surfaceId that was just created + * + * @return error code + */ + + virtual TInt MmvshcCreateSurface(const RSurfaceManager::TSurfaceCreationAttributes& aAttributes, TInt aHandle, TSurfaceId& aSurfaceId); + +public: + // === MMmfVideoPropertiesNotifier === + /** + Sets a new video properties observer. This method can be called at any + time after the media device has been instantiated. + + @param aObserver New observer object. + */ + virtual void MmvpnSetObserver(MMmfVideoPropertiesObserver* aObserver); + +public: + + void ReturnPicToDecoder(TVideoPicture* aPic); + TInt AttemptToPost(); + +public: + //=== MMdfTrickPlayControl === = + /** + * Query the Direction capabilities from the MDF decoders and + * post processor. + * + */ + virtual void MmvprcGetPlayRateCapabilitiesL(TVideoPlayRateCapabilities& aCapabilities); + + /** + * Sets the playback speed. A negative rate means play backward. + * +/- percentage. + * + */ + virtual void MmvprcSetPlayRateL(const TInt aRate); + + /** + * Gets the playback speed. A negative rate means play backward. + * +/- percentage. + * + */ + virtual TInt MmvprcPlayRateL(); + + /** + * Sets the step frame number in frame step mode + * +/- frames + */ + virtual void MmvprcStepFrameL(const TInt aStep); + + /** + * Registers the observer + */ + virtual void MmvprcSetObserver(MMmfVideoPlayRateObserver& aObserver); + +public: + + // === MMmfVideoSecureOutput === + /** + * Notifies the media device if the content can only be sent to a + * secure output. The device display is typically considered a + * secure output, but a high-quality unprotected analog or digital + * video output connector is not. By default all content can be + * sent to both secure and insecure outputs. + * + * This method can only be called before the media device has been + * initialised with InitializeL(). + * + * @param aSecure Set to ETrue if the content can only be sent to + * a secure output, EFalse if both secure and unsecure outputs can + * be used. + * + * @leave KErrNotSupported Insecure outputs cannot be + * disabled. The client should not play protected content. + */ + virtual void MmvsoSetSecureOutputL(TBool aSecure); + +public: + //=== AdvancedVideoSecureOutput === = + virtual void MmavsoSetAllowedOutputL(TUint aAllowedOutputMask); + +public: + // === MMmfPostInitializeRequest === + virtual void MmpirPostInitializeRequest(MMmfPostInitializeResponse& aResponse); + +protected: + + // === CMMFVideoPostProcHwDevice === + /** + Set the proxy implementation to be used. Called just after the object is constructed. + @param "aProxy" "The proxy to use." + */ + void SetProxy(MMMFDevVideoPlayProxy& aProxy); + +protected: + + /** + * Symbian 2nd phase constructor . + */ + void ConstructL(); + +private: + TInt IsTimeToPost(TVideoPicture* frame, TInt64& delta); + TVideoPicture* CreateBuffersL(TInt aBufId); + void CreateVBMBuffersL(); + TInt SetupExternalSurface(const TSurfaceId &aSurfaceID); + void ReleaseInputQ(); + void ReleaseProcessQ(); + void ReleasePicture(TVideoPicture *pic); + void PublishSurfaceCreated(); + void PublishSurfaceUpdated(); + TInt SetupSurface(); + void SetSurfaceAttributes(const TSize& aSize, TInt aNumBuf); + TInt GetID(TVideoPicture *aPicture); + TInt GetExternalBufferID(TVideoPicture *aPicture); + TInt RegisterSurface(const TSurfaceId& aSurfaceId); + TInt IsGceReady(); + void SetTimer(TInt64 aDelta); + TInt ConvertPostProcBuffer(TVideoPicture* pSrc, TVideoPicture* pDest); + void AddPictureToVBMQ(TVideoPicture *pic); + void AddPictureToColorConversionQ(TVideoPicture *pic); + void ResetCountingBuffer(); + void PicturesSkipped(); + TVideoPicture* DoColorConvert(TVideoPicture* aPicture); + + /** + Adds a picture to the Input queue. Based on the timestamp of the picture, + it is either appeneded at the end of the queue or inserted at the + appropriate position. The queue is arranged in the ascending order. + The ret value indicates if the head of the queue was changed or not. + */ + TInt AddToQ(TVideoPicture* aPicture); + + /** + Removes a picture from Input queue based on the playrate. + If the playrate is +ve ie forward playback head will be removed + and if the playrate is -ve ie backward playback tail + will be removed. + */ + void RemoveFromQ(); + + /** + Returns a picture from Input queue based on the playrate. + If the playrate is +ve ie forward playback head will be returned + and if the playrate is -ve ie backward playback tail + will be returned. + */ + TVideoPicture* PeekQ(); + + /** + Adds a surface hint to a video surface. If there is any hint already added, + the surface is updated with the new hint. + */ + TInt AddHints(); + + #ifdef _DUMP_YUV_FRAMES + void captureYuv(TVideoPicture* aPicture); + #endif + + TInt SetSourceFormat(); + TInt SetSourceRange(); + TInt ColorConvert(tBaseVideoFrame* aInputFrame, TUint8* aDestPtr, tWndParam* aInputCropWindow, tWndParam* aOutputCropWindow); + +private: + + // + // C++ default constructor. + // + CNGAPostProcHwDevice(); + + // + // State of post processor + // + enum TPPState + { + EInitializing, + EInitialized, + EPlaying, + EPaused, + EStopped + }; + + enum TTimeToPost + { + ESkipIt = -1, + EPostIt = 0, + EDelayIt = 1, + }; + +private: + + MMMFDevVideoPlayProxy* iProxy; + CMMFVideoDecodeHwDevice* iInputDecoderDevice; + RArray iInputQ; + RArray iProcessQ; + MMMFClockSource* iClockSource; + TTimeIntervalMicroSeconds iCurrentPlaybackPosition; + TPPState iPPState; + CNGAPostProcSurfaceHandler* iSurfaceHandler; + CNGAPostProcSessionManager* iSessionManager; + + RSurfaceManager::TSurfaceCreationAttributesBuf iAttributes; + RChunk iChunk; + RSurfaceManager::TInfoBuf iInfo; + TSurfaceId iSurfaceId; + TBool iIsInputEnded; + CNGAPostProcTimer* iPostingTimer; + CMMFDevVideoPlay::TPictureCounters iPictureCounters; + TBool iFirstPictureUpdated; + TBool iUsingExternalSurface; + TBool iIsColorConversionNeeded; + RArray iColorConversionQ; + TBool iSurfaceCreatedEventPublished; + TInt iOverflowPictureCounter; + TInt iVideoFrameBufSize; + TBool iResourceLost; + TBool iRedrawDone; + // Flag to indicate that the redraw surface has been created, and + // can be used in a subsequent call ro Redraw() + TBool iRedrawSurfaceInUse; + + //-- members for buffer management -- + MMmfVideoBufferManagementObserver* iVBMObserver; + TBufferOptions iVBMBufferOptions; + RArray iVBMBufferReferenceQ; + RArray iVBMBufferQ; + TBool iVBMEnabled; + RArray iSupportedInputFormats; + TInt count; + + //-- members for Surface Hints -- + RSurfaceManager::THintPair iHint; + TUint iSurfaceMask; + TUid iSurfaceKey; + + //-- members for Surface support -- + MMMFVideoSurfaceObserver* iVideoSurfaceObserver; + MMmfVideoPropertiesObserver* iVPObserver; + RWsSession iWsSession; + TSize iPicSize; + TUint iAspectRatioNum; + TUint iAspectRatioDenom; + //-- members for Trickplay support -- + TInt iStepFrameCount; + TInt iPlayRate; + TBool iKeyFrameMode; + MMmfVideoPlayRateObserver* iFPObserver; + TUint8 iSkippedFramesCountingBuffer[64]; + TUint8 iSkippedFramesInLast64Frames; + TUint8 iCurrentPosInFramesCountingBuffer; + TUncompressedVideoFormat iVideoFormat; + //---------- utility variables ------- + // Image source format + TUint8 iSourceFormat; + + //Image range + TUint8 iSourceRange; + + //-- members for PostInitializeRequest support -- + MMmfPostInitializeResponse* iPostInitializeResponse; + TBool iIsExternalChunk; +}; + +/** + * Timer of Posting + */ + +class CNGAPostProcTimer: public CTimer + { +public: + static CNGAPostProcTimer* NewL( CNGAPostProcHwDevice& aParent ); + ~CNGAPostProcTimer(); + +protected: + void RunL(); + +private: + CNGAPostProcTimer( CNGAPostProcHwDevice& aParent ); + void ConstructL(); + +private: + CNGAPostProcHwDevice& iParent; +}; + +#endif //__NGAPOSTPROCHWDEVICE_H__ +