/*
* 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 <e32base.h>
#include <devvideoplay.h>
#include <devvideobase.h>
#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<TUid> iCheckDecoders;
// array of Accelerated Decoders
RArray<TUid> 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