diff -r 000000000000 -r 951a5db380a0 videoeditorengine/vedengine/videoprocessor/inc/videoprocessor.h
--- /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