/*

* 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

    *