rvmdm.c

h.248协议源码

/*$
{function:
	{name: rvMdmTermClassRegisterRemoveFromContextCB}
	{class: RvMdmTermClass}
	{include: rvmdm.h}
	{description:
		{p: Register a callback to report when the termination is no longer in an active
		    context. Registration of this callback is optional. }
	}
	{proto: void rvMdmTermClassRegisterRemoveFromContextCB(RvMdmTermClass* c,RvMdmTermRemoveFromContextCB removeFromContextF);}
	{params:
		{param: {n:c} {d:A pointer to termination class object.}}
		{param: {n:removeFromContextF} {d:The callback function.}}
	}
	{notes:
		{note: 
			Register only if the application needs to explicitly track the association between a 
			termination and the context where it is active.
		}
	}
}
$*/
void rvMdmTermClassRegisterRemoveFromContextCB(RvMdmTermClass* c,RvMdmTermRemoveFromContextCB removeFromContextF) {
	c->removeFromContextF = removeFromContextF;
}

/*$
{function:
	{name: rvMdmTermClassRegisterClearDetectEventCB}
	{class: RvMdmTermClass}
	{include: rvmdm.h}
	{description:
		{p: Optional - Register a callback to 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 rvMdmTermClassRegisterClearDetectEventCB(RvMdmTermClass* c,RvMdmTermClearDetectEventCB clearDetectF);}
	{params:
		{param: {n:c} {d:A pointer to termination class object.}}
		{param: {n:clearDetectF} {d:The callback function.}}
	}
}
$*/
void rvMdmTermClassRegisterClearDetectEventCB(RvMdmTermClass* c,RvMdmTermClearDetectEventCB clearDetectF) {
	c->clearDetectEventF = clearDetectF;
}


/* Default termination class callbacks */
/* By now they are "do nothing" functions */
/* Later may return error or do something */
static RvBool defaultTermStartSignal(RvMdmTerm* term,RvMdmSignal * s,OUT RvMdmError* mdmError) {
	return rvFalse;
}
static RvBool defaultTermStopSignal(RvMdmTerm* term,RvMdmSignal * s,OUT RvMdmError* mdmError) {
	return rvFalse;
}
static RvBool defaultTermPlaySignal(RvMdmTerm* term,RvMdmSignal * s,RvBool reportCompletion,
										OUT RvMdmError* mdmError) {
	return rvFalse;
}
static RvBool defaultTermCreateMedia(RvMdmTerm* term,RvMdmMediaStream* media,RvMdmMediaStreamDescr* streamDescr,
										   OUT RvMdmError* mdmError) {
	return 0;
}
static RvBool defaultTermDestroyMedia(RvMdmTerm* term,RvMdmMediaStream* media,OUT RvMdmError* mdmError) {
	return rvFalse;
}
static RvBool defaultTermModifyMedia(RvMdmTerm* term,RvMdmMediaStream* media,
									 RvMdmMediaStreamDescr* streamDescr,RvMdmError* mediaError) {
	return rvFalse;
}

static void defaultTermStats(RvMdmTerm* term,RvMegacoStatisticsDescriptor* stats) {
	return;
}
static void defaultTermResetStats(RvMdmTerm* term) {
	return;
}
static RvBool defaultTermSetState(RvMdmTerm* term,
									  RvMegacoParameterList* stateParameters,
									  OUT RvMdmError* mdmError) {
	return rvFalse;
}
/* static void defaultTermGetState(RvMdmTerm* term,
								RvMegacoParameterList* stateParameters) {
	return;
} */
static void	defaultAddToContext(RvMdmTerm* x,RvMdmContext* context) {
	return;
}
static void	defaultMoveFromContext(RvMdmTerm* x,RvMdmContext* oldContext) {
	return;
}
static void	defaultRemoveFromContext(RvMdmTerm* x,RvMdmContext* context) {
	return;
}
static void defaultClearDetectEvent(struct RvMdmTerm_* term) {
	return;
}


/*Private Functions:*/
/*$
{protected_function:
	{name: rvMdmTermClassConstructA_}
	{class: RvMdmTermClass}
	{include: rvmdm.h}
	{description:
		{p: Constructor.}
	}
	{proto: void rvMdmTermClassConstructA_(RvMdmTermClass * c,RvAlloc * a);}
	{params:
		{param: {n:c} {d:A pointer to termination class object.}}
		{param: {n:a} {d:Allocator.}}
	}
}
$*/
void rvMdmTermClassConstructA_(RvMdmTermClass * c,RvAlloc * a) {
	c->startSignalF = defaultTermStartSignal;
	c->stopSignalF = defaultTermStopSignal ;
	c->playSignalF = defaultTermPlaySignal ;
	c->createMediaF = defaultTermCreateMedia;
	c->destroyMediaF = defaultTermDestroyMedia;
	c->modifyMediaF = defaultTermModifyMedia;
	c->statisticsF = defaultTermStats;
	c->resetStatsF = defaultTermResetStats;
	c->setStateF = defaultTermSetState;
	rvMegacoMediaDescriptorConstructA(&c->mediaCaps,a);
	rvMegacoPackagesDescriptorConstructA(&c->pkgsCaps,a);
	c->addToContextF = defaultAddToContext;
	c->moveFromContextF = defaultMoveFromContext;
	c->removeFromContextF = defaultRemoveFromContext;
	c->clearDetectEventF = defaultClearDetectEvent;
	c->classData = 0;
	c->a = a;
}

/*$
{protected_function:
	{name: rvMdmTermClassDestruct_}
	{class: RvMdmTermClass}
	{include: rvmdm.h}
	{description:
		{p: Destructor.}
	}
	{proto: void rvMdmTermClassDestruct_(RvMdmTermClass * c);}
	{params:
		{param: {n:c} {d:A pointer to termination class object.}}
	}
}
$*/
void rvMdmTermClassDestruct_(RvMdmTermClass * c) {
	rvMegacoMediaDescriptorDestruct(&c->mediaCaps);
	rvMegacoPackagesDescriptorDestruct(&c->pkgsCaps);
}

RvMegacoMediaDescriptor* rvMdmTermClassGetMediaCapabilites_(RvMdmTermClass * c) {
	return &c->mediaCaps;
}

RvMegacoPackagesDescriptor* rvMdmTermClassGetPackages_(RvMdmTermClass * c) {
	return &c->pkgsCaps;
}

/*------------------------------------------------------------------------------*/
/* RvMdmTerm methods			                                                */
/*------------------------------------------------------------------------------*/
/*$
{function:
	{name: rvMdmTermProcessEvent}
	{class: RvMdmTerm}
	{include: rvmdm.h}
	{description:
		{p: Report an event detected in the termination.}
	}
	{proto: void rvMdmTermProcessEvent(RvMdmTerm* term,const char* pkg,const char* id,RvMdmMediaStream* media,RvMegacoParameterList* args);}
	{params:
		{param: {n:term} {d:A pointer to termination object.}}
		{param: {n:pkg} {d:The package id.}}
		{param: {n:id} {d:The event id.}}
		{param: {n:media} {d:The user id of the media stream where the event was detected,
						   or 0 if the event is not releated to any media.}}
		{param: {n:args} {d:The event parameters or NULL.}}
	}
}
$*/
void rvMdmTermProcessEvent(RvMdmTerm* term,const char* pkg,const char* id,RvMdmMediaStream* media,RvMegacoParameterList* args) {
	term->xTermClbks->processF(term,pkg,id,media,args);
}

/*$
{function:
	{name: rvMdmTermSignalCompleted}
	{class: RvMdmTerm}
	{include: rvmdm.h}
	{description:
		{p: Report that a signal has played to its completion. 
			This function should be called when the signal was applied with the 
			"report completion" flag, or for a timeout or on-off signal when the
			application stops the signal before receiving a "StopSignal" callback.}
	}
	{proto: void rvMdmTermSignalCompleted(RvMdmTerm* term,const char* pkg,const char* id,
										  RvMdmMediaStream* media,RvBool normal);}
	{params:
		{param: {n:term} {d:A pointer to termination object.}}
		{param: {n:pkg} {d:The package id.}}
		{param: {n:id} {d:The signal id.}}
		{param: {n:media} {d:The media where the signal was applied.}}
		{param: {n:normal} {d:Set to rvTrue if the signal completed normaly,rvFalse if was
		                      interrupted before normal completion.}}
	}
}
$*/
void rvMdmTermSignalCompleted(RvMdmTerm* term,const char* pkg,const char* id,
							  RvMdmMediaStream* media,RvBool normal) {
	term->xTermClbks->SignalCompletedF(term,pkg,id,media,normal);
}

/*$
{function:
	{name: rvMdmTermGetUserData}
	{class: RvMdmTerm}
	{include: rvmdm.h}
	{description:
		{p: Returns the user data associated with the termination.}
	}
	{proto: void * rvMdmTermGetUserData(RvMdmTerm* term);}
	{params:
		{param: {n:term} {d:A pointer to termination object.}}
	}
	{returns: 
		The termination user data or NULL if not set.
	}
}
$*/
void * rvMdmTermGetUserData(RvMdmTerm* term) {
	return term->userData;
}

/*$
{function:
	{name: rvMdmTermSetUserData}
	{class: RvMdmTerm}
	{include: rvmdm.h}
	{description:
		{p: Sets user data associated with the termination.}
	}
	{proto: void rvMdmTermSetUserData(RvMdmTerm* term,void* data);}
	{params:
		{param: {n:term} {d:A pointer to termination object.}}
		{param: {n:data} {d:The user data.}}
	}
	{notes:
		{note: 
			Use this function to associate application data and memory with 
			the termination. In this way the application may avoid the need to
			have his own database of terminations.
		}
	}
}
$*/
void rvMdmTermSetUserData(RvMdmTerm* term,void* data) {
	term->userData = data;
}

/*$
{function:
	{name: rvMdmTermGetClassData}
	{class: RvMdmTerm}
	{include: rvmdm.h}
	{description:
		{p: Gets the user data associated with the termination class to which the 
			termination belongs.}
	}
	{proto: void * rvMdmTermGetClassData(RvMdmTerm* term);}
	{params:
		{param: {n:term} {d:A pointer to termination object.}}
	}
	{returns: 
		The termination class user data or NULL if not set.
	}
	{notes:
		{note: 
			This function may allow the user to share some common resources 
			between terminations of the same class.
		}
	}
}
$*/
void * rvMdmTermGetClassData(RvMdmTerm* term) {
	return term->termClass->classData;
}

/*$
{function:
	{name: rvMdmTermGetType}
	{class: RvMdmTerm}
	{include: rvmdm.h}
	{description:
		{p: Gets the termination type.}
	}
	{proto: RvMdmTermType rvMdmTermGetType(RvMdmTerm* term);}
	{params:
		{param: {n:term} {d:A pointer to termination object.}}
	}
	{returns: 
		The termination type (ephemeral,physical,undefined).
	}
}
$*/
RvMdmTermType rvMdmTermGetType(RvMdmTerm* term) {
	return term->xTermClbks->getTypeF(term->xTerm);
}

/*$
{function:
	{name: rvMdmTermGetMediaRequirements}
	{class: RvMdmTerm}
	{include: rvmdm.h}
	{description:
		{p: Gets the description for the media to be created in the termination, for
			a termination of type RV_MDMTERMTYPE_UNKNOWN.}
	}
	{proto: const RvMegacoMediaDescriptor * rvMdmTermGetMediaRequirements(RvMdmTerm* tempTerm);}
	{params:
		{param: {n:tempTerm} {d:A pointer to termination object.}}
	}
	{returns: 
		A descriptor for the media that has to be created in the termination or NULL.
		Return value will be not null only for terminations of type RV_MDMTERMTYPE_UNKNOWN.
	}
	{notes:
		{note: 
			This function will usually be called from the SelectTermination callback to
			get information about the type of termination that has to be selected.
		}
	}
}
$*/
const RvMegacoMediaDescriptor * rvMdmTermGetMediaRequirements(RvMdmTerm* tempTerm) {
	return tempTerm->requestedMedia;
}

/*$
{protected_function:
	{name: rvMdmTermUpdateState_}
	{class: RvMdmTerm}
	{include: rvmdm.h}
	{description:
		{p: update the state of the termination (stream independent properties).}
	}
	{proto: RvBool rvMdmTermUpdateState_(RvMdmTerm* term,
							 RvMegacoParameterList* stateParameters,
							 OUT RvMdmError* mdmError);}
	{params:
		{param: {n:term} {d:termination.}}
		{param: {n:stateParameters} {d: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.
		If there are underspecified or overspecified values in stateParameters, set the correct
		values.
	}
}
$*/
RvBool rvMdmTermUpdateState_(RvMdmTerm* term,
							 RvMegacoParameterList* stateParameters,
							 OUT RvMdmError* mdmError) {
	return term->termClass->setStateF(term,stateParameters,mdmError);
}

/*$
{protected_function:
	{name: rvMdmTermCreateMediaStream_}
	{class: RvMdmTerm}
	{include: rvmdm.h}
	{description:
		{p: Create a media stream on a termination.}
	}
	{proto: RvMdmMediaStream* rvMdmTermCreateMediaStream_(RvMdmTerm* term,,RvMdmMediaStream* media,
													 RvMdmMediaStreamDescr* streamDescr,
													 RvMdmError* mediaError);}
	{params:
		{param: {n:term} {d:Termination.}}
		{param: {n:media} {d:Media object.}}
		{param: {n:streamDescr} {d:Properties of the media.}}
		{param: {n:mdmError} {d:(Optional) Use to set error information.}}
	}
	{returns: 
		Return the user identifier of the new media, or 0 if it fails.
		The selected values must be set in streamDescr.
	}
}
$*/
RvBool rvMdmTermCreateMediaStream_(RvMdmTerm* term,RvMdmMediaStream* media,RvMdmMediaStreamDescr* streamDescr,RvMdmError* mediaError) {
	return term->termClass->createMediaF(term,media,streamDescr,mediaError);
}

/*$
{protected_function:
	{name: rvMdmTermModifyMediaStream_}
	{class: RvMdmTerm}
	{include: rvmdm.h}
	{description:
		{p: Modify the characteristics of a media on a termination.}
	}
	{proto: RvBool rvMdmTermModifyMediaStream_(RvMdmTerm* term,RvMdmMediaStream* media,
											   RvMdmMediaStreamDescr* streamDescr,
											   RvMdmError* mediaError);}
	{params:
		{param: {n:term} {d:Termination.}}
		{param: {n:mediaStream} {d:user identifier of the media.}}
		{param: {n:streamDescr} {d:Properties of the media.}}
		{param: {n:mediaError} {d:(Optional) Use to set error information.}}
	}
	{returns: 
		Return rvFalse of it fails.
		The selected values must be set in streamDescr.
	}
}
$*/
RvBool rvMdmTermModifyMediaStream_(RvMdmTerm* term,RvMdmMediaStream* media,RvMdmMediaStreamDescr* streamDescr,RvMdmError* mediaError) {
	return term->termClass->modifyMediaF(term,media,streamDescr,mediaError);
}

/*$
{protected_function: