diff -r 000000000000 -r ed9695c8bcbe vtprotocols/inc/mvtprotocolhandler.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/vtprotocols/inc/mvtprotocolhandler.h Mon Nov 23 14:47:47 2009 +0200 @@ -0,0 +1,1131 @@ +/* +* 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 +#include +#include +#include + +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 + { + EVtUiiDTFM, + 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& 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& 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 + * + * @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 not a reference buffer + * . + * @return The created buffer + */ + virtual CMMFBuffer* CreateSourceBufferL( + TMediaId aMediaId, + CMMFBuffer& aSinkBuffer, + TBool &aReference ) {return NULL;} + + /** + * Method to 'logon' the data source to the same thread that source will be supplying data in. + * + * This method may be required as the thread that the data source 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 SourceThreadLogon rather than in the creation + * of the data source. + * + * This is a virtual function that a derrived data source can implement if any thread specific + * initialisation is required and/or the data source 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 SourceThreadLogon as opposed to say the constructor. + * + * + * @return KErrNone if successful, otherwise a system wide error code. + */ + virtual TInt SourceThreadLogon( MAsyncEventHandler& aEventHandler ) {return KErrNone;} + + /** + * Method to 'logoff' the data source from the same thread that source supplies data in. + * + * This method may be required as the thread that the data source 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 SourceThreadLogoff rather than in the destructor + * + * This is a virtual function that a derrived data source can implement if any thread specific + * releasing of resources is required. + */ + virtual void SourceThreadLogoff() {} + + /** + * Method to 'prime' the data source + * + * This is a virtual function that a derrived data source can implement if + * any data source specific 'priming' is required + */ + virtual TInt SourcePrimeL() {return 0;} + + /** + * Method to 'play' the data source + * + * This is a virtual function that a derrived data source can implement if + * any data source specific action is required prior to 'playing'ie the start of data transfer + */ + virtual TInt SourcePlayL() {return 0;} + + /** + * Method to 'pause' the data source + * + * This is a virtual function that a derrived data source can implement if + * any data source specific action is required to 'pause' + */ + virtual TInt SourcePauseL() {return 0;} + + /** + * Method to 'stop' the data source + * + * This is a virtual function that a derrived data source can implement if + * any data source specific action is required to 'stop' + */ + virtual TInt SourceStopL() {return 0;} + private: + TUid iDataSourceType; + }; + +class MCommServer + { + }; + +class MVtProtocolCommand + { + public: + enum TVtProtocolState + { + EIdle, + EInitializing, + ESetup, + EConnecting, + EConnected, + EDisconnecting, + EResetting + }; + }; + +class MVtProtocolHandler + { + public: + + /** + * Handle an event that has been generated. + * + * @param "aResponse" "The response to a previously issued command." + */ + virtual void HandleSessionCommandEventL(const TVtCommandResponse& aResponse) = 0; + + /** + * Handle an informational event that has been generated. + * + * @param "aEvent" "The event to be handled." + */ + virtual void HandleSessionInformationalEventL(const TVtIndicationEvent& aEvent) = 0; + + /** + * Handle an error event that has been generated. + * + * @param "aEvent" "The event to be handled." + */ + virtual void HandleSessionErrorEventL(const TVtErrorEvent& aEvent) = 0; + + /** + * Signals completion of the audio output control command. + * @param aId The command id of the completed command. + * @param aCmd The command type. + * @param aContextData The context data passed in with the command. + * @param aStatus The command completion status. + **/ + virtual void HandleAudioOutputControlCommandComplete(TInt aId, TVtAudioOutputControlCommand aCmd, TAny *aContextData ,TInt aStatus) = 0; + /** + * Handle an event that has been generated. + * + * @param "aResponse" "The response to a previously issued command." + */ + virtual void HandleVideoEncoderCommandCompletedL(const TVtCommandResponse& aResponse) = 0; + + /** + * Handle an event that has been generated. + * + * @param "aEvent" "The event to be handled." + */ + virtual void HandleVideoEncoderInformationalEventL(const TVtIndicationEvent& aEvent) = 0; + + /** + * Handle an event that has been generated. + * + * @param "aResponse" "The response to a previously issued command." + */ + virtual void HandleH324MConfigCommandCompletedL(const TVtCommandResponse& aResponse) = 0; + + /** + * Handle an event that has been generated. + * + * @param "aEvent" "The event to be handled." + */ + virtual void HandleH324MConfigInformationalEventL(const TVtIndicationEvent& aEvent) = 0; + virtual ~MVtProtocolHandler() {} + }; + + +class MVtSessionCommand : public MVtProtocolCommand + { + public: + /** + * This function is valid only in the EIdle state. It is a no-op when + * invoked in any other state. It causes the protocol to transition + * to the ESetup state. The terminal remains in the EInitializing state during + * the transition. + * + * + * @param aInitInfo + * A reference to a TVtInitInfo structure which set Mona on and off + * + * @leave This method can leave with one of the following error codes + * KErrNoMemory if the SDK failed to allocate memory during this operation + * @returns A unique command id for asynchronous completion + **/ + virtual TInt InitProtocolL(TVtInitInfo& aInitInfo) = 0; + + /** + * For an incoming track (MVTVideoSink) this function pauses sending + * media to the sink (output device) and stops the sink. It then does the protocol + * negotiations with the remote terminal to pause the logical channel for + * the specified track. + * + * For outgoing, it pauses the sending of media from the source and calls Stop() on the + * source. It also performs any necessary protocol negotiations with the remote terminal. + * EVtCommandPause will be sent to the observer when the processing completes. + * + * @returns A unique command id for asynchronous completion + **/ + virtual TInt PauseVideoL(MVTVideoSource& aDataSource) = 0; + virtual TInt PauseVideoL(MVTVideoSink& aDataSink) = 0; + virtual TInt PauseAudioL(MVTAudioSource& aAudioSource) = 0; + + /** + * Resume a previously paused incoming or outgoing track. For incoming, + * this function starts resumes playing out the media to the appropriate + * sink based on the current settings. For outgoing it resumes encoding + * and sending media from the source. + * EVtCommandResume will be invoked will be invoked on the observer when the processing completes. + * + * @returns A unique command id for asynchronous completion + **/ + virtual TInt ResumeVideoL(MVTVideoSource& aDataSource) = 0; + virtual TInt ResumeVideoL(MVTVideoSink& aDataSink) = 0; + virtual TInt ResumeAudioL(MVTAudioSource& aAudioSource) = 0; + + /** + * This function is valid only in the ESetup and EInitializing state. It is a + * no-op when invoked in the EIdle state + * + * It causes the protocol to transition back to the EIdle state. The + * terminal remains in the EResetting state during the transition. + * + * While resetting, the protocol de-allocates all resources resources that + * had been previously allocated. When it completes, ResetComplete is called + * and the protocol reverts to the EIdle state. + * + * @leave This method can leave with one of the following error codes + * KErrNoMemory if the SDK failed to allocate memory during this operation + * @returns A unique command id for asynchronous completion + **/ + virtual TInt ResetProtocolL() = 0; + + /** + * This function can be invoked only in the ESetup state. The terminal starts connecting with the remote + * terminal based on the specified options and capabilities. + * The EVtCommandConnect command completion event will be passed to the observer + * when connect completes. + * Details about the negotiated session may be obtained by calling the GetSessionParamsL API. + * GetSessionParamsL may be called after call setup is started to get the list of available channels + * and their capabilities. + * Incoming tracks may be opened before ConnectL completes and will be indicated via the + * EVtIndicationIncommingTrack event. + * + * @param aComm + * An optional pointer to a comm server to provide comm source and sink end-points. + * @returns A unique command id for asynchronous completion + **/ + virtual TInt ConnectToProtocolL(MCommServer* aComm) = 0; + + /** + * Allows an application to provide a media source to be associated with a logical channel + * of communication with the peer. Sources should be added after the EVtIndicationOutgoingTrack + * indication is received for a newly established logical channel. The media type and + * channel id associated with the logical channel are specified as part of the indication. + * This function accepts a MVtVideoSource which provides additional functionality + * for advertizing capability and exposing configuration APIs. + * Data sources could be of the following types: + * a)raw media sources like camera, microphone etc. + * b)sources of compressed data like file, gateway component etc. + * + * @param aChannelId + * Indicates the channel id to be associated with this source. + * @param aDataSource + * reference to the data source + * @leave This method can leave with one of the following error codes + * KErrNotSupported if the format of the sources/sinks is incomtible with what the SDK can handle + * KErrNoMemory if the SDK failed to allocate memory during this operation + * @return A unique command id for asynchronous completion + */ + virtual TInt AddVideoSourceL(const TUint aChannelId, MVTVideoSource &aDataSource) = 0; + virtual TInt AddAudioSourceL(const TUint aChannelId, MVTAudioSource &aDataSource) = 0; + + /** + * Allows an application to provide a media sink for rendering an incoming media bitstream in a + * logical channel of communication with the peer. + * AddDataSinkL can be called only for established incoming logical channels identified by a unique + * channel id. + * Regular incoming channels are established by the peer and are + * indicated using the EVtIndicationIncomingTrack indication. + * This function takes in PV extension to MVtVideoSink or MVtAudioSink which provides additional functionality + * for advertizing capability and exposing configuration APIs. + * EVtCommandAddDataSink event is sent to the observer on completion of this call. + * + * @param aChannelId + * Indicates the channel id to be associated with this sink. + * @param aDataSink The data sink to be added + * + * @return A unique command id for asynchronous completion + **/ + virtual TInt AddVideoSinkL(const TUint aChannelId, MVTVideoSink &aDataSink) = 0; + virtual TInt AddAudioSinkL(const TUint aChannelId, MVTAudioSink &aDataSink) = 0; + + /** + * This API is to allow the user to cancel all pending requests. The current request being + * processed, if any, will also be aborted. + * EVtCommandCancelAllCommands will be passed to the command observer on completion. + * @returns A unique command id for asynchronous completion + **/ + virtual TInt CancelAllCommandsL( ) = 0; + + /** + * The Disconnect call is valid only when invoked in the EConnecting, and + * EConnected states. It causes the terminal to transition to the + * EDisconnecting state. All the media tracks both incoming and outgoing + * will be closed on invoking Disconnect. On completion, the terminal + * goes to the ESetup state. + * + * It is a no-op when called in any other state. + * + * This is an asynchronous request. The EvtCommandDisconnect event will be + * sent to the observer when the request processing is complete. This + * is the only event the Phone application should expect after calling + * Disconnect. + * + * @returns A unique command id for asynchronous completion + **/ + virtual TInt DisconnectFromProtocolL() = 0; + + /** + * This API is to allow for extensibility of the protocol interface. + * It allows a caller to ask for an instance of a particular interface object to be returned. + * The mechanism is analogous to the COM IUnknown method. The interfaces are identified with + * an interface ID that is a UUID as in DCE and a pointer to the interface object is + * returned if it is supported. Otherwise the returned pointer is NULL. + * @param aType + * @param aProtocolCommand + * @exception not_supported + * leaves if the specified interface id is not supported. + **/ + virtual TInt GetProtocolInterfaceL(TVtConfigType aType, MVtProtocolCommand*& aProtocolCommand) = 0; + + /** + * This APIis to be used to release an interface that was previously obtained using + * QueryInterfaceL. + * @param aType + * @param + * @exception not_supported + * leaves if the specified interface id is not supported. + **/ + virtual TInt DeleteProtocolInterfaceL(TVtConfigType aType, MVtProtocolCommand*) = 0; + + /** + * Destructor. + */ + virtual ~MVtSessionCommand() {} + }; + +class MVTUserInput + { + public: + + /** + * @returns Returns the user input type. + **/ + virtual TUserInputType GetType() = 0; + virtual ~MVTUserInput() {} + }; + +class MVtH324ConfigCommand : public MVtProtocolCommand + { + public: + + /** + * This API allows the user to specify observers for the 324m interface. + * + * @param aHandler the observer for command status and unsolicited informational events + **/ + virtual void SetObserverL(MVtProtocolHandler* aHandler) = 0; + + /** + * Sets the vendor identification data. This does not cause the stack to issue a vendor identifiation request. + * Set to NULL to disable sending vendor id. If set to a valid parameter before Connect, it will cause the stack + * to automatically send it along with the TCS message. + * @param cc + * T35 Country code + * @param ext + * T35 Extension + * @param mc + * T35 Manufacturer code + * @param aProduct + * Product number + * @param aVersion + * Version number + **/ + virtual TInt SetVendorId(TUint8 cc, TUint8 ext, TUint32 mc, const TDesC8* aProduct, const TDesC8* aVersion) = 0; + /** + * This API allows the user to send a videoTemporalSpatialTradeOff command to the peer. + * It is a request to the remote encoder to adjust its encoding in accordance with the tradeoff value. + * A value of 0 indicates a high spatial resolution and a value of 31 indicates a high frame rate. + * The values from 0 to 31 indicate monotonically a higher frame rate. Actual values do not correspond + * to precise values of spatial resolution or frame rate. + * + **/ + virtual TInt SendVideoTemporalSpatialTradeoffCommand(TUint aLogicalChannel, TUint8 aTradeoff)=0; + + /** + * This API allows the user to send a videoTemporalSpatialTradeOff command to the peer. + * It is an indication to the remote decoder that the local encoder has adjusted its encoding parameters + * according to the tradeoff value. + * A value of 0 indicates a high spatial resolution and a value of 31 indicates a high frame rate. + * The values from 0 to 31 indicate monotonically a higher frame rate. Actual values do not correspond + * to precise values of spatial resolution or frame rate. + * + **/ + virtual TInt SendVideoTemporalSpatialTradeoffIndication(TUint aLogicalChannel, TUint8 aTradeoff)=0; + + /** + * This API allows the user to specify the supported resolutions for video for transmit and receive. + * + **/ + virtual TInt SetSupportedResolutions( ) = 0; + + /** + * This API allows the user to set options for fast call setup procedures + **/ + + virtual TInt SetFastCsupOptions( ) = 0; + + /** + * Causes the protocol to send the specified user input to the remote terminal using + * control channel. The user input can be either DTMF ot Alphanumeric + * @param user_input A pointer to MVTUserInput + * @returns A unique command id for asynchronous completion + **/ + virtual TInt SendUserInputMessageL(MVTUserInput& user_input) = 0; + }; + +class MVtVideoConfigCommand : public MVtProtocolCommand + { + public: + + /** + * This API allows the user to specify separate observers for the extension interface. + * + * @param aHandler the observer for unsolicited informational events + **/ + virtual void SetObserverL(MVtProtocolHandler* aHandler) = 0; + + /** + * Sets the I-Frame refresh rate of the encoded output. + * + * @param aIFrameInterval I-Frame rate in seconds per I-Frame + * @return True if successful, else false + */ + virtual TInt SetIntraFrameInterval(TUint32 aIFrameInterval) = 0; + + /** + * Requests the encoder to encode the next frame as an I-Frame. If successful, the next encoded + * frame will be an I-Frame. + * + * @return True for success, else false + */ + virtual TInt RequestNextIntraFrame() = 0; + + /** + * Sets the frame rate of encoded output for the specified layer. + * @param aFrameRate Frame rate for the specified layer in frames per second. + * @return True if successful, else false. + */ + virtual TInt SetVideoFrameRate(TUint32 aFrameRate) = 0; + }; + +class MVtAudioConfigCommand : public MVtProtocolCommand + { + public: + + /** + * This API allows the user to specify observers for the 324m interface. + * + * @param aHandler + **/ + virtual void SetObserverL(MVtProtocolHandler* aHandler) = 0; + + /** + * Method to set the playback volume to the specified value. + * + * This is a pure virtual function that each derived class must implement. + * It is also an asynchronous function which will be answered with a callback. + * + * @param aNewVolume + * An input parameter to hold the value for the requested playback volume. + * + * @returns Returns a command ID that can be used to identify a command completion result with corresponding request. + */ + virtual TInt SetAudioVolumeL(TInt aVolume) = 0; + + /** + * Method to get the maximum valid value for the playback volume. + * + * This is a pure virtual function that each derived class must implement. + * It is also an asynchronous function which will be answered with a callback. + * + * @param aMaxVolume + * An output parameter to hold the value for the maximum valid playback volume. + * Note that the parameter should not be used until the callback indicates that the + * method has completed. + * + * @returns Returns a command ID that can be used to identify a command completion result with corresponding request. + */ + virtual TInt GetMaxAudioVolumeL(TInt& aMaxVolume) = 0; + }; + +class VTProtocolFactory + { + public: + + /** + * Create one instance. + */ + IMPORT_C static MVtSessionCommand* CreateSessionCommandL(MVtProtocolHandler* aProtocolHandler, TBool aEnableProxy, TVt3G324MSupported& a3G324MSupported); + + /** + * This function allows the application to delete an instance of a terminal + * and reclaim all allocated resources. A terminal should be deleted only in + * the EIdle state. An attempt to delete a terminal in any other state will + * result in unpredictable behavior. + * + * @param terminal the terminal to be deleted. + * + **/ + IMPORT_C static void DeleteSessionCommand( MVtSessionCommand* aSessionCommand ); + + /** + * Creates an instance of a DevSound audio data source. + * + * @param None + * + * @returns A pointer to the interface + **/ + IMPORT_C static MVTAudioSource* CreateAudioSource(); + + /** + * Deletes an instance of a DevSound audio data source + * that was previously created with CreateAudioSource(); + * + * @param aSource The audio data source to be deleted. + * + * @returns status + **/ + IMPORT_C static TInt DeletAudioSource(MVTAudioSource *aSource); + + /** + * Creates an instance of a DevSound audio data sink. + * + * @param None + * + * @returns A pointer to the interface + **/ + IMPORT_C static MVTAudioSink* CreateAudioSink(); + + /** + * Deletes an instance of a DevSound audio data sink + * that was previously created with CreateAudioSink(); + * + * @param The audio data sink to be deleted. + * + * @returns status + **/ + IMPORT_C static TInt DeleteAudioSink(MVTAudioSink *aSink); + + /** + * Creates an instance of a comm server of a particular name, to be used to + * initialize the terminal. + * + * + * @returns A pointer to a terminal or leaves if the type is invalid or the system is out of resources + **/ + IMPORT_C static MCommServer* CreateCommServerL(const TDesC & aName, TBool aEnableBitReversal=EFalse); + + /** + * This function allows the application to delete an instance of a comm server + * and reclaim all allocated resources. A comm server should be deleted only when the + * protocol is in the EIdle state. An attempt to delete a comm server in any other state + * could result in memory corruption within the protocol. This function will leave with + * KErrInUse if the comm server is still in use. However it will not check the state of the + * protocol that is using the comm server. + * + * @param aCommServer the comm server to be deleted. + * + * @returns a status code indicating success or failure + **/ + IMPORT_C static void DeleteCommServerL(MCommServer* aCommServer); + + /** + * Create instance. + * @param aUIITyep + * @param aTone + */ + IMPORT_C static MVTUserInput* CreateUserInputIndication(TUserInputType aUIIType, TUint8 aTone); + + /** + * Delete instance. + * @param aUII + */ + IMPORT_C static void DeleteUserInputIndication(MVTUserInput* aUII); + + /** + * + * @param aAudioSink + */ + IMPORT_C static MVtAudioConfigCommand* GetAudioConfigCommandL(MVTAudioSink* aAudioSink); + }; + +#endif +// End of File + \ No newline at end of file