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

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

IP电话/视频会议

开发平台：

WINDOWS

rtpstuff.cpp：源码内容
  1. /*
  2.  * $Revision: 1.15 $
  3.  * $Date: 1998/11/03 19:29:00 $
  4.  */
  6. ////////////////////////////////////////////////////////////////
  7. //               Copyright (c) 1996-98 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. // Example programs are provided soley to demonstrate one     //
  21. // possible use of the stack libraries and are included for   //
  22. // instructional purposes only.  You are free to use, modify  //
  23. // and/or redistribute any portion of code in the example     //
  24. // programs.  However, such examples are not intended to      //
  25. // represent production quality code.                         //
  26. //                                                            //
  27. // THE COPYRIGHT HOLDERS PROVIDE THESE EXAMPLE PROGRAMS       //
  28. // "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED     //
  29. // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED     //
  30. // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A            //
  31. // PARTICULAR PURPOSE.                                        //
  32. ////////////////////////////////////////////////////////////////
  34. #include <stdio.h>
  35. #include <fcntl.h>
  37. #if (defined(WIN32))
  38. #include <windows.h>
  39. #include <winsock.h>
  40. #include <assert.h>
  41. #elif defined(VXWORKS)
  42. #include "vxWorks.h"
  43. #include "taskLib.h"
  44. #include "semLib.h"
  45. #include "selectLib.h"
  46. #include "fcntl.h"
  47. #include "sockLib.h"
  48. #include "inetLib.h"
  49. #include "hostLib.h"
  50. #else
  51. #include <sys/types.h>
  52. #include <sys/socket.h>
  53. #include <netdb.h>
  54. #include <netinet/in.h>
  55. #include <arpa/inet.h>
  56. #if (defined(__hpux))
  57. #include <pthread.h>
  58. #else
  59. #include <thread.h>
  60. #endif
  61. #include <unistd.h>
  62. #include <signal.h>
  63. #include <errno.h>
  64. #if (defined(USE_POLL))
  65. #include <stropts.h>
  66. #include <sys/poll.h>
  67. #endif
  68. #endif
  70. #include "exchange.h"
  71. #include "util/platform.h"
  72. #include "rtpstuff.h"
  73. #include "api/apierr.h"
  75. #if (!defined(WIN32))
  76. #define INVALID_SOCKET  -1
  77. #define INVALID_HANDLE_VALIE -1
  78. #define SOCKET_ERROR -1
  79. #endif
  81. #define RTCP_INTERVAL 60
  83. #define FRAMES_PER_RTP_PACKET 3
  84. #define AUDIO_FRAME_SIZE 24
  85. #define AUDIO_FRAME_SIZE_IN_MS 30
  88. #if (defined(VXWORKS))
  89. #define AUDIO_FILE "/tmp/sample.723"
  90. #else
  91. #define AUDIO_FILE "sample.723"
  92. #endif
  95. #define PORT_LOWER_LIMIT 8000
  96. #define PORT_UPPER_LIMIT 10000
  98. static unsigned short next_port = PORT_LOWER_LIMIT;
  100. // ip and port in netbyte order...
  101. int
  102. H245RTPSession::my_bind(SOCKET s, unsigned int ip, unsigned short *port)
  103. {
  104. sockaddr_in addr;
  105. int ret;
  107. addr.sin_family = AF_INET;
  108. addr.sin_port =  (*port) ? (*port) : htons(INADDR_ANY);
  109. #if (defined(VXWORKS)) // vxworks does not allow us to bind to a named address
  110. addr.sin_addr.s_addr =  htonl(INADDR_ANY);
  111. #else
  112. addr.sin_addr.s_addr = (ip) ? (ip) : htonl(INADDR_ANY);
  113. #endif
  115. {
  116. ret = bind(s, (sockaddr*)&addr, sizeof(addr));
  118. if (!ret)
  119. {
  120. #if(defined(__sun) || defined(WIN32))
  121. int address_length = sizeof(addr);
  122. #else
  123. size_t address_length = sizeof(addr);
  124. #endif
  126. #if defined(__hpux)
  127. ::getsockname(s, (sockaddr *)&addr, (int *)&address_length);
  128. #else
  129. ::getsockname(s, (sockaddr *)&addr, &address_length);
  130. #endif
  132. *port = addr.sin_port;
  133. }
  134. }
  135. return ret;
  136. }
  138. // ip and port in netbyte order..
  139. int
  140. H245RTPSession::my_connect(SOCKET s, unsigned int ip, unsigned short port)
  141. {
  142. sockaddr_in addr;
  144. addr.sin_family = AF_INET;
  145. addr.sin_port =  port;
  146. addr.sin_addr.s_addr = ip;
  148. return connect(s, (sockaddr*)&addr, sizeof(addr));
  149. }
  151. void 
  152. H245RTPSession::socket_error(SOCKET s, char *message)
  153. {
  154. LOG("H245RTPSession::socket_errorn");
  156. #if (defined(WIN32))
  157. LOG("H245RTPSession::socket = %d, errno = %d, %sn",
  158. s, WSAGetLastError(), message);
  160. #else
  161. LOG("H245RTPSession::socket = %d, errno = %d, %sn",
  162. s, errno, message);
  163. #endif
  164. }
  167. // return 0 on success, -1 on failure.
  168. H245RTPSession::H245RTPSession(char * session_name, int pt,int sr, int &status):
  169. RTPSession(session_name, pt, sr)
  170. {
  171. LOG("H245RTPSession::H245RTPSessionn");
  173. audio_fh = NULL;
  174. framer = deframer = NULL;
  175. rtcp_packet = NULL;
  177. status = 0;
  178. lrtp_port = 0;
  179. lrtcp_port = 0;
  180. rrtp_port = 0;
  181. rrtcp_port = 0;
  183. current_tc = 0;
  185. remote_address = 0;
  186. local_address = HTONS(INADDR_ANY);
  188. #if defined(WIN32)
  189. stop_rtpsession_socket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
  190. #elif defined(VXWORKS)
  191. stop_rtpsession_socket = -1;
  192. #else
  193. if (pipe(stop_rtpsession_pipefds) < 0)
  194. {
  195. LOG("pipe creation failedn");
  196. }
  198. stop_rtpsession_socket = stop_rtpsession_pipefds[0];
  199. #endif
  201. lrtp_socket = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
  202. lrtcp_socket = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
  203. rrtp_socket = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
  204. rrtcp_socket = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
  206. if ( lrtp_socket == INVALID_SOCKET ||
  207. lrtcp_socket== INVALID_SOCKET ||
  208. rrtp_socket== INVALID_SOCKET ||
  209. rrtcp_socket== INVALID_SOCKET
  210. #if !defined(VXWORKS) && !defined(__hpux)
  211. || stop_rtpsession_socket == INVALID_SOCKET
  212. #endif
  213. )
  214. {
  215. status = -1;
  216. socket_error((unsigned int)-1,"Socket creation failedn");
  217. }
  219. #if (defined(VXWORKS))
  220. thread_id = ERROR;
  221. #elif (defined(__hpux))
  222. thread_id = cma_c_null;
  223. #else
  224. thread_id = 0;
  225. #if (defined(WIN32))
  226. thread_handle = INVALID_HANDLE_VALUE;
  227. #endif
  228. #endif
  229. }
  231. H245RTPSession::~H245RTPSession()
  232. {
  233. // Stop the RTP session...
  234. StopSession();
  236. #if (!defined(WIN32))
  237. #define closesocket close
  238. #endif
  240. if (lrtp_socket != INVALID_SOCKET)
  241. {
  242. closesocket(lrtp_socket);
  243. }
  245. if (lrtcp_socket != INVALID_SOCKET)
  246. {
  247. closesocket(lrtcp_socket);
  248. }
  250. if (rrtp_socket != INVALID_SOCKET)
  251. {
  252. closesocket(rrtp_socket);
  253. }
  255. if (rrtcp_socket != INVALID_SOCKET)
  256. {
  257. closesocket(rrtcp_socket);
  258. }
  260. #if !defined(WIN32)
  261. #undef closesocket
  262. #endif
  264. // Free up other resources..
  266. // asked to terminate ourselves;
  267. if (audio_fh != NULL)
  268. {
  269. fclose(audio_fh);
  270. audio_fh = NULL;
  271. }
  272. if (framer)
  273. {
  274. delete framer;
  275. }
  277. if (deframer)
  278. {
  279. delete deframer;
  280. }
  282. if (rtcp_packet)
  283. {
  284. delete rtcp_packet;
  285. }
  286. #if (!defined(WIN32) && !defined(VXWORKS))
  287. if (stop_rtpsession_pipefds[0] != INVALID_SOCKET)
  288. {
  289. close(stop_rtpsession_pipefds[0]);
  290. close(stop_rtpsession_pipefds[1]);
  291. }
  292. #endif
  293. }
  295. int 
  296. H245RTPSession::SetLocalPorts(unsigned int ip, unsigned short &rtp_port, 
  297. unsigned short &rtcp_port)
  298. {
  299. unsigned short tmp1, tmp2;
  301. local_address = ip;
  302. if (rtp_port == 0 || rtcp_port == 0)
  303. {
  304. tmp1 = htons(next_port);
  305. tmp2 = htons(next_port + 1);
  306. next_port += 2;
  308. if (next_port == PORT_UPPER_LIMIT)
  309. {
  310. next_port = PORT_LOWER_LIMIT;
  311. }
  312. }
  313. else
  314. {
  315. tmp1 = rtp_port;
  316. tmp2 = rtcp_port;
  317. }
  318. // Warning! if bind fails on the following, you should try binding 
  319. //          for the next consecutive pair of ports and not simply return error
  320. if (!lrtp_port)
  321. {
  322. lrtp_port = tmp1;
  323. if (my_bind(lrtp_socket, ip, &lrtp_port) == SOCKET_ERROR)
  324. {
  325. socket_error(lrtp_socket, "bind, lrtp_socket");
  326. return(-1);
  327. }
  328. rtp_port = lrtp_port;
  329. }
  330. else
  331. {
  332. rtp_port = lrtp_port;
  333. }
  335. if (!lrtcp_port)
  336. {
  337. lrtcp_port = tmp2;
  339. if (my_bind(lrtcp_socket, ip, &lrtcp_port) == SOCKET_ERROR)
  340. {
  341. socket_error(lrtp_socket, "bind, lrtp_socket");
  342. return(-1);
  343. }
  344. rtcp_port = lrtcp_port;
  345. }
  346. else
  347. {
  348. rtcp_port = lrtcp_port;
  349. }
  352. return(0);
  353. }
  355. void
  356. H245RTPSession::GetLocalPorts(unsigned int& ip, unsigned short &rtp_port,
  357. unsigned short &rtcp_port)
  358. {
  359. ip = local_address;
  360. rtp_port = lrtp_port;
  361. rtcp_port = lrtcp_port;
  362. }
  364. // assumes unicast ip address for now....
  366. int
  367. H245RTPSession::SetRemotePorts(unsigned int ip, unsigned short rtp_port, 
  368. unsigned short rtcp_port)
  369. {
  370. remote_address = ip;
  373. if (!rrtp_port && rtp_port) 
  374. {
  375. rrtp_port = rtp_port;
  376. if (my_connect(rrtp_socket, ip, rrtp_port) == SOCKET_ERROR)
  377. {
  378. socket_error(rrtp_socket, "connect, rrtp_socket");
  379. return(-1);
  380. }
  381. }
  383. if (!rrtcp_port && rtcp_port)
  384. {
  385. rrtcp_port = rtcp_port;
  386. if (my_connect(rrtcp_socket, ip, rrtcp_port) == SOCKET_ERROR)
  387. {
  388. socket_error(rrtp_socket, "connect, rrtp_socket");
  389. return(-1);
  390. }
  391. }
  394. return(0);
  395. }
  397. int
  398. H245RTPSession::StartSession()
  399. {
  400. static int first_time = 1;
  401. LOG("H245RTPSession::StartSessionn");
  403. if (init_rtp_session() != 0)
  404. {
  405. LOG("H245RTPSession:: cannot init h245 rtp sessionn");
  406. return(-1);
  407. }
  409. #if (defined(WIN32))
  410. thread_handle = (HANDLE) _beginthreadex(NULL, 
  411. 0 , 
  412. _begin_rtp_session,
  413. this, 
  414. 0,
  415. (unsigned *)&thread_id);
  417. if (thread_handle == INVALID_HANDLE_VALUE)
  418. {
  419. return(-1);
  420. }
  421. else
  422. {
  423. LOG("H245RTPSession::Successfully spawned rtp sessionn");
  424. }
  425. #elif (defined(VXWORKS))
  426. thread_id = taskSpawn("do_rtp",
  427. 90,
  428. 0,
  429. 8096,
  430. (FUNCPTR)_begin_rtp_session,
  431. (int)this,
  432. 0,0,0,0,0,0,0,0,0);
  433. if (thread_id == ERROR)
  434. {
  435. LOG("StartSession: taskSpawn failed, errno = 0x%xn", errno);
  436. return -1;
  437. }
  438. #elif (defined(__hpux))
  439.  
  440.     int ret = pthread_create(   &thread_id,
  441.                                 pthread_attr_default,
  442.                                 _begin_rtp_session,
  443.                                 this);
  444.  
  445.     LOG("StartSession: pthread_create returned for &thread_id: %xn",&thread_id)
  446. ;
  447.  
  448.     if (ret != 0)
  449.     {
  450.         LOG("StartSession: thread creation failed, errno = %dn", errno);
  451.         return(-1);
  452.     }
  453.     else
  454.     {
  455.         LOG("H245RTPSession::Successfully spawned rtp sessionn");
  456.     }
  457. #else
  458. int ret = thr_create(NULL, 
  459. 0 , 
  460. _begin_rtp_session,
  461. this, 
  462. 0,
  463. &thread_id);
  465. if (ret != 0)
  466. {
  467. LOG("StartSession: thread creation failed, errno = %dn", errno);
  468. return(-1);
  469. }
  470. else
  471. {
  472. LOG("H245RTPSession::Successfully spawned rtp sessionn");
  473. }
  474. #endif
  476. if (first_time)
  477. {
  478. first_time = 0;
  479. }
  480. return(0);
  481. }
  483. void 
  484. H245RTPSession::StopSession()
  485. {
  486. LOG("stopping session thread_id = %dn", thread_id);
  487. #if (defined(WIN32))
  488. if (thread_handle != INVALID_HANDLE_VALUE)
  489. {
  490. if (stop_rtpsession_socket != INVALID_SOCKET)
  491. {
  492. closesocket(stop_rtpsession_socket);
  493. stop_rtpsession_socket = INVALID_SOCKET;
  494. }
  496. // Wait for the thread to exit.
  498. if (WaitForSingleObject(thread_handle, 1000*5) == WAIT_TIMEOUT)
  499. {
  500. LOG("Wait for RTP thread timedoutn");
  501. TerminateThread(thread_handle,0);
  502. }
  504. CloseHandle(thread_handle);
  505. thread_handle = INVALID_HANDLE_VALUE;
  506. }
  507. #elif (defined(VXWORKS))
  508. if (thread_id != ERROR)
  509. {
  510. LOG("Calling taskIdVerify(%d)n",thread_id);
  511. if (taskIdVerify(thread_id) == OK)
  512. {
  513. LOG("Calling taskDelete(%d)n",thread_id);
  514. if (taskDelete(thread_id) == ERROR)
  515. {
  516. LOG("StopSession: taskDelete failed..n");
  517. }
  518. }
  519. }
  520. #elif (defined(__hpux))
  521.  
  522.     if (!pthread_equal(thread_id,cma_c_null))
  523.     {
  524.         pthread_t who_exited;
  525.         pthread_addr_t status;
  526.  
  527.         close (stop_rtpsession_pipefds[0]);
  528.         close (stop_rtpsession_pipefds[1]);
  529.  
  530.         stop_rtpsession_pipefds[0]=stop_rtpsession_pipefds[1] = INVALID_SOCKET;
  531.  
  532.         // Wait for the thread to exit.
  533.  
  534.         if (pthread_join(thread_id,&status) != 0)
  535.         {
  536.             LOG("Wait for RTP thread timedoutn");
  537.             pthread_cancel(thread_id);
  538.         }
  539.  
  540.         pthread_detach(&thread_id);
  541.  
  542.         thread_id = cma_c_null;
  543. }
  544. #else
  545. if (thread_id != 0)
  546. {
  547. thread_t who_exited;
  548. void *status;
  550. close (stop_rtpsession_pipefds[0]);
  551. close (stop_rtpsession_pipefds[1]);
  553. stop_rtpsession_pipefds[0]=stop_rtpsession_pipefds[1] = INVALID_SOCKET;
  555. // Wait for the thread to exit.
  557. if (thr_join(thread_id,&who_exited,&status) != 0)
  558. {
  559. LOG("Wait for RTP thread timedoutn");
  560. thr_kill(thread_id,SIGHUP);
  561. }
  562. thread_id = 0;
  563. }
  564. #endif
  565. }
  567. int 
  568. H245RTPSession::init_rtp_session()
  569. {
  570. LOG("H245RTPSession::init_rtp_sessionn");
  572. // assign port numbers and bind
  574. if (lrtp_port == 0 || lrtcp_port == 0)
  575. {
  576. if (SetLocalPorts(local_address, lrtp_port, lrtcp_port) 
  577. == -1)
  578. {
  579. LOG("H245RTPSession::SetLocalPorts failedn");
  580. return(-1);
  581. }
  582. }
  584. return(0);
  585. }
  587. void
  588. H245RTPSession::recv_rtcp_packet(SOCKET rtcp_sock,
  589. RTCPPacket *packet)
  590. {
  591. unsigned int ntp_sec;
  592. unsigned int ntp_frac;
  593. char buffer[4096];
  594. char *buf = buffer;
  595. int buf_len = sizeof(buffer);
  596. int length;
  599. length = recv(rtcp_sock, buf,buf_len,0);
  601. ntp64time(ntp_sec,ntp_frac);
  603. packet->Deframe(buf,length, ntp_sec,
  604. ntp_frac);
  606. #if (defined(__ENABLE_LOGGING__))
  607. RTCPSenderInfo *sender_info;
  608. packet->GetSenderInfo(sender_info);
  610. if (sender_info)
  611. {
  612. LOG("tSender infont{n");
  613. LOG("ttNum packets = %dn", sender_info->sr_np);
  614. LOG("ttNum bytes = %dnt}n", sender_info->sr_nb);
  615. }
  617. int rr;
  618. RTCPReceptionReport *rr_list;
  620. rr = packet->GetReceptionReports(rr_list);
  622. if (rr > 0)
  623. LOG("tReceiver report for %d receiversn",rr);
  625. while (rr > 0)
  626. {
  627. LOG("t{n"
  628. "ttrr_srcid = 0x%lxn"
  629. "ttrr_loss = %d:%dn"
  630. "ttrr_ehsr = %dn"
  631. "ttrr_dv = %dn"
  632. "ttrr_lsr = %dn"
  633. "ttrr_dlsr = %dn"
  634. "t}n",
  635. rr_list[rr - 1].rr_srcid,
  636. RTCP_GET_INCREMENTAL_LOSS(rr_list[rr - 1].rr_loss),
  637. RTCP_GET_CUMULATIVE_LOSS(rr_list[rr - 1].rr_loss),
  638. rr_list[rr - 1].rr_ehsr,
  639. rr_list[rr - 1].rr_dv,
  640. rr_list[rr - 1].rr_lsr,
  641. rr_list[rr - 1].rr_dlsr);
  643. --rr;
  644. }
  646. RTPEndpointInfo *e;
  648. e = GetParticipant(packet->GetSSRC());
  649. if (e)
  650. {
  651. RTPEndpointStats res;
  653. e->GetStatistics(res);
  655. if (res.es_received > 0)
  656. {
  657. LOG("tEndpoint stats for 0x%lxn"
  658. "t{n"
  659. "ttprobation = 0x%lxn"
  660. "ttmisorder = %dn"
  661. "ttreceived = %dn"
  662. "ttdelay_variance = %dn"
  663. "ttpackets_sent = %dn"
  664. "ttoctets_sent = %dn"
  665. "t}n",
  666. res.es_ssrc,
  667. res.es_probation,
  668. res.es_misorder,
  669. res.es_received,
  670. res.es_delay_variance,
  671. res.es_packets_sent,
  672. res.es_octets_sent);
  673. }
  674. }
  675. #endif
  676. }
  678. void
  679. H245RTPSession::send_rtcp_packet(SOCKET rtcp_sock,
  680. RTCPPacket *packet)
  681. {
  682. unsigned int ntp_sec;
  683. unsigned int ntp_frac;
  685. ntp64time(ntp_sec,ntp_frac);
  687. packet->Frame(current_tc, ntp_sec,
  688. ntp_frac, 0,0, NULL,0);
  690. send(rtcp_sock,packet->GetPacket(),
  691. packet->GetPacketLength(),0);
  692. }
  695. #if (defined(WIN32))
  696. unsigned __stdcall
  697. #elif (defined(VXWORKS))
  698. int
  699. #else
  700. void *
  701. #endif
  702. H245RTPSession::_begin_rtp_session(void *c)
  703. {
  704. H245RTPSession *s = (H245RTPSession *) c;
  705. s->do_rtp();
  706. return 0;
  707. }
  709. #if defined(USE_POLL)
  710. #define RTP_SOCKET_INDEX   0
  711. #define RTCP_SOCKET_INDEX  1
  712. #define INTERCONNECT_INDEX 2
  713. void 
  714. H245RTPSession::do_rtp()
  715. {
  716. int nfds;
  717. int length;
  718. char buffer[4096];
  719. char *buf = buffer;
  720. struct pollfd pfds[8];
  721. int packets_sent_count = 0;
  722. int packets_recd_count = 0;
  723. int buf_len = sizeof(buffer);
  724. int interconnect;
  725. struct timeval timeout;
  726. int tout = AUDIO_FRAME_SIZE_IN_MS * FRAMES_PER_RTP_PACKET; /*ms*/
  728. audio_fh = fopen(AUDIO_FILE, "r+b");
  729. if (audio_fh == NULL)
  730. {
  731. LOG("Error: do_rtp, failed to open %sn", AUDIO_FILE);
  732. }
  734. rtcp_packet = new RTCPPacket(this);
  735. deframer = new RTPPacket(this,0);
  737. timeout.tv_sec = 0;
  738. timeout.tv_usec = tout; 
  741. // Set the session payload type..
  742. SetPayloadType(local_pt);
  744. LOG("Begin _do_rtpn");
  746. interconnect = stop_rtpsession_socket;
  748. // First identify ourselves in the session..
  749. send_rtcp_packet(rrtcp_socket,  rtcp_packet);
  751. memset(pfds,0, sizeof(pfds));
  753. nfds = 2;
  754. pfds[RTP_SOCKET_INDEX].fd = lrtp_socket;
  755. pfds[RTP_SOCKET_INDEX].events = POLLIN;
  756. pfds[RTCP_SOCKET_INDEX].fd = lrtcp_socket;
  757. pfds[RTCP_SOCKET_INDEX].events = POLLIN;
  758. if (interconnect != INVALID_SOCKET)
  759. {
  760. nfds++;
  761. pfds[INTERCONNECT_INDEX].fd = interconnect;
  762. }
  765. while (1)
  766. {
  767. int ret;
  768. pfds[RTCP_SOCKET_INDEX].revents = 0;
  769. pfds[RTCP_SOCKET_INDEX].revents = 0;
  772. if ((poll(pfds,nfds,tout) == 0) && audio_fh != NULL)
  773. {
  774. // The two types of Frame functions have been demonstrated
  775. // below (within the #if 1 else #endif).
  776. #if 1
  777. if (!framer)
  778. {
  779. length = fread(buf, 1,
  780.  (AUDIO_FRAME_SIZE * FRAMES_PER_RTP_PACKET), audio_fh);
  781. if (length <= 0)
  782. {
  783. fclose(audio_fh);
  784. audio_fh = NULL;
  785. }
  787. framer = new RTPPacket(this,length);
  788. LOG("Framer created payload len = %d, packetlen = %dn",
  789. length, framer->GetMaxPacketLength());
  790. memcpy(framer->GetPayload(), buf, length);
  791. }
  792. else
  793. {
  794. length = fread(framer->GetPayload(), 1,
  795. (AUDIO_FRAME_SIZE * FRAMES_PER_RTP_PACKET),
  796.    audio_fh);
  797. if (length <= 0) 
  798. {
  799. rewind(audio_fh);
  800. continue;
  801. }
  802. }
  804. framer->Frame(current_tc, 0, length);
  806. send(rrtp_socket, framer->GetPacket(),
  807. framer->GetPacketLength(),0);
  808. #else
  810. // BEGIN: New RTPPacket::Frame demo
  812. // Following code demonstrates use of RTPPacket::Frame
  813. // with one less buffer copy.
  815. if (!framer)
  816. {
  817. // Don't let RTPPacket allocate any space for
  818. // the payload (max_payload = 0)
  819. framer = new RTPPacket(this,0);
  820. }
  822. // Leave just enough space at the beginning of the
  823. // buffer for RTPHeader..
  824. length = fread(buffer + framer->GetHeaderLength(),1,
  825.  (AUDIO_FRAME_SIZE * FRAMES_PER_RTP_PACKET), audio_fh);
  826. if (length <= 0) 
  827. {
  828. rewind(audio_fh);
  829. continue;
  830. }
  831. framer->Frame(buf,sizeof(buffer),current_tc,0,length);
  833. send(rrtp_socket, buffer,framer->GetPacketLength(),0);
  835. // END:: New RTPPacket::Frame demo
  836. #endif
  837. current_tc += (AUDIO_FRAME_SIZE_IN_MS * FRAMES_PER_RTP_PACKET)*8;
  838. packets_sent_count++;
  840. timeout.tv_sec = 0;
  841. timeout.tv_usec = tout;
  842. }
  844. if ((interconnect != INVALID_SOCKET) && 
  845. pfds[INTERCONNECT_INDEX].revents)
  846. {
  847. LOG("H245RTPSession::do_rtp "
  848. "pfds[INTERCONNECT_INDEX].revents = %xn", 
  849. pfds[INTERCONNECT_INDEX].revents);
  850. LOG("RTPThread:: exitingn");
  851. #if defined(__hpux)
  852. pthread_exit(NULL);
  853. #else
  854. thr_exit(NULL);
  855. #endif
  856. }
  858. if (pfds[RTP_SOCKET_INDEX].revents & POLLIN)
  859. {
  860. length = recv(lrtp_socket,buf,buf_len,0);
  862. if (length > 0)
  863. {
  865. int ret = deframer->Deframe(buf,length,current_tc);
  867. if (!PROT_IS_SUCCESS(ret))
  868. {
  869. LOG("RTPPacket::Deframe returned %dn",ret);
  870. }
  872. ++packets_recd_count;
  873. }
  874. }
  876. if (pfds[RTCP_SOCKET_INDEX].revents & POLLIN)
  877. {
  878. recv_rtcp_packet(lrtcp_socket, rtcp_packet);
  879. }
  882. if ((packets_recd_count == RTCP_INTERVAL) ||
  883. (packets_sent_count == RTCP_INTERVAL))
  884. {
  885. send_rtcp_packet(rrtcp_socket,  rtcp_packet);
  886. packets_recd_count = 0;
  887. packets_sent_count = 0;
  888. }
  889. }
  890. }
  892. #else // USE_POLL
  893. void 
  894. H245RTPSession::do_rtp()
  895. {
  896. int nfds;
  897. int length;
  898. char buffer[4096];
  899. char *buf = buffer;
  900. fd_set  read_fds;
  901. fd_set except_fds;
  902. int packets_sent_count = 0;
  903. int packets_recd_count = 0;
  904. int buf_len = sizeof(buffer);
  905. int interconnect;
  906. struct timeval timeout;
  907. int tout = AUDIO_FRAME_SIZE_IN_MS * FRAMES_PER_RTP_PACKET * 1000; /*us*/
  909. audio_fh = fopen(AUDIO_FILE, "r+b");
  910. if (audio_fh == NULL)
  911. {
  912. LOG("Error: do_rtp, failed to open %sn", AUDIO_FILE);
  913. }
  915. rtcp_packet = new RTCPPacket(this);
  916. deframer = new RTPPacket(this,0);
  918. timeout.tv_sec = 0;
  919. timeout.tv_usec = tout; 
  922. // Set the session payload type..
  923. SetPayloadType(local_pt);
  925. LOG("Begin _do_rtpn");
  927. interconnect = stop_rtpsession_socket;
  929. // First identify ourselves in the session..
  931. send_rtcp_packet(rrtcp_socket,  rtcp_packet);
  933. if (lrtp_socket > lrtcp_socket)
  934. {
  935. nfds = lrtp_socket;
  936. }
  937. else
  938. {
  939. nfds = lrtcp_socket;
  940. }
  941. if ((interconnect != INVALID_SOCKET) && (nfds < interconnect))
  942. {
  943. nfds = interconnect; 
  944. }
  945. ++nfds;
  947. while (1)
  948. {
  949. int select_ret;
  951. FD_ZERO(&read_fds);
  952. FD_ZERO(&except_fds);
  954. FD_SET(lrtp_socket, &read_fds);
  955. FD_SET(lrtcp_socket, &read_fds);
  956. if (interconnect != INVALID_SOCKET)
  957. {
  958. FD_SET(interconnect, &read_fds);
  959. FD_SET(interconnect, &except_fds);
  960. }
  962. select_ret = select(
  963. nfds,
  964. &read_fds, 
  965. NULL,
  966. &except_fds, 
  967. &timeout);
  969. #if (defined(WIN32))
  970. assert(SOCKET_ERROR == -1);
  971. #endif
  972. if (select_ret == -1)
  973. {
  974. LOG("RTPThread:: exitingn");
  975. #if (defined(WIN32))
  976. //closesocket(interconnect);
  977. //_endthreadex(2);
  978. return;
  979. #elif (defined(VXWORKS))
  980. return;
  981. #else
  982. thr_exit(NULL);
  983. #endif
  984. }
  985. else if (select_ret == 0 && audio_fh != NULL)
  986. {
  987. // The two types of Frame functions have been demonstrated
  988. // below (within the #if 1 else #endif).
  989. #if 1
  990. if (!framer)
  991. {
  992. length = fread(buf, 1,
  993.  (AUDIO_FRAME_SIZE * FRAMES_PER_RTP_PACKET), audio_fh);
  994. if (length <= 0)
  995. {
  996. fclose(audio_fh);
  997. audio_fh = NULL;
  998. }
  1000. framer = new RTPPacket(this,length);
  1001. LOG("Framer created payload len = %d, packetlen = %dn",
  1002. length, framer->GetMaxPacketLength());
  1003. memcpy(framer->GetPayload(), buf, length);
  1004. }
  1005. else
  1006. {
  1007. length = fread(framer->GetPayload(), 1,
  1008. (AUDIO_FRAME_SIZE * FRAMES_PER_RTP_PACKET),
  1009.    audio_fh);
  1010. if (length <= 0) 
  1011. {
  1012. rewind(audio_fh);
  1013. continue;
  1014. }
  1015. }
  1017. framer->Frame(current_tc, 0, length);
  1019. send(rrtp_socket, framer->GetPacket(),
  1020. framer->GetPacketLength(),0);
  1021. #else
  1023. // BEGIN: New RTPPacket::Frame demo
  1025. // Following code demonstrates use of RTPPacket::Frame
  1026. // with one less buffer copy.
  1028. if (!framer)
  1029. {
  1030. // Don't let RTPPacket allocate any space for
  1031. // the payload (max_payload = 0)
  1032. framer = new RTPPacket(this,0);
  1033. }
  1035. // Leave just enough space at the beginning of the
  1036. // buffer for RTPHeader..
  1037. length = fread(buffer + framer->GetHeaderLength(),1,
  1038.  (AUDIO_FRAME_SIZE * FRAMES_PER_RTP_PACKET), audio_fh);
  1039. if (length <= 0) 
  1040. {
  1041. rewind(audio_fh);
  1042. continue;
  1043. }
  1044. framer->Frame(buf,sizeof(buffer),current_tc,0,length);
  1046. send(rrtp_socket, buffer,framer->GetPacketLength(),0);
  1048. // END:: New RTPPacket::Frame demo
  1049. #endif
  1050. current_tc += (AUDIO_FRAME_SIZE_IN_MS * FRAMES_PER_RTP_PACKET)*8;
  1051. packets_sent_count++;
  1053. timeout.tv_sec = 0;
  1054. timeout.tv_usec = tout;
  1055. }
  1057. if (interconnect != INVALID_SOCKET && 
  1058. FD_ISSET(interconnect, &except_fds))
  1059. {
  1060. // printf("do_rtp: exceptionn");
  1061. LOG("RTPThread:: exitingn");
  1062. #if (defined(WIN32))
  1063. //closesocket(interconnect);
  1064. //_endthreadex(2);
  1065. return;
  1066. #elif (defined(VXWORKS))
  1067. return;
  1068. #else
  1069. thr_exit(NULL);
  1070. #endif
  1071. }
  1073. if (FD_ISSET(lrtp_socket,&read_fds))
  1074. {
  1075. length = recv(lrtp_socket,buf,buf_len,0);
  1077. if (length > 0)
  1078. {
  1080. int ret = deframer->Deframe(buf,length,current_tc);
  1082. if (!PROT_IS_SUCCESS(ret))
  1083. {
  1084. LOG("RTPPacket::Deframe returned %dn",ret);
  1085. }
  1087. ++packets_recd_count;
  1088. }
  1089. }
  1091. if (FD_ISSET(lrtcp_socket,&read_fds))
  1092. {
  1093. recv_rtcp_packet(lrtcp_socket, rtcp_packet);
  1094. }
  1097. if ((packets_recd_count == RTCP_INTERVAL) ||
  1098. (packets_sent_count == RTCP_INTERVAL))
  1099. {
  1100. send_rtcp_packet(rrtcp_socket,  rtcp_packet);
  1101. packets_recd_count = 0;
  1102. packets_sent_count = 0;
  1103. }
  1104. }
  1105. }
  1106. #endif