rvsdpobjs.h

h.248协议源码

	int				ttl,num_addr;
} RvSdpConnection;

RV_SDP_DECLSPEC RvSdpConnection* rvSdpConnectionConstructN(RvSdpConnection *connection,
										   RvSdpNetType nettype,
										   RvSdpAddrType addrtype,
										   const char* address,size_t len,RvAlloc* alloc);
#define rvSdpConnectionConstructA(c,n,at,a,al) rvSdpConnectionConstructN(c,n,at,a,strlen(a),al);
#define rvSdpConnectionConstruct(c,n,at,a) rvSdpConnectionConstructN(c,n,at,a,strlen(a),&rvDefaultAlloc);

RV_SDP_DECLSPEC RvSdpConnection* rvSdpConnectionCopy(RvSdpConnection *d,const RvSdpConnection* s);
RV_SDP_DECLSPEC RvSdpConnection* rvSdpConnectionConstructCopyA(RvSdpConnection *d,const RvSdpConnection* s,RvAlloc* alloc);
RV_SDP_DECLSPEC RvSdpConnection* rvSdpConnectionConstructCopy(RvSdpConnection *d,const RvSdpConnection* s);
RV_SDP_DECLSPEC void rvSdpConnectionDestruct(RvSdpConnection *connection);

/*void rvSdpConnectionSetNetType(RvSdpConnection *connection,RvSdpNetType type);*/
#define rvSdpConnectionSetNetType(c,t) ((c)->nettype=t)
/*RvSdpNetType	rvSdpConnectionGetNetType(const RvSdpConnection *connection);*/
#define rvSdpConnectionGetNetType(c) ((c)->nettype)

RV_SDP_DECLSPEC void rvSdpConnectionSetNetTypeStr(RvSdpConnection *connection,const char* type);
RV_SDP_DECLSPEC void rvSdpConnectionSetNetTypeStrN(RvSdpConnection *connection,const char* type,size_t n);
RV_SDP_DECLSPEC const char* rvSdpConnectionGetNetTypeStr(const RvSdpConnection *connection);

/*void rvSdpConnectionSetAddrType(RvSdpConnection *connection,RvSdpAddrType type);*/
#define rvSdpConnectionSetAddrType(c,t) ((c)->addrtype=t)
/*RvSdpAddrType	rvSdpConnectionGetAddrType(const RvSdpConnection *connection);*/
#define rvSdpConnectionGetAddrType(c) ((c)->addrtype)

RV_SDP_DECLSPEC void rvSdpConnectionSetAddrTypeStr(RvSdpConnection *c,const char* t);
RV_SDP_DECLSPEC void rvSdpConnectionSetAddrTypeStrN(RvSdpConnection *c,const char* t,size_t n);
RV_SDP_DECLSPEC const char* rvSdpConnectionGetAddrTypeStr(const RvSdpConnection* c);

/*void rvSdpConnectionSetAddress(RvSdpConnection *connection,const char* addr);*/
#define rvSdpConnectionSetAddress(c,a)  rvSdpStringAssign(&(c)->address,a)
/*const char* rvSdpConnectionGetAddress(const RvSdpConnection *connection);*/
#define rvSdpConnectionGetAddress(c)	rvSdpStringGetData(&(c)->address)

RV_SDP_DECLSPEC void rvSdpConnectionSetAddressTTL(RvSdpConnection *connection,int ttl);
/*#define rvSdpConnectionSetAddressTTL(c,ttl) ((c)->ttl=ttl)*/
/*int rvSdpConnectionGetAddressTTL(const RvSdpConnection *connection);*/
#define rvSdpConnectionGetAddressTTL(c)		((c)->ttl)

/*void rvSdpConnectionSetAddressNum(RvSdpConnection *connection,int num);*/
#define rvSdpConnectionSetAddressNum(c,n)	((c)->num_addr=n)
/*int rvSdpConnectionGetAddressNum(const RvSdpConnection *connection);*/
#define rvSdpConnectionGetAddressNum(c)		((c)->num_addr)

/******************* Key methods ********************************/
typedef struct RvSdpKey {
	/* Key fields */
	RvSdpEncrMethod	type;	/* prompt,clear,base64,uri */
#ifdef RV_SDPSYMB_USESTRING
	RvString		type_str;
#endif
	RvString		data;	/* including uri */
} RvSdpKey;

RV_SDP_DECLSPEC RvSdpKey* rvSdpKeyConstructN(RvSdpKey *key,RvSdpEncrMethod type,
							  const char* data,size_t len,RvAlloc* alloc);
#define rvSdpKeyConstructA(k,t,d,a) rvSdpKeyConstructN(k,t,d,strlen(d),a)
#define rvSdpKeyConstruct(k,t,d,a)	rvSdpKeyConstructA(k,t,d,&rvDefaultAlloc)

RV_SDP_DECLSPEC RvSdpKey* rvSdpKeyCopy(RvSdpKey *d,const RvSdpKey* s);
RV_SDP_DECLSPEC RvSdpKey* rvSdpKeyConstructCopyA(RvSdpKey *d,const RvSdpKey* s,RvAlloc* a);
RV_SDP_DECLSPEC RvSdpKey* rvSdpKeyConstructCopy(RvSdpKey *d,const RvSdpKey* s);
RV_SDP_DECLSPEC void rvSdpKeyDestruct(RvSdpKey *key);

/*void rvSdpKeySetType(RvSdpKey *key,RvSdpEncrMethod method);*/
#define rvSdpKeySetType(key,m) ((key)->type=m)
/*RvSdpEncrMethod rvSdpKeyGetType(const RvSdpKey *key);*/
#define rvSdpKeyGetType(key) ((key)->type)

RV_SDP_DECLSPEC void rvSdpKeySetTypeStr(RvSdpKey *key,const char* method);
RV_SDP_DECLSPEC void rvSdpKeySetTypeStrN(RvSdpKey *key,const char* method,size_t n);
RV_SDP_DECLSPEC const char* rvSdpKeyGetTypeStr(const RvSdpKey *key);

/*void rvSdpKeySetData(RvSdpKey *key,const char* data);*/
#define rvSdpKeySetData(key,data) rvSdpStringAssign(&(key)->data,data)
/*const char* rvSdpKeyGetData(const RvSdpKey *key);*/
#define rvSdpKeyGetData(key) rvSdpStringGetData(&(key)->data)

/******************* Attribute methods ********************************/
typedef int RvSdpAttrType;

typedef struct RvSdpAttribute_{
	RvString name;
	RvString value;
} RvSdpAttribute;

rvDeclareList(RvSdpAttribute)
typedef RvList(RvSdpAttribute) RvSdpAttributeList;
#define rvSdpAttributeListConstructA rvListConstruct(RvSdpAttribute)
#define rvSdpAttributeListConstructCopy rvListConstructCopy(RvSdpAttribute)
#define rvSdpAttributeListDestruct rvListDestruct(RvSdpAttribute)
#define rvSdpAttributeListCopy rvListCopy(RvSdpAttribute)
#define rvSdpAttributeListEqual rvListEqual(RvSdpAttribute)
#define rvSdpAttributeListAdd rvListPushBack(RvSdpAttribute)
#define rvSdpAttributeListClear rvListClear(RvSdpAttribute)
#define rvSdpAttributeListGetSize rvListSize
#define rvSdpAttributeListGetElem rvListAt(RvSdpAttribute)

#define RvSdpAttributeConstructCopy	rvSdpAttributeConstructCopyA
#define RvSdpAttributeDestruct	rvSdpAttributeDestruct
#define RvSdpAttributeCopy	rvSdpAttributeCopy
#define RvSdpAttributeEqual(d,s) rvSdpMemEqual(d,s,RvSdpAttribute)

RV_SDP_DECLSPEC RvSdpAttribute* rvSdpAttributeConstructN(RvSdpAttribute* x,const char* name,size_t nlen,const char* value,size_t vlen,RvAlloc* a) ;
#define rvSdpAttributeConstructA(x,n,v,a) rvSdpAttributeConstructN(x,n,strlen(n),v,strlen(v),a)
#define rvSdpAttributeConstruct(x,n,v) rvSdpAttributeConstructA(x,n,v,&rvDefaultAlloc)

RV_SDP_DECLSPEC RvSdpAttribute* rvSdpAttributeConstructCopyA(RvSdpAttribute* d,const RvSdpAttribute* s,RvAlloc* alloc);
RV_SDP_DECLSPEC RvSdpAttribute* rvSdpAttributeConstructCopy(RvSdpAttribute* d,const RvSdpAttribute* s);
RV_SDP_DECLSPEC void rvSdpAttributeDestruct(RvSdpAttribute* x);
RV_SDP_DECLSPEC RvSdpAttribute* rvSdpAttributeCopy(RvSdpAttribute* d,const RvSdpAttribute* s);

/*void rvSdpAttributeSetName(RvSdpAttribute*  a,const char* name);*/
#define	rvSdpAttributeSetName(a,new_name)  rvSdpStringAssign(&(a)->name,new_name)
/*const char*	rvSdpAttributeGetName(const RvSdpAttribute*  a);*/
#define	rvSdpAttributeGetName(a) rvSdpStringGetData(&(a)->name)

/*void rvSdpAttributeSetValue(RvSdpAttribute*  a,const char* value);*/
#define	rvSdpAttributeSetValue(a,new_value)   rvSdpStringAssign(&(a)->value,new_value)
/*const char*	rvSdpAttributeGetValue(const RvSdpAttribute*  a);*/
#define	rvSdpAttributeGetValue(a)  rvSdpStringGetData(&(a)->value)


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

typedef struct RvSdpRtpMap_{
	int			payload;
	RvString	enc_name;
	RvUint32	clock_rate;
/*	int			channels; */
	RvString    enc_parameters;
} RvSdpRtpMap;

rvDeclareList(RvSdpRtpMap)
typedef RvList(RvSdpRtpMap) RvSdpRtpMapList;
#define rvSdpRtpMapListConstructA rvListConstruct(RvSdpRtpMap)
#define rvSdpRtpMapListConstructCopy rvListConstructCopy(RvSdpRtpMap)
#define rvSdpRtpMapListDestruct rvListDestruct(RvSdpRtpMap)
#define rvSdpRtpMapListCopy rvListCopy(RvSdpRtpMap)
#define rvSdpRtpMapListEqual rvListEqual(RvSdpRtpMap)
#define rvSdpRtpMapListAdd rvListPushBack(RvSdpRtpMap)
#define rvSdpRtpMapListClear rvListClear(RvSdpRtpMap)
#define rvSdpRtpMapListGetSize rvListSize
#define rvSdpRtpMapListGetElem rvListAt(RvSdpRtpMap)

#define RvSdpRtpMapConstructCopy	rvSdpRtpMapConstructCopyA
#define RvSdpRtpMapDestruct	rvSdpRtpMapDestruct
#define RvSdpRtpMapCopy	rvSdpRtpMapCopy
#define RvSdpRtpMapEqual(d,s) rvSdpMemEqual(d,s,RvSdpRtpMap)

RV_SDP_DECLSPEC RvSdpRtpMap* rvSdpRtpMapConstructN(RvSdpRtpMap* x,int payload,const char* encoding_name,size_t len,int rate,RvAlloc* a) ;
#define rvSdpRtpMapConstructA(x,p,e,r,a) rvSdpRtpMapConstructN(x,p,e,strlen(e),r,a)
#define rvSdpRtpMapConstruct(x,p,e,r) rvSdpRtpMapConstructA(x,p,e,r,&rvDefaultAlloc)

RV_SDP_DECLSPEC RvSdpRtpMap* rvSdpRtpMapConstructCopyA(RvSdpRtpMap* d,const RvSdpRtpMap* s,RvAlloc* alloc);
RV_SDP_DECLSPEC RvSdpRtpMap* rvSdpRtpMapConstructCopy(RvSdpRtpMap* d,const RvSdpRtpMap* s);
RV_SDP_DECLSPEC void rvSdpRtpMapDestruct(RvSdpRtpMap* x);
RV_SDP_DECLSPEC RvSdpRtpMap* rvSdpRtpMapCopy(RvSdpRtpMap* d,const RvSdpRtpMap* s);


/* Defaults number of channels is 1 for audio, NA for video */

/*void rvSdpRtpMapSetPayload(RvSdpRtpMap*  x,int payload);*/
#define	rvSdpRtpMapSetPayload(x,p)	((x)->payload=p) 
/*int rvSdpRtpMapGetPayload(const RvSdpRtpMap*  x);*/
#define	rvSdpRtpMapGetPayload(x)	((x)->payload) 

/*void rvSdpRtpMapSetEncodingName(RvSdpRtpMap*  x,const char* name); */
#define	rvSdpRtpMapSetEncodingName(x,n)	rvSdpStringAssign(&(x)->enc_name,n)
/*const char* rvSdpRtpMapGetEncodingName(const RvSdpRtpMap*  x);*/
#define	rvSdpRtpMapGetEncodingName(x)	rvSdpStringGetData(&(x)->enc_name)

/*void rvSdpRtpMapSetClockRate(RvSdpRtpMap*  x,int rate);*/
#define	rvSdpRtpMapSetClockRate(x,rate)	((x)->clock_rate=rate)
/*int rvSdpRtpMapGetClockRate(const RvSdpRtpMap*  x);*/
#define	rvSdpRtpMapGetClockRate(x)		((x)->clock_rate)

RV_SDP_DECLSPEC void rvSdpRtpMapSetEncodingParameters(RvSdpRtpMap*  x,const char* parameters);			
RV_SDP_DECLSPEC void rvSdpRtpMapSetEncodingParametersN(RvSdpRtpMap*  x,const char* parameters,int len);
/*const char* rvSdpRtpMapGetEncodingParameters(const RvSdpRtpMap*  x);*/
#define	rvSdpRtpMapGetEncodingParameters(x) rvStringGetData(&(x)->enc_parameters)

RV_SDP_DECLSPEC void rvSdpRtpMapSetChannels(RvSdpRtpMap*  x,int channels);
RV_SDP_DECLSPEC int rvSdpRtpMapGetChannels(const RvSdpRtpMap*  x);

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

typedef struct {
	RvString			information;
	RvSdpBandwidth*		bandwidth;
	RvSdpConnection*	connection;

	RvSdpKey*			key;
	RvSdpConnectionMode	send_mode;

	/* List of attributes */
	RvSdpAttributeList	attr_list;
	/* List of rtp maps */
	RvSdpRtpMapList		rtp_map_list;

} RvSdpCommonFields;		/* Fields common to session level and and media description level */

RV_SDP_DECLSPEC void rvSdpCommonFieldsConstruct(RvSdpCommonFields* c,RvAlloc* a);
RV_SDP_DECLSPEC void rvSdpCommonFieldsDestruct(RvSdpCommonFields* c,RvAlloc* a);
RV_SDP_DECLSPEC void rvSdpCommonFieldsSetConnectionN(RvSdpCommonFields* fields,RvSdpNetType type,RvSdpAddrType addr_type,const char* addr,int addr_len,RvAlloc* alloc); 
RV_SDP_DECLSPEC void rvSdpCommonFieldsSetKeyN(RvSdpCommonFields* fields,RvSdpEncrMethod em,const char* key,int key_len,RvAlloc* alloc);		
RV_SDP_DECLSPEC void rvSdpCommonFieldsSetKeyCopy(RvSdpCommonFields* fields,RvSdpKey* s,RvAlloc* alloc);
RV_SDP_DECLSPEC RvSdpAttribute * rvSdpCommonFieldsAddAttrN(RvSdpCommonFields* fields, const char *name, size_t nlen, const char* value, size_t vlen,RvAlloc* alloc); 
RV_SDP_DECLSPEC RvSdpRtpMap* rvSdpCommonFieldsAddRtpMapN(RvSdpCommonFields* fields,int payload,const char* encoding_name,size_t len,int rate,RvAlloc* a);
RV_SDP_DECLSPEC void rvSdpCommonFieldsSetInformationN(RvSdpCommonFields* fields, const char *info, size_t len);
RV_SDP_DECLSPEC void rvSdpCommonFieldsSetBandwidthN(RvSdpCommonFields* fields, const char *bwtype, size_t len,int b,RvAlloc* alloc);

/*void rvSdpCommonFieldsSetConnectionMode(RvSdpCommonFields* fields,RvSdpConnectionMode mode);*/
#define rvSdpCommonFieldsSetConnectionMode(fields,mode) ((fields)->send_mode = mode)
/*RvSdpConnectionMode rvSdpCommonFieldsGetConnectionMode(RvSdpCommonFields* fields);*/
#define rvSdpCommonFieldsGetConnectionMode(fields) ((fields)->send_mode)

#if defined(__cplusplus)
}
#endif

#endif /* RV_SDPOBJS_H */