/*

* Copyright (c) 2004-2006 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:

*

* Description:  

*

*/

#ifndef MVTENGMEDIAHANDLER_H

#define MVTENGMEDIAHANDLER_H

//  INCLUDES

#include <e32base.h>

#include <mmfdatabuffer.h>

#include <mmfutilities.h>

#include <mmfcontrollerframework.h>

typedef TInt TVtCommandId;                   

typedef TInt TVtCommandStatus;               

typedef TDesC8 TVtMIMEType;

const TUid KVTUidYUVFrameBuffer = {0xFFFFFF0d};

const TInt KVtUidDataSrcPrime	= 0xFFFFFF08;

const TInt KVtUidDataSrcPlay	= 0xFFFFFF09;

const TInt KVtUidDataSrcPause	= 0xFFFFFF0A;

const TInt KVtUidDataSrcStop	= 0xFFFFFF0B;

_LIT8(KVtVideoMIMETypeH263, "/video/x-pv/compressed/h263");

_LIT8(KVtVideoMIMETypeM4V, "/video/x-pv/compressed/m4v");

_LIT8(KVtVideoMIMETypeH264, "/video/x-pv/compressed/h264");

_LIT8(KVtAudioMIMETypeAMRIF2, "/audio/x-pv/compressed/amr/if2");

_LIT8(KVtAudioMIMETypeAMRWBIF2, "/audio/x-pv/compressed/amrwb/if2");

_LIT8(KVtVideoMIMETypeYUV420, "/video/x-pv/raw/yuv420");

enum TVt3G324MSupported

    {

    EVt3G324MMissing,

    EVt3G324MSupported

    }; 

enum TVtConfigType

    {

    EVtH324Config,

    EVtVideoEncoderConfig

    };

enum TVtCommandType {

    EVtCommandInit,

    EVtCommandGetSDKInfo,

    EVtCommandGetProtocolState = 3,

    EVtCommandReset,

    EVtCommandAddDataSource = 6,

    EVtCommandRemoveDataSource,

    EVtCommandAddDataSink,

    EVtCommandRemoveDataSink,

    EVtCommandConnect,

    EVtCommandDisconnect,

    EVtCommandPause,

    EVtCommandResume,

    EVtCommandGetProtocolInterface =20,

    EVtCommandDeleteProtocolInterface,

    EVtCommandCancelAllCommands

    };

enum TVtIndicationType 

    {

    EVtIndicationVideoSpatialTamporalTradeOffCommand,

    EVtIndicationVideoSpatialTamporalTradeOffIndication,

    EVtIndicationUserInputCapability = 6,

    EVtIndicationIncomingTrack = 41,

    EVtIndicationOutgoingTrack,

    EVtIndicationDisconnect,

    EVtIndicationClosingTrack,

    EVtIndicationCloseTrack,

    EVtIndicationPauseTrack,

    EVtIndicationResumeTrack    

    };

enum TVtMediaType      

    {

    EVtAudio = 1,

    EVtVideo,

    EVtControl,

    EVtData,

    EVtUserInput,

    EVtMediaNone

    };

enum TVtAudioOutputControlCommand   

    {

	  EVtAudioOutputControlGetMaxVolume,

	  EVtAudioOutputControlGetVolume,

	  EVtAudioOutputControlSetVolume,

	  EVtAudioOutputControlGetBalance,

	  EVtAudioOutputControlSetBalance

	  };    

const TUint8 EVtIncoming = 1;

enum TUserInputType

    {

    EVtUiiAlphaNumeric

    };

struct TVtInitInfo

    {

    TBool iAMRWBOn;

    TBool iDisableMpeg4;

    };

struct TVtIndicationEvent

    {

    public:    

        /**

         * Constructor.

         */

        TVtIndicationEvent(TInt aEventType, const TUint8 *aLocalBuffer) : iEventType(aEventType), iLocalBuffer(aLocalBuffer) 

        {}

    public:

        TInt iEventType;

        const TUint8 *iLocalBuffer;

    };

struct TVtCommandResponse

    {

    public:        

        /**

         * Constructor.

         */

        TVtCommandResponse(TVtCommandType aCmdType, TInt aCmdId, TInt iCmdStatus) : iCmdType(aCmdType), iCmdId(aCmdId), iCmdStatus(iCmdStatus)

        {}

    public:

        TVtCommandType iCmdType;

        TInt iCmdId;

        TInt iCmdStatus;

    };

struct TVtErrorEvent

    {

    public:

        /**

         * Constructor.

         */

        TVtErrorEvent(TInt aEventType) : iEventType(aEventType) {}

    public:

        TInt iEventType;

    };

struct TVtMMFDataBuffer

    {

    public:

        /**

         * Constructor.

         */

        TVtMMFDataBuffer(CMMFBuffer* aMmfBuffer,TSize  aFrameSize, TPtr8& aPtr) : iMmfBuffer(aMmfBuffer), iFrameSize(aFrameSize), iPtr(aPtr) {}

        /**

         * Get the YUV frame size.

         * @return The frame size, in pixels

         */

        TSize GetFrameSize() {return iFrameSize;}

        /**

         * Get MMF buffer.

         * @return the MMF buffer

         */

        CMMFBuffer* GetMMFBuffer() {return iMmfBuffer;}

        /**

         * Get MMF buffer.

         * @return the MMF buffer

         */

        const CMMFBuffer* GetMMFBuffer() const {return iMmfBuffer;}

        /**

        *  @return Returns a reference to the data buffer

        **/

        TPtr8& Data() {return iPtr;}

        /**

        *  @return Returns the frame size of the contained buffer.

        **/

        const TSize GetFrameSize() const {return iFrameSize;}

        /**

        *  @return Returns a reference to the data buffer

        **/

        const TPtr8& Data() const {return iPtr;}

    private:

        CMMFBuffer* iMmfBuffer;

        TSize  iFrameSize;

        TPtr8&  iPtr;

    };

class MVTVideoInput

    {

    public:

        /**

         * Set the video frame format.  This must be from the list of supported formats.

         * @param "aFormat" The mime string describing the video frame format.

         * @exception Can leave with one of the system wide error codes

         */

        virtual void SetFormatL(const TDesC8& aFormat) {}

        /**

         * Set the video frame rate.  This must be within the range of supported frame rates

         * for the current frame size.

         * @param "aFrameRate" The video frame rate to set.

         * @exception Can leave with one of the system wide error codes

         */

        virtual void SetFrameRateL(TReal32 aFrameRate) {}

        /**

         * Set the video frame size

         * @param "aSize" The video frame size, in pixels

         * @exception Can leave with one of the system wide error codes

         */

        virtual void SetVideoFrameSizeL(const TSize& aSize) {}

        /**

         * Get the video frame size

         * @param "aSize" The video frame size, in pixels

         * @exception Can leave with one of the system wide error codes

         */

        virtual void GetVideoFrameSizeL(TSize& aSize) const {}

        /**

         * This API returns multimedias type supported by the data source/sink - 

         * Audio, Video, Data etc.  Each supported type is indicated by a MIME type structure.

         * @return 

         **/

        virtual const RArray<TDesC8* >& GetMultimediaTypesL() const {}

    };

class MVTVideoOutput

    {

    public:

        /**

        *  Sets the data format using MIME string.

        *  @param aFormat The format as a MIME string.

        **/

        virtual void SetFormatL(const TDesC8& aFormat) {}

        /**

         * Set the video frame size

         * @param "aSize" The video frame size, in pixels

         * @exception Can leave with one of the system wide error codes

         **/

        virtual void SetVideoFrameSizeL(const TSize& aSize) {}

        /**

         * Get the video frame size

         * @param "aSize" The video frame size, in pixels

         * @exception Can leave with one of the system wide error codes

         **/

        virtual void GetVideoFrameSizeL(TSize& aSize) const {}

        /**

         * This API returns multimedias type supported by the data source/sink - 

         * Audio, Video, Data etc.  Each supported type is indicated by a MIME type structure.

         * @return 

         **/

        virtual const RArray<TDesC8* >& GetMultimediaTypesL() const {}

    };

//This class is empty

class MVTAudioSource

    {

    };

//This class is empty

class MVTAudioSink

    {

    };

class MVTVideoSource;

class MVTVideoSink : public MVTVideoOutput

    {

    public:

        /**

         * Constructor.

         */

        MVTVideoSink(TUid aType): iDataSinkType(aType) {}

        /**

         * Method called by a data source to request the data sink to empty aBuffer of data.

         *

         * This is a pure virtual function that each derived class must implement.

         * This method is used when a data sink is passively waiting for requests from a supplier ie a data source

         * to empty a buffer.  The data sink must call the BufferEmptiedL member on aSupplier when it has emptied

         * the buffer of it's data - the data sink can either make this callback synchronously or asynchronously.

         * 

         * @param   "aBuffer"

         *          The full buffer that needs emptying of it's data

         *

         * @param   "aSupplier" 

         *          The data source that supplied the data. The data sink needs this to make the BufferEmptiedL

         *          callback on aSupplier to indicate to the data source that the data sink has finished with the buffer.

         *

         * @param   "aMediaId"

         *          This identifies the type of media eg audio or video and the stream id.

         *          This parameter is required in cases where the source can supply data

         *          of more than one media type and/or multiple strams of data

         */

        virtual void EmptyBufferL(

            TVtMMFDataBuffer aDataBuffer,

            MVTVideoSource* aSupplier,

            TMediaId aMediaId ) {}

        /**

         * Method called by a data source to pass back an filled buffer to the sink

         *

         * This is a pure virtual function that each derived class must implement.

         * This method is used as the callback when the data sink actively requests a supplier ie a data source

         * to fill a buffer by calling the data sources FillBufferL.

         * When the data sink gets this callback it knows that the buffer has been filled and is ready to be emptied

         * 

         * @param   "aBuffer"

         *          The buffer that has been filled by a data source and is now available for processing

         */

         virtual void BufferFilledL( CMMFBuffer* aBuffer ) = 0;

        /**

         * Method to indicate whether the data sink can create a buffer.

         *

         * This is a pure virtual function that each derived class must implement.

         * 

         * @return  ETrue if the data sink can create a buffer else EFalse

         */

        virtual TBool CanCreateSinkBuffer() {return EFalse;}

        /**

         * Returns a buffer created by the data sink

         *

         * This is a pure virtual function that each derived class must implement.

         *

         * @param   "aMediaId"

         *          This identifies the type of media eg audio or video and the stream id.

         *          This parameter is required in cases where the source can supply data

         *          of more than one media type and/or multiple strams of data.

         *

         * @param   "aReference"

         *          This must be written to by the method to indicate whether the created buffer is

         *          a 'reference' buffer.  A 'reference' buffer is a buffer that is owned by the sink

         *          and should be used in preference to the source buffer provided the source buffer

         *          is also not a reference buffer.

         * .  

         * @return  The created buffer

         */

        virtual CMMFBuffer* CreateSinkBufferL(

            TMediaId aMediaId,

            TBool &aReference ) {return NULL;}

        /**

         * Method to 'logon' the data sink to the same thread that sink will be consuming data in.

         *

         * This method may be required as the thread that the data sink was created in is not always

         * the same thread that the data transfer will take place in.  Therefore any thread specific

         * initialisation needs to be performed in the SinkThreadLogon rather than in the creation 

         * of the data sink.

         *

         * This is a virtual function that a derrived data sink can implement if any thread specific

         * initialisation is required and/or the data sink can create any asynchronous events.

         * 

         * 

         * @param   "aEventHandler"

         *          This is an MAsyncEventHandler to handle asynchronous events that occur during the

         *          transfer of multimedia data.  The event handler must be in the same thread as the data transfer

         *          thread - hence the reason it is passed in the SinkThreadLogon as opposed to say the constructor.

         *

         *

         * @return  KErrNone if successful, otherwise a system wide error code.

         */

        virtual TInt SinkThreadLogon( MAsyncEventHandler& aEventHandler ) {return KErrNone;}

        /**

         * Method to 'logoff' the data sink from the same thread that sink consumes data in.

         *

         * This method may be required as the thread that the data sink is deleted in may not be

         * the same thread that the data transfer took place in.  Therefore any thread specific

         * releasing of resources needs to be performed in the SinkThreadLogoff rather than in the destructor

         *

         * This is a virtual function that a derrived data sink can implement if any thread specific

         * releasing of resources is required.

         */

        virtual void SinkThreadLogoff() {}

        /**

         * Method to 'prime' the data sink

         *

         * This is a virtual function that a derrived data sink can implement if 

         * any data sink specific 'priming' is required

         */

        virtual TInt SinkPrimeL() {return 0;}

        /**

         * Method to 'play' the data sink

         *

         * This is a virtual function that a derrived data sink can implement if 

         * any data sink specific action is required prior to 'playing'ie the start of data transfer

         */

        virtual TInt SinkPlayL() {return 0;}

        /**

         * Method to 'pause' the data sink

         *

         * This is a virtual function that a derrived data sink can implement if 

         * any data sink specific action is required to 'pause'

         */

        virtual TInt SinkPauseL() {return 0;}

        /**

         * Method to 'stop' the data sink

         *

         * This is a virtual function that a derrived data sink can implement if 

         * any data sink specific action is required to 'stop'

         */

        virtual TInt SinkStopL() {return 0;}

    private:

        TUid iDataSinkType;

    };

class MVTVideoSource : public MVTVideoInput

    {

    public:

        /**

         * Constructor.

         */

    MVTVideoSource(TUid aType): iDataSourceType(aType) {}

        /**

         * Method called by a data sink to request the data source to fill aBuffer with data.

         *

         * This is a pure virtual function that each derived class must implement.

         * This method is used when a data source is passively waiting for requests from a consumer ie a data sink

         * to fill a buffer.  The data source must call the BufferFilledL member on aConsumer when it has filled

         * the buffer with data - the data source can either make this callback synchronously or asynchronously.

         * 

         * @param   "aBuffer"

         *          The buffer that needs filling with data

         *

         * @param   "aConsumer" 

         *          The data sink that consumes the data. The data source needs this to make the BufferFilledL

         *          callback on aConsumer when the data source has completed filling the aBuffer.

         *

         * @param   "aMediaId"

         *          This identifies the type of media eg audio or video and the stream id.

         *          This parameter is required in cases where the source can supply data

         *          of more than one media type and/or multiple strams of data eg a multimedia file

         */

    virtual void FillBufferL(

            CMMFBuffer* aBuffer,

            MVTVideoSink* aConsumer,

            TMediaId aMediaId ) {}

        /**

         * Method called by a data sink to pass back an emptied buffer to the source

         *

         * This is a pure virtual function that each derived class must implement.

         * This method is used as the callback when the data source actively requests a consumer ie a data sink

         * to empty a buffer by calling the data sinks EmptyBufferL.

         * When the data source gets this callback it knows that the buffer has been emptied and can be reused

         * 

         * @param   "aBuffer"

         *          The buffer that has been emptied by a data sink and is now available for reuse

         */

    virtual void BufferEmptiedL( CMMFBuffer* aBuffer ) = 0;

        /**

         * Method to indicate whether the data source can create a buffer.

         *

         * This is a pure virtual function that each derived class must implement.

         * 

         * @return  ETrue if the data source can create a buffer else EFalse

         */

    virtual TBool CanCreateSourceBuffer() {return EFalse;}

        /**

         * Returns a buffer created by the data source

         *

         * This is a pure virtual function that each derived class must implement.

         *

         * @param   "aMediaId"

         *          This identifies the type of media eg audio or video and the stream id.

         *          This parameter is required in cases where the source can supply data

         *          of more than one media type and/or multiple strams of data eg a multimedia file

         *

         * @param   "aReference"

         *          This must be written to by the method to indicate whether the created buffer is

         *          a 'reference' buffer.  A 'reference' buffer is a buffer that is owned by the source

         *          and should be used in preference to the sink buffer provided the sink buffer

         *          is also not a reference buffer

         * .  

         * @return  The created buffer

         */

    virtual CMMFBuffer* CreateSourceBufferL(

                TMediaId aMediaId,

                TBool &aReference ) {return NULL;}

        /**

         * Returns a buffer created by the data source

         *

         * This is a virtual function that a derived class can implement.

         * This can be used in preference to the above CreateSourceBufferL method in cases where

         * the source buffer creation has a dependancy on the sink buffer

         *

         * @param   "aMediaId"

         *          This identifies the type of media eg audio or video and the stream id.

         *          This parameter is required in cases where the source can supply data

         *          of more than one media type and/or multiple strams of data eg a multimedia file

         *

         * @param   "aSinkBuffer"

         *          The sink buffer the nature of which may influence the creation of the source buffer

         *