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

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

IP电话/视频会议

开发平台：

WINDOWS

rtptst.cpp：源码内容
  1. /*
  2.  * $Revision: 1.1 $
  3.  * $Date: 1997/08/15 15:45:39 $
  4.  */
  6. ////////////////////////////////////////////////////////////////
  7. //               Copyright (c) 1996 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. ////////////////////////////////////////////////////////////////
  19. /////////////////////////////////////////////////////////////////
  20. // File : rtptst.cpp    //
  21. //                                                             //
  22. // Test the RTP library.                                       //
  23. // Bidirectional RTP pipe.                                     //
  24. // Read from local and write into remote and vice versa..      //
  25. // Treats packets from remote side as being conformat to the   //
  26. // RTP protocol, and the local side as raw UDP packets.    //
  27. //                                                             //
  28. //    ---------------------------------------------            //
  29. //     REMOTE         RTPTST.EXE           LOCAL               //
  30. //      END                                 END                //
  31. //    ---------------------------------------------            //
  32. //      RTP ----->   Deframe RTP -----> UDP packets            //
  33. //      Packets                                                //
  34. //                                                             //
  35. //      RTP                                                    //
  36. //      Packets <------Frame RTP <-----UDP packets             //
  37. //                                                            //
  38. // History:    //
  39. //  24_Jan_1997 Created    //
  40. // 15_Aug_1997 Merged the win32 and unix versions.    //
  41. //    //
  42. /////////////////////////////////////////////////////////////////
  44. #include "stdio.h"
  45. #if (defined(WIN32))
  46. #include <windows.h>
  47. #include <winsock.h>
  48. #include <assert.h>
  49. #else
  50. #include <sys/types.h>
  51. #include <sys/socket.h>
  52. #include <netdb.h>
  53. #include <netinet/in.h>
  54. #include <arpa/inet.h>
  55. #include <thread.h>
  56. #include <unistd.h>
  57. #include <signal.h>
  58. #include <errno.h>
  59. #endif
  61. #include "rtp/rtp.h"
  63. #if (!defined(WIN32))
  64. #define SOCKET_ERROR -1
  65. #if (defined(__sun))
  66. #define INADDR_NONE 0xFFFFFFFF
  67. #endif
  68. typedef int SOCKET;
  69. #endif
  71. #define NUM_PATHS 2
  72. #define RTCP_INTERVAL 60 // rtcp activity once every 60 packets(90ms).
  74. char ip_address[2][256];
  75. unsigned short src_port[NUM_PATHS];
  76. unsigned short dst_port[NUM_PATHS];
  77. struct sockaddr_in src_addr[NUM_PATHS];
  78. struct sockaddr_in dst_addr[NUM_PATHS];
  79. SOCKET src[NUM_PATHS], dst[NUM_PATHS];
  80. SOCKET path[NUM_PATHS];
  81. SOCKET rtcp[2];
  82. struct sockaddr_in rtcp_addr[NUM_PATHS];
  83. int use_rtp = 1;
  85. void
  86. print_usage(char *appname)
  87. {
  88. printf("Usage: %s nonrtp-ip/input/output rtp-ip/input/outputn", appname);
  89. }
  91. void
  92. addr_init(struct sockaddr_in *addr, char *ip_address, 
  93. unsigned short port)
  94. {
  95. unsigned long ip;
  97. memset(addr, 0, sizeof(*addr));
  98. addr->sin_family = AF_INET;
  99. addr->sin_port = htons(port);
  101. if (ip_address)
  102. {
  103. ip = inet_addr(ip_address); 
  104. if (ip == INADDR_NONE)
  105. {
  106. struct hostent *hent_p = 
  107. gethostbyname((char *)ip_address);
  109. if(hent_p == NULL)
  110. {
  111. printf("Gethostbyname failed on %sn",ip_address);
  112. return;
  113. }
  115. ip = *(unsigned long *)(hent_p->h_addr_list[0]);
  116. }
  117. }
  118. else
  119. {
  120. ip = INADDR_ANY;
  121. }
  123. addr->sin_addr.s_addr = ip;
  124. }
  126. void 
  127. socket_error(SOCKET s, char *message)
  128. {
  129. #if (defined(WIN32))
  130. printf("socket = %d, errno = %d, %sn",
  131. s, WSAGetLastError(), message);
  133. #else
  134. printf("socket = %d, errno = %d, %sn",
  135. s, errno, message);
  136. #endif
  137. }
  139. void just_do_it()
  140. {
  141. fd_set  read_fds;
  142. char buffer[4096];
  143. char *buf = buffer;
  144. int buf_len = sizeof(buffer);
  145. int length;
  146. int i;
  147. int packets_sent_count = 0;
  148. int packets_recd_count = 0;
  150. printf("Begin...n");
  152. path[0] = dst[1];
  153. path[1] = dst[0];
  155. FD_ZERO(&read_fds);
  157. for (i=0; i<NUM_PATHS; ++i)
  158. {
  159. FD_SET(src[i],&read_fds);
  160. }
  162. if (use_rtp)
  163. {
  164. boolean frame[2];
  165. RTPSession session(ip_address[0],RTPPacket::PT_PCMU,8000);
  166. RTPPacket *framer = NULL;
  167. RTPPacket *deframer = NULL;
  168. RTCPPacket rtcp_packet(&session);
  169. int nfds = 0;
  171. deframer = new RTPPacket(&session,0);
  172. frame[0] = TRUE;
  173. frame[1] = FALSE;
  175. for (i=0;i<NUM_PATHS;++i)
  176. {
  177. if (nfds < src[i])
  178. {
  179. nfds = src[i];
  180. }
  181. }
  182. nfds++;
  184. while (1)
  185. {
  186. select(nfds, &read_fds, NULL, NULL, NULL);
  188. for (i=0;i<NUM_PATHS;++i)
  189. {
  190. if (FD_ISSET(src[i],&read_fds))
  191. {
  192. if (frame[i])
  193. {
  195. if (!framer)
  196. {
  197. length = recv(src[i],buf, buf_len,0);
  198. framer = new RTPPacket(&session,length);
  199. printf("Framer created payload len = %d, packetlen = %dn",
  200. length, framer->GetMaxPacketLength());
  201. memcpy(framer->GetPayload(), buf, length);
  202. }
  203. else
  204. {
  205. length = recv(src[i],framer->GetPayload(),
  206. framer->GetMaxPayloadLength(),0);
  207. }
  209. framer->Frame(session.GetMediaTime(),0, length);
  211. send(path[i], framer->GetPacket(),
  212. framer->GetPacketLength(),0);
  214. packets_sent_count++;
  216. }
  217. else
  218. {
  219. length = recv(src[i],buf,buf_len,0);
  221. if (length > 0)
  222. {
  223. int ret = 
  224. deframer->Deframe(buf,length, session.GetMediaTime());
  226. if (ret != 0)
  227. {
  228. printf("RTPPacket::Deframe returned %dn",ret);
  229. }
  230. send(path[i], deframer->GetPayload(),
  231. deframer->GetPayloadLength(),0);
  232. ++packets_recd_count;
  233. }
  234. }
  235. }
  236. }
  238. if (FD_ISSET(rtcp[0],&read_fds))
  239. {
  240. unsigned int ntp_sec;
  241. unsigned int ntp_frac;
  242. RTCPSenderInfo *sender_info;
  244. printf("Received rtcp packet..n");
  246. length = recv(rtcp[0], buf,buf_len,0);
  248. ntp64time(ntp_sec,ntp_frac);
  251. rtcp_packet.Deframe(buf,length, ntp_sec,
  252. ntp_frac);
  255. rtcp_packet.GetSenderInfo(sender_info);
  257. if (sender_info)
  258. {
  259. printf("Sender info..n");
  260. printf("Num packets = %dn", sender_info->sr_np);
  261. printf("Num bytes = %dn", sender_info->sr_nb);
  262. }
  266. int rr;
  267. RTCPReceptionReport *rr_list;
  269. rr = rtcp_packet.GetReceptionReports(rr_list);
  271. printf("Receiver report for %d reportsn",rr);
  273. while (rr > 0)
  274. {
  275. printf("{n"
  276. "trr_srcid = 0x%lxn"
  277. "trr_loss = %d:%dn"
  278. "trr_ehsr = %dn"
  279. "trr_dv = %dn"
  280. "trr_lsr = %dn"
  281. "trr_dlsr = %dn"
  282. "}n",
  283. rr_list[rr - 1].rr_srcid,
  284. RTCP_GET_INCREMENTAL_LOSS(rr_list[rr - 1].rr_loss),
  285. RTCP_GET_CUMULATIVE_LOSS(rr_list[rr - 1].rr_loss),
  286. rr_list[rr - 1].rr_ehsr,
  287. rr_list[rr - 1].rr_dv,
  288. rr_list[rr - 1].rr_lsr,
  289. rr_list[rr - 1].rr_dlsr);
  290. --rr;
  291. }
  293. RTPEndpointInfo *e;
  295. e = session.GetParticipant(rtcp_packet.GetSSRC());
  296. if (e)
  297. {
  298. RTPEndpointStats res;
  300. e->GetStatistics(res);
  302. printf("Endpoint stats for 0x%lxn"
  303. "{n"
  304. "tprobation = %dn"
  305. "tmisorder = %dn"
  306. "treceived = %dn"
  307. "tdelay_variance = %dn"
  308. "tpackets_sent = %dn"
  309. "toctets_sent = %dn"
  310. "}n",
  311. res.es_ssrc,
  312. res.es_probation,
  313. res.es_misorder,
  314. res.es_received,
  315. res.es_delay_variance,
  316. res.es_packets_sent,
  317. res.es_octets_sent);
  318. }
  319. }
  321. if ((packets_sent_count == RTCP_INTERVAL) || (packets_recd_count ==
  322. RTCP_INTERVAL))
  323. {
  324. unsigned int ntp_sec;
  325. unsigned int ntp_frac;
  327. //TODO
  328. // build and send an RTCP report
  331. printf("Sending rtcp packet..n");
  333. ntp64time(ntp_sec,ntp_frac);
  335. rtcp_packet.Frame(session.GetMediaTime(), ntp_sec,
  336. ntp_frac, 0,0, NULL,0);
  338. send(rtcp[1],rtcp_packet.GetPacket(),
  339. rtcp_packet.GetPacketLength(),0);
  341. if (packets_sent_count == RTCP_INTERVAL)
  342. {
  343. packets_sent_count = 0;
  344. }
  345. else
  346. {
  347. packets_recd_count = 0;
  348. }
  350. }
  353. FD_ZERO(&read_fds);
  355. for (i=0; i<NUM_PATHS; ++i)
  356. {
  357. FD_SET(src[i],&read_fds);
  358. }
  360. FD_SET(rtcp[0],&read_fds); // rtcp socket.
  361. }
  362. }
  363. else
  364. {
  365. while (1)
  366. {
  368. select(0, &read_fds, NULL, NULL, NULL);
  371. for (i=0;i<NUM_PATHS;++i)
  372. {
  373. if (FD_ISSET(src[i],&read_fds))
  374. {
  375. length = recv(src[i],buf,buf_len,0);
  376. if (length > 0)
  377. {
  378. send(path[i],buf,length,0);
  379. }
  380. }
  381. }
  383. FD_ZERO(&read_fds);
  385. for (i=0; i<NUM_PATHS; ++i)
  386. {
  387. FD_SET(src[i],&read_fds);
  388. }
  390. }
  391. }
  393. }
  394. int
  395. parse_command_line(int argc, char **argv)
  396. {
  397. int tmp1;
  398. int tmp2;
  400. if (argc < 3)
  401. {
  402. return 1;
  403. }
  406. if (sscanf(argv[1], "%[^/]%*[/]%d%*[/]%d", ip_address[0], 
  407. &tmp1, &tmp2) != 3)
  408. {
  409. return 1;
  410. }
  411. src_port[0] = tmp1;
  412. dst_port[0] = tmp2;
  414. if (sscanf(argv[2], "%[^/]%*[/]%d%*[/]%d", ip_address[1], 
  415. &tmp1, &tmp2) != 3)
  416. {
  417. return 1;
  418. }
  420. src_port[1] = tmp1;
  421. dst_port[1] = tmp2;
  423. printf("%s/%d/%dn",ip_address[0], src_port[0], dst_port[0]);
  424. printf("%s/%d/%dn",ip_address[1], src_port[1], dst_port[1]);
  426. if (argc >= 4)
  427. {
  428. if (!stricmp(argv[3],"nortp"))
  429. use_rtp = 0;
  430. else
  431. use_rtp = 1;
  432. }
  434. printf("USE_RTP = %sn",use_rtp ? "Yes" : "No");
  436. return 0;
  437. }
  439. int
  440. main (int argc, char ** argv)
  441. {
  442. #if (defined(WIN32))
  443.     WSADATA wsadata;
  445. WSAStartup(MAKEWORD(1,1), &wsadata);
  446. #endif
  448. if (parse_command_line(argc,argv))
  449. {
  450. print_usage(argv[0]);
  451. exit(1);
  452. }
  454. int i;
  456. // the sockets...
  458. src[0] = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
  459. src[1] = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
  460. dst[0] = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
  461. dst[1] = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
  463. if (src[0] == SOCKET_ERROR || dst[0] == SOCKET_ERROR ||
  464. (src[1] == SOCKET_ERROR || dst[1] == SOCKET_ERROR))
  465. {
  466. #if (defined(WIN32))
  467. printf("Socket creation failed %dn", WSAGetLastError());
  468. #else
  469. printf("Socket creation failed %dn", errno);
  470. #endif
  471. exit(0);
  472. }
  474. for (i=0;i<NUM_PATHS; ++i)
  475. {
  476. addr_init(src_addr + i, NULL, src_port[i]);
  477. addr_init(dst_addr + i, ip_address[i], dst_port[i]);
  479. printf("binding on socket = %d, ip = 0x%lx, port = %dn", src[i], 
  480. htonl(((struct sockaddr_in*)(src_addr + i))->sin_addr.s_addr),
  481. htons(((struct sockaddr_in*)(src_addr + i))->sin_port));
  482. if (bind(src[i],(struct sockaddr*)(src_addr + i),
  483. sizeof(struct sockaddr_in)) == SOCKET_ERROR)
  484. {
  485. socket_error(src[i],"bind");
  486. exit(1);
  487. }
  489. printf("connect on socket = %d, ip = 0x%x, port = %dn", dst[i], 
  490. htonl(((struct sockaddr_in*)(dst_addr + i))->sin_addr.s_addr),
  491. htons(((struct sockaddr_in*)(dst_addr + i))->sin_port));
  492. if (connect(dst[i],(struct sockaddr*)(dst_addr + i),
  493. sizeof(struct sockaddr_in)) == SOCKET_ERROR)
  494. {
  495. socket_error(dst[i],"connect");
  496. exit(1);
  497. }
  499. }
  501. rtcp[0] = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);// recv
  502. rtcp[1] = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP); // send
  504. addr_init(rtcp_addr + 0, NULL, src_port[1] + 1); // listen
  505. addr_init(rtcp_addr + 1, ip_address[1], dst_port[1] + 1); // send
  507. if (connect(rtcp[1],(struct sockaddr*)(rtcp_addr + 1),
  508. sizeof(struct sockaddr_in)) == SOCKET_ERROR)
  509. {
  510. socket_error(rtcp[1],"connect");
  511. exit(1);
  512. }
  514. if (bind(rtcp[0],(struct sockaddr*)(rtcp_addr + 0),
  515. sizeof(struct sockaddr_in)) == SOCKET_ERROR)
  516. {
  517. socket_error(rtcp[0],"bind");
  518. exit(1);
  519. }
  521. just_do_it();
  522. }