rvmdm.h

h.248协议源码

	}
}
$*/
typedef void (*RvMdmTermAddToContextCB)(struct RvMdmTerm_* x,RvMdmContext* context);

/*$
{callback:
	{name: RvMdmTermMoveFromContextCB}	
	{include: rvmdm.h}
	{description:
		{p: Called to report when the termination has been moved to a different active
		    context.}
	}
	{proto: void (*RvMdmTermMoveFromContextCB)(RvMdmTerm* x,RvMdmContext* newContext,RvMdmContext* oldContext);
	}
	{params:
		{param: {n:x} {d:termination.}}
		{param: {n:newContext} {d:The new context.}}
		{param: {n:oldContext} {d:The old context.}}
	}
	{notes:
		{note: 
			Register only if the application needs to explicitly track the association between a 
			termination and the context where it is active.
		}
	}
}
$*/
typedef void (*RvMdmTermMoveFromContextCB)(struct RvMdmTerm_* x,RvMdmContext* oldContext);

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

/*------------------------------------------------------------------------------*/
/* XTerm Callback types                                                         */ 
/*------------------------------------------------------------------------------*/
/*$
{private_callback:
	{name: RvMdmXTermProcessEventCB}	
	{include: rvmdm.h}
	{description:
		{p: Function type of callback to process events.}

	}
	{proto: void (*RvMdmXTermProcessEventCB)(RvMdmXTerm* term,
											 const char* id,const char* pkg,
											 RvMdmMediaStream* media,RvMdmParameterList * args);
	}
	{params:
		{param: {n:xterm} {d:A pointer to the concrete termination.}}
		{param: {n:id} {d:The event id.}}
		{param: {n:pkg} {d:The pkg id.}}
		{param: {n:media} {d:The media stream where the event was detected.}}
		{param: {n:args} {d:The event arguments.}}
	}
}
$*/
typedef void (*RvMdmXTermProcessEventCB)(RvMdmXTerm* term,
										 const char* pkg,const char* id,
										 RvMdmMediaStream* media,RvMdmParameterList * args);

/*$
{private_callback:
	{name: RvMdmXTermSignalCompletedCB}
	{include: rvmdm.h}
	{description:
		{p: Report that a signal has played to its completion. 
			This function should be called when the signal was applied using the 
			"PlaySignal" callback with the "report completion" flag set to true,
			or for a signal applied with the "StartSignal" callback when the
			application stops the signal before receiving a "StopSignal" callback.}
	}
	{proto: void (*RvMdmXTermSignalCompletedCB)(RvMdmXTerm* xTerm,const char * pkg,const char * id,RvMdmMediaStream* media,RvBool normal);}
	{params:
		{param: {n:xTerm} {d:Pointer to concrete termination.}}
		{param: {n:id} {d:The signal id.}}
		{param: {n:pkg} {d:The package 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 aborted or failed for any reason. For signals applied 
							  by calling the "StartSignal" callback, this should always be
							  rvFalse.}}
	}
}
$*/
typedef void (*RvMdmXTermSignalCompletedCB)(RvMdmXTerm* xTerm,const char * pkg,const char * id,RvMdmMediaStream* media,RvBool normal);

/*$
{private_callback:
	{name: RvMdmXTermGetTypeCB}
	{include: rvmdm.h}
	{description:
		{p: Gets the termination type.}
	}
	{proto: RvMdmTermType (*RvMdmXTermGetTypeCB)(RvMdmXTerm* xTerm);}
	{params:
		{param: {n:xTerm} {d:Pointer to concrete termination.}}
	}
	{returns: 
		The termination type (ephemeral,physical,undefined).
	}
}
$*/
typedef RvMdmTermType (*RvMdmXTermGetTypeCB)(RvMdmXTerm* xTerm);


/*$
{private_callback:
	{name: RvMdmXTermGetId}
	{include: rvmdm.h}
	{description:
		{p: Gets the termination id.}
	}
	{proto: const char* (*RvMdmXTermGetId)(RvMdmXTerm* xTerm);}
	{params:
		{param: {n:xTerm} {d:Pointer to concrete termination.}}
	}
	{returns: 
		The termination id.
	}
	{notes:
		{note: 
			For a temporary termination inside the SelectTermination callback
			this may return a partial id.
		}
	}
}
$*/
typedef const char* (*RvMdmXTermGetId)(RvMdmXTerm* xTerm);


typedef struct RvMdmXTermClbks_ {
	RvMdmXTermProcessEventCB		 processF;
	RvMdmXTermSignalCompletedCB      SignalCompletedF;
	RvMdmXTermGetTypeCB				 getTypeF;
	RvMdmXTermGetId					 getIdF;
} RvMdmXTermClbks;

/*------------------------------------------------------------------------------*/
/*$
{type:
	{name: RvMdmTermClass}
	{include: rvmdm.h}
	{description: 
		{p: Describes a type of terminations.}
		{p: All the terminations from the same class will share callbacks and capabilities.}
		{p: More than one class can be defined, to support different types of terminations
		    with different capabilities and different callback implementations.
		}
	}	
	{protected_methods:
		{method: void rvMdmTermClassConstructA_(RvMdmTermClass * c,RvAlloc * a);}
		{method: void rvMdmTermClassDestruct_(RvMdmTermClass * c);}
	}
	{methods:
		{method: void rvMdmTermClassSetUserData(RvMdmTermClass * c ,void * data);}
		{method: void rvMdmTermClassRegisterStartSignalCB(RvMdmTermClass* c,RvMdmTermStartSignalCB startSignalF);}
		{method: void rvMdmTermClassRegisterStopSignalCB(RvMdmTermClass* c, RvMdmTermStopSignalCB stopSignalF);}
		{method: void rvMdmTermClassRegisterPlaySignalCB(RvMdmTermClass* c, RvMdmTermPlaySignalCB playSignalF);}
		{method: void rvMdmTermClassRegisterCreateMediaCB(RvMdmTermClass* c,RvMdmTermCreateMediaCB createMediaF);}
		{method: void rvMdmTermClassRegisterDestroyMediaCB(RvMdmTermClass* c,RvMdmTermDestroyMediaCB DestroyMediaF);}
		{method: void rvMdmTermClassRegisterModifyMediaCB(RvMdmTermClass* c,RvMdmTermModifyMediaCB modifyMediaF);}
		{method: void rvMdmTermClassRegisterStatsCB(RvMdmTermClass* c,RvMdmTermStatsCB statisticsF);}
		{method: void rvMdmTermClassRegisterResetStatsCB(RvMdmTermClass* c,RvMdmTermResetStatsCB resetStatsF);}
		{method: void rvMdmTermClassRegisterSetStateCB(RvMdmTermClass* c,RvMdmTermSetStateCB setStateF);}
		{method: void rvMdmTermClassRegisterAddToContextCB(RvMdmTermClass* c,RvMdmTermAddToContextCB addToContextF);}
		{method: void rvMdmTermClassRegisterMoveFromContextCB(RvMdmTermClass* c,RvMdmTermMoveFromContextCB moveFromContextF);}
		{method: void rvMdmTermClassRegisterRemoveFromContextCB(RvMdmTermClass* c,RvMdmTermRemoveFromContextCB removeFromContextF);}
		{method: void rvMdmTermClassRegisterClearDetectEventCB(RvMdmTermClass* c,RvMdmTermClearDetectEventCB clearDetectF);}
		{method: void rvMdmTermClassAddMediaCapabilities(RvMdmTermClass *c, const RvSdpMsgList * localDescr, 
		  const RvSdpMsgList * remoteDescr,const RvMdmParameterList* localProperties);}
		{method: void rvMdmTermClassAddSupportedPkg(RvMdmTermClass *c,const char* name,unsigned int version);}

	}
}
$*/

typedef struct RvMdmTermClass_ {
	RvMdmTermStartSignalCB		startSignalF;
	RvMdmTermStopSignalCB		stopSignalF;
	RvMdmTermPlaySignalCB		playSignalF;
	RvMdmTermCreateMediaCB		createMediaF;
	RvMdmTermDestroyMediaCB		destroyMediaF;
	RvMdmTermModifyMediaCB		modifyMediaF;
	RvMdmTermStatsCB			statisticsF;
	RvMdmTermResetStatsCB       resetStatsF;
	RvMdmTermSetStateCB         setStateF;
	RvMdmMediaDescriptor		mediaCaps;
	RvMegacoPackagesDescriptor  pkgsCaps;
	/* Context callbacks */
	RvMdmTermAddToContextCB			addToContextF;
	RvMdmTermMoveFromContextCB		moveFromContextF;
	RvMdmTermRemoveFromContextCB	removeFromContextF;
	/* Disable event detection for all events called with rvMdmPackageRegisterEnableDetectEventCB() */
	RvMdmTermClearDetectEventCB     clearDetectEventF;

	void * classData;
	RvAlloc * a;
} RvMdmTermClass;

void rvMdmTermClassSetUserData(RvMdmTermClass * c ,void * data);

/* Signal callbacks registration */
void rvMdmTermClassRegisterStartSignalCB(RvMdmTermClass* c,RvMdmTermStartSignalCB startSignalF);
void rvMdmTermClassRegisterStopSignalCB (RvMdmTermClass* c, RvMdmTermStopSignalCB stopSignalF);
void rvMdmTermClassRegisterPlaySignalCB (RvMdmTermClass* c, RvMdmTermPlaySignalCB playSignalF);

/* Register callback to call when creating or deleting the media stream */
void rvMdmTermClassRegisterCreateMediaCB(RvMdmTermClass* c,RvMdmTermCreateMediaCB createMediaF);
void rvMdmTermClassRegisterDestroyMediaCB(RvMdmTermClass* c,RvMdmTermDestroyMediaCB destroyMediaF);

/* Callback to use when modifying media stream properties */
void rvMdmTermClassRegisterModifyMediaCB(RvMdmTermClass* c,RvMdmTermModifyMediaCB modifyMediaF);


/* Get statistics from terminations */
void rvMdmTermClassRegisterStatsCB(RvMdmTermClass* c,RvMdmTermStatsCB statisticsF);
void rvMdmTermClassRegisterResetStatsCB(RvMdmTermClass* c,RvMdmTermResetStatsCB resetStatsF);

/* Set function to update termination state for not stream dependent propierties
   Doesn't include buffering */
void rvMdmTermClassRegisterSetStateCB(RvMdmTermClass* c,RvMdmTermSetStateCB setStateF);

/* Capabilities */
void rvMdmTermClassAddMediaCapabilities(RvMdmTermClass *c,
										const RvSdpMsgList * localDescr,
										const RvSdpMsgList * remoteDescr,
										const RvMdmParameterList* localProperties);
void rvMdmTermClassAddSupportedPkg(RvMdmTermClass *c,const char* name,unsigned int version);

/* Select codecs */
/*void rvMdmTermClassRegisterNegotiateCB(RvMdmTermClass* c,RvMdmTermNegotiateCB negotiateF);*/

/* Context callbacks */
void rvMdmTermClassRegisterAddToContextCB(RvMdmTermClass* c,RvMdmTermAddToContextCB addToContextF);
void rvMdmTermClassRegisterMoveFromContextCB(RvMdmTermClass* c,RvMdmTermMoveFromContextCB moveFromContextF);
void rvMdmTermClassRegisterRemoveFromContextCB(RvMdmTermClass* c,RvMdmTermRemoveFromContextCB removeFromContextF);

/* Disable event detection */
void rvMdmTermClassRegisterClearDetectEventCB(RvMdmTermClass* c,RvMdmTermClearDetectEventCB clearDetectF);


/*Private Functions:*/
/* Constructor */
void rvMdmTermClassConstructA_(RvMdmTermClass * c,RvAlloc * a);
void rvMdmTermClassDestruct_(RvMdmTermClass * c);

RvMdmMediaDescriptor* rvMdmTermClassGetMediaCapabilites_(RvMdmTermClass * c);
RvMegacoPackagesDescriptor* rvMdmTermClassGetPackages_(RvMdmTermClass * c);


/*------------------------------------------------------------------------------*/
/*$
{type:
	{name: RvMdmTerm}
	{include: rvmdm.h}
	{description: {p: Describes a  termination.}}
	{protected_methods:
		{method: RvBool rvMdmTermUpdateState_(RvMdmTerm* term, RvMdmParameterList* stateParameters, OUT RvMdmError* mdmError);}
		{method: RvBool rvMdmTermCreateMediaStream_(RvMdmTerm* term,RvMdmMediaStream* media,RvMdmMediaStreamDescr* streamDescr,RvMdmError* mediaError);}
		{method: RvBool rvMdmTermModifyMediaStream_(RvMdmTerm* term,RvMdmMediaStream* media,RvMdmMediaStreamDescr* streamDescr,RvMdmError* mediaError);}
		{method: RvBool rvMdmTermDestroyMediaStream_(RvMdmTerm* term,RvMdmMediaStream* mediaStream,OUT RvMdmError* mdmError);}
		{method: void rvMdmTermConstruct_(RvMdmTerm* term,RvMdmTermClass* termClass,RvMdmXTermClbks* xTermClbks,RvMdmXTerm* xTerm);}
		{method: void rvMdmTermDestruct_(RvMdmTerm* term);}
		{method: RvMdmXTerm * rvMdmTermGetXTerm_(RvMdmTerm* term);}
		{method: RvBool rvMdmTermStartSignal_(RvMdmTerm* term,RvMdmSignal * s,OUT RvMdmError* mdmError);}
		{method: RvBool rvMdmTermStopSignal_(RvMdmTerm* term,RvMdmSignal * s,OUT RvMdmError* mdmError);}
		{method: RvBool rvMdmTermPlaySignal_(RvMdmTerm* term,RvMdmSignal * s,RvBool reportCompletion,OUT RvMdmError* mdmError);}
		{method: void rvMdmTermSetRequestedMedia_(RvMdmTerm* term,const RvMdmMediaDescriptor *  media);}
	}
	{methods:
		{method: void rvMdmTermProcessEvent(RvMdmTerm* term,const char* pkg,const char* id,RvMdmMediaStream* media,RvMdmParameterList * args);}
		{method: void rvMdmTermSignalCompleted(RvMdmTerm* term,const char* pkg,const char* id,RvMdmMediaStream* media,RvBool normal);}
		{method: void * rvMdmTermGetUserData(RvMdmTerm* term);}
		{method: void   rvMdmTermSetUserData(RvMdmTerm* term,void * data);}
		{method: void * rvMdmTermGetClassData(RvMdmTerm* term);}
		{method: RvMdmTermType rvMdmTermGetType(RvMdmTerm* term);}
		{method: const RvMdmMediaDescriptor * rvMdmTermGetMediaRequirements(RvMdmTerm* term);}
		{method: RvMdmContext* rvMdmTermGetContext(RvMdmTerm* term);}
		{method: const char* rvMdmTermGetId(RvMdmTerm* term);}
	}
}
$*/

typedef struct RvMdmTerm_ {
	RvMdmTermClass *             termClass;  
	void *                       userData;
	RvMdmXTermClbks *		     xTermClbks;
	RvMdmXTerm *                 xTerm;
	const RvMdmMediaDescriptor *    requestedMedia;
} RvMdmTerm;


/*Public:*/
/* Events processing */
void rvMdmTermProcessEvent(RvMdmTerm* term,const char* pkg,const char* id,RvMdmMediaStream* media,RvMdmParameterList * args);
void rvMdmTermSignalCompleted(RvMdmTerm* term,const char* pkg,const char* id,RvMdmMediaStream* media,RvBool normal);

void * rvMdmTermGetUserData(RvMdmTerm* term);
void    rvMdmTermSetUserData(RvMdmTerm* term,void * data);
/* This is the user data set at the class level */
void * rvMdmTermGetClassData(RvMdmTerm* term);
RvMdmTermType rvMdmTermGetType(RvMdmTerm* term);

const RvMdmMediaDescriptor * rvMdmTermGetMediaRequirements(RvMdmTerm* term);

/* Media related */
/* state doesn't include buffer ! */
RvBool rvMdmTermUpdateState_(RvMdmTerm* term,
							 RvMdmParameterList* stateParameters,
							 OUT RvMdmError* mdmError);

RvBool rvMdmTermCreateMediaStream_(RvMdmTerm* term,RvMdmMediaStream* media,RvMdmMediaStreamDescr* streamDescr,RvMdmError* mediaError);
RvBool rvMdmTermModifyMediaStream_(RvMdmTerm* term,RvMdmMediaStream* media,RvMdmMediaStreamDescr* streamDescr,RvMdmError* mediaError);
RvBool rvMdmTermDestroyMediaStream_(RvMdmTerm* term,RvMdmMediaStream* mediaStream,OUT RvMdmError* mdmError);


/* Stats */
void  rvMdmTermGetStats_(RvMdmTerm* term,RvMdmStatisticsDescriptor* stats);
void  rvMdmTermResetStats_(RvMdmTerm* term);