rvmdm.h

h.248协议源码

	}
	{notes:
		{note: 
			Call rvMdmTermGetUserData() to get the user data associated with term.
		}
	}
}
$*/
typedef RvBool (*RvMdmTermStartSignalCB)(struct RvMdmTerm_* term,RvMdmSignal * s,OUT RvMdmError* mdmError);

/*------------------------------------------------------------------------------*/
/*$
{callback:
	{name: RvMdmTermStopSignalCB}	
	{include: rvmdm.h}
	{description:
		{p: Called to stop a signal in a termination.}
	}
	{proto: RvBool (*RvMdmTermStopSignalCB)(RvMdmTerm* term,RvMdmSignal * s,OUT RvMdmError* mdmError);}
	{params:
		{param: {n:term} {d:The termination.}}
		{param: {n:s} {d:The signal.}}
		{param: {n:mdmError} {d:(Optional) Use to set error information.}}
	}
	{returns: 
		Return "rvFalse" if it fails. In this case mdmError can be set. If is not set, a default error value will be assigned.
	}
	{notes:
		{note: 
			Call rvMdmTermGetUserData() to get the user data associated with term.
		}
	}
}
$*/
typedef RvBool (*RvMdmTermStopSignalCB)(struct RvMdmTerm_* term,RvMdmSignal * s,OUT RvMdmError* mdmError);


/*------------------------------------------------------------------------------*/
/*$
{callback:
	{name: RvMdmTermPlaySignalCB}	
	{include: rvmdm.h}
	{description:
		{p: Called to play a signal on a termination. This signal is played to completion 
		    by the application and not stopped by the termination manager.}

	}
	{proto: RvBool (*RvMdmTermPlaySignalCB)(RvMdmTerm* term,RvMdmSignal * s,RvBool reportCompletion,
											 OUT RvMdmError* mdmError);}
	{params:
		{param: {n:term} {d:The termination.}}
		{param: {n:s} {d:The signal.}}
		{param: {n:reportCompletion} 
			{d:If rvTrue, the application must call rvMdmTermSignalCompleted when the signal ends.}}
		{param: {n:mdmError} {d:(Optional) Use to set error information.}}
	}
	{returns: 
		Return "rvFalse" if it fails. In this case mdmError can be set. If is not set, a default error value will be assigned.
	}
	{notes:
		{note: 
			Call rvMdmTermGetUserData() to get the user data associated with term.
		}
	}
}
$*/
typedef RvBool (*RvMdmTermPlaySignalCB)(struct RvMdmTerm_* term,RvMdmSignal * s,RvBool reportCompletion,
										 OUT RvMdmError* mdmError);
/*------------------------------------------------------------------------------*/
/*$
{callback:
	{name: RvMdmTermCreateMediaCB}	
	{include: rvmdm.h}
	{description:
		{p: Functions that follow this template are called to create a media stream on a 
		    termination with the appropiate media parameters}

	}
	{proto: typedef RvBool (*RvMdmTermCreateMediaCB)(RvMdmTerm* term,RvMdmMediaStream* media,
												INOUT RvMdmMediaStreamDescr* streamDescr,
												OUT RvMdmError* mdmError);
	}
	{params:
		{param: {n:term} {d:Termination.}}
		{param: {n:media} {d:Pointer to the new media object.}}
		{param: {n:streamDescr} {d:(Input/Output) Properties of the media.}}
		{param: {n:mdmError} {d:(Optional) Use to set error information.}}
	}
	{returns: 
		Return RvFalse if it fails. In this case mdmError can be set. 
		If is not set, a default error value will be assigned.
		In return streamDescr must contain only the selected values (The application must fill 
		underspecified values and choose from overspecified values).
		The application must call rvMdmMediaStreamDescrReportLocalDescr(), rvMdmMediaStreamDescrReportRemoteDescr(),
		and/or rvMdmMediaStreamDescrReportControlParameters() in the streamDescr to indicate which fields were
		modified and have to be reported back to the MGC.
	}
	{notes:
		{note:
			The function rvMdmMediaStreamSetUserData can be called to associate the
			media with user data.
		}
	}
}
$*/
typedef RvBool (*RvMdmTermCreateMediaCB)(struct RvMdmTerm_* term,RvMdmMediaStream* media,
												RvMdmMediaStreamDescr* streamDescr,
												OUT RvMdmError* mdmError);

/*------------------------------------------------------------------------------*/
/*$
{callback:
	{name: RvMdmTermDestroyMediaCB}	
	{include: rvmdm.h}
	{description:
		{p: Functions that follow this template are called to close a media stream 
		    on a termination and release resources.}

	}
	{proto: RvBool (*RvMdmTermDestroyMediaCB)(RvMdmTerm* term,RvMdmMediaStream* media,
											   OUT RvMdmError* mdmError);
	}
	{params:
		{param: {n:term} {d:Termination.}}
		{param: {n:mediaStream} {d:user identifier of the media.}}
		{param: {n:mdmError} {d:(Optional) Use to set error information.}}
	}
	{returns: 
		Return rvFalse of it fails. In this case mdmError can be set. 
		If is not set, a default error value will be assigned.
	}
	{notes:
		{note: 
			Call rvMdmMediaStreamGetUserData() to get the user data associated with media.
		}
	}
}
$*/
typedef RvBool (*RvMdmTermDestroyMediaCB)(struct RvMdmTerm_* term,RvMdmMediaStream* media,OUT RvMdmError* mdmError);
 
/*------------------------------------------------------------------------------*/
/*$
{callback:
	{name: RvMdmTermModifyMediaCB}	
	{include: rvmdm.h}
	{description:
		{p: Functions that follow this template are called to modify the characteristics
		    of a media stream on a termination.}

	}
	{proto: RvBool (*RvMdmTermModifyMediaCB)(RvMdmTerm* term,RvMdmMediaStream* media,
										 INOUT RvMdmMediaStreamDescr* streamDescr,RvMdmError* mediaError);
	}
	{params:
		{param: {n:term} {d:Termination.}}
		{param: {n:mediaStream} {d:user identifier of the media stream.}}
		{param: {n:streamDescr} {d:(Input/Output) Properties of the media stream.}}
		{param: {n:mediaError} {d:(Optional) Use to set error information.}}
	}
	{returns: 
		Return rvFalse of it fails. In this case mediaError can be set. 
		If is not set, a default error value will be assigned.
		In return streamDescr must contain only the selected values (The application must fill 
		underspecified values and choose from overspecified values).
		The application must call rvMdmMediaStreamDescrReportLocalDescr(), rvMdmMediaStreamDescrReportRemoteDescr(),
		and/or rvMdmMediaStreamDescrReportControlParameters() in the streamDescr to indicate which fields were
		modified and have to be reported back to the MGC.
	}
}
$*/
typedef RvBool (*RvMdmTermModifyMediaCB)(struct RvMdmTerm_* term,RvMdmMediaStream* media,
										 RvMdmMediaStreamDescr* streamDescr,RvMdmError* mediaError);
 
/*------------------------------------------------------------------------------*/
/*$
{callback:
	{name: RvMdmTermClearDetectEventCB}	
	{include: rvmdm.h}
	{description:
		{p: Notify the application that explicit events detection can be disabled. 
		    This applies to events when the detection was enabled by a call to 
			RvMdmEnableDetectEventCB.}
	}
	{proto: void (*RvMdmTermClearDetectEventCB)(struct RvMdmTerm_* term);}
	{params:
		{param: {n:term} {d:The termination.}}
	}
}
$*/
typedef void (*RvMdmTermClearDetectEventCB)(struct RvMdmTerm_* term);


/*------------------------------------------------------------------------------*/
/*$
{callback:
	{name: RvMdmTermMgrConnectCB}	
	{include: rvmdm.h}
	{description:
		{p: Called to connect a media stream in one termination to a media stream in another termination.
		}

	}
	{proto: RvBool (*RvMdmTermMgrConnectCB)(RvMdmTermMgr* mgr,RvMdmTerm* source,RvMdmMediaStream* m1,
										 RvMdmTerm* target,RvMdmMediaStream* m2,
										 RvMdmStreamDirection direction,OUT RvMdmError* mdmError);}
	{params:
		{param: {n:mgr} {d:The termination manager.}}
		{param: {n:source} {d:First termination.}}
		{param: {n:m1} {d:Media stream in first termination.}}
		{param: {n:target} {d:Second termination.}}
		{param: {n:m2} {d:Media stream in second termination.}}
		{param: {n:direction} {d:Direction of the media flow (RV_MDMSTREAMDIRECTION_BOTHWAYS or RV_MDMSTREAMDIRECTION_SOURCE2TARGET).}
		}
		{param: {n:mdmError} {d:(Optional) Use to set error information.}}
	}
	{returns: 
		Return "rvFalse" if it fails. In this case mdmError can be set. If is not set, a default error value will be assigned.
	}
}
$*/
typedef RvBool (*RvMdmTermMgrConnectCB)(struct RvMdmTermMgr_* mgr,struct RvMdmTerm_* source,RvMdmMediaStream* m1,struct RvMdmTerm_* target,RvMdmMediaStream* m2,
									 RvMdmStreamDirection direction,OUT RvMdmError* mdmError);

/*$
{callback:
	{name: RvMdmTermMgrDisconnectCB}	
	{include: rvmdm.h}
	{description:
		{p: Called to disconnect a media stream in a termination from a media stream in another termination.
		}

	}
	{proto: RvBool (*RvMdmTermMgrDisconnectCB)(RvMdmTermMgr* mgr,RvMdmTerm* source,RvMdmMediaStream* m1,
											   RvMdmTerm* target,RvMdmMediaStream* m2,
											   OUT RvMdmError* mdmError);}
	{params:
		{param: {n:mgr} {d:The termination manager.}}
		{param: {n:source} {d:First termination.}}
		{param: {n:m1} {d:Media stream in first termination.}}
		{param: {n:target} {d:Second termination.}}
		{param: {n:m2} {d:Media stream in second termination.}}
		{param: {n:mdmError} {d:(Optional) Use to set error information.}}
	}
	{returns: 
		Return "rvFalse" if it fails. In this case mdmError can be set. 
		If is not set, a default error value will be assigned.
	}
}
$*/
typedef RvBool (*RvMdmTermMgrDisconnectCB)(struct RvMdmTermMgr_* mgr,struct RvMdmTerm_* source,RvMdmMediaStream* m1,
										struct RvMdmTerm_* target,RvMdmMediaStream* m2,
										OUT RvMdmError* mdmError);



/*------------------------------------------------------------------------------*/
/*$
{callback:
	{name: RvMdmTermStatsCB}	
	{include: rvmdm.h}
	{description:
		{p: Called to get statistics from termination.}
	}
	{proto: void (*RvMdmTermStatsCB)(RvMdmTerm* term,RvMdmStatisticsDescriptor* stats);}
	{params:
		{param: {n:term} {d:termination.}}
		{param: {n:stats} {d:(Output)termination statistics.}}
	}
	{returns: 
		The current value of the statistics kept in the termination.
	}
}
$*/
typedef void (*RvMdmTermStatsCB)(struct RvMdmTerm_* term,RvMdmStatisticsDescriptor* stats);

/*------------------------------------------------------------------------------*/
/*$
{callback:
	{name: RvMdmTermResetStatsCB}	
	{include: rvmdm.h}
	{description:
		{p: Called to reset termination statistics.}
	}
	{proto: void (*RvMdmTermResetStatsCB)(RvMdmTerm* term);}
	{params:
		{param: {n:term} {d:termination.}}
	}
}
$*/
typedef void (*RvMdmTermResetStatsCB)(struct RvMdmTerm_* term);

/*------------------------------------------------------------------------------*/
/*$
{callback:
	{name: RvMdmTermSetStateCB}	
	{include: rvmdm.h}
	{description:
		{p: Called to update the state of the termination (stream independent properties).}

	}
	{proto: RvBool (*RvMdmTermSetStateCB)(RvMdmTerm* term,
									  INOUT RvMdmParameterList* stateParameters,
									  OUT RvMdmError* mdmError);
	}
	{params:
		{param: {n:term} {d:termination.}}
		{param: {n:stateParameters} {d:(Input/Output) List of state properties.}}
		{param: {n:mdmError} {d:(Optional) Use to set error information.}}
	}
	{returns: 
		Return "rvFalse" if it fails. In this case mdmError can be set. 
		If is not set, a default error value will be assigned.
		In return stateParameters must contain only the selected values (The application must fill 
		underspecified values and choose from overspecified values).

	}
}
$*/
typedef RvBool (*RvMdmTermSetStateCB)(struct RvMdmTerm_* term,
									  RvMdmParameterList* stateParameters,
									  OUT RvMdmError* mdmError);

/*------------------------------------------------------------------------------*/
/*$
{callback:
	{name: RvMdmTermAddToContextCB}	
	{include: rvmdm.h}
	{description:
		{p: Called to report when the termination has been added to an active
		    context.}
	}
	{proto: void (*RvMdmTermAddToContextCB)(RvMdmTerm* x,RvMdmContext* context);
	}
	{params:
		{param: {n:x} {d:termination.}}
		{param: {n:context} {d:The context.}}
	}
	{notes:
		{note: 
			Register only if the application needs to explicitly track the association between a 
			termination and the context where it is active.
		}