rvsdpobjs.c

h.248协议源码

	rvStringDestruct(&connection->addrtype_str);
#endif
	rvStringDestruct(&connection->address);
}

void  rvSdpConnectionSetAddressTTL(RvSdpConnection *connection,int ttl) {
	connection->ttl = ttl;
}

/* Make macro
RvSdpNetType	rvSdpConnectionGetNetType(const RvSdpConnection *connection) {
	return connection->nettype;
}

RvSdpAddrType	rvSdpConnectionGetAddrType(const RvSdpConnection *connection) {
	return connection->addrtype;
}
const char *	rvSdpConnectionGetAddress(const RvSdpConnection *connection) {
	return rvStringGetData(&connection->address);
}
*/

void rvSdpConnectionSetNetTypeStr(RvSdpConnection * c,const char * t) {
#ifdef RV_SDPSYMB_USESTRING
	c->nettype = RV_SDPNETTYPE_UNKNOWN;
	rvStringAssign(&(c)->nettype_str,t);
#endif
}
void rvSdpConnectionSetNetTypeStrN(RvSdpConnection *c,const char * t,size_t n) {
#ifdef RV_SDPSYMB_USESTRING
	c->nettype = RV_SDPNETTYPE_UNKNOWN;
	rvStringAssignN(&(c)->nettype_str,t,n);
#endif
}

const char * rvSdpConnectionGetNetTypeStr(const RvSdpConnection *connection) {
#ifdef RV_SDPSYMB_USESTRING
	return rvStringGetData(&(connection)->nettype_str);
#else
	return empty_str;
#endif
}

void rvSdpConnectionSetAddrTypeStr(RvSdpConnection *c,const char * t) {
#ifdef RV_SDPSYMB_USESTRING
	c->addrtype = RV_SDPADDRTYPE_UNKNOWN;
	rvStringAssign(&(c)->addrtype_str,t);
#endif
}
void rvSdpConnectionSetAddrTypeStrN(RvSdpConnection *c,const char * t,size_t n) {
#ifdef RV_SDPSYMB_USESTRING
	c->addrtype = RV_SDPADDRTYPE_UNKNOWN;
	rvStringAssignN(&(c)->addrtype_str,t,n);
#endif
}

const char * rvSdpConnectionGetAddrTypeStr(const RvSdpConnection* c) {
#ifdef RV_SDPSYMB_USESTRING
	return rvStringGetData(&(c)->addrtype_str);
#else
	return empty_str;
#endif
}

/******************* Key methods ********************************/

RvSdpKey * rvSdpKeyConstructN(RvSdpKey *key,RvSdpEncrMethod type,
							  const char * data,size_t len,RvAlloc * alloc) {
	key->type = type;
#ifdef RV_SDPSYMB_USESTRING
	rvStringConstructN(&key->type_str,"",0,alloc);
#endif
	rvStringConstructN(&key->data,data,len,alloc);
	return key;
}
RvSdpKey * rvSdpKeyCopy(RvSdpKey *d,const RvSdpKey * s) {
	if(rvSdpKeyGetType(s)==RV_SDPENCRMTHD_UNKNOWN)
		rvSdpKeySetTypeStr(d,rvSdpKeyGetTypeStr(s));
	else
		d->type = rvSdpKeyGetType(s);
	rvStringAssign(&d->data,rvSdpKeyGetData(s));
	return d; 
}
RvSdpKey * rvSdpKeyConstructCopyA(RvSdpKey *d,const RvSdpKey * s,RvAlloc * alloc) {
	rvSdpKeyConstructA(d,rvSdpKeyGetType(s),rvSdpKeyGetData(s),alloc);
	if(rvSdpKeyGetType(s)==RV_SDPENCRMTHD_UNKNOWN)
		rvSdpKeySetTypeStr(d,rvSdpKeyGetTypeStr(s));
	return d;
}
RvSdpKey * rvSdpKeyConstructCopy(RvSdpKey *d,const RvSdpKey * s) {
	return rvSdpKeyConstructCopyA(d,s,&rvDefaultAlloc);
}
void rvSdpKeyDestruct(RvSdpKey *key) {
	key->type = (RvSdpEncrMethod)RV_SDPFIELD_NOTSET;
	rvStringDestruct(&key->data);
#ifdef RV_SDPSYMB_USESTRING
	rvStringDestruct(&key->type_str);
#endif
}

/* Make macro
RvSdpEncrMethod rvSdpKeyGetType(const RvSdpKey *key) {
	return key->type;
}
const char * rvSdpKeyGetData(const RvSdpKey *key) {
	return rvStringGetData(&key->data);
}
*/

void  rvSdpKeySetTypeStr(RvSdpKey *key,const char * method) {
#ifdef RV_SDPSYMB_USESTRING
	key->type = RV_SDPENCRMTHD_UNKNOWN;
	rvStringAssign(&key->type_str,method);
#endif
}
void  rvSdpKeySetTypeStrN(RvSdpKey *key,const char * method,size_t n) {
#ifdef RV_SDPSYMB_USESTRING
	key->type = RV_SDPENCRMTHD_UNKNOWN;
	rvStringAssignN(&key->type_str,method,n);
#endif
}

const char * rvSdpKeyGetTypeStr(const RvSdpKey *key) {
#ifdef RV_SDPSYMB_USESTRING
	return rvStringGetData(&(key)->type_str);
#else
	return empty_str;
#endif
}

/******************* Attribute methods ********************************/

RvSdpAttribute * rvSdpAttributeConstructN(RvSdpAttribute * x,const char* name,size_t nlen,const char * value,size_t vlen,RvAlloc * alloc) {
	rvStringConstructN(&x->name,name,nlen,alloc);
	rvStringConstructN(&x->value,value,vlen,alloc);
	return x;
}

RvSdpAttribute * rvSdpAttributeConstructCopyA(RvSdpAttribute * d,const RvSdpAttribute * s,RvAlloc * alloc) {
	rvStringConstruct(&d->name,rvSdpAttributeGetName(s),alloc);
	rvStringConstruct(&d->value,rvSdpAttributeGetValue(s),alloc);
	return d;	
}
RvSdpAttribute * rvSdpAttributeConstructCopy(RvSdpAttribute * d,const RvSdpAttribute * s) {
	return rvSdpAttributeConstructCopyA(d,s,&rvDefaultAlloc);
}
void rvSdpAttributeDestruct(RvSdpAttribute * x) {
	rvStringDestruct(&x->name);
	rvStringDestruct(&x->value);	
}
RvSdpAttribute * rvSdpAttributeCopy(RvSdpAttribute * d,const RvSdpAttribute * s) {
	rvStringAssign(&d->name,rvSdpAttributeGetName(s));
	rvStringAssign(&d->value,rvSdpAttributeGetValue(s));
	return d;
}

/* Make macro
const char *	rvSdpAttributeGetName(const RvSdpAttribute *  a) {
	return rvStringGetData(&a->name);
}
const char *	rvSdpAttributeGetValue(const RvSdpAttribute *  a){
	return rvStringGetData(&a->value);
}
*/

/***************** Rtp map *****************************************/
/*
     a=rtpmap:<payload type> <encoding name>/<clock rate>[/<encoding
     parameters>]
*/

RvSdpRtpMap * rvSdpRtpMapConstructN(RvSdpRtpMap * x,int payload,const char * encoding_name,size_t len,int rate,RvAlloc * a) {
	x->payload = payload;
	rvStringConstructN(&x->enc_name,encoding_name,len,a);
	x->clock_rate=rate;
	rvStringConstruct(&x->enc_parameters,"",a);
	return x;
}

RvSdpRtpMap * rvSdpRtpMapConstructCopyA(RvSdpRtpMap * d,const RvSdpRtpMap * s,RvAlloc * alloc) {
	rvSdpRtpMapConstructA(d,rvSdpRtpMapGetPayload(s),rvSdpRtpMapGetEncodingName(s),
						  rvSdpRtpMapGetClockRate(s),alloc);
	rvSdpRtpMapSetEncodingParameters(d,rvSdpRtpMapGetEncodingParameters(d));
	return d;
}

RvSdpRtpMap * rvSdpRtpMapConstructCopy(RvSdpRtpMap * d,const RvSdpRtpMap * s) {
	return rvSdpRtpMapConstructCopyA(d,s,&rvDefaultAlloc);
}

void rvSdpRtpMapDestruct(RvSdpRtpMap * x) {
	rvStringDestruct(&x->enc_name);
	rvStringDestruct(&x->enc_parameters);
}

RvSdpRtpMap * rvSdpRtpMapCopy(RvSdpRtpMap * d,const RvSdpRtpMap * s) {
	rvSdpRtpMapSetClockRate(d,rvSdpRtpMapGetClockRate(s));
	rvSdpRtpMapSetPayload(d,rvSdpRtpMapGetPayload(s));
	rvSdpRtpMapSetEncodingName(d,rvSdpRtpMapGetEncodingName(s));
	rvSdpRtpMapSetEncodingParameters(d,rvSdpRtpMapGetEncodingParameters(s));
	return d;
}

/* Defaults number of channels is 1 for audio, NA for video */
void rvSdpRtpMapSetChannels(RvSdpRtpMap * x,int channels) {
	char parameters[16];
	sprintf(parameters,"%d",channels);
	rvStringAssign(&x->enc_parameters,parameters);
}

int	rvSdpRtpMapGetChannels(const RvSdpRtpMap *  x) {
	const char * params = rvStringGetData(&(x)->enc_parameters);
	if(strlen(params))
		return atoi(params);
	return 1;
}

void rvSdpRtpMapSetEncodingParameters(RvSdpRtpMap * x,const char * parameters) {
	rvStringAssign(&x->enc_parameters,parameters);
}

void rvSdpRtpMapSetEncodingParametersN(RvSdpRtpMap * x,const char * parameters,int len) {
	rvStringAssignN(&x->enc_parameters,parameters,len);
}

/* Make macro
int	rvSdpRtpMapGetPayload(const RvSdpRtpMap *  x) {
	return x->payload;
}
const char *	rvSdpRtpMapGetEncodingName(const RvSdpRtpMap *  x) {
	return rvStringGetData(&x->enc_name);
}
int	rvSdpRtpMapGetClockRate(const RvSdpRtpMap *  x) {
	return x->clock_rate;
}
int	rvSdpRtpMapGetChannels(const RvSdpRtpMap *  x) {
	return x->channels;
}
*/

/***************** Common fields *****************************************/

/* Internal functions */
/* Note: the parser and MediaDescr constructors will have to be modify 
   to support multiple media descriptors */


void rvSdpCommonFieldsConstruct(RvSdpCommonFields * c,RvAlloc * a) {

	rvStringConstruct(&c->information,"",a);
	c->bandwidth = NULL;
	c->connection = NULL;
	c->key = NULL;
	c->send_mode = RV_SDPCONNECTMODE_NOTSET;
	rvSdpAttributeListConstructA(&c->attr_list,a);
	rvSdpRtpMapListConstructA(&c->rtp_map_list,a);
}

void rvSdpCommonFieldsDestruct(RvSdpCommonFields * c,RvAlloc * a) {

	rvStringDestruct(&c->information);

	if(c->connection != NULL) {
		rvSdpConnectionDestruct(c->connection);
		rvAllocDeallocate(a,sizeof(RvSdpConnection),c->connection);
	}
	if(c->bandwidth != NULL) {
		rvSdpBandwidthDestruct(c->bandwidth);
		rvAllocDeallocate(a,sizeof(RvSdpBandwidth),c->bandwidth);
	}
	if(c->key != NULL) {
		rvSdpKeyDestruct(c->key);
		rvAllocDeallocate(a,sizeof(RvSdpKey),c->key);
	}
	
	rvSdpAttributeListDestruct(&c->attr_list);
	rvSdpRtpMapListDestruct(&c->rtp_map_list);
}

static void rvSdpCommonFieldsResetKey(RvSdpCommonFields* fields,RvAlloc * alloc) {
	if(fields->key!=NULL)
		rvSdpKeyDestruct(fields->key);
	else
		fields->key = (RvSdpKey *)rvAllocAllocate(alloc,sizeof(RvSdpKey));
}

void rvSdpCommonFieldsSetKeyN(RvSdpCommonFields* fields,RvSdpEncrMethod em,const char* key,int key_len,RvAlloc * alloc) {
	rvSdpCommonFieldsResetKey(fields,alloc);
	rvSdpKeyConstructN(fields->key,em,key,key_len,alloc);
}

void rvSdpCommonFieldsSetKeyCopy(RvSdpCommonFields* fields,RvSdpKey * s,RvAlloc * alloc) {
	rvSdpCommonFieldsResetKey(fields,alloc);
	rvSdpKeyConstructCopyA(fields->key,s,alloc);
}

void rvSdpCommonFieldsSetConnectionN(RvSdpCommonFields* fields,RvSdpNetType type,RvSdpAddrType addr_type,const char* addr,int addr_len,RvAlloc * alloc) {
	if(fields->connection!=NULL)
		rvSdpConnectionDestruct(fields->connection);
	else
		fields->connection = (RvSdpConnection *)rvAllocAllocate(alloc,sizeof(RvSdpConnection));
	rvSdpConnectionConstructN(fields->connection,type,addr_type,addr,addr_len,alloc);
}

void rvSdpCommonFieldsSetInformationN(RvSdpCommonFields* fields, const char *info, size_t len) {
	rvStringAssignN(&fields->information,info,len);	
}

void rvSdpCommonFieldsSetBandwidthN(RvSdpCommonFields* fields, const char *bwtype, size_t len,int b,RvAlloc * alloc) {
	if(fields->bandwidth!=NULL)
		rvSdpBandwidthDestruct(fields->bandwidth);
	else
		fields->bandwidth =(RvSdpBandwidth *)rvAllocAllocate(alloc,sizeof(RvSdpBandwidth));
	rvSdpBandwidthConstructN(fields->bandwidth,bwtype,len,b,alloc);
}

RvSdpAttribute * rvSdpCommonFieldsAddAttrN(RvSdpCommonFields* fields,const char *name, size_t nlen, const char * value, size_t vlen,RvAlloc * alloc) {
	RvSdpAttribute * attr = rvListAllocBack(RvSdpAttribute)(&fields->attr_list);
	rvSdpAttributeConstructN(attr,name,nlen,value,vlen,alloc);
	return attr;
}

RvSdpRtpMap * rvSdpCommonFieldsAddRtpMapN(RvSdpCommonFields* fields,int payload,const char * encoding_name,size_t len,int rate,RvAlloc * a) {
	RvSdpRtpMap * map = rvListAllocBack(RvSdpRtpMap)(&fields->rtp_map_list);
	rvSdpRtpMapConstructN(map,payload,encoding_name,len,rate,a);
	return map;
}