rvmdmpkg.h

h.248协议源码

		{p: Template for a callback function that is used to build a digitmap 
			completion event for a given package.
			This callback will be called by the Media Device Manager (when it generates 
			a digitMap completion event) to add package specific information. }

	}
	{proto: void(*RvMdmDigitMapBuildCompletionEvCB)(OUT RvMdmParameterList* parameters,
													const char* digitString,
													RvMdmDigitMapMatchType matchType,
													void* userData);}
	{params:
		{param: {n:parameters} {d:Add output parameters for the completion event to this list.}}
		{param: {n:digitString}  {d:The string of digits accumulated according to a digitmap.}}
		{param: {n:matchType} {d:The status of the match between the string and the digitmap.}}
		{param: {n:userData} {d:User data set in the RvMdmDigitMapData constructor.}}
	}
	{notes:
		{note: 
			Register only for packages which support digitmap events.
		}
	}
}
$*/
typedef void(*RvMdmDigitMapBuildCompletionEvCB)(RvMdmParameterList* parameters,
												 const char* digitString,
												 RvMegacoDigitMapMatchType matchType,
												 void* userData);

/* Return mapped character or zero */
/*------------------------------------------------------------------------------*/
/*$
{callback:
	{name: RvMdmDigitMapTranslateEventCB}	
	{include: rvmdm.h}
	{description:
		{p: Translates (maps) the events of the package to valid digitmap 
		    symbols ('0'-'9', 'A'-'F'). 
		 }
	}
	{proto: char (*RvMdmDigitMapTranslateEventCB)(const char* eventName, 
												  const RvMdmParameterList* parameters);}
	{params:
		{param: {n:eventName} {d:The name of the event.}}
		{param: {n:parameters} {d:The parameter list of the event.}}
	}
	{returns: 
		The digitmap symbol for this event or RV_MDM_NOMATCH if the event 
		doesn't map to a digitmap symbol, RV_MDMTERMEVENT_IGNORE if the event is to 
		be ignored.
	}
	{notes:
		{note: 
			This callback will be called by the Media Device Manager when it receives
			an event from the package.
		}
		{note: 
			Register only for packages which support digitmap events.
		}
	}
}
$*/
typedef char (*RvMdmDigitMapTranslateEventCB)(const char* eventName, 
											  const RvMdmParameterList* parameters);

/*$
{type:
	{name: RvMdmDigitMapData}
	{include: rvmdm.h}
	{description: {p: Defines the package specific handling of digitmap events,including the 
					  mapping of package events to digitmap symbols and the production of the
					  digitmap completion event.}}
	{methods:
		{method: void rvMdmDigitMapDataConstruct(RvMdmDigitMapData* dmData,
								const char* completionEventName,
								RvMdmDigitMapBuildCompletionEvCB completeEvF,
								RvMdmDigitMapTranslateEventCB    translateF);}
		{method: void rvMdmDigitMapDataDestruct(RvMdmDigitMapData* dmData);}
	}
	{notes:
		{note:  Use only for packages implementing digitmaps events. }
		{note:  MEGACO: Currently only DTMF detection Package. }
	}
}
$*/


typedef struct RvMdmDigitMapData_ {
	RvMegacoPackageItem				  pkgItem;
	RvMdmDigitMapBuildCompletionEvCB  evCompleteF;
	RvMdmDigitMapTranslateEventCB	  translateF;
	RvAlloc * alloc;
	void * userData;
} RvMdmDigitMapData;

void rvMdmDigitMapDataConstruct(RvMdmDigitMapData* dmData,
								const char* completionEventName,
								RvMdmDigitMapBuildCompletionEvCB completeEvF,
								RvMdmDigitMapTranslateEventCB    translateF,
								void * userData);
void rvMdmDigitMapDataConstructA(RvMdmDigitMapData* dmData,
								 const char* completionEventName,
								 RvMdmDigitMapBuildCompletionEvCB completeEvF,
								 RvMdmDigitMapTranslateEventCB  translateF,
								 void* userData,
								 RvAlloc * alloc);
void rvMdmDigitMapDataDestruct(RvMdmDigitMapData* dmData);

void rvMdmDigitMapDataCopyConstruct(RvMdmDigitMapData* d,RvMdmDigitMapData* s,RvAlloc* a);

/*---------------------------------------------------------------------------------*/
/* Internal objects related to package information                                 */
/*---------------------------------------------------------------------------------*/
typedef struct RvMdmEventInfo_
{
	RvMdmEventParamCB			paramF;
	RvMdmTermEnableDetectEventCB	enableF;
} RvMdmEventInfo;

typedef struct RvMdmSignalInfo_
{
	RvMdmSignalType type;
	RvMilliseconds  duration;
} RvMdmSignalInfo;

#define RvMdmEventInfoDestruct		rvDefaultDestruct
#define RvMdmEventInfoConstructCopy rvDefaultConstructCopy

#define RvMdmSignalInfoDestruct rvDefaultDestruct
#define RvMdmSignalInfoConstructCopy rvDefaultConstructCopy

rvDeclareMap(RvIString, RvMdmEventInfo)
rvDeclareMap(RvIString, RvMdmSignalInfo)

/*------------------------------------------------------------------------------*/

/*
registerTermStateProperty(name,value)
registerLocalControlProperty(name,value)
registerStatistic(name)
registerDigitMapInfo
*/

/*$
{type:
	{name: RvMdmPackage}
	{include: rvmdm.h}
	{description: {p: Defines a package (group of signals/events/properties/statistics).}}
	{methods:
		{method: void rvMdmPackageRegisterSignal(RvMdmPackage* x,RvMdmSignalData* signal);}
		{method: void rvMdmPackageRegisterEvent(RvMdmPackage* x,RvMdmEventData* event);}
		{method: void rvMdmPackageRegisterTermStateProperty(RvMdmPackage* x,const char* name,
															const RvMegacoParameterValue* value);}
		{method: void rvMdmPackageRegisterLocalControlProperty(RvMdmPackage* x,const char* name,
															   const RvMegacoParameterValue* value);}
		{method: void rvMdmPackageRegisterStatistic(RvMdmPackage* x,const char* name);}
		{method: void rvMdmPackageRegisterDigitMapData(RvMdmPackage* x,RvMdmDigitData* data);}
		{method: void rvMdmPackageRegisterEventParametersCB(RvMdmPackage* x,const char* id,RvMdmEventParamCB func);}
		{method: void rvMdmPackageRegisterEnableDetectEventCB(RvMdmPackage* x,const char* id,RvMdmTermEnableDetectEventCB func);}
	}
}
$*/
/* Save in the package only the information that will be needed later */
typedef struct RvMdmPackage_ {
	struct RvMdmTermMgr_*					mgr;
	RvString								name;
	RvMdmParameterList					localControlProperties;
	RvMegacoTerminationStateDescriptor		termStateProperties;
	RvMegacoStatisticsDescriptor			statistics;
	RvMegacoSignalsDescriptor				signals;
	RvMegacoEventsDescriptor				events;
	RvMap(RvIString, RvMdmEventInfo)		eventInfo;
	RvMap(RvIString, RvMdmSignalInfo)		signalInfo;
	RvAlloc*								alloc;
	size_t refs; 
} RvMdmPackage;

void rvMdmPackageRegisterSignal(RvMdmPackage* x,RvMdmSignalData* signal);
void rvMdmPackageRegisterEvent(RvMdmPackage* x,RvMdmEventData* event);
void rvMdmPackageRegisterEventParametersCB(RvMdmPackage* x,const char* id,RvMdmEventParamCB func);
void rvMdmPackageRegisterEnableDetectEventCB(RvMdmPackage* x,const char* id,RvMdmTermEnableDetectEventCB func);
void rvMdmPackageRegisterTermStateProperty(RvMdmPackage* x,const char* name, const RvMegacoParameterValue* value);
void rvMdmPackageRegisterLocalControlProperty(RvMdmPackage* x,const char* name, const RvMegacoParameterValue* value);
void rvMdmPackageRegisterStatistic(RvMdmPackage* x,const char* name);

void rvMdmPackageConstruct_(RvMdmPackage* x,const char* name,struct RvMdmTermMgr_* mgr,RvAlloc* a);
void rvMdmPackageDestruct_(RvMdmPackage* x);

/* Append values, for audit */
void rvMdmPackageAppendSignals_(RvMdmPackage* pkg,RvMegacoSignalsDescriptor* sigDescr);
void rvMdmPackageAppendEvents1_(RvMdmPackage* pkg,RvMegacoEventsDescriptor* evDescr);
void rvMdmPackageAppendEvents2_(RvMdmPackage* pkg,RvMegacoEventBufferDescriptor* evBufDescr);
void rvMdmPackageAppendEvents3_(RvMdmPackage* pkg,RvMegacoObservedEventsDescriptor* obsEvDescr,RvAlloc* a);
void rvMdmPackageAppendStats_(RvMdmPackage* pkg,RvMegacoStatisticsDescriptor* statsDescr);
void rvMdmPackageAppendTermState_(RvMdmPackage* pkg,RvMegacoTerminationStateDescriptor* termStateDescr);
void rvMdmPackageAppendLocalControl_(RvMdmPackage* pkg,RvMdmParameterList* localControl);


/* Optional */
/* Note: DigitMap data is not actually saved in the package but in the separated 
   digit map database */
void rvMdmPackageRegisterDigitMapData(RvMdmPackage* x,RvMdmDigitMapData* data);

/* Pkg data declaration */
typedef struct RvMdmPackage_ *RvMdmPackagePtr;
rvDeclareMap(RvIString,RvMdmPackagePtr)
typedef RvMap(RvIString,RvMdmPackagePtr) RvMdmPackageData;
#define rvMdmPackageDataConstruct rvMapConstruct(RvIString, RvMdmPackagePtr)
#define rvMdmPackageDataDestruct rvMapDestruct

/* Build default packages */
void rvMdmPackageBuildGenericPkg(RvMdmPackage* pkg);

#endif /* RV_MDMPKG_H */