/*

* 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 movie processor implementation.

*

*/

#ifndef     __MOVIEPROCESSORIMPL_H__

#define     __MOVIEPROCESSORIMPL_H__

#ifndef __E32BASE_H__

#include <e32base.h>

#endif

#include "mp4demux.h"

#include "parser.h"

#include "videoprocessor.h"

#include "VedCommon.h"

#include "VedMovieImp.h"

#include "VedVideoClipInfoImp.h"

#include "VedVideoClipGenerator.h"

#include "VedRgb2YuvConverter.h"

//  FORWARD DECLARATIONS

class CStatusMonitor;

class CActiveQueue;

class CVideoProcessor;

class CDemultiplexer; 

class CComposer; 

class CVideoEncoder;

class CVedMovie;

class MVedMovieProcessingObserver;

class CDisplayChain;

class CTranscoder;

class CAudioProcessor;

class CSizeEstimate;

class CVedAVCEdit;

// audio operation

enum TAudioOperation

{

	EAudioRetain = 0,

	EAudioMute,

	EAudioReplace

};

enum TVideoOperation  // used in image insertion

{

    EVideoEncodeFrame = 0,

    EVideoWriteFrameToFile

};

// video frame parameters

struct TFrameParameters

{	

	TInt64 iTimeStamp;

	TUint8 iType;	

};

// H.263 TR parameters

struct TTrParameters

{

	TInt iTrPrevNew; 

	TInt iTrPrevOrig; 

};

// video clip parameters

struct TVideoClipParameters

{

	TInt64 iStartTime; 

	TInt64 iEndTime; 

}; 

//  CLASS DEFINITIONS

class CMovieProcessorImpl : public CActive, public MVedVideoClipGeneratorFrameObserver,

                            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 TDataFormat

    {    

        EData3GP,  // 3GP

        EDataAutoDetect // autodetect type

    };    

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);

    /** Frame insertion support 

	 * From CVedVideoClipGenerator, this function is callback indicating image is ready

	 * @param aError      <code>KErrNone</code>, if frame was completed successfully; 

	 *                    one of the system wide error codes, if frame generation failed

     * @param aFrame      pointer to frame, if it was completed successfully;

	 *                    <code>NULL</code>, if frame generation failed

	 */

	void NotifyVideoClipGeneratorFrameCompleted(CVedVideoClipGenerator& aGenerator, 

        TInt aError, CFbsBitmap* aFrame);    

    /**

    * From MThumbnailObserver

	* 

	* Called when thumbnail generation is ready

	*	

    * @param aError error code

    */ 

    void NotifyThumbnailReady(TInt aError);

public:  // New functions

    /** 

     * Constructors for instantiating new video processors.

     * Should reserve as little resources as possible at this point.

	 */

	static CMovieProcessorImpl* NewL();

	static CMovieProcessorImpl* 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 ~CMovieProcessorImpl();

	/**

	 * Do all initializations necessary to start processing a movie, e.g. open files, allocate memory.

	 * If this method leaves, destructor should be called to free allocated resources. 

     * Starts processing after initializations are done.

     *

	 * @param aMovie  movie to process

	 * @param aFilename  output file name

	 * @param aFileHandle output file handle

     * @param aObserver observer object    

     *

	 */

	void StartMovieL(CVedMovieImp* aMovie, const TDesC& aFileName, RFile* aFileHandle,

	                 MVedMovieProcessingObserver *aObserver);			

    /** Create 3gp generated clips 

     * Create all the necessary 3gp files before inserting them into the actual movie

     * If this method leaves, destructor should be called to free allocated resources. 

     * Starts processing after initializations are done.

     *

     * @param aCreateMode mode of operation of the create image files function

     */

	TInt CreateImage3GPFilesL(TVideoOperation aCreateMode);

	/** Prepare for 3gp generated clips

	 * Create all the data structures necessary for 3gp files creation before calling create.

	 * If this method leaves, destructor should be called to free allocated resources. 

     * Starts processing after initializations are done.

     *

	 * @param aCreateMode        mode of operation of the create image files function

	 */

	TInt ProcessImageSetsL(TVideoOperation aCreateMode);

	/** Encode raw frames for 3gp generated clips

	 * This method is used to encode a raw frame for 3gp generated clips

	 * If this method leaves, destructor should be called to free allocated resources. 

     * VideEncoder should be created and initialized before using this function

     * 

	 */

	TInt EncodeImageFrameL();

	/** Process raw frames for 3gp generated clips

	 * Decide what to do in this function - whether to call encoder or compose output

	 * If this method leaves, destructor should be called to free allocated resources. 

     * Starts processing after initializations are done.

     *

	 */

	void DoImageSetProcessL();

	/**

	 * 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 aFileName  name of the file to generate thumbnail from

	 * @param aFileHandle  handle of the file to generate thumbnail from

     * @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(const TDesC& aFileName, 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

	 * @param aFactor     Pointer to a TVedTranscodeFactor structure, which is updated by this method

	 *

	 * @return  

	 *          

	 */

	void ProcessThumbL(TRequestStatus &aStatus, TVedTranscodeFactor* aFactor);

	 /** 

	 * 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 aFileName  name of the file to read

	 * @param aFileHandle handle of file to read

	 * @param aVideoFormat  for returning the video format

     * @param aVideoType Type of video data

	 * @param aResolution  for returning the resolution

	 * @param aAudioType Type of audio data

     * @param aDuration  for returning the duration

     * @param aVideoFrameCount Number of video frames in the clip	 

	 * @param aSamplingRate Audio sampling rate

	 * @param aChannelMode Audio channel mode

	 */

	void GetClipPropertiesL(const TDesC& aFileName, RFile* aFileHandle, TVedVideoFormat& aFormat,

		TVedVideoType& aVideoType, TSize& aResolution, TVedAudioType& aAudioType, 

		TTimeIntervalMicroSeconds& aDuration, TInt& aVideoFrameCount,TInt& aSamplingRate, 

		TVedAudioChannelMode& aChannelMode);	

    /**

	 * Read video frame information from the specified video clip file and fills array of info for 

     * all frames in video.The file should be opened with EFileShareReadersOnly share mode. Video processor 

	 * should not free the video frame info array after it has passed it on as a return value 

	 * of this function. Returned array should be allocated with User::AllocL() and should be 

	 * freed by the caller of this method with User::Free(). 

	 *

	 * 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

	 *

	 * @param aFileName             name of the file to read

	 * @param aFileHandle           handle of the file to read

	 * @param aVideoFrameInfoArray  Array for video frame parameters

	 */

    void GenerateVideoFrameInfoArrayL(const TDesC& aFileName, RFile* aFileHandle, TVedVideoFrameInfo*& aVideoFrameInfoArray);

    /**

     * Get movie size estimate

     *

     * @param aMovie Movie for which the estimate is done

     * @return Movie size in bytes

     */

    TInt GetMovieSizeEstimateL(const CVedMovie* aMovie);    

    /**

     * Calculate movie size estimate for MMS

     *          

     * @param aMovie			Movie object 

     * @param aTargetSize		Maximum size allowed

     * @param aStartTime		Time of the first frame included in the MMS output

     * @param aEndTime			Time of the last frame included in the MMS output

     * @return Error code

     */

    TInt GetMovieSizeEstimateForMMSL(const CVedMovie* aMovie, TInt aTargetSize, 

		TTimeIntervalMicroSeconds aStartTime, TTimeIntervalMicroSeconds& aEndTime);

    /**

	 *  Cancels the processing of a movie	 

	 */

    void CancelProcessingL();

    /**

     * Enhances the visual quality of the frame

     *     

     */				

	void EnhanceThumbnailL(const CFbsBitmap* aInBitmap, CFbsBitmap* aTargetBitmap); 

    /**

     * Get number of frames in output movie

     *     

     * @return Number of output frames

     */				

	inline TInt GetOutputNumberOfFrames() const { return iOutputNumberOfFrames; }

	/**

	* Get the file name of the current clip

	*     

	* @return File name of the current clip

	*/				

	inline TFileName GetCurrentClipFileName() const { return iClipFileName; }

    /**

     * Get number of frames in current 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 color effect for the current clip

     *     

     * @return Color effect

     */

	inline TVedColorEffect GetColorEffect() const { return iColorEffect; } 

	inline void GetColorTone(TInt& aU, TInt& aV) { aU=iColorToneU; aV=iColorToneV; }

    /**

     * Get number of audio frames in one 3gp sample

     *     

     * @return Number of frames in sample

     */

    inline TInt GetAudioFramesInSample() const { return iAudioFramesInSample; }

    /**

     * Finalize processing a clip

     *     

     */

    void FinalizeVideoClip();

    /**

     * Set frame type 

     *

     * @param aFrameIndex Index to the frame

     * @param aType P frame = 0, I frame = 1

     */    

    void SetFrameType(TInt aFrameIndex, TUint8 aType);

    /**

     * 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;    

    /**

     * Get video timestamp in ticks from timestamp in ms

     *

     * @param aTimeStampInMs Time in ms

     * @param aCommonTimeScale ETrue for using the output time scale

     *                         EFalse for using the scale of current clip

     * @return Timestamp in ticks

     */        

    TInt64 GetVideoTimeInTicksFromMs(TInt64 aTimeStampInMs, TBool aCommonTimeScale) const;

    /**

     * Get audio timestamp in ticks from timestamp in ms

	 *

	 * @param aTimeStampInMs Time in ms 		

	 * @return Timestamp in ticks

	 */ 	 

	TUint GetAudioTimeInTicksFromMs(TUint aTimeStampInMs) const;        

	/**

     * Get audio timestamp in ms from timestamp in ticks

	 *

	 * @param aTimeStampInTicks Time in ticks 		

	 * @return Timestamp in milliseconds

	 */ 	 

	TUint GetAudioTimeInMsFromTicks(TUint aTimeStampInTicks) const;

    /**

     * 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 iStartFrameIndex; }

    /**

     * Get frame type at specified index

     *

     * @param aIndex Frame index

     * @return Frame type

     */

    inline TInt8 GetVideoFrameType(TInt aIndex) const { return iParser->GetVideoFrameType(aIndex); };

    inline TInt8 VideoFrameType(TInt aIndex) const

        {

        if (iThumbnailInProgress || (iFrameParameters == 0))

            {

            return iParser->GetVideoFrameType(iParser->GetStartFrameIndex() + aIndex);

            }

        return (TInt8) iFrameParameters[aIndex].iType;

        }

     /**

     * Get frame timestamp at specified index, in ticks

     *

     * @param aIndex Frame index

     * @return timestamp in ticks

     */

    inline TInt64 VideoFrameTimeStamp(TInt aIndex)

        {

        if (iThumbnailInProgress || (iFrameParameters == 0))

            {

            TInt startTimeInTicks = 0;

            iParser->GetVideoFrameStartTime(iParser->GetStartFrameIndex() + aIndex, &startTimeInTicks);

            return startTimeInTicks;

            }

        return (TInt64) iFrameParameters[aIndex].iTimeStamp;

        }

    inline void SetTrPrevNew(TInt aTr) { iTr.iTrPrevNew = aTr; }

    inline void SetTrPrevOrig(TInt aTr) { iTr.iTrPrevOrig = aTr; }

    inline TInt GetTrPrevNew() const { return iTr.iTrPrevNew; }

    inline TInt GetTrPrevOrig() const { return iTr.iTrPrevOrig; }

    /**

     * Get pointer to demultiplexer object

     *     

     * @return demux pointer

     */

    inline CDemultiplexer* GetDemux() const { return iDemux; }

    /**

     * Get the start time for the current clip

     *     

     * @return Time in microseconds

     */

	inline TTimeIntervalMicroSeconds GetStartCutTime() const { return iStartCutTime; }

     /**

     * Get thumbnail processing status

     * 

     * @return ETrue if thumbnail is being processed, EFalse otherwise

     */

    inline TBool IsThumbnailInProgress() const { return iThumbnailInProgress; }

    /**

     * Get the end time for the current clip

     *     

     * @return Time in microseconds

     */

	inline TTimeIntervalMicroSeconds GetEndCutTime() const { return iEndCutTime; }