/*

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

* Transcoder.

*

*/

#ifndef CTRTRANSCODER_H

#define CTRTRANSCODER_H

// INCLUDES

#include <e32base.h>

#include <e32cmn.h>

#include <BITDEV.H>                 // for CFbsScreenDevice

#include <CCMRMediaSink.h>

#include "ctrcommon.h"

// FORWARD DECLARATIONS

class MTRVideoPictureSink;

class MTRTranscoderObserver;

class MCMRMediaSink;

// CLASS DECLARATION

/**

*  CTranscoder interface class

*  Using CTRTranscoder: 

*  - Create the transcoder instance 

*  - Open the transcoder with specified options

*  - Give settings

*  - Initialize the transcoder with given options

*  - Start transcoding after initializing is completed with MtroInitializeComplete observer callback.

*  - Stop transcoding

*  - Delete the transcoder instance

*  @lib TRANSCODER.LIB

*  @since 3.1

*/

class CTRTranscoder : public CBase

    {

    public:

        // Video data format

        enum TTRVideoDataType

            {

            ETRDuCodedPicture = 0,  // Each data unit contains one coded video picture

            ETRDuVideoSegment,  // Each data unit contains one coded video segment (according resync value (MPEG4) and GOB header in H.263)

            ETRYuvRawData420,   // Each data unit represents uncompressed video picture in YUV 4:2:0 format

            ETRYuvRawData422    // Each data unit represents uncompressed video picture in YUV 4:2:2 format

            };

        // Transcoder operational mode

        enum TTROperationalMode

            {

            EFullTranscoding = 0,   // Full transcoding operation

            EDecoding,          // Decoding only (picture resampling is possible)

            EEncoding,          // Encoding only (picture resampling is possible)

            EResampling,        // Picture resampling only (for YUV In / Out data)

            EOperationNone      // None

            };

    public: // Constructors and destructor

        /**

        * Two-phased constructor. Create an instance the transcoder instance

        * @param aObserver Transcoder observer

        * @return CTranscoder instance. Can leave with Symbian error code

        */

        IMPORT_C static CTRTranscoder* NewL(MTRTranscoderObserver& aObserver);

        /**

        * Destructor.

        */

        virtual ~CTRTranscoder();

    public:

        /**

        * Open the transcoder. Instantiates other submodules based on the selected operational mode. 

        * @param aMediaSink MCMRMediaSink for encoded data output

        * @param aMode Mode for the transcoder, operation to perform

        * @param aMimeTypeInputFormat  Mime type for input format

        * @param aMimeTypeOutputFormat Mime type for otput format

        * @param aRealTimeProcessing Specifies how to process data. ETrue - Real-time processing; EFalse - non-real time. 

        * If the processing cannot be performed in real-time, the transcoder process data as fast as it can. 

        * @return void. Can leave (KErrNotSupported - selected operation or codecs are not supported, 

        * @ or any other Symbian error code )

        */

        virtual void OpenL( MCMRMediaSink* aMediaSink, 

                            CTRTranscoder::TTROperationalMode aMode, 

                            const TDesC8& aInputMimeType, 

                            const TDesC8& aOutputMimeType, 

                            const TTRVideoFormat& aVideoInputFormat, 

                            const TTRVideoFormat& aVideoOutputFormat, 

                            TBool aRealTime ) = 0;

        // Information methods

        /**

        * 

        * @param

        * @return

        */

        virtual TBool SupportsInputVideoFormat(const TDesC8& aMimeType) = 0;

        /**

        * 

        * @param

        * @return

        */

        virtual TBool SupportsOutputVideoFormat(const TDesC8& aMimeType) = 0;

        /**

        * Initializes the transcoder. Initializing completes asynchronously with MtroInitializeComplete observer callback.

        * @param none

        * @return void

        */

        virtual void InitializeL() = 0;

        /**

        * Starts transcoding. 

        * @param none

        * @return void. Can leave with Symbian error code in case of an error. 

        */

        virtual void StartL() = 0;

        /**

        * Stops transcoding synchronously. Use this method to stop data processing synchronously. In this case 

        * all active requests are cancelled and data that was not processed is returned to data owner immediately. 

        * @param none

        * @return void. Can leave with Symbian error code in case of an error. 

        */

        virtual void StopL() = 0;

        /**

        * Stops transcoding asynchronously. The transcoder use this signal to ensure that the remaining data gets processed, 

        * without waiting for new data. This method is mainly useful for file-to-file conversions and other non-realtime 

        * processing. 

        * @param none

        * @return void. Can leave with Symbian error code in case of an error. 

        */

        virtual void AsyncStopL() = 0;

        /**

        * Pauses transcoding.

        * @param 

        * @return void. Can leave with Symbian error code in case of an error. 

        */

        virtual void PauseL() = 0;

        /**

        * Resumes transcoding. 

        * @param 

        * @return void. Can leave with Symbian error code in case of an error. 

        */

        virtual void Resume() = 0;

        //  AA

        virtual void SetDecoderInitDataL(TPtrC8& aInitData) = 0;

        /**

        * Sets bit rate parameter for transcoded bitstream. Can be run-time setting

        * @param aBitRate Bitrate

        * @return void Can leave with KErrNotSupported

        */

        virtual void SetVideoBitRateL(TUint aBitRate) = 0;

        /**

        * Sets frame rate for decoded bitstream. Can be run-time setting. 

        * @param aFrameRate Frame rate

        * @return void Can leave with KErrNotSupported

        */

        virtual void SetFrameRateL(TReal aFrameRate) = 0;

        /**

        * Sets channel bit error rate. Can be run-time setting

        * @param aErrorRate Channel expected error rate.

        *        aErrorRate = 0.0     - low bit error rate or error is not expected

        *        aErrorRate = 0.00001 - medium bit error rate

        *        aErrorRate = 0.0001  - high bit error rate

        * @return void

        */

        virtual void SetChannelBitErrorRateL(TReal aErrorRate) = 0;

        /**

        * Sets misc video coding options

        * @param aOptions Coding options

        * @return void

        */

        virtual void SetVideoCodingOptionsL(TTRVideoCodingOptions& aOptions) = 0;

        /**

        * Makes a request to retrieve the intermediate content from the transcoder

        * @param aRetrieve: ETrue - retrieve; EFalse - don't retrieve.

        * @param aSize Requested picture size for intermediate decoded picture

        * @param aSink 

        * @return void Can leave with KErrNotSupported, if the intermediate picture size is not supported

        */

        //virtual void RetrieveIntermediateContentL(TSize& aSize, MTRVideoPictureSink* aSink) = 0;

        virtual void SetVideoPictureSinkOptionsL(TSize& aSize, MTRVideoPictureSink* aSink) = 0;

        /**

        * Makes a request to use direct screen access

        * @param aUseDSA Use Direct Screen Access (DSA). ETrue - use DSA; EFalse - don't use DSA. 

        * @param aOptions Display options, valid only if aUseDSA is set to ETrue

        * @return void Can leave with KErrNotSupported, the DSA is not supported. 

        */

        virtual void UseDirectScreenAccessL(TBool aUseDSA, CFbsScreenDevice& aScreenDevice, TTRDisplayOptions& aOptions) = 0;

        /**

        * Gets the current output bit rate for transcoded bit stream

        * @param none

        * @return TUint Bit rate

        */

        virtual TUint GetVideoBitRateL() = 0;

        /**

        * Gets the current frame rate for transcoded stream

        * @param none

        * @return TReal Framerate

        */

        virtual TReal GetFrameRateL() = 0;

        /**

        * Retrieve currently used codec for transcoding stream

        * @param aVideoMimeType video mime type

        * @return void

        */

        virtual void GetVideoCodecL(TDes8& aVideoMimeType) = 0;

        /**

        * Get transcoded picture size

        * @param aSize Picture size

        * @return void

        */

        virtual void GetTranscodedPictureSizeL(TSize& aSize) = 0;

        // Data transfer methods

        /**

        * Sends filled buffer with new portion of the bitstream to transcoder. Note, this is asynchronous operation, 

        * and this bufer is returned back with Transcoder Observer call MtroReturnCodedBuffer(aBuffer); 

        * @param aBuffer Media buffer. It is not allowed to use this buffer on the client side until it is returned back 

        * from the transcoder with MtroReturnCodedBuffer(aBuffer).

        * @return void 

        */

        virtual void WriteCodedBufferL(CCMRMediaBuffer* aBuffer) = 0;

        /**

        * Sends video picture to transcoder / releases decoded picture (Decode mode)

        * @param aPicture Video picture

        * @return void

        */

        virtual void SendPictureToTranscoderL(TTRVideoPicture* aPicture) = 0;

        /**

        * Resample picture in Resampling only mode. The client should specify souce picture and buffer for target 

        * resampled picture

        * @param aSrc Source picture

        * @param aTrg Target picture

        * @return void

        */

        virtual void ResampleL(TPtr8& aSrc, TPtr8& aTrg) = 0;

        // Video Editor specific API:

        /**

        * Gets coding-standard specific initialization output. The buffer is pushed to the cleanup stack, 

        * and the caller is responsible for deallocating it. 

        * @param none

        * @return HBufC8 Coding options (VOL header)

        */

        virtual HBufC8* GetCodingStandardSpecificInitOutputLC() = 0;

        /**

        * Enables / Disables use of picture sink; Note: This method is relevant only for full transcoding use cases;

        * This cnage is applied for the next written coded buffer with WriteCodedBufferL

        * @param aEnable ETrue: Picture sink is enabled; EFalse: Picture sink is disabled

        * @return none

        */

        virtual void EnablePictureSink(TBool aEnable) = 0;

        /**

        * Enable / Disable use of Encoder; Note: This method is relevant only for full transcoding use cases;

        * By default encoding is always enabled in FullTranscoding mode

        * This cnage is applied for the next written coded buffer with WriteCodedBufferL

        * @param aEnable ETue: Encoder is enabled; EFalse: Encoder is disabled

        * @return none

        */

        virtual void EnableEncoder(TBool aEnable) = 0;

        /**

        * Requests random access point to the following transcoded picture

        * This change is applied for the next written coded buffer with WriteCodedBufferL

        * @param none

        * @return none

        */

        virtual void SetRandomAccessPoint() = 0;

        /**

        * Returns a time estimate of how long it takes to process one second of the input video with the

        * current transcoder settings. OpenL must be called before calling this function. Estimate

        * will be more accurate if InitializeL is called before calling this function.

        * @param aInput Input video format

        * @param aOutput Output video format

        * @return TReal Time estimate in seconds

        */

        virtual TReal EstimateTranscodeTimeFactorL(const TTRVideoFormat& aInput, const TTRVideoFormat& aOutput) = 0;

        /**

        * Get max number of frames in processing.

        * This is just a recommendation, not a hard limit.

        * @return TInt Number of frames

        */

        virtual TInt GetMaxFramesInProcessing() = 0;

        /**

        * Enable / Disable pausing of transcoding if resources are lost. If enabled transcoder

        * will notify the observer about resource losses by calling MtroSuspend / MtroResume

        * @param aEnable ETrue: Pausing is enabled

        *                EFalse: Pausing is disabled and resource losses will cause a fatal error

        * @return none

        */

        virtual void EnablePausing(TBool aEnable) = 0;

    };

#endif