rvmdm.c

h.248协议源码

/******************************************************************************
Filename   : rvMdm.c
Description: Methods for Media Device Manager 
******************************************************************************
                Copyright (c) 1999 RADVision Inc.
************************************************************************
NOTICE:
This document contains information that is proprietary to RADVision LTD.
No part of this publication may be reproduced in any form whatsoever 
without written prior approval by RADVision LTD..

RADVision LTD. reserves the right to revise this publication and make 
changes without obligation to notify any person of such revisions or 
changes.
******************************************************************************
$Revision:$
$Date:11.15.00$
$Author: D.Elbert$
******************************************************************************/
#include <string.h>
#include "rvstr.h"
#include "rvmdmpkg.h"
#include "rvmdm.h"
#include "rvmegacotermmgr.h"
#include "rvmegacocontext.h"
#include "rvmegacotermevent.h"

/*------------------------------------------------------------------------------*/
/* RvMdmError methods                                                           */
/*------------------------------------------------------------------------------*/
/*$
{protected_function:
	{name: rvMdmErrorConstruct_}
	{class: RvMdmError}
	{include: rvmdm.h}
	{description:
		{p: Construct an error descriptor.}
	}
	{proto: void rvMdmErrorConstruct_(OUT RvMdmError* mdmError);}
	{params:
		{param: {n:mdmError} {d:The error object.}}
	}
}
$*/
void rvMdmErrorConstruct_(OUT RvMdmError* mdmError) {
	mdmError->code = 0;
	mdmError->msg[0] = '\0';
}

/*$
{function:
	{name: rvMdmErrorSet}
	{class: RvMdmError}
	{include: rvmdm.h}
	{description:
		{p: Set the error code and message (text).}
	}
	{proto: void rvMdmErrorSet(OUT RvMdmError* mdmError,int code,const char* msg);}
	{params:
		{param: {n:mdmError} {d:The error object.}}
		{param: {n:code} {d:The error code.}}
		{param: {n:msg} {d:The message text.}}
	}
}
$*/
void rvMdmErrorSet(OUT RvMdmError* mdmError,int code,const char* msg) {
	mdmError->code = code;
	strncpy(mdmError->msg,msg,sizeof(mdmError->msg)-1);
}

/*$
{protected_function:
	{name: rvMdmErrorGetMsg_}
	{class: RvMdmError}
	{include: rvmdm.h}
	{description:
		{p: Gets the error message.}
	}
	{proto: const char* rvMdmErrorGetMsg_(OUT RvMdmError* mdmError);}
	{params:
		{param: {n:mdmError} {d:The error object.}}
	}
	{returns:
		The error message ( a zero length string if not set).
	}
}
$*/
const char* rvMdmErrorGetMsg_(OUT RvMdmError* mdmError) {
	return mdmError->msg;
}

/*$
{protected_function:
	{name: rvMdmErrorGetCode_}
	{class: RvMdmError}
	{include: rvmdm.h}
	{description:
		{p: Gets the error code.}
	}
	{proto: unsigned int rvMdmErrorGetCode_(OUT RvMdmError* mdmError);}
	{params:
		{param: {n:mdmError} {d:The error object.}}
	}
	{returns:
		The error code ( 0 if not set).
	}
}
$*/
unsigned int rvMdmErrorGetCode_(OUT RvMdmError* mdmError) {
	return mdmError->code;
}

/*------------------------------------------------------------------------------*/
/* RvMdmMediaStreamDescr methods                                                      */
/*------------------------------------------------------------------------------*/
/*$
{function:
	{name: rvMdmMediaStreamDescrGetMode}
	{class: RvMdmMediaStreamDescr}
	{include: rvmdm.h}
	{description:
		{p: Gets the mode of the media stream (towards the outside of the context).}
	}
	{proto: RvMegacoStreamMode rvMdmMediaStreamDescrGetMode(RvMdmMediaStreamDescr* x);}
	{params:
		{param: {n:x} {d:The media descriptor object.}}
	}
	{returns:
		The media stream mode.
	}
}
$*/
RvMdmStreamMode rvMdmMediaStreamDescrGetMode(RvMdmMediaStreamDescr* x) {
	return x->mode;
}

/*$
{function:
	{name: rvMdmMediaStreamDescrGetLocalDescr}
	{class: RvMdmMediaStreamDescr}
	{include: rvmdm.h}
	{description:
		{p: Gets the local media descriptor for a media stream.}
	}
	{proto: RvSdpMsgList * rvMdmMediaStreamDescrGetLocalDescr(RvMdmMediaStreamDescr* x);}
	{params:
		{param: {n:x} {d:The media descriptor object.}}
	}
	{returns:
		The local media descriptor (NULL if absent).
	}
}
$*/
RvSdpMsgList * rvMdmMediaStreamDescrGetLocalDescr(RvMdmMediaStreamDescr* x) {
	return x->localDescr;
}

/*$
{function:
	{name: rvMdmMediaStreamDescrGetRemoteDescr}
	{class: RvMdmMediaStreamDescr}
	{include: rvmdm.h}
	{description:
		{p: Gets the remote media descriptor for a media stream.}
	}
	{proto: RvSdpMsgList * rvMdmMediaStreamDescrGetRemoteDescr(RvMdmMediaStreamDescr* x);}
	{params:
		{param: {n:x} {d:The media descriptor object.}}
	}
	{returns:
		The remote media descriptor (NULL if absent).
	}
}
$*/
RvSdpMsgList * rvMdmMediaStreamDescrGetRemoteDescr(RvMdmMediaStreamDescr* x) {
	return x->remoteDescr;
}

/*$
{function:
	{name: rvMdmMediaStreamDescrGetControlParameters}
	{class: RvMdmMediaStreamDescr}
	{include: rvmdm.h}
	{description:
		{p: Gets the local control parameters for a media stream.}
	}
	{proto: RvMegacoParameterList *rvMdmMediaStreamDescrGetControlParameters(RvMdmMediaStreamDescr* x);}
	{params:
		{param: {n:x} {d:The media descriptor object.}}
	}
	{returns:
		The local control parameters (NULL if absent).
	}
}
$*/
RvMegacoParameterList *rvMdmMediaStreamDescrGetControlParameters(RvMdmMediaStreamDescr* x) {
	return x->localControl;
}

/*$
{function:
	{name: rvMdmMediaStreamDescrGetReserveValueMode}
	{class: RvMdmMediaStreamDescr}
	{include: rvmdm.h}
	{description:
		{p: Gets the reserve value mode for a media stream.}
	}
	{proto: RvBool rvMdmMediaStreamDescrGetReserveValueMode(RvMdmMediaStreamDescr* x);}
	{params:
		{param: {n:x} {d:The media descriptor object.}}
	}
	{returns:
		rvTrue if set, else rvFalse.
	}
}
$*/
RvBool rvMdmMediaStreamDescrGetReserveValueMode(RvMdmMediaStreamDescr* x) {
	return x->reserveValue;
}

/*$
{function:
	{name: rvMdmMediaStreamDescrGetReserveGroupMode}
	{class: RvMdmMediaStreamDescr}
	{include: rvmdm.h}
	{description:
		{p: Gets the reserve group mode for a media stream.}
	}
	{proto: RvBool rvMdmMediaStreamDescrGetReserveGroupMode(RvMdmMediaStreamDescr* x);}
	{params:
		{param: {n:x} {d:The media descriptor object.}}
	}
	{returns:
		rvTrue if set, else rvFalse.
	}
}
$*/
RvBool rvMdmMediaStreamDescrGetReserveGroupMode(RvMdmMediaStreamDescr* x) {
	return x->reserveGroup;
}

/*$
{function:
	{name: rvMdmMediaStreamDescrReportLocalDescr}
	{class: RvMdmMediaStreamDescr}
	{include: rvmdm.h}
	{description:
		{p: Called to indicate that the local media descriptor has been modified.
		    The application will usually call this function after changing the 
			local media descriptor by selecting a value from overspecified 
			values or setting a value that was underspecified (e.g. the local UDP port).}
	}
	{proto: void rvMdmMediaStreamDescrReportLocalDescr(RvMdmMediaStreamDescr* x);}
	{params:
		{param: {n:x} {d:The media descriptor object.}}
	}
}
$*/
void rvMdmMediaStreamDescrReportLocalDescr(RvMdmMediaStreamDescr* x) {
	x->reportFlag |= RV_MDMMEDIASTREAM_REPORTLOCAL;
}

/*$
{function:
	{name: rvMdmMediaStreamDescrReportRemoteDescr}
	{class: RvMdmMediaStreamDescr}
	{include: rvmdm.h}
	{description:
		{p: Called to indicate that the remote media descriptor has been modified.
		    The application will usually call this function after changing the 
			remote media descriptor by selecting a value from overspecified 
			values or setting a value that was underspecified. }
	}
	{proto: void rvMdmMediaStreamDescrReportRemoteDescr(RvMdmMediaStreamDescr* x);}
	{params:
		{param: {n:x} {d:The media descriptor object.}}
	}
}
$*/
void rvMdmMediaStreamDescrReportRemoteDescr(RvMdmMediaStreamDescr* x) {
	x->reportFlag |= RV_MDMMEDIASTREAM_REPORTREMOTE;
}

/*$
{function:
	{name: rvMdmMediaStreamDescrReportControlParameters}
	{class: RvMdmMediaStreamDescr}
	{include: rvmdm.h}
	{description:
		{p: Called to indicate that the local control parameters have been modified.
		    The application will usually call this function after changing the 
			local control parameters by selecting a value from overspecified 
			values or setting a value that was underspecified. }
	}
	{proto: void rvMdmMediaStreamDescrReportControlParameters(RvMdmMediaStreamDescr* x);}
	{params:
		{param: {n:x} {d:The media descriptor object.}}
	}
}
$*/
void rvMdmMediaStreamDescrReportControlParameters(RvMdmMediaStreamDescr* x) {
	x->reportFlag |= RV_MDMMEDIASTREAM_REPORTCONTROL;
}


/*$
{protected_function:
	{name: rvMdmMediaStreamDescrConstruct_}
	{class: RvMdmMediaStreamDescr}
	{include: rvmdm.h}
	{description:
		{p: Constructs the media descriptor.}
	}
	{proto: rvMdmMediaStreamDescr* rvMdmMediaStreamDescrConstruct_(RvMdmMediaStreamDescr* x,
									       RvBool reserveValue,
										   RvBool reserveGroup,
										   RvMegacoStreamMode mode,
										   RvMegacoParameterList* localControl,
										   RvSdpMsgList * localDescr,
										   RvSdpMsgList * remoteDescr);}
	{params:
		{param: {n:x} {d:The media descriptor object.}}
	}
	{returns:
		A pointer to the object.
	}
}
$*/
RvMdmMediaStreamDescr* rvMdmMediaStreamDescrConstruct_(RvMdmMediaStreamDescr* x,
									       RvBool reserveValue,
										   RvBool reserveGroup,
										   RvMdmStreamMode mode,
										   RvMdmParameterList* localControl,
										   RvSdpMsgList * localDescr,
										   RvSdpMsgList * remoteDescr) {

	x->localControl = localControl;
	x->localDescr = localDescr;
	x->mode = mode;
	x->remoteDescr = remoteDescr;
	x->reserveGroup = reserveGroup;
	x->reserveValue = reserveValue;
	x->reportFlag = 0;
	return x;
}


/*------------------------------------------------------------------------------*/
/*  RvMdmSignal methods                                                         */
/*------------------------------------------------------------------------------*/

/*$
{protected_function:
	{name: rvMdmSignalConstruct_}
	{class: RvMdmSignal}
	{include: rvmdm.h}
	{description:
		{p: Constructs a signal.}
	}
	{proto: void rvMdmSignalConstruct_(RvMdmSignal * signal,
						  const char* id,const char* pkg,
						  const RvMegacoParameterList* args,
						  RvMdmMediaStream* mediaStream);}
	{params:
		{param: {n:signal} {d:The signal object.}}
		{param: {n:id} {d:The signal id.}}
		{param: {n:pkg} {d:The pkg id.}}
		{param: {n:media} {d:The media stream where the should be applied. 0 is none.}}
		{param: {n:args} {d:The signal arguments.}}
	}

}
$*/
void rvMdmSignalConstruct_(RvMdmSignal * signal,
						  const char* id,const char* pkg,
						  const RvMegacoParameterList* args,
						  RvMdmMediaStream* mediaStream) {
	signal->id = id;
	signal->pkg = pkg;
	signal->params = args;
	signal->mediaStream  = mediaStream;
}


/*$
{function:
	{name: rvMdmSignalGetId}
	{class: RvMdmSignal}
	{include: rvmdm.h}
	{description:
		{p: Gets the signal id.}
	}
	{proto: const char* rvMdmSignalGetId(const RvMdmSignal * signal);}
	{params:
		{param: {n:signal} {d:The signal object.}}
	}
	{returns: The signal id.}
}
$*/
const char* rvMdmSignalGetId(const RvMdmSignal * signal) {
	return signal->id;
}

/*$
{function:
	{name: rvMdmSignalGetPkg}
	{class: RvMdmSignal}
	{include: rvmdm.h}
	{description:
		{p: Gets the package to which the signal belongs.}
	}
	{proto: const char* rvMdmSignalGetPkg(const RvMdmSignal * signal);}
	{params:
		{param: {n:signal} {d:The signal object.}}
	}
	{returns: The signal package.}
}
$*/
const char* rvMdmSignalGetPkg(const RvMdmSignal * signal) {
	return signal->pkg;
}

/*$
{function:
	{name: rvMdmSignalGetArguments}
	{class: RvMdmSignal}
	{include: rvmdm.h}
	{description:
		{p: Gets the signal arguments.}
	}