--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mmserv/thumbnailengine/TneProcessorInc/TNEProcessorImpl.h Tue Feb 02 01:08:46 2010 +0200
@@ -0,0 +1,760 @@
+/*
+* 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: Header file for TNE processor implementation
+*
+*/
+
+
+
+#ifndef __TNEPROCESSORIMPL_H__
+#define __TNEPROCESSORIMPL_H__
+
+#ifndef __E32BASE_H__
+#include <e32base.h>
+#endif
+
+#include "TNEDecoderWrap.h"
+#include "parser.h"
+#include "mp4parser.h"
+#include "TNEVideoClipInfoImp.h"
+
+#include <TNECommon.h>
+
+// FORWARD DECLARATIONS
+class CMP4Parser;
+class CDisplayChain;
+
+// used in image insertion
+enum TVideoOperation
+{
+ EVideoEncodeFrame = 0,
+ EVideoWriteFrameToFile
+};
+
+// video frame parameters
+struct TFrameParameters
+{
+ TInt64 iTimeStamp;
+ TUint8 iType;
+};
+
+
+// Logging path
+_LIT( KTNEModuleLogPath, "\\logs\\testframework\\TNEModule\\" );
+// Log file
+_LIT( KTNEModuleLogFile, "TNEEngine.txt" );
+
+
+// CLASS DEFINITIONS
+class CTNEProcessorImpl : public CActive, public MThumbnailObserver
+{
+public:
+
+ // Error codes
+ enum TErrorCode
+ {
+ EInvalidProcessorState = -1000,
+ EUnsupportedFormat = -1001,
+ EVideoTooLarge = -1002,
+ EStreamCorrupted = -1003,
+ EInvalidStreamData = -1004,
+ EInvalidInternalState = -1050
+ // Also error codes <EInvalidInternalState may be returned, they can be
+ // considered fatal internal errors.
+ };
+
+ // Input data format
+ enum TFileFormat
+ {
+ EData3GP, // 3GP
+ EDataAutoDetect // autodetect type
+ };
+
+public:
+
+ struct TStreamParameters
+ {
+ TUint iWidth;
+ TUint iHeight;
+ TInt64 iPicturePeriodNsec;
+ TUint iIntraFrequency;
+ TUint iReferencePicturesNeeded; // 0 = disable RPS
+ TUint iNumScalabilityLayers;
+ TUint iLayerFrameRates[8]; // frames per 256 sec
+ };
+
+public: // Functions from base classes
+
+ /**
+ * From CActive Active object running method
+ */
+ void RunL();
+
+ /**
+ * From CActive Active object cancelling method
+ */
+ void DoCancel();
+
+ /**
+ * From CActive Active Error handling method
+ */
+ TInt RunError(TInt aError);
+
+ /**
+ * From MThumbnailObserver.
+ * Notifies the client that the thumbnail is available
+ * @param none
+ * @return error code
+ */
+ void MNotifyThumbnailReady(TInt aError);
+
+ /**
+ * From MThumbnailObserver.
+ * noties the client tha decoded frame is ready
+ * @param none
+ * @return none
+ */
+ void MPictureFromDecoder(TVideoPicture* aPicture);
+
+
+ /**
+ * From MThumbnailObserver.
+ * Returns media bitstream buffer to the client
+ * @param none
+ * @return none
+ */
+ void MReturnCodedBuffer(TVideoBuffer* aBuffer);
+
+ /**
+ * From MThumbnailObserver.
+ * Request for more buffers from decoder
+ * @param none
+ * @return none
+ */
+ void MSendEncodedBuffer();
+
+
+public: // New functions
+
+ /**
+ * Constructors for instantiating new video processors.
+ * Should reserve as little resources as possible at this point.
+ */
+ static CTNEProcessorImpl* NewL();
+ static CTNEProcessorImpl* NewLC();
+
+ /**
+ * Destructor can be called at any time (i.e., also in the middle of a processing operation)
+ * Should release all allocated resources, including releasing all allocated memory and
+ * *deleting* all output files that are currently being processed but not yet completed.
+ */
+ virtual ~CTNEProcessorImpl();
+
+
+ /**
+ * Do all initializations necessary to start generating a thumbnail, e.g. open files,
+ * allocate memory. The video clip file should be opened with EFileShareReadersOnly
+ * share mode. The thumbnail should be scaled to the specified resolution and
+ * converted to the specified display mode. If this method leaves, destructor should be called to free
+ * allocated resources.
+ *
+ * Possible leave codes:
+ * - <code>KErrNoMemory</code> if memory allocation fails
+ * - <code>KErrNotFound</code> if there is no file with the specified name
+ * in the specified directory (but the directory exists)
+ * - <code>KErrPathNotFound</code> if the specified directory
+ * does not exist
+ * - <code>KErrUnknown</code> if the specified file is of unknown format
+ * - <code>KErrNotSupported</code> if the specified combination of parameters
+ * is not supported
+ *
+ * @param aFileHandle file handle to the clip from which to generate the thumbnail
+ * @param aIndex Frame index for selecting the thumbnail frame
+ * -1 means the best thumbnail is retrieved
+ * @param aResolution resolution of the desired thumbnail bitmap, or
+ * <code>NULL</code> if the thumbnail should be
+ * in the original resolution
+ * @param aDisplayMode desired display mode; or <code>ENone</code> if
+ * any display mode is acceptable
+ * @param aEnhance apply image enhancement algorithms to improve
+ * thumbnail quality; note that this may considerably
+ * increase the processing time needed to prepare
+ * the thumbnail
+ */
+ void StartThumbL(RFile& aFileHandle, TInt aIndex, TSize aResolution,
+ TDisplayMode aDisplayMode, TBool aEnhance);
+
+ /**
+ * Starts thumbnail generation. Thumbnail generation is an asynchronous operation,
+ * and its completion is informed to the caller via Active object request completion;
+ * the iStatus member of the caller is passed as a parameter to this method.
+ *
+ * This method may leave if an error occurs in initiating the thumbnail generation.
+ * If this method leaves, destructor should be called to free allocated resources.
+ *
+ * @param aStatus Reference to caller's iStatus member variable
+ *
+ * @return
+ *
+ */
+ void ProcessThumbL(TRequestStatus &aStatus);
+
+ /**
+ * Decodes the encoded frame for thumbnail generation. Thumbnail generation is an asynchronous operation,
+ * and its completion is informed to the caller via Active object request completion;
+ * the iStatus member of the caller is passed as a parameter to this method.
+ *
+ * This method may leave if an error occurs in initiating the thumbnail generation.
+ * If this method leaves, destructor should be called to free allocated resources.
+ *
+ * @param aStatus Reference to caller's iStatus member variable
+ *
+ * @return
+ *
+ */
+ void DecodeThumb(TBool aFirstFrame);
+
+ /**
+ * Method for retrieving the completed thumbnail bitmap.
+ *
+ * Video processor should not free the CFbsBitmap instance after it has passed it on
+ * as a return value of this function
+ *
+ */
+ void FetchThumb(CFbsBitmap*& aThumb);
+
+ /**
+ * Read clip header from the specified file and return its properties.
+ * This method should leave if clip is invalid, cannot be opened, etc.
+ *
+ * @param aFileHandle file handle to the file for reading
+ * @param aVideoFormat for returning the video format
+ * @param aVideoType Type of video data
+ * @param aResolution for returning the resolution
+ * @param aVideoFrameCount Number of video frames in the clip
+ */
+ void GetClipPropertiesL(RFile& aFileHandle, TTNEVideoFormat& aFormat,
+ TTNEVideoType& aVideoType, TSize& aResolution,
+ TInt& aVideoFrameCount);
+
+ /**
+ * Enhances the visual quality of the frame
+ *
+ */
+ void EnhanceThumbnailL(const CFbsBitmap* aInBitmap, CFbsBitmap* aTargetBitmap);
+
+
+ /**
+ * Get the file name of the clip
+ *
+ * @return File name of the clip
+ */
+ inline TFileName GetClipFileName() const { return iClipFileName; }
+
+ /**
+ * Get number of frames in clip
+ *
+ * @return Number of frames in clip
+ */
+ inline TInt GetClipNumberOfFrames() const { return iParser->GetNumberOfFramesInClip(); }
+
+ /**
+ * Get the timescale of the current video clip
+ *
+ * @return Timescale
+ */
+ inline TInt GetVideoClipTimeScale() const { return iParser->iStreamParameters.iVideoTimeScale; }
+
+
+ /**
+ * Get video frame index based on timestamp
+ *
+ * @param aTime Frame timestamp in microseconds
+ * @return Frame index
+ */
+ TInt GetVideoFrameIndex(TTimeIntervalMicroSeconds aTime) const;
+
+ /**
+ * Get frame index for the first frame in current clip
+ *
+ * @param aTime Timestamp in microseconds
+ * @return Frame index
+ */
+ inline TInt GetStartFrameIndex() const { return iStartThumbIndex; }
+
+ /**
+ * Get frame type at specified index
+ *
+ * @param aIndex Frame index
+ * @return Frame type
+ */
+ inline TInt8 GetVideoFrameType(TInt aIndex) const { return iParser->GetVideoFrameType(aIndex); };
+
+ /**
+ * Retrieve a video YUV frame from the tmp file
+ * @param aBuf Descriptor containing the YUV frame
+ * @param aLength Length of the descriptor
+ * @param aDuration The frame duration
+ * @param aTimeStamp The frame timestamp
+ * @return Error code
+ */
+ TInt GetVideoFrameFromFile(TDes8& aBuf, TInt aLength, TInt& aDuration, TInt64& aTimeStamp);
+
+ /**
+ * Get the next frame duration and timestamp
+ * @param aDuration The frame duration
+ * @param aTimeStamp The frame timestamp
+ * @param aIndex Index of timestamp to get
+ * @param aTimeStampOffset Offset for timestamp
+ * @return Error code
+ */
+ void GetNextFrameDuration(TInt& aDuration, TInt64& aTimeStamp, TInt aIndex, TInt& aTimeStampOffset);
+
+ /**
+ * Get the resolution of the current video clip
+ *
+ * @return resolution
+ */
+ TSize GetVideoClipResolution();
+
+ /**
+ * Get video timestamp in ms from timestamp in ticks
+ *
+ * @param aTimeStampInTicks Time in ticks
+ * @param aCommonTimeScale ETrue for using the output time scale
+ * EFalse for using the scale of current clip
+ * @return Timestamp in milliseconds
+ */
+ TInt64 GetVideoTimeInMsFromTicks(TInt64 aTimeStampInTicks, TBool aCommonTimeScale) const;
+
+ /**
+ * Stops processing
+ *
+ * @return Error code
+ */
+ TInt Stop();
+
+ /**
+ * Stops processing and closes all submodules except status monitor & video encoder
+ *
+ * @return Error code
+ */
+ TInt Close();
+
+ /**
+ * Checks if a frame has "good" or "legible" quality
+ *
+ * @param aYUVDataPtr Pointer to the frame to be checked
+ *
+ * @return 1 if frame quality is OK, 0 otherwise
+ */
+ TInt CheckFrameQuality(TUint8* aYUVDataPtr);
+
+ /**
+ * Gets the average frame rate of current video clip
+ *
+ * @return Frame rate
+ */
+ TReal GetVideoClipFrameRate();
+
+private: // Constants
+
+ // state
+ enum TProcessorState
+ {
+ EStateIdle = 0,
+ EStateOpened, // clip is open at the decoder (?)
+ EStatePreparing,
+ EStateReadyToProcess,
+ EStateProcessing
+ };
+
+
+ // Video types
+ enum TVideoType
+ {
+ EVideoNone = 0,
+ EVideoH263Profile0Level10,
+ EVideoH263Profile0Level45,
+ EVideoMPEG4
+ };
+
+ // Multiplex types
+ enum TMuxType
+ {
+ EMuxNone = 0,
+ EMux3GP
+ };
+
+ enum TDataFormat
+ {
+ EDataUnknown = 0,
+ EDataH263,
+ EDataMPEG4,
+ EDataAVC
+ };
+
+private:
+
+ /**
+ * By default Symbian OS constructor is private.
+ */
+ void ConstructL();
+
+ /**
+ * c++ default constructor
+ */
+ CTNEProcessorImpl();
+
+ /**
+ * Opens a 3gp clip for processing
+ *
+ * @param aFileName Clip filename
+ * @param aDataFormat Clip file format
+ *
+ * @return Error code
+ */
+ TInt OpenStream(RFile& aFileHandle, TFileFormat aDataFormat);
+
+ /**
+ * Closes the processed clip from parser
+ *
+ * @return Error code
+ */
+ TInt CloseStream();
+
+ /**
+ * Prepares the processor for processing a movie
+ *
+ * @return Error code
+ */
+ TInt Prepare();
+
+ /**
+ * Deletes objects used in processing
+ *
+ */
+ void DoCloseVideoL();
+
+ /**
+ * Sets output audio & video formats
+ *
+ */
+ void SetOutputMediaTypesL();
+
+ /**
+ * Gets bitstream modes of input clips
+ *
+ */
+ void GetTranscodeFactorsL();
+
+ /**
+ * Sets video transcoding parameters
+ *
+ */
+ void SetupTranscodingL();
+
+ /**
+ * Resets variables used in processing
+ *
+ */
+ void Reset();
+
+ /**
+ * Sets suitable default values for parameters
+ *
+ */
+ void SetHeaderDefaults();
+
+ /**
+ * Parses the clip header
+ *
+ * @param aStreamParams Destination structure for stream parameters
+ * @param Filename of the clip
+ *
+ */
+ void ParseHeaderOnlyL(CParser::TStreamParameters& aStreamParams, RFile& aFileHandle);
+
+ /**
+ * Copies stream parameters from source to destination structure
+ *
+ * @param aDestParameters Destination structure
+ * @param aSrcParameters Source structure
+ *
+ */
+ void UpdateStreamParameters(CParser::TStreamParameters& aDestParameters,
+ CParser::TStreamParameters& aSrcParameters);
+
+ /**
+ * Parse the clip header & update internal variables accordingly
+ *
+ */
+ void ParseHeaderL();
+
+ /**
+ * Initializes the processor for the next clip to be processed,
+ * called for each clip
+ */
+ void InitializeClipL(RFile& aFileHandle);
+
+
+ /**
+ * Reports an error in thumbnail generator
+ * to the caller
+ *
+ * @return ETrue if error was reported, EFalse otherwise
+ */
+ TBool HandleThumbnailError(TInt aError);
+
+ /**
+ * Create and Initialize the decoder
+ */
+ void CreateAndInitializeDecoderL();
+
+ /**
+ * Parse the clips mime type
+ */
+ void ParseMimeTypeL();
+
+ /**
+ * Get the video frame format
+ */
+ TInt GetFrameL();
+
+ /**
+ * Writes a buffered frame to output file
+ *
+ * @return Error code
+ */
+ TInt ReadVideoFrame();
+
+ /**
+ * CTNEProcessorImpl::ReadAndUpdateFrame
+ * Reads a frame from input queue to internal buffer
+ * (other items were commented in a header).
+ */
+ TInt ReadAndUpdateFrame();
+
+private: // Data
+
+ // current processor state
+ TProcessorState iState;
+
+ // current stream data format
+ TFileFormat iFileFormat;
+
+ // stream start reading buffer
+ TUint8 *iReadBuf;
+ // buffer length
+ TUint iBufLength;
+
+ // wait scheduler
+ CActiveSchedulerWait *iWaitScheduler;
+ TBool iWaitSchedulerStarted;
+
+ // Filename of the current clip
+ TFileName iClipFileName;
+
+ // Thumbnail resolution
+ TSize iOutputThumbResolution;
+ // Thumbnail index
+ TInt iThumbIndex;
+ // Thumbnail display mode
+ TDisplayMode iThumbDisplayMode;
+ // Thumbnail enhance
+ TBool iThumbEnhance;
+
+ // Flag for indicating decoder wrapper state
+ TBool iDecoderInitPending;
+
+//******************************************
+
+ // data buffer for the current compressed frame
+ TUint8 *iDataBuffer;
+ // buffer total length
+ TUint iBufferLength;
+ // amount of data in buffer
+ TUint iDataLength;
+ // current stream data format
+ TDataFormat iDataFormat;
+ // length of the current frame in the buffer
+ TUint iCurrentFrameLength;
+
+ // for searching a good thumbnail
+ TInt iFramesToSkip;
+
+ // number of frame skip cycles done to get a good thumbnail
+ TInt iNumThumbFrameSkips;
+
+ // is decode in progress ?
+ TBool iDecodePending;
+
+ // timestamp of previous frame
+ TTimeIntervalMicroSeconds iPreviousTimeStamp;
+
+ // the video decoder
+ CTNEDecoderWrap *iDecoder;
+
+ // CCMR media buffer sent to decoder
+ TVideoBuffer* iMediaBuffer;
+
+ // Concatenated YUV data for decoded frame
+ TUint8 *iFrameBuffer;
+
+ // are we decoding?
+ TBool iDecoding;
+
+ // Input mimetype
+ TBufC8<256> iMimeType;
+ // Short mimetype
+ TBufC8<256> iShortMimeType;
+
+ // Codec level
+ TInt iCodecLevel;
+ // Input codec
+ TInt iCodec;
+ // Input Max Bit Rate
+ TUint iMaxBitRate;
+
+ // AVC Stuff
+ // number of bytes representing the NalUnitLength
+ TInt iNalUnitBytes;
+
+//***********************************************
+
+
+ // True if processing has been cancelled
+ TBool iProcessingCancelled;
+
+ // timestamp for encoding ending black frames
+ TTimeIntervalMicroSeconds iTimeStamp;
+
+ // stream duration: max. of audio,video
+ TInt64 iVideoClipDuration;
+
+ // output video buffer for one frame
+ HBufC8 *iOutVideoBuffer;
+
+ // Is there a frame in buffer ?
+ TBool iFrameBuffered;
+
+ // Timestamp of buffered frame
+ TInt64 iBufferedTimeStamp;
+
+ // key frame info of buffered frame
+ TBool iBufferedKeyFrame;
+
+ TBool iFirstFrameBuffered;
+
+ // Are we processing a thumbnail ?
+ // TBool iThumbnailInProgress;
+
+ // index of the first frame in clip
+ TInt iStartThumbIndex;
+
+ // @@ YHK HARI
+ TInt iAVCDecodedFrameNumber;
+ TBool iThumbFrameDecoded;
+
+ // buffer pointers for thumbnail generation
+ TUint8* iYuvBuf;
+ TUint8* iRgbBuf;
+
+ // for storing the converted YUV image in generation case
+ TUint8 *iYuvImageBuf;
+
+ // flag for reseting the encoder to encode an intra frame
+ TBool iIntraResetRequest;
+
+ TInt iMP4SpecificSize;
+
+ // Is it the first frame of a clip
+ TBool iFirstFrameOfClip;
+
+ // for setting the first frame flag
+ // when doing wipe/crossfade transitions
+ TBool iFirstFrameFlagSet;
+
+ TInt iVideoFrameNumber;
+ TInt iVideoIntraFrameNumber;
+
+
+ // MPEG-4 VOS size
+ TInt iOutputMpeg4VosSize;
+
+// @@ YHK demux
+ // the demultiplexer
+// CDemultiplexer *iDemux;
+
+ // the video decoder input queue
+// CActiveQueue *iVideoQueue;
+
+ // file format parser
+ CMP4Parser *iParser;
+
+ // frame enhancement
+ CDisplayChain *iEnhancer;
+
+ // does the stream have video?
+ TBool iHaveVideo;
+ // video stream type
+ TVideoType iVideoType;
+
+ // is the stream multiplexed?
+ TBool iIsMuxed;
+ // multiplex type
+ TMuxType iMuxType;
+
+
+ // amount of data in buffer
+ TUint iBufData;
+ // reading descriptor
+ TPtr8 iReadDes;
+
+ // demux parameters read
+// CMP4Demux::TStreamParameters iMP4Parameters;
+// CMP4Demux::TOutputChannel iMP4Channels[2];
+
+ // video stream parameters
+ CTNEProcessorImpl::TStreamParameters iVideoParameters;
+
+ // stream length in milliseconds
+ TUint iStreamLength;
+ // stream size in bytes
+ TUint iStreamSize;
+ // stream average bitrate
+ TUint iStreamBitrate;
+ // is it possible to seek in the file
+ TBool iCanSeek;
+
+
+ RFile iCurClip;
+ RFs iFs;
+ TBool iFsConnected;
+
+ TInt iCurClipIndex;
+
+
+ TInt iCurrentVideoSize;
+
+ TRequestStatus *iThumbnailRequestStatus;
+ CFbsBitmap* iOutBitmap;
+
+ friend class CMP4Parser;
+};
+
+
+#endif // __TNEPROCESSORIMPL_H__
+
+// End of File