开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
packet.h
资源名称：h323.zip　[点击查看]
上传用户：hnnddl
上传日期：2007-01-06
资源大小：3580k
文件大小：10k
源码类别：

IP电话/视频会议

开发平台：

WINDOWS

packet.h：源码内容
  1. /*
  2.  * $Revision: 1.5 $
  3.  * $Date: 1997/11/20 19:23:11 $
  4.  */
  6. ////////////////////////////////////////////////////////////////
  7. //               Copyright (c) 1996,97 Lucent Technologies    //
  8. //                       All Rights Reserved                  //
  9. //                                                            //
  10. //                       THIS IS UNPUBLISHED                  //
  11. //                       PROPRIETARY SOURCE                   //
  12. //                   CODE OF Lucent Technologies              //
  13. //      AND elemedia    //
  14. //                                                            //
  15. //           The copyright notice above does not evidence any //
  16. //          actual or intended publication of such source code//
  17. ////////////////////////////////////////////////////////////////
  18. //
  19. /////////////////////////////////////////////////////////////////
  20. // File : pkt.h        //
  21. //                                                             //
  22. // This file declares  RTPPacket and RTCPPacket classes        //
  23. //    //
  24. //                                                            //
  25. // History:    //
  26. //  20_Jan_1997 Created    //
  27. // 17_Feb_1997                                                //
  28. //  14_Feb_1997 Cosmetic changes to fn names and arg list.     //
  29. // 01_May_1997 max_payload_length, max_datagram_length..    //
  30. // 08_Jul_1997 Merged Sun5 changes.    //
  31. // 20_Aug_1997 Another Frame function in RTPPacket, for    //
  32. // retransissions..    //
  33. // 04_Nov_1997 Updated the payload types for RTP    //
  34. // 17_Nov_1997 Added 2 new variants of RTPPacket::Frame    //
  35. // these methods allow the caller to supply    //
  36. // the buffer, hence avoiding a copy operation.   //
  37. //    //
  38. /////////////////////////////////////////////////////////////////
  40. #if !defined(__PKT_H__)
  41. #define __PKT_H__
  43. #define MASK(BITS,SHIFT) (((1 << (BITS)) - 1) << (SHIFT))
  44. enum
  45. {
  46. RTP_VERSION_BITS = 2U,
  47. RTP_VERSION_SHIFT = 14U,
  48. RTP_VERSION_MASK = MASK(RTP_VERSION_BITS,RTP_VERSION_SHIFT),
  49. RTP_PADDING_BITS = 1U,
  50. RTP_PADDING_SHIFT = 13U,
  51. RTP_PADDING_MASK = MASK(RTP_PADDING_BITS,RTP_PADDING_SHIFT),
  52. RTP_EXTENSION_BITS = 1U,
  53. RTP_EXTENSION_SHIFT = 12U,
  54. RTP_EXTENSION_MASK = MASK(RTP_EXTENSION_BITS,RTP_EXTENSION_SHIFT),
  55. RTP_CC_BITS = 4U,
  56. RTP_CC_SHIFT = 8U,
  57. RTP_CC_MASK = MASK(RTP_CC_BITS,RTP_CC_SHIFT),
  58. RTP_MARKER_BITS = 1U,
  59. RTP_MARKER_SHIFT = 7U,
  60. RTP_MARKER_MASK = MASK(RTP_MARKER_BITS,RTP_MARKER_SHIFT),
  61. RTP_PT_BITS = 7U,
  62. RTP_PT_SHIFT = 0U,
  63. RTP_PT_MASK = MASK(RTP_PT_BITS,RTP_PT_SHIFT)
  64. };
  66. #define RTP_GET_VERSION(F) (((F) & RTP_VERSION_MASK) >> RTP_VERSION_SHIFT)
  67. #define RTP_GET_PADDING(F) (((F) & RTP_PADDING_MASK) >> RTP_PADDING_SHIFT)
  68. #define RTP_GET_CC(F) (((F) & RTP_CC_MASK) >> RTP_CC_SHIFT)
  69. #define RTP_GET_PT(F) (((F) & RTP_PT_MASK) >> RTP_PT_SHIFT)
  70. #define RTP_GET_EXTENSION(F) (((F) & RTP_EXTENSION_MASK) >>
  71. RTP_EXTENSION_SHIFT)
  72. #define RTP_GET_MARKER(F) (((F) & RTP_MARKER_MASK) >> RTP_MARKER_SHIFT)
  74. #define RTP_SET_VERSION(F,V)
  75. {
  76. (F) &= ~RTP_VERSION_MASK;
  77. (F) |= ((V) << RTP_VERSION_SHIFT)
  78. & RTP_VERSION_MASK;
  79. }
  81. #define RTP_SET_PADDING(F,P)
  82. {
  83. (F) &= ~RTP_PADDING_MASK;
  84. (F) |= ((P) << RTP_PADDING_SHIFT)
  85. & RTP_PADDING_MASK;
  86. }
  88. #define RTP_SET_EXTENSION(F,E)
  89. {
  90. (F) &= ~RTP_EXTENSION_MASK;
  91. (F) |= ((E) << RTP_EXTENSION_SHIFT)
  92. & RTP_EXTENSION_MASK;
  93. }
  95. #define RTP_SET_CC(F,COUNT)
  96. {
  97. (F) &= ~RTP_CC_MASK;
  98. (F) |= ((COUNT) << RTP_CC_SHIFT)
  99. & RTP_CC_MASK;
  100. }
  103. #define RTP_SET_MARKER(F,M)
  104. {
  105. (F) &= ~RTP_MARKER_MASK;
  106. (F) |= ((M) << RTP_MARKER_SHIFT)
  107. & RTP_MARKER_MASK;
  108. }
  110. #define RTP_SET_PT(F,PT)
  111. {
  112. (F) &= ~RTP_PT_MASK;
  113. (F) |= ((PT) << RTP_PT_SHIFT)
  114. & RTP_PT_MASK;
  115. }
  118. #define RTCP_GET_CUMULATIVE_LOSS(L)
  119. ((((unsigned long)L) & (unsigned long)0xFFFFFF00) >> 8)
  122. #define RTCP_GET_INCREMENTAL_LOSS(L) ((L) & 0xFF)
  125. enum
  126. {
  127. RTCP_VERSION_BITS = 2U,
  128. RTCP_VERSION_SHIFT = 14U,
  129. RTCP_VERSION_MASK = MASK(RTCP_VERSION_BITS,RTCP_VERSION_SHIFT),
  130. RTCP_PADDING_BITS = 1U,
  131. RTCP_PADDING_SHIFT = 13U,
  132. RTCP_PADDING_MASK = MASK(RTCP_PADDING_BITS,RTCP_PADDING_SHIFT),
  133. RTCP_CC_BITS = 5U,
  134. RTCP_CC_SHIFT = 8U,
  135. RTCP_CC_MASK = MASK(RTCP_CC_BITS,RTCP_CC_SHIFT),
  136. RTCP_PT_BITS = 8U,
  137. RTCP_PT_SHIFT = 0U,
  138. RTCP_PT_MASK = MASK(RTCP_PT_BITS,RTCP_PT_SHIFT)
  139. };
  142. #define RTCP_GET_VERSION(F)
  143. (((F) & RTCP_VERSION_MASK) >> RTCP_VERSION_SHIFT)
  145. #define RTCP_GET_PADDING(F)
  146. (((F) & RTCP_PADDING_MASK) >> RTCP_PADDING_SHIFT)
  148. #define RTCP_GET_COUNT(F)
  149. (((F) & RTCP_CC_MASK) >> RTCP_CC_SHIFT)
  151. #define RTCP_GET_PT(F)
  152. (((F) & RTCP_PT_MASK) >> RTCP_PT_SHIFT)
  155. #define RTCP_SET_VERSION(F,V)
  156. {
  157. (F) &= ~RTCP_VERSION_MASK;
  158. (F) |= ((V) << RTCP_VERSION_SHIFT)
  159. & RTCP_VERSION_MASK;
  160. }
  162. #define RTCP_SET_PADDING(F,P)
  163. {
  164. (F) &= ~RTCP_PADDING_MASK;
  165. (F) |= ((P) << RTCP_PADDING_SHIFT)
  166. & RTCP_PADDING_MASK;
  167. }
  170. #define RTCP_SET_COUNT(F,COUNT)
  171. {
  172. (F) &= ~RTCP_CC_MASK;
  173. (F) |= ((COUNT) << RTCP_CC_SHIFT)
  174. & RTCP_CC_MASK;
  175. }
  177. #define RTCP_SET_PT(F,PT)
  178. {
  179. (F) &= ~RTCP_PT_MASK;
  180. (F) |= ((PT) << RTCP_PT_SHIFT)
  181. & RTCP_PT_MASK;
  182. }
  184. #undef MASK
  186. class Logger;
  188. class DLLEXPORT RTCPPacket 
  189. {
  190. public:
  192. friend class RTPSession;
  194. enum PayloadTypes
  195. {
  196. PT_SENDER_REPORT = 200,
  197. PT_RECEIVER_REPORT = 201,
  198. PT_SDES = 202,
  199. PT_BYE = 203,
  200. PT_APP = 204
  201. };
  203. enum SDESTypes
  204. {
  205. ST_CNAME = 1,
  206. ST_NAME = 2,
  207. ST_EMAIL = 3,
  208. ST_PHONE = 4,
  209. ST_LOC = 5,
  210. ST_TOOL = 6,
  211. ST_NOTE = 7,
  212. ST_PRIV = 8
  213. };
  215. RTCPPacket(RTPSession *session);
  216. ~RTCPPacket();
  218. void GetSenderInfo(RTCPSenderInfo *&sender_info);
  220. int GetReceptionReports(
  221. RTCPReceptionReport *&reception_report_list);
  223. // Get the raw bytes for an RTCP packet,
  224. // for sending out on the n/w.
  226. char *GetPacket();
  227. int GetPacketLength();
  229. unsigned int GetSSRC();
  231. ProtReturnCode Deframe(char *data, int length, unsigned int ntp_sec,
  232. unsigned int ntp_frac);
  234. ProtReturnCode Frame(unsigned int rtp_time, unsigned int ntp_sec,
  235. unsigned int ntp_frac, int extra_sdes,
  236. int bye, char *bye_reason, int length);
  238. protected:
  239. char *data;
  240. int  length;
  242. // SSRC of the sender.
  244. unsigned int ssrc;
  246. // these are maintained in host byte order.
  248. RTCPSenderInfo *sender_info;
  249. RTCPReceptionReport *reception_reports;
  250. int rr_count;
  252. // The session to which this packet belongs
  254. RTPSession *session;
  256. private:
  258. Logger *_logger;
  259. };
  261. struct RTPHeader;
  263. // 
  264. // The RTP packet class.
  265. //
  267. class DLLEXPORT RTPPacket
  268. {
  269. public:
  271. friend class RTPSession;
  273. // List of RTP payload types
  275. enum PayloadType
  276. {
  277. // Video encodings...
  279. // PT_RGB8 = 23,  // 8-bit dithered RGB  --> UNASSIGNED
  280. // PT_HDCC = 24,  // SGI proprietary  --> UNASSIGNED
  281. PT_CELLB = 25,  // Sun CellB, 90000Hz
  282. PT_JPEG = 26, // JPEG, 90000Hz
  283. // PT_CUSEEME = 27,// Cornell CU-SeeMe --> UNASSIGNED
  284. PT_NV = 28, // Xerox PARC nv, 90000Hz
  285. // PT_PICW = 29, // BB&N PictureWindow --> UNASSIGNED
  286. // PT_CPV = 30, // Concept/Bolter/Viewpoint codec --> UNASSIGNED
  287. PT_H261 = 31, // ITU H.261, 90000Hz
  288. PT_MPEG = 32,  // MPEG-I & MPEG-II, 90000Hz
  289. PT_MP2T = 33,  // MPEG-II either audio or video, 90000Hz
  290. PT_H263 = 34, // ITU H.263, 90000Hz
  292. // Audio encodings...
  294. PT_PCMU = 0, // ITU G.711 Ulaw,8000Hz,1ch
  295. PT_CELP = 1, // 1016 audio,8000Hz,1ch
  296. PT_G726_32 = 2, // ITU G726, 8000Hz, 1ch (previously ITU G.721)
  297. PT_GSM = 3, // Group Speciale Mobile, GSM 6.10 audio,8000Hz,1ch
  298. PT_G723 = 4, // ITU G723.1,8000Hz,1ch
  299. PT_DVI4_8K = 5, // 8000Hz,1ch
  300. PT_DVI4_16K = 6,// 16000Hz,1ch
  301. PT_LPC = 7, // 8000Hz,1ch
  302. PT_PCMA = 8, // ITU G.711 Alaw,8000Hz,1ch
  303. PT_G722 = 9, // ITU G.722, 16000Hz,1ch
  304. PT_L16_2C = 10, // 44100Hz,2ch
  305. PT_L16_1C = 11, // 44100Hz,1ch
  306. PT_MPA = 14, // MPEG Audio,90000Hz
  307. PT_G728 = 15, // ITU G.728,8000Hz,1ch
  308. PT_DVI4_11 = 16,// DVI4 audio,11025Hz,1ch
  309. PT_DVI4_22 = 17,// DVI4 audio,22050Hz,1ch
  310. PT_G729 = 18,  // ITU G.729,8000Hz,1ch
  311. PT_CN = 19 // Comfort Noise?,8000Hz,1ch
  312. };
  314. // session: pointer to the session class to which
  315. // this packet belongs.
  316. // payload_length: The maximum length of the payload 
  317. // that is expected to be recd or sent in this session.
  319. RTPPacket(RTPSession *session, int max_payload_length = 0);
  320. ~RTPPacket();
  322. char *GetHeader();
  323. int GetHeaderLength();
  325. char* GetHeaderExt();
  326. int GetHeaderExtLength();
  327. int GetHeaderExtType();
  329. char *GetPayload();
  330. int GetPayloadLength();
  332. char *GetPacket();
  333. int GetPacketLength();
  335. // The following methods return information in
  336. // host byte order.
  338. unsigned short GetSequenceNumber();
  340. unsigned short GetFlags();
  341. ProtReturnCode SetFlags(unsigned short flags);
  343. unsigned int GetSSRC();
  344. unsigned int GetTimestamp();
  346. // Return the CSRC list.
  347. unsigned int *GetCSRCList();
  349. // Called to un-frame an incoming RTP packet.
  350. ProtReturnCode Deframe(char *data, int length,
  351. unsigned int arrival_time);
  353. // Called for framing an RTP packet, to be sent out. Sequence
  354. // numbers are generated internally.
  355. ProtReturnCode Frame(unsigned int rtp_time,
  356. int marker, int payload_length);
  358. // Buffer is user supplied, and note that the RTP header is
  359. // copied at the beginning of the buffer. 
  360. // Caveat: the buffer has to be aligned to a longword boundary
  361. //         in architectures that do not support misaligned accesses.
  362. ProtReturnCode Frame(char *buffer, int buffer_length,
  363. unsigned int rtp_time, int marker, int payload_length);
  365. // Called for framing an RTP packet to be sent out. Sequence
  366. // number can be supplied. This is used whenever a retransmission
  367. // of a lost packet is deemed necessary.
  368. ProtReturnCode Frame(unsigned short sequence_no, unsigned int rtp_time,
  369. int marker, int payload_length);
  371. // buffer is user supplied and note that the RTP header is
  372. // copied at the beginning of the buffer.
  373. // Caveat: the buffer has to be aligned to a longword boundary
  374. //         in architectures that do not support misaligned accesses.
  375. ProtReturnCode Frame(char *buffer, int buffer_length,
  376. unsigned short sequence_no, unsigned int rtp_time,
  377. int marker, int payload_length);
  379. // Methods return the maximum payload/packet lengths.
  380. int GetMaxPayloadLength();
  381. int GetMaxPacketLength();
  383. protected:
  385. RTPHeader *header;
  386. unsigned int * csrc_list;
  387. char *header_extension;
  388. int header_extension_length;
  389. int header_extension_type;
  390. char *payload;
  391. int max_payload_length;
  392. int cur_payload_length;
  394. unsigned short rtp_flags;
  396. // saved datagram.
  398. char *datagram;
  399. int max_datagram_length;
  400. int cur_datagram_length;
  402. RTPSession* session;
  404. private:
  406. Logger *_logger;
  407. };
  409. #endif