rvmdm.h

h.248协议源码

/******************************************************************************
Filename   : rvmdm.h
Description: Header file 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$
******************************************************************************/
#ifndef RV_MDM_H
#define RV_MDM_H

#include "rvtypes.h"
#include "rvptrlist.h"
#include "rvalloc.h"
#include "rvsdp.h"
#include "rvmegacoobjects.h"
#include "rvmdmpkg.h"
#include "rvmegacoentity.h"

/*------------------------------------------------------------------------------*/
/*  Forward declarations                                                        */
/*------------------------------------------------------------------------------*/

struct RvMdmTerm_;
struct RvMdmTermMgr_;
struct RvMdmTermDefaultProperties_;
struct RvMdmDigitMapData_;

#include "rvmdmalias.h"


/*------------------------------------------------------------------------------*/
/*$
{type:
	{name: RvMdmStreamDirection}
	{include: rvmdm.h}
	{description: 
		{p: Describes the direction of connected media flows:}
		{p: RV_MDMSTREAMDIRECTION_ISOLATE - No media flow.}
		{p: RV_MDMSTREAMDIRECTION_BOTHWAYS - Bidirectional media flow.}
		{p: RV_MDMSTREAMDIRECTION_SOURCE2TARGET - Unidirectional flow, from source to target.}
	}
}
$*/

typedef enum {
	RV_MDMSTREAMDIRECTION_NULL, /* Use for non existing link */
	RV_MDMSTREAMDIRECTION_ISOLATE,
	RV_MDMSTREAMDIRECTION_BOTHWAYS,
	RV_MDMSTREAMDIRECTION_SOURCE2TARGET,
	RV_MDMSTREAMDIRECTION_TARGET2SOURCE
} RvMdmStreamDirection;

/*------------------------------------------------------------------------------*/
/*$
{type:
	{name: RvMdmTermType}
	{include: rvmdm.h}
	{description: 
		{p: Describes the termination type:}
		{p: RV_MDMTERMTYPE_UNKNOWN   - Undefined or unresolved type (for temporary termination).}
		{p: RV_MDMTERMTYPE_PHYSICAL  - Physical termination.}
		{p: RV_MDMTERMTYPE_EPHEMERAL - Ephemeral termination.}
	}
}
$*/

typedef enum { 
	RV_MDMTERMTYPE_UNKNOWN,
	RV_MDMTERMTYPE_PHYSICAL,
	RV_MDMTERMTYPE_EPHEMERAL
} RvMdmTermType;

typedef void RvMdmXTermMgr;
typedef void RvMdmXTerm;

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

/*$
{type:
	{name: RvMdmMediaStream}
	{include: rvmdm.h}
	{description: {p: Represent a media stream.}}
	{methods:
		{method: void * rvMdmMediaStreamGetUserData(RvMdmMediaStream* media);}
		{method: void rvMdmMediaStreamSetUserData(RvMdmMediaStream* media,void * data);}
	}
}
$*/
void * rvMdmMediaStreamGetUserData(RvMdmMediaStream* media);
void rvMdmMediaStreamSetUserData(RvMdmMediaStream* media,void * data);

/*------------------------------------------------------------------------------*/
/*$
{type:
	{name: RvMdmError}
	{include: rvmdm.h}
	{description: {p: Object used to set an error msg.}}
	{protected_methods:
		{method: void rvMdmErrorConstruct_(OUT RvMdmError* mdmError);}
		{method: const char* rvMdmErrorGetMsg_(OUT RvMdmError* mdmError);}
		{method: unsigned int rvMdmErrorGetCode_(OUT RvMdmError* mdmError);}
	}
	{methods:
		{method: void rvMdmErrorSet(OUT RvMdmError* mdmError,int code,const char* msg);}
	}
}
$*/

typedef struct RvMdmError_ {
	char msg[81];
	unsigned int code;
} RvMdmError;

void rvMdmErrorConstruct_(OUT RvMdmError* mdmError);
void rvMdmErrorSet(OUT RvMdmError* mdmError,int code,const char* msg);
const char* rvMdmErrorGetMsg_(OUT RvMdmError* mdmError);
unsigned int rvMdmErrorGetCode_(OUT RvMdmError* mdmError);


/*$
{type:
	{name: RvMdmMediaStreamDescr}
	{include: rvmdm.h}
	{description: {p: Conveys media information.}}
	{protected_methods:
		{method: RvMdmMediaStreamDescr*	rvMdmMediaStreamDescrConstruct_(RvMdmMediaStreamDescr* x,
		  RvBool reserveValue, RvBool reserveGroup, RvMdmStreamMode mode,
		  RvMdmParameterList* localControl, RvSdpMsgList * localDescr, RvSdpMsgList * remoteDescr);}
	}
	{methods:
		{method: RvMdmStreamMode rvMdmMediaStreamDescrGetMode(RvMdmMediaStreamDescr* x);}
		{method: RvSdpMsgList * rvMdmMediaStreamDescrGetLocalDescr(RvMdmMediaStreamDescr* x);}
		{method: RvSdpMsgList * rvMdmMediaStreamDescrGetRemoteDescr(RvMdmMediaStreamDescr* x);}
		{method: RvMdmParameterList *rvMdmMediaStreamDescrGetControlParameters(RvMdmMediaStreamDescr* x);}
		{method: RvBool rvMdmMediaStreamDescrGetReserveValueMode(RvMdmMediaStreamDescr* x);}
		{method: RvBool rvMdmMediaStreamDescrGetReserveGroupMode(RvMdmMediaStreamDescr* x);}
		{method: void	rvMdmMediaStreamDescrReportLocalDescr(RvMdmMediaStreamDescr* x);}
		{method: void	rvMdmMediaStreamDescrReportRemoteDescr(RvMdmMediaStreamDescr* x);}
		{method: void   rvMdmMediaStreamDescrReportControlParameters(RvMdmMediaStreamDescr* x);}
	}
}
$*/

typedef enum {
	RV_MDMMEDIASTREAM_REPORTLOCAL   = 1,
	RV_MDMMEDIASTREAM_REPORTREMOTE  = 2,
	RV_MDMMEDIASTREAM_REPORTCONTROL = 4
} RvMdmMediaStreamDescrReport;

typedef struct RvMdmMediaStreamDescr_ {
	RvBool reserveValue;
	RvBool reserveGroup;
	RvMdmParameterList* localControl;
	RvSdpMsgList * localDescr;	
	RvSdpMsgList * remoteDescr;	
	RvMdmStreamMode mode;
	RvMdmMediaStreamDescrReport reportFlag; 
} RvMdmMediaStreamDescr;

RvMdmStreamMode rvMdmMediaStreamDescrGetMode(RvMdmMediaStreamDescr* x);
RvSdpMsgList * rvMdmMediaStreamDescrGetLocalDescr(RvMdmMediaStreamDescr* x); 
RvSdpMsgList * rvMdmMediaStreamDescrGetRemoteDescr(RvMdmMediaStreamDescr* x);
RvMdmParameterList *rvMdmMediaStreamDescrGetControlParameters(RvMdmMediaStreamDescr* x);
RvBool rvMdmMediaStreamDescrGetReserveValueMode(RvMdmMediaStreamDescr* x);
RvBool rvMdmMediaStreamDescrGetReserveGroupMode(RvMdmMediaStreamDescr* x);
void rvMdmMediaStreamDescrReportLocalDescr(RvMdmMediaStreamDescr* x);
void rvMdmMediaStreamDescrReportRemoteDescr(RvMdmMediaStreamDescr* x);
void rvMdmMediaStreamDescrReportControlParameters(RvMdmMediaStreamDescr* x);

RvMdmMediaStreamDescr*rvMdmMediaStreamDescrConstruct_(RvMdmMediaStreamDescr* x,
									       RvBool reserveValue,
										   RvBool reserveGroup,
										   RvMdmStreamMode mode,
										   RvMdmParameterList* localControl,
										   RvSdpMsgList * localDescr,
										   RvSdpMsgList * remoteDescr);

#define rvMdmMediaStreamDescrIsReportRemote_(x) ((x)->reportFlag & RV_MDMMEDIASTREAM_REPORTREMOTE )
#define rvMdmMediaStreamDescrIsReportLocal_(x) ((x)->reportFlag & RV_MDMMEDIASTREAM_REPORTLOCAL )
#define rvMdmMediaStreamDescrIsReportControl_(x) ((x)->reportFlag & RV_MDMMEDIASTREAM_REPORTCONTROL )
/*------------------------------------------------------------------------------*/
/*$
{type:
	{name: RvMdmSignal}
	{include: rvmdm.h}
	{description: {p: Describes a signal applied to a termination.}}
	{protected_methods:
		{method: void rvMdmSignalConstruct_(RvMdmSignal * signal,
						  const char* id,const char* pkg,const RvMdmParameterList* args,
						  RvMdmMediaStream* mediaStream);}
	}
	{methods:
		{method: const char* rvMdmSignalGetId(const RvMdmSignal * signal);}
		{method: const char* rvMdmSignalGetPkg(const RvMdmSignal * signal);}
		{method: const  RvMdmParameterList *rvMdmSignalGetArguments(const RvMdmSignal *signal);}
		{method: RvMdmMediaStream* rvMdmSignalGetMediaStream(const RvMdmSignal * signal);}
	}
}
$*/

typedef struct RvMdmSignal_ {
	const char* id;
	const char* pkg;
	const RvMdmParameterList* params;
	RvMdmMediaStream* mediaStream;
} RvMdmSignal;

void rvMdmSignalConstruct_(RvMdmSignal * signal,
						  const char* id,const char* pkg,const RvMdmParameterList* args,
						  RvMdmMediaStream* mediaStream);

/*Public:*/
const char* rvMdmSignalGetId(const RvMdmSignal * signal);
const char* rvMdmSignalGetPkg(const RvMdmSignal * signal);
const  RvMdmParameterList* rvMdmSignalGetArguments(const RvMdmSignal *signal);
RvMdmMediaStream* rvMdmSignalGetMediaStream(const RvMdmSignal * signal);



/*------------------------------------------------------------------------------*/
/*$
{callback:
	{name: RvMdmTermMgrSelectTerminationCB}	
	{include: rvmdm.h}
	{description:
		{p: Called to select a termination (either physical or ephemeral).}

	}
	{proto: RvMdmTerm* (*RvMdmTermMgrSelectTerminationCB)(RvMdmTermMgr* mgr,RvMdmTerm* tempTerm);}
	{params:
		{param: {n:mgr} {d:The termination manager.}}
		{param: {n:tempTerm} {d:A "placeholder" termination used to get information about the requested
		                        termination like media requirements,partial name or active context.}}
	}
	{notes:
		{note: 
			To select an "ephemeral" termination, first registred it by calling 
			rvMdmTermMgrRegisterEphemeralTerm().
			The user can obtain information needed to resolve the type of or the specific
			termination to be selected by quering the tempTerm. For example, if the partial 
			name is "rtp/<wildcard>" the user will know that the selected termination 
			must be an rtp termination.
		}
	}
}
$*/
typedef struct RvMdmTerm_* (*RvMdmTermMgrSelectTerminationCB)(struct RvMdmTermMgr_* mgr,struct RvMdmTerm_* tempTerm);

/*------------------------------------------------------------------------------*/
/*$
{callback:
	{name: RvMdmTermMgrDeleteEphTermCB}	
	{include: rvmdm.h}
	{description:
		{p: Called to notify the application that the resources used for an 
		    ephemeral termination can be released.}
		{p: Returning from this callback the termination is no longer registred with the
		    termination manager.}
	}
	{proto: void (*RvMdmTermMgrDeleteEphTermCB)(RvMdmTermMgr* mgr,RvMdmTerm* ephTerm);}
	{params:
		{param: {n:mgr} {d:The termination manager.}}
		{param: {n:ephTerm} {d:The ephemeral termination.}}
	}
}
$*/
typedef void (*RvMdmTermMgrDeleteEphTermCB)(struct RvMdmTermMgr_* mgr,struct RvMdmTerm_* ephTerm);

/*------------------------------------------------------------------------------*/
/*$
{callback:
	{name: rvMdmTermMgrContextCreatedCB}	
	{include: rvmdm.h}
	{description:
		{p: Called to reports that a new active context has been created.}
	}
	{proto: void (*RvMdmTermMgrContextCreatedCB)(RvMdmTermMgr* mgr,RvMdmContext* context);}
	{params:
		{param: {n:mgr} {d:The termination manager.}}
		{param: {n:context} {d:The new context.}}
	}
	{notes:
		{note: 
			Register only if the application needs to explicitly know when contexts are created.
		}
	}
}
$*/
typedef void (*RvMdmTermMgrContextCreatedCB)(struct RvMdmTermMgr_* mgr,RvMdmContext* context);

/*------------------------------------------------------------------------------*/
/*$
{callback:
	{name: rvMdmTermMgrContextDeletedCB}	
	{include: rvmdm.h}
	{description:
		{p: Called to report that an active contex is going to be deleted (is not active anymore).}
	}
	{proto: void (*RvMdmTermMgrContextDeletedCB)(RvMdmTermMgr* mgr,RvMdmContext* context);}
	{params:
		{param: {n:mgr} {d:The termination manager.}}
		{param: {n:context} {d:The context.}}
	}
	{notes:
		{note: 
			Register only if the application needs to explicitly know when contexts are deleted.
		}
	}
}
$*/
typedef void (*RvMdmTermMgrContextDeletedCB)(struct RvMdmTermMgr_* mgr,RvMdmContext* context);

/*------------------------------------------------------------------------------*/
/*$
{callback:
	{name: RvMdmTermStartSignalCB}	
	{include: rvmdm.h}
	{description:
		{p: Called to start a signal in a termination.
		    This signal will usually not stop by itself but only when the callback registred
			with rvMdmTermClassRegisterStopSignalCB() is called. }
	}
	{proto: RvBool (*RvMdmTermStartSignalCB)(RvMdmTerm* term,RvMdmSignal * s,OUT RvMdmError* mdmError);}
	{params:
		{param: {n:term} {d:The termination.}}
		{param: {n:s} {d:The signal.}}
		{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.