--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/vtprotocolsstub/inc/mvtprotocolhandler.h Mon Nov 23 14:47:47 2009 +0200
@@ -0,0 +1,1124 @@
+/*
+* Copyright (c) 2008 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: Video Telephony Protocol interface
+*
+*/
+
+#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(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<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
+ *
+ * @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