--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/videoeditorengine/vedengine/videoprocessor/inc/videoprocessor.h Fri Jan 29 14:08:33 2010 +0200
@@ -0,0 +1,1003 @@
+/*
+* Copyright (c) 2010 Ixonos Plc.
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the "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:
+* Ixonos Plc
+*
+* Description:
+* Header file for video processor.
+*
+*/
+
+
+#ifndef __VIDEOPROCESSOR_H__
+#define __VIDEOPROCESSOR_H__
+
+// INCLUDES
+#ifndef _H263DAPI_H_
+#include "h263dapi.h"
+#endif
+
+#include "videodecoder.h"
+#include "vedVideoclip.h"
+
+
+// FORWARD DECLARATIONS
+class CActiveQueue;
+class CStatusMonitor;
+class CMovieProcessorImpl;
+class CVideoEncoder;
+class CVedH263Dec;
+class CMPEG4Timer;
+class CVedAVCEdit;
+
+#include "CTRTranscoderObserver.h"
+#include "CTRTranscoder.h"
+#include "CTRCommon.h"
+#include <CCMRMediaSink.h>
+#include "CTRVideoPictureSink.h"
+
+enum TTransitionColor
+{
+ EColorNone = 0,
+ EColorBlack,
+ EColorWhite,
+ EColorTransition
+};
+
+enum TTransitionPosition
+{
+ EPositionNone = 0,
+ EPositionStartOfClip,
+ EPositionEndOfClip
+};
+
+
+// Threshold for using postfilter. Assumption is that CIF is encoded with high bitrate => no need for postfilter
+const TInt KThrWidthForPostFilter = 176;
+
+// CLASS DEFINITIONS
+
+
+// Observer class for thumbnail generation
+class MThumbnailObserver
+{
+public:
+ void NotifyThumbnailReady(TInt aError);
+};
+
+class MTimerObserver
+{
+public:
+ virtual void MtoTimerElapsed(TInt aError) = 0;
+
+};
+
+
+// Timer class to use when waiting for encoding to complete
+class CCallbackTimer : public CActive
+{
+
+public:
+
+ /**
+ * Two-phased constructor.
+ */
+ static CCallbackTimer* NewL(MTimerObserver& aObserver);
+
+ /**
+ * Destructor.
+ */
+ ~CCallbackTimer();
+
+public:
+
+ /**
+ * Set timer
+ *
+ * @param aDuration Duration
+ */
+ void SetTimer(TTimeIntervalMicroSeconds32 aDuration);
+
+
+ /**
+ * Query whether timer is active
+ *
+ * @return TRUE if timer is pending
+ */
+ inline TBool IsPending() { return iTimerRequestPending; }
+
+ /**
+ * Cancel timer
+ */
+ void CancelTimer();
+
+private:
+
+ /**
+ * C++ default constructor.
+ */
+ CCallbackTimer(MTimerObserver& aObserver);
+
+ /**
+ * Symbian 2nd phase constructor
+ */
+ void ConstructL();
+
+protected:
+
+ /**
+ * From CActive.
+ * @param
+ * @return void
+ */
+ void RunL();
+
+ /**
+ * From CActive.
+ * @param
+ * @return void
+ */
+ void DoCancel();
+
+ /**
+ * From CActive.
+ * @param
+ * @return void
+ */
+ TInt RunError(TInt aError);
+
+
+private: // Data
+
+ MTimerObserver& iObserver;
+
+ RTimer iTimer;
+
+ TBool iTimerCreated;
+ TBool iTimerRequestPending;
+};
+
+
+
+class CVideoProcessor : public CVideoDecoder, public MVideoRenderer,
+ public MTRTranscoderObserver, public MTRVideoPictureSink,
+ public MCMRMediaSink, public MTimerObserver
+
+{
+public: // constants
+ enum TErrorCode
+ {
+ EInternalAssertionFailure = -1400,
+ EDecoderFailure = -1401
+ };
+
+ enum TTimingSource
+ {
+ ETemporalReference = 0,
+ ETimeStamp
+ };
+
+ enum TDecoderFrameOperation
+ {
+ EDecodeAndWrite = 1,
+ EDecodeNoWrite,
+ EWriteNoDecode,
+ ENoDecodeNoWrite
+ };
+
+ enum TTranscoderMode
+ {
+ EDecodeOnly = 1,
+ EFull,
+ EFullWithIM,
+ EUndefined
+ };
+
+public: // Data structures
+ struct TStreamParameters
+ {
+ TUint iWidth;
+ TUint iHeight;
+ TInt64 iPicturePeriodNsec;
+ TUint iIntraFrequency;
+ TUint iReferencePicturesNeeded; // 0 = disable RPS
+ TUint iNumScalabilityLayers;
+ TUint iLayerFrameRates[8]; // frames per 256 sec
+ TTimingSource iTiming;
+ };
+
+
+private: // Data structures
+
+ // structure to store information about frames
+ // in decoding/transcoding progress
+ struct TFrameInformation
+ {
+ TTranscoderMode iTranscoderMode;
+
+ TInt iFrameNumber;
+ TInt64 iTimeStamp; // timestamp in ticks
+ TBool iEncodeFrame; // ETrue if frame will be encoded
+ TBool iKeyFrame;
+
+ // transition frame info
+ TBool iTransitionFrame; // is this a transition frame?
+ TBool iFirstTransitionFrame; // is this the first transition frame in this instance?
+ TTransitionPosition iTransitionPosition;
+ TTransitionColor iTransitionColor;
+ TInt iTransitionFrameNumber;
+
+ TBool iModificationApplied; // has intermediate modification been done ?
+ TBool iRepeatFrame; // ETrue for second instance of a color transition frame
+
+ };
+
+public: // New functions
+
+ /**
+ * Two-phased constructor.
+ *
+ * @param anInputQueue Input active queue
+ * @param aStreamParameters Stream parameters
+ * @param aProcessor Video processor object
+ * @param aStatusMonitor Status monitor object
+ * @param aEncoder Video encoder object
+ * @param aPriority Active object priority
+ */
+
+ static CVideoProcessor* NewL(CActiveQueue *anInputQueue,
+ CVideoProcessor::TStreamParameters *aStreamParameters,
+ CMovieProcessorImpl* aProcessor,
+ CStatusMonitor *aStatusMonitor,
+ CVedAVCEdit *aAvcEdit,
+ TBool aThumbnailMode,
+ TInt aPriority=EPriorityStandard);
+
+
+ /**
+ * Destructor.
+ */
+ ~CVideoProcessor();
+
+public: // Functions from base classes
+
+ /**
+ * From CActive Active object running method
+ */
+ void RunL();
+
+ /**
+ * From CActive Active object cancelling method
+ */
+ void DoCancel();
+
+ /**
+ * From CActive Active object error handling method
+ */
+ TInt RunError(TInt aError);
+
+ /**
+ * From CDecoder Start video decoding
+ */
+ void Start();
+
+ /**
+ * From CDecoder Stop video decoding
+ */
+ void Stop();
+
+ /**
+ * From CDataProcessor Notifies that input stream has ended
+ */
+ void StreamEndReached(TAny *aUserPointer);
+
+ /**
+ * From CDataProcessor Notifies that new input queue blocks are available
+ */
+ void InputDataAvailable(TAny *aUserPointer);
+
+ /**
+ * From MVideoRenderer Renders a decoded frame
+ */
+ TInt RenderFrame(TAny* aFrame);
+
+ /**
+ * From MTRTranscoderObserver
+ */
+ void MtroInitializeComplete(TInt aError);
+
+ /**
+ * From MTRTranscoderObserver
+ */
+ void MtroFatalError(TInt aError);
+
+ /**
+ * From MTRTranscoderObserver
+ */
+ void MtroReturnCodedBuffer(CCMRMediaBuffer* aBuffer);
+
+ /**
+ * From MTRTranscoderObserver
+ */
+ void MtroSetInputFrameRate(TReal& aRate);
+
+ /**
+ * From MTRTranscoderObserver
+ */
+ void MtroAsyncStopComplete();
+
+ /**
+ * From MTRTranscoderObserver
+ */
+ void MtroSuspend();
+
+ /**
+ * From MTRTranscoderObserver
+ */
+ void MtroResume();
+
+ /**
+ * From MTRVideoPictureSink
+ */
+ void MtroPictureFromTranscoder(TTRVideoPicture* aPicture);
+
+ /**
+ * From MCMRMediaSink
+ */
+ void WriteBufferL(CCMRMediaBuffer* aBuffer);
+
+ /**
+ * From MCMRMediaSink
+ */
+ TInt SetVideoFrameSize(TSize aSize);
+
+ /**
+ * From MCMRMediaSink
+ */
+ TInt SetAverageVideoBitRate(TInt aBitRate);
+
+ /**
+ * From MCMRMediaSink
+ */
+ TInt SetMaxVideoBitRate(TInt aBitRate);
+
+ /**
+ * From MCMRMediaSink
+ */
+ TInt SetAverageAudioBitRate(TInt aBitRate);
+
+ /**
+ * From MTimerObserver
+ */
+ void MtoTimerElapsed(TInt aError);
+
+public: // New functions
+
+ /**
+ * Generates a thumbnail image
+ *
+ * @param aYUVDataPtr For returning the thumbnail
+ * @param aFrameIndex Frame index of the thumbnail image
+ * -1 means best thumbnail is generated
+ * @param aStartFrameIndex Frame index of the start frame (last intra before thumbnail)
+ *
+ * @return Error code
+ */
+
+ /**
+ * Starts generating a thumbnail image
+ *
+ * @param aThumbObserver Observer class
+ * @param aFrameIndex Frame index of the thumbnail image
+ * -1 means best thumbnail is generated
+ * @param aStartFrameIndex Frame index of the start frame (last intra before thumbnail)
+ * @param aFactor Pointer to transcode factor structure
+ *
+ * @return Error code
+ */
+ TInt ProcessThumb(MThumbnailObserver* aThumbObserver, TInt aFrameIndex,
+ TInt aStartFrameIndex, TVedTranscodeFactor* aFactor);
+
+ TInt FetchThumb(TUint8** aYUVDataPtr);
+
+ /**
+ * Gets the frame number of the current frame
+ *
+ */
+ TInt GetFrameNumber() { return iFrameNumber; };
+
+ /**
+ * Keeps track whether the clip was resolution transcoded
+ *
+ */
+ inline TInt GetChangeResolution() const { return iFullTranscoding; };
+
+ /*
+ * Checks whether the resynch bit is set if set then resets to zero
+ *
+ * @return TBool
+ */
+ TBool CheckVosHeaderL(TPtrC8& aBuf);
+
+ /**
+ * Gets the transcode factor from the current clip
+ * @param aFactor For returning the transcode factor
+ * @return error code
+ */
+ TInt GetTranscodeFactorL(TVedTranscodeFactor& aFactor);
+
+ /*
+ * Writes a delayed frame, i.e. a frame which has been buffered
+ * since transcoder has unprocesessed frames that must be written
+ * before this frame
+ */
+ void WriteDelayedFrameL();
+
+ /*
+ * Checks if there are any frames waiting to be encoded inside transcoder
+ * @return TBool
+ */
+ TBool IsEncodeQueueEmpty();
+
+ /*
+ * Calculates encoding delay based on what kind of frame is
+ * next in the encoding queue
+ *
+ * @return Delay in microseconds
+ */
+ TInt GetEncodingDelay();
+
+ /*
+ * Checks if the next frame in processing queue
+ * is being encoded
+ *
+ * @return TBool result
+ */
+ TBool IsNextFrameBeingEncoded();
+
+ /*
+ * Gets MPEG-4 VOS header size in bytes (from encoder)
+ *
+ * @return TInt VOS size
+ */
+ TInt GetVosHeaderSize();
+
+private: // internal methods
+
+ /**
+ * C++ default constructor.
+ *
+ * @param anInputQueue Input active queue
+ * @param aStreamParameters Stream parameters
+ * @param aProcessor Video processor object
+ * @param aStatusMonitor Status monitor object
+ * @param aEncoder Video encoder object
+ * @param aPriority Active object priority
+ */
+ CVideoProcessor(CActiveQueue *anInputQueue,
+ TStreamParameters *aStreamParameters,
+ CMovieProcessorImpl* aProcessor,
+ CStatusMonitor *aStatusMonitor,
+ CVedAVCEdit *aAvcEdit,
+ TBool aThumbnailMode,
+ TInt aPriority);
+
+
+ /**
+ * Symbian 2nd phase constructor
+ */
+ void ConstructL();
+
+ /**
+ * Processes one input video frame
+ *
+ * @return ETrue If the current clip has been
+ * processed entirely, EFalse if not
+ */
+ TBool ProcessFrameL();
+
+ /**
+ * Processes the second frame of a color transition double frame
+ */
+ TBool Process2ndColorTransitionFrameL();
+
+ /**
+ * Read one frame from input queue to internal buffer
+ *
+ * @return ETrue if a complete frame was read, EFalse otherwise.
+ */
+ TInt ReadFrame();
+
+ /**
+ * Reads a H.263 frame from input queue to internal buffer
+ *
+ * @return ETrue if a complete frame was read, EFalse otherwise.
+ */
+ TBool ReadH263Frame();
+
+ /**
+ * Reads a MPEG-4 frame from input queue to internal buffer
+ *
+ * @return ETrue if a complete frame was read, EFalse otherwise.
+ */
+ TBool ReadMPEG4Frame();
+
+ /**
+ * Reads an AVC frame from input queue to internal buffer
+ *
+ * @return ETrue if a complete frame was read, EFalse otherwise.
+ */
+ TBool ReadAVCFrame();
+
+ /**
+ * 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);
+
+ /**
+ * Apply color effect on a frame
+ *
+ * @param aColorEffect Effect to be used
+ * @param aYUVDataPtr Pointer to the frame
+ * @param aColorToneYUV for extracting the UV values
+ * @return void
+ */
+ void ApplySpecialEffect(TInt aColorEffect, TUint8* aYUVDataPtr,
+ TInt aColorToneU, TInt aColorToneV);
+
+ /**
+ * Convert frame operation enumeration to TInt
+ *
+ * @param aFrameOperation Frame operation
+ *
+ * @return Frame operation as TInt
+ */
+ TInt TFrameOperation2TInt(TDecoderFrameOperation aFrameOperation);
+
+ /**
+ * Convert color effect enumeration to TInt
+ *
+ * @param aColorEffect Color effect
+ *
+ * @return Color effect as TInt
+ */
+ TInt TColorEffect2TInt(TVedColorEffect aColorEffect);
+
+ /**
+ * Determines transition effect parameters
+ *
+ * @param aTransitionEffect Output: ETrue if transition effect is to be applied
+ * @param aStartOfClipTransition ETrue if starting transition is to be applied
+ * @param aEndOfClipTransition ETrue if ending transition is to be applied
+ * @param aStartTransitionColor Color for starting transition
+ * @param aEndTransitionColor Color for ending transition
+ *
+ * @return Error code
+ */
+ TInt DetermineClipTransitionParameters(TInt& aTransitionEffect,TInt& aStartOfClipTransition,
+ TInt& aEndOfClipTransition,TTransitionColor& aStartTransitionColor,TTransitionColor& aEndTransitionColor);
+
+
+ /**
+ * Applies fading transition effect to YUV frame
+ *
+ * @param aYUVPtr Pointer to the frame
+ * @param aTransitionPosition 1 = start transition, 2 = end transition
+ * @param aTransitionColor Transition color to be used (EColorWhite/EColorBlack/EColorTransition)
+ * @param aTransitionFrameNumber ordinal number of transition frame (0 - (number of transition frames - 1))
+ *
+ * @return void
+ */
+ void ApplyFadingTransitionEffect(TUint8* aYUVPtr, TTransitionPosition aTransitionPosition,
+ TTransitionColor aTransitionColor, TInt aTransitionFrameNumber);
+
+ /**
+ * Applies blending transition effect between YUV frames
+ *
+ * @param aYUVPtr1 Pointer to the frame 1
+ * @param aYUVPtr2 Pointer to the frame 2
+ * @param aRepeatFrame True for the second instance of two frames to be blended
+ * @param aTransitionFrameNumber ordinal number of transition frame (0 - (number of transition frames - 1))
+ *
+ * @return void
+ */
+ void ApplyBlendingTransitionEffect(TUint8* aYUVPtr1,TUint8* aYUVPtr2, TInt aRepeatFrame,
+ TInt aTransitionFrameNumber);
+
+
+ /**
+ * Applies sliding transition effect between YUV frames
+ *
+ * @param aYUVPtr1 Pointer to the frame 1
+ * @param aYUVPtr2 Pointer to the frame 2
+ * @param aRepeatFrame True for the second instance of two frames to be blended
+ * @param aTransitionFrameNumber ordinal number of transition frame (0 - (number of transition frames - 1))
+ *
+ * @return void
+ */
+ void ApplySlidingTransitionEffect(TUint8* aYUVPtr1,TUint8* aYUVPtr2, TVedMiddleTransitionEffect aVedMiddleTransitionEffect,
+ TInt aRepeatFrame, TInt aTransitionFrameNumber);
+
+ /**
+ * Get the start transition info of the next clip
+ *
+ * @return void
+ */
+ void GetNextClipTransitionInfo();
+
+ /*
+ * Resolution Transcoder
+ * Determine if the resolution transcoding will apply to the current clip
+ *
+ */
+ TBool DetermineResolutionChange();
+
+ /*
+ *
+ * Determine if frame rate needs to be changed for the current clip
+ *
+ */
+ TBool DetermineFrameRateChange();
+
+ /*
+ *
+ * Determine if bitrate needs to be changed for the current clip
+ *
+ */
+ TBool DetermineBitRateChange();
+
+ /*
+ * Calculate the duration of current frame
+ *
+ * @param aFrameNumber frame number
+ *
+ * @return Frame duration in ticks
+ */
+ TInt GetFrameDuration(TInt aFrameNumber);
+
+ /*
+ * Decode frame using vedh263decoder
+ *
+ * @param aOperation Operation
+ * @param aModeChanged ETrue if compressed domain transcoding is neede
+ * @param aFrameSizeInBytes Return value, coded output frame size in bytes
+ * @param aVosHeaderSize Return value, size of VOS header in bytes
+ */
+ void DecodeFrameL(TInt aOperation, TBool aModeChanged, TInt& aFrameSizeInBytes);
+
+ /*
+ * Create and initialize transcoder
+ *
+ * @param aInputType Input video type
+ * @param aMode Transcoder operational mode to be used
+ *
+ */
+ void CreateAndInitializeTranscoderL(TVedVideoType aInputType, CTRTranscoder::TTROperationalMode aMode);
+
+ /*
+ * Determines if compressed domain transcoding is needed
+ *
+ */
+ TBool GetModeChangeL();
+
+ /*
+ * Processes a thumbnail frame
+ *
+ * @param aFirstFrame ETrue if the first thumbnail frame is being processed
+ */
+ void ProcessThumb(TBool aFirstFrame);
+
+ /*
+ * Calculate the number of transition frames
+ *
+ * @param aStartCutTime Start cut time
+ * @param aEndCutTime End cut time
+ */
+ void GetNumberOfTransitionFrames(TTimeIntervalMicroSeconds aStartCutTime,
+ TTimeIntervalMicroSeconds aEndCutTime);
+
+ /*
+ * Set parameters needed to process a transition frame
+ *
+ * @param aIncludedFrameNumber Ordinal counting from the first included frame number
+ * @param aDecodeFrame ETrue if this frame must be decoded in order to apply end transition
+ */
+ void SetTransitionFrameParams(TInt aIncludedFrameNumber, TBool& aDecodeFrame);
+
+ /*
+ * Sets output codec parameters
+ *
+ * aMimeType Output mime type
+ */
+ void SetOutputVideoCodecL(const TPtrC8& aMimeType);
+
+ /*
+ * Generates bitstream for a not coded frame
+ * to be used in color transitions
+ */
+ void GenerateNotCodedFrameL();
+
+ /*
+ * Reads a frame from input queue and writes it to transcoder
+ *
+ */
+ void ReadAndWriteThumbFrame();
+
+ /*
+ * Does thumbnail finalization, stops processing and informs observer
+ *
+ * aError Error code for observer
+ */
+ void FinalizeThumb(TInt aError);
+
+ /*
+ * Writes a frame to output file
+ *
+ * @param aBuf Buffer containing the frame
+ * @param aDurationInTicks Frame duration in ticks
+ * @param aFrameNumber Frame number
+ * @return ETrue if clip end was written
+ */
+ TBool WriteFrameToFileL(TPtr8& aBuf, TInt aDurationInTicks, TInt aFrameNumber);
+
+ /*
+ * Writes a frame to transcoder
+ *
+ * @param aFrameNumber Frame number
+ * @param aKeyFrame ETrue for a keyframe
+ * @param aVolHeaderInBuffer ETrue if frame buffer contains MPEG-4 VOL header
+ */
+ void WriteFrameToTranscoderL(TInt aFrameNumber, TBool aKeyFrame, TBool aVolHeaderInBuffer);
+
+ /*
+ * Handles a decoded thumbnail frame received from transcoder
+ *
+ * @param aPicture Pointer to received picture
+ */
+ void HandleThumbnailFromTranscoder(TTRVideoPicture* aPicture);
+
+ /*
+ * Handles a decoded "decode-only" frame received from transcoder
+ *
+ * @param aPicture Pointer to received picture
+ * @param aIndex Index of decoded frame to iFrameInfoArray
+ */
+ void HandleDecodeOnlyFrameFromTranscoder(TTRVideoPicture* aPicture, TInt aIndex);
+
+ /*
+ * Handles a decoded transition frame (intermediate frame) received from transcoder
+ *
+ * @param aPicture Pointer to received picture
+ * @param aIndex Index of decoded frame to iFrameInfoArray
+ */
+ void HandleTransitionFrameFromTranscoder(TTRVideoPicture* aPicture, TInt aIndex);
+
+ /*
+ * Inserts AVC/MPEG-4 decoder specific info data in front of internal coded frame buffer
+ *
+ */
+ void InsertDecoderSpecificInfoL();
+
+private: // internal constants
+ enum TDataFormat
+ {
+ EDataUnknown = 0,
+ EDataH263,
+ EDataMPEG4,
+ EDataAVC
+ };
+
+
+private: // data
+ CActiveQueue *iQueue; // input data queue
+ TBool iReaderSet; // have we been set as reader?
+ CStatusMonitor *iMonitor; // status monitor object
+ CMovieProcessorImpl *iProcessor;
+
+ CVedH263Dec *iDecoder; // H.263/MPEG-4 decoder
+
+ TUint iVideoWidth, iVideoHeight; // video picture dimensions
+ TInt64 iPicturePeriodNsec; // one PCF tick period in nanoseconds
+ TDataFormat iDataFormat; // the stream data format
+ TUint iIntraFrequency; // intra picture frequency (intras per 256 sec)
+ TUint iReferencePicturesNeeded; // number of reference pictures needed
+
+ TBool iFirstFrameFlag; // flag for decoder: is this the first frame?
+
+ TDecoderFrameOperation iFrameOperation;
+
+ TInt iNumberOfIncludedFrames;
+
+ TBool iDecoding; // are we decoding?
+ TBool iStreamEnd; // has stream end been reached?
+ TBool iEncoderResetPending; // is the encoder being reseted
+
+ TPtr8 *iBlock; // queue block
+ TUint iBlockPos; // current block position
+ TUint8 *iDataBuffer; // data buffer for the current compressed frame
+ TUint iBufferLength; // buffer total length
+ TUint iDataLength; // amount of data in buffer
+ TUint iCurrentFrameLength; // the length of the current frame in the buffer
+
+ TUint8 *iFrameBuffer; // Concatenated YUV data for decoded frame
+
+ TUint8 *iOutVideoFrameBuffer; // data buffer for the output compressed frame
+ TInt iOutVideoFrameBufferLength; // buffer total length
+ TInt iOutDataLength; // amount of data in buffer
+ TPtr8 iWriteDes; // writing descriptor for encoding
+ TInt iFrameNumber; // current frame number
+ TInt iNumberOfFrames; // no. of frames in current clip
+ TInt iPreviousFrameIncluded; // ETrue if previous frame was included in output movie
+ TInt iTrPrevious;
+
+ // transition effects
+ TInt iTransitionEffect; // is transition effect to be applied?
+ TInt iStartOfClipTransition; // is starting transition effect to be applied ?
+ TInt iEndOfClipTransition; // is ending transition effect to be applied ?
+
+ TInt iStartNumberOfTransitionFrames; // number of frames in transition
+ TInt iEndNumberOfTransitionFrames; // number of frames in transition
+ TInt iTransitionFrameNumber;
+ TInt iNextTransitionNumber;
+
+ TInt iFirstFrameInRange; // is the current frame the first to be included in output movie
+ TInt iFirstIncludedFrameNumber; // number of first included frame
+ TTransitionColor iStartTransitionColor; // color for starting transition
+ TTransitionColor iEndTransitionColor;// color for ending transition
+
+ // number of preceding I frame (for end-of-clip trans.)this number is relative of start-of-clip
+ TInt iLastIntraFrameBeforeTransition; //The last intra frame before transition effect takes place.
+
+ TTimingSource iTiming;
+
+ // for transition effect - blending and sliding
+ TInt iFrameDuration;
+ TBool iRepeatFrame;
+ TInt64 iTimeStamp;
+ TUint8 *iOrigPreviousYUVBuffer;
+ TUint8 *iColorTransitionBuffer;
+
+ CMPEG4Timer *iMPEG4Timer; // Stores MPEG-4 timing information
+
+ CTRTranscoder *iTransCoder;
+ CCMRMediaBuffer* iMediaBuffer;
+
+ TBool iTranscoderInitPending; // is transcoder init in progress ?
+ TBool iDecodePending; // is decode in progress ?
+ TBool iTranscoderStarted; // has transcoder been started ?
+ TBool iFrameToEncode; // should current frame be encoded ? (: could be changed to local for ProcessFrame)
+
+ TBool iTransitionFrame;
+ TBool iFirstTransitionFrame;
+ TTransitionPosition iTransitionPosition;
+ TTransitionColor iTransitionColor;
+
+ // for color toning
+ TInt iFirstFrameQp; // QP for first MPEG4 frame, used for color toning
+
+ TBool iFullTranscoding; // Flag to indicate whether current clip needs to be fully
+ // transcoded (decode & encode)
+
+ TBool iThumbnailMode; // True if we are generating a thumbnail frame
+
+ TInt iThumbFrameIndex; // index of thumbnail to be generated, >= 0 means a specific frame,
+ // < 0 means the first "good" or "legible" frame
+ TInt iThumbFrameNumber;
+ TInt iFramesToSkip; // for searching a good thumbnail
+
+ MThumbnailObserver* iThumbObserver; // observer for thumbnail operation
+
+ HBufC8* iDecoderSpecificInfo; // decoder specific info header read from input stream, to be sent to transcoder
+ TBool iDecoderSpecificInfoSent; // True if decoder specific info has been sent to transcoder
+
+ HBufC8* iOutputVolHeader; // VOL header read from encoder, to be inserted in the first
+ // encoded frame buffer
+
+ TBool iOutputVolHeaderWritten; // True if VOL/AVC header has been written to output bitstream
+
+ RArray<TFrameInformation> iFrameInfoArray; // array for storing info about frames in progress
+
+ TTranscoderMode iTranscoderMode; // current transcoder operation mode
+
+ // used & max frame size, and info if size can be arbitrary
+ TSize iMaxOutputResolution;
+ TBool iArbitrarySizeAllowed;
+
+ // max allowed frame rate
+ TReal32 iMaxOutputFrameRate;
+
+ // target and max allowed bit rate
+ TInt iOutputBitRate;
+ TInt iMaxOutputBitRate;
+
+ // Mime type for encoded data
+ TBuf8<256> iOutputMimeType;
+
+ TBool iDelayedWrite; // True if a frame has to be stored for later writing since
+ // there are frames inside the transcoder that have to be written
+ // before this frame
+ HBufC8* iDelayedBuffer; // buffer for storing the frame
+ TInt64 iDelayedTimeStamp; // timestamp
+ TBool iDelayedKeyframe; // is it a keyframe
+
+ TInt iTimeStampIndex; // index for reading stored timestamps in case of color transition
+ TBool iFirstColorTransitionFrame; // True if we are processing the first frame of a
+ // 'doubled' frame in color transitions
+
+ TInt iTimeStampOffset; // offset to be added to timestamps, got from processor
+
+ CCallbackTimer* iTimer; // timer for waiting encoding to complete
+
+ TBool iStreamEndRead;
+
+ TBool iProcessingComplete;
+
+ TInt iInputMPEG4ProfileLevelId; // profile-level id for MPEG-4 input
+
+ // Timer timeout, depends on codec and resolution
+ TUint iMaxEncodingDelay;
+
+ TInt iNumThumbFrameSkips; // number of frame skip cycles done to get a
+ // a good thumbnail
+
+ TTimeIntervalMicroSeconds iPreviousTimeStamp; // timestamp of previous frame
+
+ TInt iSkippedFrameNumber; // frame number of skipped frame
+
+ TInt64 iCutInTimeStamp; // timestamp of cut-in point, needed in color transitions
+
+ TBool iDecodingSuspended; // flag for suspended decoding
+
+ HBufC8* iNotCodedFrame; // buffer for not coded frame
+
+ TInt iInputTimeIncrementResolution; // MPEG-4 time increment resolution from input clip
+
+ TBool iFirstFrameAfterTransition; // True for first frame after start transition
+
+ TBool iFirstRead; // True for first read frame
+
+ TBool iThumbDecoded; // flag for indicating when a thumb has been decoded,
+ // needed in AVC thumbnail generation
+
+ TInt iInputAVCLevel; // level of input AVC clip
+
+ TInt iFrameLengthBytes; // number of bytes used for NAL length in input
+ TInt iThumbFramesToWrite; // number of thumb frames to write to transcoder
+
+ CVedAVCEdit* iAvcEdit; // AVC editing instance
+
+ TBool iEncodeUntilIDR; // Flag for encoding until IDR
+
+ TBool iIsThumbFrameBeingCopied; // True if thumbnail frame has been sent for
+ // decoding, but MtroReturnCodedBuffer hasn't been called
+
+ TInt iModifiedFrameNumber; // frame number modification for AVC decoder,
+ // used with color transitions
+
+ TInt iMaxItemsInProcessingQueue; // Maximum number of frames kept in transcoder
+ // processing queue
+
+ TInt iLastWrittenFrameNumber; // number of last written frame
+
+ TInt iDelayedFrameNumber; // number of delayed frame
+
+ TBool iInitializing; // True when initialisation is ongoing
+ TVedVideoBitstreamMode iInputStreamMode; //MPEG-4 bitstream mode in input clip
+};
+
+#endif // __VIDEOPROCESSOR_H__
+
+// End of File