rvsdpmedia.c

h.248协议源码

/******************************************************************************
Filename    :rvsdpmedia.c
Description : Access functions for SDP Media descriptor
******************************************************************************
                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:1.0$
$Date:12/20/99$
$Author:Dan Elbert$
******************************************************************************/
#include <stdio.h>

#include "rvtypes.h"
#include "rvsdpmsg.h"
#include "rvalloc.h"
#include "rvdefalloc.h"
#include "rvsdpobjs.h"
#include "rvsdpmedia.h"

#define RV_SDPVERSION "0"


/******* List declarations *****************************/
rvDefineList(RvSdpMediaDescr)
rvDefineListAt(RvSdpMediaDescr)
rvDefineListAllocBack(RvSdpMediaDescr)

rvDefineList(RvString)
rvDefineListAt(RvString)
rvDefineListAllocBack(RvString)

void rvSdpMediaConstruct(RvSdpMedia	* m,RvSdpMediaType media_type,int port,RvSdpProtocol protocol,RvAlloc * a) {
	m->media_type = media_type ;
#ifdef RV_SDPSYMB_USESTRING
	rvStringConstruct(&m->media_type_str,"",a);
#endif
	rvStringConstruct(&m->control_method, "", a);
	m->port = port;
	m->num_of_ports = RV_SDPFIELD_NOTSET;
	m->protocol= protocol;
#ifdef RV_SDPSYMB_USESTRING
	rvStringConstruct(&m->protocol_str,"",a);
#endif
	rvListConstruct(RvString)(&m->fmt_list, a);

	/* vcId */
	rvListConstruct(RvString)(&m->vcid_value, a);
}

void rvSdpMediaDestruct(RvSdpMedia	* m) {
#ifdef RV_SDPSYMB_USESTRING
	rvStringDestruct(&m->media_type_str);
#endif
	rvStringDestruct(&m->control_method);
#ifdef RV_SDPSYMB_USESTRING
	rvStringDestruct(&m->protocol_str);
#endif
	rvListDestruct(RvString)(&m->fmt_list);
	rvListDestruct(RvString)(&m->vcid_value);
}

RvSdpMediaDescr* rvSdpMediaDescrConstructA(RvSdpMediaDescr* descr,RvSdpMediaType media_type,int port,RvSdpProtocol protocol,RvAlloc * a) {
	rvSdpMediaConstruct(&descr->media,media_type,port,protocol,a);
	rvSdpCommonFieldsConstruct(&descr->fields,a);
	descr->alloc=a;
	return descr;
}

void rvSdpMediaDescrDestruct(RvSdpMediaDescr * descr) {
	rvSdpMediaDestruct(&descr->media);
	rvSdpCommonFieldsDestruct(&descr->fields,descr->alloc);	
}

RvSdpMediaDescr* rvSdpMediaDescrConstructCopyA(RvSdpMediaDescr* d,const RvSdpMediaDescr* s,RvAlloc * a) {
	RvSdpConnection * s_conn;
	RvSdpKey * key;
	RvSdpBandwidth * bandwidth;
	size_t i;
	RvSdpAttribute * attr;
	RvSdpRtpMap * map,* new_map;

	d->sdp = s->sdp;
	d->alloc = a;

	rvSdpMediaDescrConstructA(d,rvSdpMediaDescrGetMediaType(s),rvSdpMediaDescrGetPort(s),rvSdpMediaDescrGetProtocol(s),a);
	if(rvSdpMediaDescrGetMediaType(s)==RV_SDPMEDIATYPE_UNKNOWN)
		rvSdpMediaDescrSetMediaTypeStr(d,rvSdpMediaDescrGetMediaTypeStr(s));
	if(rvSdpMediaDescrGetProtocol(s)==RV_SDPPROTOCOL_UNKNOWN)
		rvSdpMediaDescrSetProtocolStr(d,rvSdpMediaDescrGetProtocolStr(s));

	rvSdpMediaDescrSetNASCtrlMethod(d,rvSdpMediaDescrGetNASCtrlMethod(s));
	rvSdpMediaDescrSetNumOfPorts(d,rvSdpMediaDescrGetNumOfPorts(s));
	rvListCopy(RvString)(&d->media.fmt_list,&s->media.fmt_list);

	for (i=0;i<4;i++)
		d->media.vcid_type[i] = s->media.vcid_type[i];
	rvListCopy(RvString)(&d->media.vcid_value,&s->media.vcid_value);

	rvSdpMediaDescrSetInformation(d,rvSdpMediaDescrGetInformation(s));

	if( (s_conn = rvSdpMediaDescrGetConnection(s))!=NULL ) {
		d->fields.connection = (RvSdpConnection *)rvAllocAllocate(d->alloc,sizeof(RvSdpConnection));
		rvSdpConnectionConstructCopyA(d->fields.connection,s_conn,d->alloc);	
	}
	
	if( (key = rvSdpMediaDescrGetKey(s))!=NULL )
		rvSdpCommonFieldsSetKeyCopy(&d->fields,key,d->alloc);

	if( (bandwidth = rvSdpMediaDescrGetBandwidth(s))!=NULL )
		rvSdpMediaDescrSetBandwidth(d,rvSdpBandwidthGetType(bandwidth),rvSdpBandwidthGetValue(bandwidth));

	for(i=0;i<rvSdpMediaDescrGetNumOfAttr(s);i++) {
		attr = rvSdpMediaDescrGetAttribute(s,i);
		rvSdpMediaDescrAddAttr(d,rvSdpAttributeGetName(attr),rvSdpAttributeGetValue(attr));
	}

	for(i=0;i<rvSdpMediaDescrGetNumOfRtpMap(s);i++) {	
		map = rvSdpMediaDescrGetRtpMap(s,i);
		new_map = rvSdpMediaDescrAddRtpMap(d,rvSdpRtpMapGetPayload(map),rvSdpRtpMapGetEncodingName(map),
										rvSdpRtpMapGetClockRate(map));
		rvSdpRtpMapSetEncodingParameters(new_map,rvSdpRtpMapGetEncodingParameters(map));
	}

	rvSdpMediaDescrSetConnectionMode(d,rvSdpMediaDescrGetConnectionMode(s));

	return d;
}

RvSdpMediaDescr* rvSdpMediaDescrConstructCopy(RvSdpMediaDescr *d,const RvSdpMediaDescr *s) {
	return rvSdpMediaDescrConstructCopyA(d,s,&rvDefaultAlloc);
}

RvSdpMediaDescr * rvSdpMediaDescrCopy(RvSdpMediaDescr * d,const RvSdpMediaDescr * s) {
	rvSdpMediaDescrDestruct(d);
	return rvSdpMediaDescrConstructCopyA(d,s,d->alloc);
}


/********************************************************************/
/*  Media description access  functions								*/
/********************************************************************/

void rvSdpMediaDescrSetNASCtrlMethod(RvSdpMediaDescr* descr, const char* cm) {
	rvStringAssign(&descr->media.control_method,cm);
}

void rvSdpMediaDescrSetCtrlMethodN(RvSdpMediaDescr* descr, const char * ctrl_method, int len)  {
	rvStringAssignN(&descr->media.control_method, ctrl_method, len);
}

void rvSdpMediaDescrAddFormat(RvSdpMediaDescr* descr,const char* fmt) {
	RvString * str = rvListAllocBack(RvString)(&descr->media.fmt_list);
	rvStringConstructA(str, fmt, rvListGetAllocator(&descr->media.fmt_list));
}

size_t rvSdpMediaDescrGetNumOfFormats(const RvSdpMediaDescr* descr) {
	return (rvListSize(&descr->media.fmt_list));
}
const char *rvSdpMediaDescrGetFormat(RvSdpMediaDescr* descr, size_t index) {
	return rvStringGetData(rvListAt(RvString)(&descr->media.fmt_list,index));
}
void rvSdpMediaDescrRemoveFormat(RvSdpMediaDescr* descr, size_t index) {
	size_t j;
	RvListIter(RvString) iter = rvListBegin(&descr->media.fmt_list);
	if (index < rvListSize(&descr->media.fmt_list)) {
		for (j = 0; j < index; ++j)
			iter = rvListIterNext(iter);
		rvListErase(RvString)(&descr->media.fmt_list, iter);
	}
}

void rvSdpMediaDescrAddFormatN(RvSdpMediaDescr* descr,const char* fmt,int len) {
	RvString * str = rvListAllocBack(RvString)(&descr->media.fmt_list);
	rvStringConstructN(str, fmt,len, rvListGetAllocator(&descr->media.fmt_list));
}

void rvSdpMediaDescrClearFormat(RvSdpMediaDescr* descr) {
	rvListClear(RvString)(&descr->media.fmt_list);
}
size_t rvSdpMediaDescrGetNumOfPayloads(const RvSdpMediaDescr* descr) {
	return rvListSize(&descr->media.fmt_list);
}
int rvSdpMediaDescrGetPayloadNumber(RvSdpMediaDescr* descr, size_t index) {
	return atoi(*rvListAt(RvString)(&descr->media.fmt_list,index));
}
void rvSdpMediaDescrAddPayloadNumber(RvSdpMediaDescr* descr,int payload) {
	char payload_str[32];
	RvString * str;
	sprintf(payload_str,"%d",payload);
	str = rvListAllocBack(RvString)(&descr->media.fmt_list);
	rvStringConstructA(str, payload_str, rvListGetAllocator(&descr->media.fmt_list));
}

size_t rvSdpMediaDescrGetNumOfAttr(const RvSdpMediaDescr* descr) {
	return rvListSize(&descr->fields.attr_list);
}

RvSdpAttribute* rvSdpMediaDescrGetAttribute(const RvSdpMediaDescr* descr,size_t i) {
	return rvListAt(RvSdpAttribute)(&descr->fields.attr_list,i);
}

void rvSdpMediaDescrRemoveAttr(RvSdpMediaDescr* descr,size_t i) {
	size_t j;
	RvListIter(RvSdpAttribute) iter = rvListBegin(&(descr->fields.attr_list));
	if (i < rvListSize(&(descr->fields.attr_list))) {
		for (j = 0; j < i ;j++)
			iter = rvListIterNext(iter);
		rvListErase(RvSdpAttribute)(&(descr->fields.attr_list), iter);
	}
}

void rvSdpMediaDescrClearAttr(RvSdpMediaDescr* descr) {
	rvListClear(RvSdpAttribute)(&descr->fields.attr_list);
}

size_t rvSdpMediaDescrGetNumOfRtpMap(const RvSdpMediaDescr* descr) {
	return rvListSize(&descr->fields.rtp_map_list);
}
RvSdpRtpMap* rvSdpMediaDescrGetRtpMap(const RvSdpMediaDescr* descr,size_t index) {
	return rvListAt(RvSdpRtpMap)(&descr->fields.rtp_map_list,index);
}

void rvSdpMediaDescrRemoveRtpMap(RvSdpMediaDescr* descr, size_t index) {
	size_t j;
	RvListIter(RvSdpRtpMap) iter = rvListBegin(&descr->fields.rtp_map_list);
	if (index < rvListSize(&descr->fields.rtp_map_list)) {
		for (j = 0; j < index ;j++)
			iter = rvListIterNext(iter);
		rvListErase(RvSdpRtpMap)(&descr->fields.rtp_map_list, iter);
	}
}

void rvSdpMediaDescrClearRtpMap(RvSdpMediaDescr* x) {
	rvListClear(RvSdpRtpMap)(&(x)->fields.rtp_map_list);
}

void rvSdpMediaDescrSetMediaTypeStrN(RvSdpMediaDescr* descr,const char * type,size_t n) {
#ifdef RV_SDPSYMB_USESTRING
	rvSdpMediaDescrSetMediaType(descr,RV_SDPMEDIATYPE_UNKNOWN);
	rvStringAssignN(&descr->media.media_type_str,type,n);
#endif
}
void rvSdpMediaDescrSetMediaTypeStr(RvSdpMediaDescr* descr,const char * type) {
#ifdef RV_SDPSYMB_USESTRING
	rvSdpMediaDescrSetMediaType(descr,RV_SDPMEDIATYPE_UNKNOWN);
	rvStringAssign(&(descr)->media.media_type_str,type);
#endif
}

const char * rvSdpMediaDescrGetMediaTypeStr(const RvSdpMediaDescr* descr) {
#ifdef RV_SDPSYMB_USESTRING
	return  rvStringGetData(&(descr)->media.media_type_str);
#else
	return empty_str;
#endif
}

void rvSdpMediaDescrSetProtocolStr(RvSdpMediaDescr* descr,const char * protocol) {
#ifdef RV_SDPSYMB_USESTRING
	rvSdpMediaDescrSetProtocol(descr,RV_SDPPROTOCOL_UNKNOWN);
	rvStringAssign(&(descr)->media.protocol_str,protocol);
#endif
}

void rvSdpMediaDescrSetProtocolStrN(RvSdpMediaDescr* descr,const char * protocol,size_t n) {
#ifdef RV_SDPSYMB_USESTRING
	rvSdpMediaDescrSetProtocol(descr,RV_SDPPROTOCOL_UNKNOWN);
	rvStringAssignN(&(descr)->media.protocol_str,protocol,n);
#endif
}

const char * rvSdpMediaDescrGetProtocolStr(const RvSdpMediaDescr* descr) {
#ifdef RV_SDPSYMB_USESTRING
	return  rvStringGetData(&(descr)->media.protocol_str);
#else
	return empty_str;
#endif
}

/* ------- VcId Field --------*/
void rvSdpMediaDescrAddVcIdN(RvSdpMediaDescr* descr,int type,const char* value,int len) {
	RvString * str = rvListAllocBack(RvString)(&descr->media.vcid_value);
	rvStringConstructN(str, value,len, rvListGetAllocator(&descr->media.vcid_value));
	descr->media.vcid_type[rvSdpMediaDescrGetVcIdNum(descr) - 1] = type;
}

RvSdpVcId rvSdpMediaDescrGetVcIdType(const RvSdpMediaDescr* descr, size_t idx)
{
	return descr->media.vcid_type[idx];
}

const char *rvSdpMediaDescrGetVcIdValue(RvSdpMediaDescr* descr, size_t idx)
{
	return rvStringGetData(rvListAt(RvString)(&descr->media.vcid_value,idx));
}

size_t rvSdpMediaDescrGetVcIdNum(const RvSdpMediaDescr* descr)
{
	return rvListSize(&descr->media.vcid_value);
}

void rvSdpMediaDescrVcIdClear(RvSdpMediaDescr* descr)
{
	rvListClear(RvString)(&descr->media.vcid_value);
}