rvmdm.h

h.248协议源码

/* Use for eph. termination inside callbacks */
const char* rvMdmTermGetId(RvMdmTerm* term);

/* Get the context where the termination is */
RvMdmContext* rvMdmTermGetContext(RvMdmTerm* term);


/* Private: */
void rvMdmTermConstruct_(RvMdmTerm* term,RvMdmTermClass* termClass,
						 RvMdmXTermClbks* xTermClbks,RvMdmXTerm* xTerm);
void rvMdmTermDestruct_(RvMdmTerm* term);

void rvMdmTermInstanciateClass_(RvMdmTerm* term,RvMdmTermClass * c,void* userData);
void rvMdmTermInstantiateXClbks_(RvMdmTerm* term,RvMdmXTermClbks * tc);	
RvMdmXTerm * rvMdmTermGetXTerm_(RvMdmTerm* term);
void rvMdmTermSetXTerm_(RvMdmTerm* term,RvMdmXTerm * xTerm);

RvBool rvMdmTermStartSignal_(RvMdmTerm* term,RvMdmSignal * s,OUT RvMdmError* mdmError);
RvBool rvMdmTermStopSignal_(RvMdmTerm* term,RvMdmSignal * s,OUT RvMdmError* mdmError);
RvBool rvMdmTermPlaySignal_(RvMdmTerm* term,RvMdmSignal * s,RvBool reportCompletion,OUT RvMdmError* mdmError);

void rvMdmTermSetRequestedMedia_(RvMdmTerm* term,const RvMdmMediaDescriptor *  media);

RvBool rvMdmTermClassIsPkgSupported_(RvMdmTermClass* termClass,const char* pkg);
RvBool rvMdmTermIsPkgSupported_(RvMdmTerm* term,const char* pkg);
RvMegacoPackagesDescriptor* rvMdmTermGetPackages_(RvMdmTerm* term);
RvMdmMediaDescriptor* rvMdmTermGetMediaCapabilites_(RvMdmTerm* term);

void rvMdmTermAddToContext_(RvMdmTerm* x,RvMdmContext* context);
void rvMdmTermRemoveFromContext_(RvMdmTerm* x,RvMdmContext* context);
void rvMdmTermMoveFromContext_(RvMdmTerm* x,RvMdmContext* context);

/* TODO: Document */
void rvMdmTermClearDetectedEvents_(RvMdmTerm* x);


/*------------------------------------------------------------------------------*/
/*$
{private_type:
	{name: RvMdmTermMgrX}
	{include: rvmdm.h}
	{description: {p:Interface to X callbacks for general mgr functions.}}
}
$*/

typedef RvBool (*RvMdmXTermMgrUnregisterTermCB)(RvMdmXTermMgr * x,RvMdmXTerm * xTerm,RvMdmServiceChange * sc);
typedef void (*RvMdmXTermMgrClearTermCB)(RvMdmXTermMgr * x,RvMdmServiceChange * sc);
typedef RvMdmTerm* (*RvMdmXTermMgrFindTermCB)(RvMdmXTermMgr * x,const char* id);

typedef RvMdmTerm* (*RvMdmXTermMgrRegisterPhysTermCB)(RvMdmXTermMgr * x,RvMdmTermClass * c,const char* id,
													  struct RvMdmTermDefaultProperties_* termProperties,
													  RvMdmServiceChange * sc);
typedef RvMdmTerm* (*RvMdmXTermMgrRegisterEphTermCB)(RvMdmXTermMgr * x,RvMdmTermClass * c,const char* id,
													 struct RvMdmTermDefaultProperties_* termProperties);
typedef RvMdmTerm* (*RvMdmXTermMgrRegisterRootTermCB)(RvMdmXTermMgr * x,RvMdmTermClass * c,
													  struct RvMdmTermDefaultProperties_* termProperties);

typedef void (*RvMdmXTermMgrStart)(RvMdmXTermMgr * x,RvMdmServiceChange * sc, int delay);
typedef void (*RvMdmXTermMgrStop)(RvMdmXTermMgr * x,RvMdmServiceChange * sc);

/*$
{callback:
	{name: RvMdmProcessEachTermCB}	
	{include: rvmdm.h}
	{description:
		{p: Functions that follows this template are passed as an argument 
			to rvMdmTermMgrForEachPhysicalTerm() or rvMdmContextForEachTerm(). 
			These functions are used to process a termination or execute some 
			application task.}
	}
	{proto: RvBool (*RvMdmProcessEachTermCB)(RvMdmTerm* term,void* data);}
	{params:
		{param: {n:term} {d:The termination.}}
		{param: {n:data} {d:The argumment to rvMdmTermMgrForEachPhysicalTerm() or
		                    rvMdmContextForEachTerm(), use to pass any user data.}}
	}
	{returns: 
		rvTrue if no further processing of terminations is required. rvFalse
		to keep processing terminations in the loop.
	}
}
$*/
typedef RvBool (*RvMdmProcessEachTermCB)(RvMdmTerm* term,void* data);

typedef RvBool (*RvMdmXTermMgrForEachPhysTermCB)(RvMdmXTermMgr* mgr,RvMdmProcessEachTermCB func,void* data);


typedef struct RvMdmXTermMgrClbks_ {
	RvMdmXTermMgrRegisterPhysTermCB	    registerPhysTermF;
	RvMdmXTermMgrRegisterEphTermCB		registerEphTermF;
	RvMdmXTermMgrRegisterRootTermCB		registerRootTermF;
	RvMdmXTermMgrUnregisterTermCB		unregisterTermF;
	RvMdmXTermMgrClearTermCB			clearTermF;
	RvMdmXTermMgrFindTermCB				findTermF;
	RvMdmXTermMgrFindTermCB				getIdleTermF;
	RvMdmXTermMgrStart					startF;
	RvMdmXTermMgrStop					stopF;
	RvMdmXTermMgrForEachPhysTermCB		forEachPhysTermF;
} RvMdmXTermMgrClbks;

/*------------------------------------------------------------------------------*/
/*$
{type:
	{name: RvMdmTermMgr}
	{include: rvmdm.h}
	{description: 
		{p: 
			Manages a set of terminations and the signals and events 
			that can be applied to them, for a given stack instance.
		}
	}
	{protected_methods:
		{method: void rvMdmTermMgrConstruct_(RvMdmTermMgr* mgr,RvAlloc * a);}
		{method: void rvMdmTermMgrRegisterXTermMgrClbks_(RvMdmTermMgr* mgr,RvMdmXTermMgrClbks * t);}
		{method: void rvMdmTermMgrRegisterRootXTermClbks_(RvMdmTermMgr* mgr,RvMdmXTermClbks * t);}
		{method: const RvMdmSignalInfo* rvMdmTermMgrGetSignalInfo_(RvMdmTermMgr* x,const RvString* pkgStr,const RvString* sigStr,RvMdmError* error);}
		{method: const RvMdmEventInfo* rvMdmTermMgrGetEventInfo_(RvMdmTermMgr* x,const RvString* pkgStr,const RvString* evStr,RvMdmError* error);}
		{method: RvBool rvMdmTermMgrConnectMediaStreams_(RvMdmTermMgr* mgr,RvMdmTerm* source,RvMdmMediaStream* m1,RvMdmTerm* target,
		  RvMdmMediaStream* m2,RvMdmStreamDirection direction,RvMdmError * error);}
		{method: RvBool rvMdmTermMgrDisconnectMediaStreams_(RvMdmTermMgr* mgr,RvMdmTerm* source,RvMdmMediaStream* m1,
		  RvMdmTerm* target,RvMdmMediaStream* m2,RvMdmError * error);}
	}
	{methods:
		{method: void rvMdmTermMgrConstructMegaco(RvMdmTermMgr* mgr,void * XStack);}
		{method: void rvMdmTermMgrDestruct(RvMdmTermMgr* mgr);}
		{method: void rvMdmTermMgrSetMaxContexts(RvMdmTermMgr* mgr,RvUint32 maxContexts);}
		{method: void rvMdmTermMgrSetMaxTermsPerContext(RvMdmTermMgr* mgr,RvUint32 maxTermsPerContext);}
		{method: void rvMdmTermMgrStart(RvMdmTermMgr* mgr,RvMdmServiceChange * sc, int delay);}
		{method: void rvMdmTermMgrStop(RvMdmTermMgr* mgr,RvMdmServiceChange * sc);}
		{method: void rvMdmTermMgrClearTerminations(RvMdmTermMgr* mgr,RvMdmServiceChange * sc);}
		{method: RvMdmTermClass * rvMdmTermMgrCreateTermClass(RvMdmTermMgr* mgr);}
		{method: RvMdmTerm*  rvMdmTermMgrRegisterPhysicalTermination(RvMdmTermMgr* mgr,RvMdmTermClass * c,const char* id,
																	 RvMdmTermDefaultProperties* termProperties,
																     RvMdmServiceChange * sc);}
		{method: RvMdmTerm*  rvMdmTermMgrRegisterEphemeralTermination(RvMdmTermMgr* mgr,RvMdmTermClass * c,const char* id,
																	  RvMdmTermDefaultProperties* termProperties);}
		{method: RvMdmTerm*  rvMdmTermMgrSetRootTermination(RvMdmTermMgr* mgr,RvMdmTermClass * c,
																 RvMdmTermDefaultProperties* termProperties);}
		{method: RvBool rvMdmTermMgrUnregisterTermination(RvMdmTermMgr* mgr,RvMdmTerm* term,RvMdmServiceChange * sc);}
		{method: RvMdmTerm* rvMdmTermMgrFindTermination(RvMdmTermMgr* mgr,const char* id);}
		{method: RvMdmTerm* rvMdmTermMgrGetIdleTermination(RvMdmTermMgr* mgr,const char* id);}
		{method: void rvMdmTermMgrRegisterSelectTermCB(RvMdmTermMgr* mgr,RvMdmTermMgrSelectTerminationCB selectF);}
		{method: void rvMdmTermMgrRegisterDeleteEphTermCB(RvMdmTermMgr* mgr,RvMdmTermMgrDeleteEphTermCB deleteEphF);
		}
		{method: RvMdmPackage* rvMdmTermMgrCreatePackage(RvMdmTermMgr* mgr,const char* name);}
		{method: RvMdmPackage* rvMdmTermMgrGetPackage(RvMdmTermMgr* mgr,const char* name);
		}
		{method: void rvMdmTermMgrRegisterContextCreatedCB(RvMdmTermMgr* mgr,RvMdmTermMgrContextCreatedCB contextCreatedF);}
		{method: void rvMdmTermMgrRegisterContextDeletedCB(RvMdmTermMgr* mgr,RvMdmTermMgrContextDeletedCB contextDeletedF);}
		{method: void rvMdmTermMgrRegisterConnectCB(RvMdmTermClass* c,RvMdmTermMgrConnectCB connectF);}
		{method: void rvMdmTermMgrRegisterDisconnectCB(RvMdmTermClass* c,RvMdmTermMgrDisconnectCB disconnectF);}
		{method: RvBool rvMdmTermMgrForEachPhysicalTerm(RvMdmTermMgr* mgr,RvMdmProcessEachTermCB func,void* data);}
		{method: void * rvMdmTermMgrGetUserData(RvMdmTermMgr* mgr);}
		{method: void   rvMdmTermMgrSetUserData(RvMdmTermMgr* mgr,void * data);}
	}
}
$*/

typedef enum {
	RV_MDMXTERMMGRTYPE_MEGACO
} RvMdmXTermMgrType;


/* Public Functions: */
typedef struct RvMdmTermMgr_ {

	RvMdmTermMgrSelectTerminationCB selectF;
	RvMdmTermMgrDeleteEphTermCB   deleteEphF;

	RvMdmTermMgrConnectCB			connectF;
	RvMdmTermMgrDisconnectCB		disconnectF;

	RvMdmXTermMgrClbks *	xTermMgrClbks;
	RvMdmXTermMgr *         xTermMgr;
	RvAlloc *				a;
	RvPtrList               termClassList;
	RvMdmXTermMgrType       xType;
	/* Packages */
	RvMdmPackageData		packageData;
	/* Packages supporting digitmap */
	RvPtrList				digitMapData; 

	/* Max number of contexts and terms */
	RvUint32			   maxContexts;
	RvUint32			   maxTermPerContext;

	/* Context callbacks */
	RvMdmTermMgrContextCreatedCB contextCreatedF;
	RvMdmTermMgrContextDeletedCB contextDeletedF;

	void*					userData;
} RvMdmTermMgr;

/* Constructor and destructor */
void rvMdmTermMgrConstruct_(RvMdmTermMgr* mgr,RvAlloc * a);
void rvMdmTermMgrConstructMegaco(RvMdmTermMgr* mgr,RvMegacoEntity* local,RvMegacoEntityAddress* mgcAddr,void * XStack);
void rvMdmTermMgrDestruct(RvMdmTermMgr* mgr);

/* Set limits */
void rvMdmTermMgrSetMaxContexts(RvMdmTermMgr* mgr,RvUint32 maxContexts);
void rvMdmTermMgrSetMaxTermsPerContext(RvMdmTermMgr* mgr,RvUint32 maxTermsPerContext);

/* Call after registering endpoints */
void rvMdmTermMgrStart(RvMdmTermMgr* mgr,RvMdmServiceChange * sc, int delay);

void rvMdmTermMgrStop(RvMdmTermMgr* mgr,RvMdmServiceChange * sc);

void rvMdmTermMgrClearTerminations(RvMdmTermMgr* mgr,RvMdmServiceChange * sc);

/* Class construction */
RvMdmTermClass * rvMdmTermMgrCreateTermClass(RvMdmTermMgr* mgr);

/* Termination registration */
RvMdmTerm*  rvMdmTermMgrRegisterPhysicalTermination(RvMdmTermMgr* mgr,RvMdmTermClass * c,const char* id,
													struct RvMdmTermDefaultProperties_* termProperties,
													RvMdmServiceChange * sc);
RvMdmTerm*  rvMdmTermMgrRegisterEphemeralTermination(RvMdmTermMgr* mgr,RvMdmTermClass * c,const char* id,
													struct RvMdmTermDefaultProperties_* termProperties);
RvMdmTerm*  rvMdmTermMgrSetRootTermination(RvMdmTermMgr* mgr,RvMdmTermClass * c,
											    struct RvMdmTermDefaultProperties_* termProperties);
RvBool rvMdmTermMgrUnregisterTermination(RvMdmTermMgr* mgr,RvMdmTerm* term,RvMdmServiceChange * sc);

/* Connect two medias */
void rvMdmTermMgrRegisterConnectCB(RvMdmTermMgr* mgr,RvMdmTermMgrConnectCB connectF);  
void rvMdmTermMgrRegisterDisconnectCB(RvMdmTermMgr* mgr,RvMdmTermMgrDisconnectCB disconnectF);

RvMdmTerm* rvMdmTermMgrFindTermination(RvMdmTermMgr* mgr,const char* id);
RvMdmTerm* rvMdmTermMgrGetIdleTermination(RvMdmTermMgr* mgr,const char* id);

/* Description: Function type for selecting an Termination to implement "any of" wildcard */
void rvMdmTermMgrRegisterSelectTermCB (RvMdmTermMgr* mgr,RvMdmTermMgrSelectTerminationCB selectF);
void rvMdmTermMgrRegisterDeleteEphTermCB(RvMdmTermMgr* mgr,RvMdmTermMgrDeleteEphTermCB releaseEphF);

/* Register a package */
RvMdmPackage* rvMdmTermMgrCreatePackage(RvMdmTermMgr* mgr,const char* name);
RvMdmPackage* rvMdmTermMgrGetPackage(RvMdmTermMgr* mgr,const char* name);

void rvMdmTermMgrRegisterContextCreatedCB(RvMdmTermMgr* mgr,RvMdmTermMgrContextCreatedCB contextCreatedF);
void rvMdmTermMgrRegisterContextDeletedCB(RvMdmTermMgr* mgr,RvMdmTermMgrContextDeletedCB contextDeletedF);

/* Add entries to the list of MGC's */
void rvMdmTermMgrMegacoMgcAddrListAdd(RvMdmTermMgr* mgr,RvMegacoEntityAddress* mgc);
/* Clear the list of MGC's */
void rvMdmTermMgrMgcAddrListClear(RvMdmTermMgr* mgr);

RvBool rvMdmTermMgrForEachPhysicalTerm(RvMdmTermMgr* mgr,RvMdmProcessEachTermCB func,void* data);

/* Private */
/* Register callbacks to X */
/* Call from Megaco or MGCP constructor */
void rvMdmTermMgrRegisterXTermMgrClbks_(RvMdmTermMgr* mgr,RvMdmXTermMgrClbks * t);
RvMdmTerm* rvMdmTermMgrSelectTermination_(RvMdmTermMgr* mgr,RvMdmTerm* tempTerm);

/* Get digitmap package info or NULL */
struct RvMdmDigitMapData_* rvMdmTermMgrGetDigitMapPkgInfo_(RvMdmTermMgr * mgr,const char * pkg);
void   rvMdmTermMgrSetDigitMapPkgInfo_(RvMdmTermMgr * mgr,struct RvMdmDigitMapData_ * dmData);

RvMdmPackage* rvMdmTermMgrGetPkgInfo_(RvMdmTermMgr *termMgr,const RvString *pkgStr,RvMdmError* error);

const RvMdmSignalInfo* rvMdmTermMgrGetSignalInfo_(RvMdmTermMgr* x,const RvString* pkgStr,const RvString* sigStr,RvMdmError* error);
const RvMdmEventInfo* rvMdmTermMgrGetEventInfo_(RvMdmTermMgr* x,const RvString* pkgStr,const RvString* evStr,RvMdmError* error);

void rvMdmTermMgrDeleteEphTerm_(RvMdmTermMgr* mgr,RvMdmTerm* ephTerm);

RvBool rvMdmTermMgrConnectMediaStreams_(RvMdmTermMgr* mgr,RvMdmTerm* source,RvMdmMediaStream* m1,RvMdmTerm* target,
										RvMdmMediaStream* m2,RvMdmStreamDirection direction,RvMdmError * error);
RvBool rvMdmTermMgrDisconnectMediaStreams_(RvMdmTermMgr* mgr,RvMdmTerm* source,RvMdmMediaStream* m1,RvMdmTerm* target,
											RvMdmMediaStream* m2,RvMdmError * error);

void rvMdmTermMgrContextCreated_(RvMdmTermMgr* mgr,RvMdmContext* context);
void rvMdmTermMgrContextDeleted_(RvMdmTermMgr* mgr,RvMdmContext* context);

void * rvMdmTermMgrGetUserData(RvMdmTermMgr* mgr);
void   rvMdmTermMgrSetUserData(RvMdmTermMgr* mgr,void * data);

typedef RvPtrListIter RvMdmTermClassIter;
RvMdmTermClass * rvMdmTermMgrGetNextTermClass_(RvMdmTermMgr* mgr,RvMdmTermClassIter* i);

/*------------------------------------------------------------------------------*/
/*$
{type:
	{name: RvMdmContext}
	{include: rvmdm.h}
	{description: {p: Groups a sets of terminations.}}
	{methods:
		{method: unsigned int rvMdmContextGetNumTerminations(RvMdmContext* x);}
		{method: RvBool		  rvMdmContextForEachTerm(RvMdmContext* x,RvMdmProcessEachTermCB func,void* data);}
		{method: RvBool		  rvMdmContextIsEmergencySet(RvMdmContext* x);}
		{method: unsigned int rvMdmContextGetPriority(RvMdmContext* x);}
		{method: void rvMdmContextSetUserData(RvMdmContext* x,void* userData);}
		{method: void* rvMdmContextGetUserData(RvMdmContext* x);}
	}
}
$*/
unsigned int rvMdmContextGetNumTerminations(RvMdmContext* x);
void		 rvMdmContextSetUserData(RvMdmContext* x,void* userData);
void*		 rvMdmContextGetUserData(RvMdmContext* x);


/*---------------------------------------------------------------------------------*/
/* Default properties                                                              */
/*---------------------------------------------------------------------------------*/
/*$
{type:
	{name: RvMdmTermDefaultProperties}
	{include: rvmdm.h}
	{description: {p: Describes the termination default properties.}}
	{methods:
		{method: void rvMdmTermDefaultPropertiesConstruct(RvMdmTermDefaultProperties* x);}
		{method: void rvMdmTermDefaultPropertiesDestruct(RvMdmTermDefaultProperties* x);}
		{method: void rvMdmTermDefaultPropertiesSetState(RvMdmTermDefaultProperties* x,
														 RvMdmTerminationStateDescriptor* state);}
		{method: void rvMdmTermDefaultPropertiesSetDigitMap(RvMdmTermDefaultProperties* x,RvMdmDigitMap* digitMap,const char* name);}
		{method: void rvMdmTermDefaultPropertiesSetRequestedEvents(RvMdmTermDefaultProperties* x,
																   RvMdmEventsDescriptor* events);}
		{method: void rvMdmTermDefaultPropertiesSetEventBuffer(RvMdmTermDefaultProperties* x,
															   RvMdmEventBufferDescriptor* eventBuffer);}
	}
}
$*/
typedef struct RvMdmTermDefaultProperties_ {
	RvMdmTerminationStateDescriptor termState;
	RvMdmEventsDescriptor			eventsDescr;
	RvMegacoDigitMapDescriptor		   digitMap;
	RvMdmEventBufferDescriptor		eventBufferDescr;
} RvMdmTermDefaultProperties;

void rvMdmTermDefaultPropertiesConstructA_(RvMdmTermDefaultProperties* x,RvAlloc* alloc);

void rvMdmTermDefaultPropertiesConstruct(RvMdmTermDefaultProperties* x);
void rvMdmTermDefaultPropertiesDestruct(RvMdmTermDefaultProperties* x);
void rvMdmTermDefaultPropertiesSetState(RvMdmTermDefaultProperties* x,RvMdmTerminationStateDescriptor* state);

void rvMdmTermDefaultPropertiesSetDigitMap(RvMdmTermDefaultProperties* x,RvMdmDigitMap* digitMap,const char* name);
void rvMdmTermDefaultPropertiesSetRequestedEvents(RvMdmTermDefaultProperties* x,RvMdmEventsDescriptor* events);
void rvMdmTermDefaultPropertiesSetEventBuffer(RvMdmTermDefaultProperties* x,RvMdmEventBufferDescriptor* eventBuffer);


#endif /* RV_MDM_H */