diff -r 000000000000 -r 71ca22bcf22a mmserv/thumbnailengine/TneProcessorInc/TNEDecoderWrap.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mmserv/thumbnailengine/TneProcessorInc/TNEDecoderWrap.h Tue Feb 02 01:08:46 2010 +0200 @@ -0,0 +1,457 @@ +/* +* Copyright (c) 2006 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: TNE Decoder wrapper +* +*/ + + + + +#ifndef TNEDECODERWRAP_H +#define TNEDECODERWRAP_H + +// INCLUDES +#include +#include +#include +#include "ctrcommon.h" // @@ YHK Check do we need this + + +// FORWARD DECLARATIONS +class MTRDevVideoClientObserver; +class TVideoBuffer; + +// Observer class for thumbnail generation +class MThumbnailObserver +{ +public: + virtual void MNotifyThumbnailReady(TInt aError) = 0; + virtual void MPictureFromDecoder (TVideoPicture* aPicture) = 0; + virtual void MReturnCodedBuffer(TVideoBuffer* aBuffer) = 0; + virtual void MSendEncodedBuffer() = 0; +}; + + +/** +* TNE decoder wrap +* @lib TNE.LIB +*/ +NONSHARABLE_CLASS(CTNEDecoderWrap) : public CBase, public MMMFDevVideoPlayObserver + { + public: // Constuctor / destructor + + /** + * Two-phased constructor. + */ + static CTNEDecoderWrap* NewL(MThumbnailObserver* aObserver); + + /** + * Destructor. + */ + ~CTNEDecoderWrap(); + + // Information methods + /** + * Checks codec support by MIME type + * @param aFormat MIME type + * @param aShortFormat MIME type (short version) + * @return TBool value: ETrue - givemn MIME type is supported; EFalse - no support; + */ + TBool SupportsCodec(const TDesC8& aFormat, const TDesC8& aShortFormat); + + /** + * Gets codec info + * @param none + * @return none + */ + void GetCodecInfoL(); + + /** + * Sets codec parameters + * @param aCodecLevel Codec level, aFormat video format, aOutputFormat Output video format + * @return none + */ + void SetDecoderParametersL(TInt aCodecLevel, const TTRVideoFormat& aFormat); + + /** + * From MMMFDevVideoPlayObserver. Notifies the client that one or more new empty input buffers are available + * @param none + * @return none + */ + void MdvpoNewBuffers(); + + /** + * From MMMFDevVideoPlayObserver. Returns a used input video picture back to the caller + * @param aPicture Video picture + * @return none + */ + void MdvpoReturnPicture(TVideoPicture *aPicture); + + /** + * From MMMFDevVideoPlayObserver. Delivers supplemental information from a coded data unit + * @param aData Data, aTimestamp TimeStamp info, aPictureId Picture Id + * @return none + */ + void MdvpoSupplementalInformation(const TDesC8 &aData, const TTimeIntervalMicroSeconds &aTimestamp, + const TPictureId &aPictureId); + + /** + * From MMMFDevVideoPlayObserver. Back channel information from the decoder, indicating a picture loss + * without specifying the lost picture + * @param none + * @return none + */ + void MdvpoPictureLoss(); + + /** + * From MMMFDevVideoPlayObserver. Back channel information from the decoder, indicating the pictures that have been lost + * @param aPictures Array with picture Ids + * @return none + */ + void MdvpoPictureLoss(const TArray< TPictureId > &aPictures); + + /** + * From MMMFDevVideoPlayObserver. Back channel information from the decoder, indicating the loss of consecutive + * macroblocks in raster scan order + * @param aFirstMacroblock First macroblock, aNumMacroblocks, Number of macroblocks, aPicture PictureId + * @return none + */ + void MdvpoSliceLoss(TUint aFirstMacroblock, TUint aNumMacroblocks, const TPictureId &aPicture); + + /** + * From MMMFDevVideoPlayObserver. Back channel information from the decoder, indicating a reference picture + * selection request + * @param aSelectionData Selection data + * @return none + */ + void MdvpoReferencePictureSelection(const TDesC8 &aSelectionData); + + /** + * From MMMFDevVideoPlayObserver. Called when a timed snapshot request has been completed + * @param aError Error, aPictureData Picture data, aPresentationTimestamp Presentation timestamp, aPictureId picture Id + * @return + */ + void MdvpoTimedSnapshotComplete(TInt aError, TPictureData *aPictureData, + const TTimeIntervalMicroSeconds &aPresentationTimestamp, const TPictureId &aPictureId); + + /** + * From MMMFDevVideoPlayObserver. Notifies the client that one or more new output pictures are available + * @param none + * @return none + */ + void MdvpoNewPictures(); + + /** + * From MMMFDevVideoPlayObserver. Reports a fatal decoding or playback error + * @param aError Rin-time error + * @return none + */ + void MdvpoFatalError(TInt aError); + + /** + * From MMMFDevVideoPlayObserver. Reports that DevVideoPlay initialization has completed + * @param aError Init error status + * @return none + */ + void MdvpoInitComplete(TInt aError); + + /** + * From MMMFDevVideoPlayObserver. Reports that the input video stream end has been reached and all pictures + * have been processed + * @param none + * @return none + */ + void MdvpoStreamEnd(); + + /** + * Returns used videopicture + * @param aPicture Video picture + * @return none + */ + void ReturnPicture(TVideoPicture* aPicture); + + /** + * Starts decoding + * @param none + * @return none + */ + void StartL(); + + /** + * Stops decoding synchronously + * @param none + * @return none + */ + void StopL(); + + /** + * Stops decoding asynchronously + * @param none + * @return none + */ + void AsyncStopL(); + + /** + * Checks decoder info + * @param aUid Decoder Uid + * @return TBool ETrue - accelerated codec; EFalse - non-accelerated codec + */ + TBool CheckDecoderInfoL(TUid aUid); + + /** + * Initialize decoder client + * @param none + * @return none + */ + void InitializeL(); + + /** + * Select decoder + * @param none + * @return none + */ + void SelectDecoderL(); + + /** + * Send buffer + * @param aBuffer Media buffer + * @return none + */ + void SendBufferL(TVideoBuffer* aBuffer); + + /** + * Write coded buffer + * @param aBuffer Media buffer + * @return none + */ + void WriteCodedBufferL(TVideoBuffer* aBuffer); + + /** + * Write coded buffer + * @param aBuffer Media buffer + * @return none + */ + + TUint GetNumInputFreeBuffers(); + + private: + /** + * C++ default constructor. + */ + CTNEDecoderWrap(MThumbnailObserver* aObserver); + + /** + * Symbian 2nd phase constructor, can leave + */ + void ConstructL(); + + private: + // Observer + MThumbnailObserver* iObserver; + + // DevVideoPlay + CMMFDevVideoPlay* iDevVideoPlay; + + // Decoder mime type + TBuf8<256> iMimeType; + + // Short version mime type + TBuf8<256> iShortMimeType; + + // Uncompressed format + TUncompressedVideoFormat iUncompressedFormat; + + // Compressed format + CCompressedVideoFormat* iCompresedFormat; + + // HwDevice Uid + THwDeviceId iHwDeviceId; + + // Video coded input buffer + TVideoInputBuffer* iInputBuffer; + + // Decoded picture + TVideoPicture* iDecodedPicture; + + // Uid + TUid iUid; + + // Coded buffer + TVideoBuffer* iCodedBuffer; + + // Codec level + TInt iCodecLevel; + + // Decoders to check + RArray iCheckDecoders; + + // array of Accelerated Decoders + RArray iAcceleratedDecoders; + + // Buffer options + CMMFDevVideoPlay::TBufferOptions iBufferOptions; + + // Fatal error code + TInt iFatalError; + + // decoder format + TTRVideoFormat iFormat; + + // Data unit type + TVideoDataUnitType iDataUnitType; + + // Stop + TBool iStop; + + TInt iState; + + // Last ts + TTimeIntervalMicroSeconds iLastTimestamp; + + // support for AVC + + //clock source + CSystemClockSource* iClockSource; + + // keep track of frame sequence number + TInt iInputFrameNum; + + }; + + +/** +* Buffer class used in TNEProcessor +* +*/ +class TVideoBuffer : public CBase + { + + public: // Constants + + // Buffer type + enum TBufferType + { + EAudioAMRNB = 0, + EAudioAMRWB, + EVideoH263, + EVideoMPEG4, + EVideoMPEG4DecSpecInfo, + EAudioQCELP13, + EAudioDecSpecInfo, + EAudioMPEG4AAC + }; + + public: // Constructors and destructor + + /** + * C++ constructors. The 1st creates a buffer to be initialized later with Set, + * and the 2nd one initializes it already here + */ + + inline TVideoBuffer() {} + + inline TVideoBuffer(const TPtrC8& aBuffer, + const TBufferType aType, + const TInt aSize, + const TBool aRandomAccessPoint, + const TTimeIntervalMicroSeconds& aTimeStamp) + : iType(aType), iSize(aSize), iRandomAccessPoint(aRandomAccessPoint), iTimeStamp(aTimeStamp), iPtr(aBuffer) {} + + /** + * Destructor. + */ + inline ~TVideoBuffer() {} + + public: // New functions + + /** + * Set the buffer parameters. This enables reusing the buffer + * @since 3.2 + * @param const TPtrC8& aBuffer Data buffer + * @param const TBufferType aType Buffer type + * @param const TInt aSize Buffer size (in bytes) + * @param const TBool aRandomAccessPoint ETrue if buffer has a video random access point + * @param const TTimeIntervalMicroSeconds& aTimeStamp Timestamp of the buffer + * @return void + */ + inline void Set(const TPtrC8& aBuffer, + const TBufferType aType, + const TInt aSize, + const TBool aRandomAccessPoint, + const TTimeIntervalMicroSeconds& aTimeStamp) + { + iType = aType; + iSize = aSize; + iRandomAccessPoint = aRandomAccessPoint; + iTimeStamp = aTimeStamp; + iPtr.Set(aBuffer); + } + + /** + * Return the data pointer + * @since 3.2 + * @return TPtrC8 pointer + */ + inline TPtrC8 Data() const { return iPtr; } + + /** + * Return buffer type + * @since 3.2 + * @return TInt Error code + */ + inline TBufferType Type() const { return iType; } + + /** + * Write Return buffer size + * @since 3.2 + * @return TInt Error code + */ + inline TInt BufferSize() const { return iSize; } + + /** + * Query whether this buffer contains a frame that can be used as a random-access point + * @since 3.2 + * @return TBool ETrue if this is a random access point + */ + inline TBool RandomAccessPoint() const { return iRandomAccessPoint; } + + /** + * Write a buffer to sink + * @since 3.2 + * @return TTimeIntervalMicroSeconds Timestamp + */ + inline TTimeIntervalMicroSeconds TimeStamp() const { return iTimeStamp; } + + private: // Data + + // media type + TBufferType iType; + + // media buffer size in bytes + TInt iSize; + + // ETrue if the media contained in this buffer + // can be used as random access point in playback + TBool iRandomAccessPoint; + + // time stamp in microseconds counting from the beginning of rec. + TTimeIntervalMicroSeconds iTimeStamp; + + // descriptor for returning the data pointer + TPtrC8 iPtr; + }; + + + +#endif // TNEDECODERWRAP_H