rvsdpmsg.c

h.248协议源码

#ifdef RV_SDPTIME_FULL
	zone = rvListAllocBack(RvSdpTimeZoneAdjust)(&x->zone_adjustment_list);
	rvSdpTimeZoneAdjustConstructN(zone,time,adjust_time,units) ;
#endif
	return zone;
}

void rvSdpMsgClearZoneAdjustment(RvSdpMsg* descr) {
#ifdef RV_SDPTIME_FULL
	rvListClear(RvSdpTimeZoneAdjust)(&descr->zone_adjustment_list);
#endif
}

size_t rvSdpMsgGetNumOfZoneAdjustments(RvSdpMsg* descr) {
	return rvListSize(&descr->zone_adjustment_list);
}

#ifdef RV_SDPTIME_FULL
RvSdpTimeZoneAdjust* rvSdpMsgGetZoneAdjustment(RvSdpMsg* descr,size_t i) {
	return rvListAt(RvSdpTimeZoneAdjust)(&descr->zone_adjustment_list,i);
}
#endif

#ifdef RV_SDPTIME_FULL
void rvSdpMsgRemoveTimeZoneAdjust(RvSdpMsg* descr,size_t index) {
	size_t j;
	RvListIter(RvSdpTimeZoneAdjust) iter = rvListBegin(&descr->zone_adjustment_list);
	if (index < rvListSize(&descr->zone_adjustment_list)) {
		for (j = 0; j < index; ++j)
			iter = rvListIterNext(iter);
		rvListErase(RvSdpTimeZoneAdjust)(&descr->zone_adjustment_list, iter);
	}
}
#endif

/*------ Attribute Field ----------------------------------*/
size_t rvSdpMsgGetNumOfAttr(const RvSdpMsg* descr) {
	return rvListSize(&descr->fields.attr_list);
}

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

RvSdpAttribute* rvSdpMsgAddAttr(RvSdpMsg* x, const char* name, const char* value) {
	return rvSdpCommonFieldsAddAttrN(&x->fields,name,strlen(name),value,strlen(value),x->alloc);
}

void rvSdpMsgRemoveAttribute(RvSdpMsg* x, size_t index) {
	size_t j;
	RvListIter(RvSdpAttribute) iter = rvListBegin(&x->fields.attr_list);
	if (index < rvListSize(&x->fields.attr_list)) {
		for (j = 0; j < index; ++j)
			iter = rvListIterNext(iter);
		rvListErase(RvSdpAttribute)(&x->fields.attr_list, iter);
	}
}

void rvSdpMsgClearAttr(RvSdpMsg* x) {
	rvListClear(RvSdpAttribute)(&x->fields.attr_list);
}

/*------ RtpMap Field ----------------------------------*/
size_t rvSdpMsgGetNumOfRtpMap(const RvSdpMsg* x) {
	return rvListSize(&x->fields.rtp_map_list);
}

RvSdpRtpMap* rvSdpMsgGetRtpMap(const RvSdpMsg* x,size_t i) {
	return rvListAt(RvSdpRtpMap)(&x->fields.rtp_map_list,i);
}

RvSdpRtpMap * rvSdpMsgAddRtpMap(RvSdpMsg* x,int payload,const char * encoding_name,int rate) {
	return  rvSdpCommonFieldsAddRtpMapN(&x->fields,payload,
										encoding_name,strlen(encoding_name),
										rate,x->alloc);
}

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

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


/*------ Media Description Field ----------------------*/
size_t rvSdpMsgGetNumOfMediaDescr(const RvSdpMsg * sdp) {
	return rvListSize(&sdp->media_descriptors);
}

RvSdpMediaDescr* rvSdpMsgGetMediaDescr(const RvSdpMsg * sdp, size_t index) {
	return rvListAt(RvSdpMediaDescr)(&sdp->media_descriptors,index);
}

RvSdpMediaDescr* rvSdpMsgAddMediaDescr(RvSdpMsg * sdp,RvSdpMediaType media_type,int port,RvSdpProtocol protocol) {
	RvSdpMediaDescr * media = rvListAllocBack(RvSdpMediaDescr)(&sdp->media_descriptors);
	rvSdpMediaDescrConstructA(media,media_type,port,protocol,sdp->alloc);
	media->sdp = sdp;
	return media;
}

RvSdpMediaDescr* rvSdpMsgAddMediaDescrAtm(RvSdpMsg * sdp,RvSdpMediaType media_type,RvSdpProtocol protocol) {
	RvSdpMediaDescr * media = rvListAllocBack(RvSdpMediaDescr)(&sdp->media_descriptors);
	rvSdpMediaDescrConstructA(media,media_type,RV_SDPPORT_ATM,protocol,sdp->alloc);
	media->sdp = sdp;
	return media;
}

void rvSdpMsgInsertMediaDescr(RvSdpMsg * sdp,RvSdpMediaDescr* descr) {
	RvSdpMediaDescr * media = rvListAllocBack(RvSdpMediaDescr)(&sdp->media_descriptors);
	rvSdpMediaDescrConstructCopyA(media,descr,sdp->alloc);
	media->sdp = sdp;
	return ;
}

void rvSdpMsgClearMediaDescr(RvSdpMsg * sdp) {
	rvListClear(RvSdpMediaDescr)(&sdp->media_descriptors);
}

void rvSdpMsgRemoveMediaDescr(RvSdpMsg * sdp,size_t index) {
	size_t j;
	RvListIter(RvSdpMediaDescr) iter = rvListBegin(&sdp->media_descriptors);
	if (index < rvListSize(&sdp->media_descriptors)) {
		for (j = 0; j < index; ++j)
			iter = rvListIterNext(iter);
		rvListErase(RvSdpMediaDescr)(&sdp->media_descriptors, iter);
	}
}


#ifdef RV_SDPDEPRECATED_MGCP1_0
static char null_str[] = "";

void	rvSdpMsgSetOriginAddress(RvSdpMsg* x,const char * origin_addr) {
	rvSdpMsgSetOrigin(x,"_","0","0",RV_SDPNETTYPE_IN,RV_SDPADDRTYPE_IP4,origin_addr);
}
RvSdpNetType rvSdpMsgGetNetworkType(const RvSdpMsg * sdp) {
	RvSdpConnection* conn = rvSdpMsgGetConnection(sdp);
	if(conn==NULL)
		return (RvSdpNetType)RV_SDPFIELD_NOTSET;
	return rvSdpConnectionGetNetType(conn);
}
RvSdpAddrType rvSdpMsgGetAddrType(const RvSdpMsg* x) {
	RvSdpConnection* conn = rvSdpMsgGetConnection(x);
	if(conn==NULL)
		return (RvSdpAddrType)RV_SDPFIELD_NOTSET;
	return rvSdpConnectionGetAddrType(conn);
}
const char*	rvSdpMsgGetAddress(const RvSdpMsg* x) {
	RvSdpConnection* conn = rvSdpMsgGetConnection(x);
	if(conn==NULL)
		return null_str;
	return rvSdpConnectionGetAddress(conn);
}
RvSdpNetType rvSdpMediaDescrGetNetworkType(const RvSdpMediaDescr* descr) {
	RvSdpConnection* conn = rvSdpMediaDescrGetConnection(descr);
	if(conn==NULL) {
		if(descr->sdp!=NULL)
			return rvSdpMsgGetNetworkType(descr->sdp);
		else
			return (RvSdpNetType)RV_SDPFIELD_NOTSET;
	}
	return rvSdpConnectionGetNetType(conn);
}
RvSdpAddrType rvSdpMediaDescrGetAddrType(const RvSdpMediaDescr* descr){
	RvSdpConnection* conn = rvSdpMediaDescrGetConnection(descr);
	if(conn==NULL) {
		if(descr->sdp!=NULL)
			return rvSdpMsgGetAddrType(descr->sdp);
		else
			return (RvSdpAddrType)RV_SDPFIELD_NOTSET;
	}
	return rvSdpConnectionGetAddrType(conn);
}
const char*	rvSdpMediaDescrGetAddress(const RvSdpMediaDescr* descr) {
	RvSdpConnection* conn = rvSdpMediaDescrGetConnection(descr);
	if(conn==NULL) {
		if(descr->sdp!=NULL)
			return rvSdpMsgGetAddress(descr->sdp);
		else
			return null_str;
	}
	return rvSdpConnectionGetAddress(conn);
}
RvSdpEncrMethod	rvSdpMsgGetKeyType(const RvSdpMsg* x) {
	RvSdpKey* k = rvSdpMsgGetKey(x);
	if(k==NULL)
		return (RvSdpEncrMethod)RV_SDPFIELD_NOTSET;
	else
		return rvSdpKeyGetType(k);
}
const char * rvSdpMsgGetKeyData(const RvSdpMsg * sdp) {
	RvSdpKey* k = rvSdpMsgGetKey(sdp);
	if(k==NULL)
		return null_str;
	else
		return rvSdpKeyGetData(k);
}
RvSdpEncrMethod	rvSdpMediaDescrGetKeyType(const RvSdpMediaDescr* descr) {
	RvSdpKey* k = rvSdpMediaDescrGetKey(descr);
	if(k==NULL) {
		if(descr->sdp!=NULL)
			return rvSdpMsgGetKeyType(descr->sdp);
		else
			return (RvSdpEncrMethod)RV_SDPFIELD_NOTSET;
	}
	else
		return rvSdpKeyGetType(k);
}
const char * rvSdpMediaDescrGetKeyData(const RvSdpMediaDescr* descr) {
	RvSdpKey* k = rvSdpMediaDescrGetKey(descr);
	if(k==NULL) {
		if(descr->sdp!=NULL)
			return rvSdpMsgGetKeyData(descr->sdp);
		else
			return null_str;
	}
	else
		return rvSdpKeyGetData(k);
}

/*--------------------------------------------------*/
/* Data structure to support a list of Sdp messages */
/*--------------------------------------------------*/
static RvBool rvSdpMsgEqual(const RvSdpMsg* a, const RvSdpMsg* b) {
	return (memcmp((void*)a,(void*)b,sizeof(RvSdpMsg))==0);
}

#define RvSdpMsgEqual	      rvSdpMsgEqual
#define RvSdpMsgConstructCopy rvSdpMsgConstructCopyA
#define RvSdpMsgDestruct	  rvSdpMsgDestruct

rvDefineList(RvSdpMsg)
rvDefineListAt(RvSdpMsg)
rvDefineListAllocBack(RvSdpMsg)

/* Get a pointer to a newly added and constructed 
   element */
RvSdpMsgList* rvSdpMsgListConstructA(RvSdpMsgList* msgList, RvAlloc* a) {
	return rvListConstruct(RvSdpMsg)(msgList, a);
}
RvSdpMsgList* rvSdpMsgListConstructCopy(RvSdpMsgList* d, const RvSdpMsgList* s, RvAlloc* a) {
	return rvListConstructCopy(RvSdpMsg)(d, s, a);
}
void rvSdpMsgListDestruct(RvSdpMsgList* msgList) {
	rvListDestruct(RvSdpMsg)(msgList);
}
RvSdpMsgList* rvSdpMsgListCopy(RvSdpMsgList* d, const RvSdpMsgList* s) {
	return rvListCopy(RvSdpMsg)(d, s);
}
RvBool rvSdpMsgListEqual(RvSdpMsgList* a, RvSdpMsgList* b) {
	return rvListEqual(RvSdpMsg)(a, b);
}
size_t rvSdpMsgListGetSize(const RvSdpMsgList* msgList) {
	return rvListSize(msgList);
}

RvSdpMsg * rvSdpMsgListAddMsg(RvSdpMsgList * msgList) {
	RvSdpMsg* msg;
	msg = rvListAllocBack(RvSdpMsg)(msgList);
	return rvSdpMsgConstructA(msg,rvListGetAllocator(msgList));
}
void rvSdpMsgListInsertMsg(RvSdpMsgList * msgList,const RvSdpMsg * msg) {
	rvListPushBack(RvSdpMsg)(msgList,msg);
}

void rvSdpMsgListRemoveElement(RvSdpMsgList* msgList, size_t index) {
	size_t j;
	RvListIter(RvSdpMsg) iter = rvListBegin(msgList);
	if (index < rvListSize(msgList)) {
		for (j = 0; j < index; ++j)
			iter = rvListIterNext(iter);
		rvListErase(RvSdpMsg)(msgList,iter);
	}
}

void rvSdpMsgListClear(RvSdpMsgList * msgList) {
	rvListClear(RvSdpMsg)(msgList);
}

RvSdpMsg * rvSdpMsgListGetElement(RvSdpMsgList * msgList, size_t index) {
	size_t j;
	RvListIter(RvSdpMsg) iter = rvListBegin(msgList);
	for (j = 0; j < index; ++j)
		iter = rvListIterNext(iter);
	return rvListIterData(iter);
}




#endif /* RV_SDPDEPRECATED_MGCP1_0 */