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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
rtp_transmitter.cpp
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：11k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

rtp_transmitter.cpp：源码内容
  1. /*
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is MPEG4IP.
  13.  * 
  14.  * The Initial Developer of the Original Code is Cisco Systems Inc.
  15.  * Portions created by Cisco Systems Inc. are
  16.  * Copyright (C) Cisco Systems Inc. 2000, 2001.  All Rights Reserved.
  17.  * 
  18.  * Contributor(s): 
  19.  * Dave Mackie dmackie@cisco.com
  20.  * Bill May  wmay@cisco.com
  21.  */
  23. #include "mp4live.h"
  24. #include "rtp_transmitter.h"
  26. // #define RTP_DEBUG 1
  28. int CRtpTransmitter::ThreadMain(void) 
  29. {
  30. while (SDL_SemWait(m_myMsgQueueSemaphore) == 0) {
  31. CMsg* pMsg = m_myMsgQueue.get_message();
  33. if (pMsg != NULL) {
  34. switch (pMsg->get_value()) {
  35. case MSG_NODE_STOP_THREAD:
  36. DoStopTransmit();
  37. delete pMsg;
  38. return 0;
  39. case MSG_NODE_START:
  40. DoStartTransmit();
  41. break;
  42. case MSG_NODE_STOP:
  43. DoStopTransmit();
  44. break;
  45. case MSG_SINK_FRAME:
  46. size_t dontcare;
  47. DoSendFrame((CMediaFrame*)pMsg->get_message(dontcare));
  48. break;
  49. }
  51. delete pMsg;
  52. }
  53. }
  55. return -1;
  56. }
  58. void CRtpTransmitter::DoStartTransmit()
  59. {
  60. if (m_sink) {
  61. return;
  62. }
  64. m_startTimestamp = GetTimestamp();
  66. if (m_pConfig->GetBoolValue(CONFIG_AUDIO_ENABLE)) {
  67. m_audioTimeScale = 
  68. m_pConfig->GetIntegerValue(CONFIG_AUDIO_SAMPLE_RATE); 
  70. m_audioDestAddress = 
  71. m_pConfig->GetStringValue(CONFIG_RTP_DEST_ADDRESS); 
  73. if (m_pConfig->GetBoolValue(CONFIG_RTP_DISABLE_TS_OFFSET)) {
  74. m_audioRtpTimestampOffset = 0;
  75. } else {
  76. m_audioRtpTimestampOffset = random();
  77. }
  79. m_audioSrcPort = GetRandomPortBlock();
  80. if (m_pConfig->GetIntegerValue(CONFIG_RTP_AUDIO_DEST_PORT) == 0) {
  81. m_pConfig->SetIntegerValue(CONFIG_RTP_AUDIO_DEST_PORT,
  82. m_audioSrcPort + 2);
  83. }
  85. m_audioRtpSession = rtp_init(m_audioDestAddress, 
  86. m_audioSrcPort, 
  87. m_pConfig->GetIntegerValue(CONFIG_RTP_AUDIO_DEST_PORT),
  88. m_pConfig->GetIntegerValue(CONFIG_RTP_MCAST_TTL), 
  89. m_rtcpBandwidth, 
  90. RtpCallback, (uint8_t *)this);
  92. m_audioQueueCount = 0;
  93. m_audioQueueSize = 0;
  95. if (!strcasecmp(m_pConfig->GetStringValue(CONFIG_AUDIO_ENCODING),
  96.   AUDIO_ENCODING_MP3)) {
  97. m_audioFrameType = CMediaFrame::Mp3AudioFrame;
  98. m_audioPayloadBytesPerPacket = 4;
  99. m_audioPayloadBytesPerFrame = 0;
  100. } else { // AAC
  101. m_audioFrameType = CMediaFrame::AacAudioFrame;
  102. m_audioPayloadBytesPerPacket = 2;
  103. m_audioPayloadBytesPerFrame = 2;
  104. }
  105. }
  107. if (m_pConfig->GetBoolValue(CONFIG_VIDEO_ENABLE)) {
  108. m_videoDestAddress = 
  109. m_pConfig->GetStringValue(CONFIG_RTP_DEST_ADDRESS); 
  111. if (m_pConfig->GetBoolValue(CONFIG_RTP_DISABLE_TS_OFFSET)) {
  112. m_videoRtpTimestampOffset = 0;
  113. } else {
  114. m_videoRtpTimestampOffset = random();
  115. }
  117. m_videoSrcPort = GetRandomPortBlock();
  118. if (m_pConfig->GetIntegerValue(CONFIG_RTP_VIDEO_DEST_PORT) == 0) {
  119. m_pConfig->SetIntegerValue(CONFIG_RTP_VIDEO_DEST_PORT,
  120. m_videoSrcPort + 2);
  121. }
  123. m_videoRtpSession = rtp_init(m_videoDestAddress, 
  124. m_videoSrcPort, 
  125. m_pConfig->GetIntegerValue(CONFIG_RTP_VIDEO_DEST_PORT),
  126. m_pConfig->GetIntegerValue(CONFIG_RTP_MCAST_TTL), 
  127. m_rtcpBandwidth, 
  128. RtpCallback, (uint8_t *)this);
  129. }
  131. if (m_audioRtpSession || m_videoRtpSession) {
  132. // automatic sdp file generation
  133. GenerateSdpFile(m_pConfig);
  135. m_sink = true;
  136. }
  137. }
  139. void CRtpTransmitter::DoStopTransmit()
  140. {
  141. if (!m_sink) {
  142. return;
  143. }
  145. if (m_audioRtpSession) {
  146. // send any pending frames
  147. SendQueuedAudioFrames();
  149. rtp_done(m_audioRtpSession);
  150. m_audioRtpSession = NULL;
  151. }
  152. if (m_videoRtpSession) {
  153. rtp_done(m_videoRtpSession);
  154. m_videoRtpSession = NULL;
  155. }
  157. m_sink = false;
  158. }
  160. void CRtpTransmitter::DoSendFrame(CMediaFrame* pFrame)
  161. {
  162. if (pFrame == NULL) {
  163. return;
  164. }
  165. if (!m_sink) {
  166. delete pFrame;
  167. return;
  168. }
  170. if (pFrame->GetType() == m_audioFrameType && m_audioRtpSession) {
  171. SendAudioFrame(pFrame);
  173. } else if (pFrame->GetType() == CMediaFrame::Mpeg4VideoFrame 
  174.   && m_videoRtpSession) {
  175. SendMpeg4VideoWith3016(pFrame);
  177. } else {
  178. delete pFrame;
  179. }
  180. }
  182. void CRtpTransmitter::SendAudioFrame(CMediaFrame* pFrame)
  183. {
  184. u_int16_t newAudioQueueSize;
  186. if (m_audioQueueCount > 0) {
  187. newAudioQueueSize =
  188. m_audioQueueSize 
  189. + m_audioPayloadBytesPerFrame
  190. + pFrame->GetDataLength();
  192. if (newAudioQueueSize <= 
  193.   m_pConfig->GetIntegerValue(CONFIG_RTP_PAYLOAD_SIZE)) {
  195. m_audioQueue[m_audioQueueCount++] = pFrame;
  196. m_audioQueueSize = newAudioQueueSize;
  198. // if we fill the last slot in the queue
  199. // send the packet
  200. if (m_audioQueueCount == audioQueueMaxCount) {
  201. SendQueuedAudioFrames();
  202. }
  204. return;
  206. } else {
  207. // send queued frames
  208. SendQueuedAudioFrames();
  210. // fall thru
  211. }
  212. }
  214. // by here m_audioQueueCount == 0
  216. newAudioQueueSize =
  217. m_audioPayloadBytesPerPacket
  218. + m_audioPayloadBytesPerFrame
  219. + pFrame->GetDataLength();
  221. if (newAudioQueueSize 
  222.   <= m_pConfig->GetIntegerValue(CONFIG_RTP_PAYLOAD_SIZE)) {
  224. m_audioQueue[m_audioQueueCount++] = pFrame;
  225. m_audioQueueSize = newAudioQueueSize;
  227. } else {
  228. // highly unusual case 
  229. // we need to fragment audio frame
  230. // over multiple packets
  231. SendAudioJumboFrame(pFrame);
  232. }
  233. }
  235. void CRtpTransmitter::SendQueuedAudioFrames(void)
  236. {
  237. static u_int32_t zero32 = 0;
  238. u_int8_t aacHeader[2 + (audioQueueMaxCount * 2)];
  239. struct iovec iov[audioQueueMaxCount + 1];
  241. if (m_audioQueueCount == 0) {
  242. return;
  243. }
  245. u_int32_t rtpTimestamp =
  246. AudioTimestampToRtp(m_audioQueue[0]->GetTimestamp());
  247. u_int64_t ntpTimestamp =
  248. TimestampToNtp(m_audioQueue[0]->GetTimestamp());
  250. #if RTP_DEBUG
  251. debug_message("A ts %llu rtp %u ntp %u.%u",
  252. m_audioQueue[0]->GetTimestamp(),
  253. rtpTimestamp,
  254. (u_int32_t)(ntpTimestamp >> 32),
  255. (u_int32_t)ntpTimestamp);
  256. #endif
  258. // check if RTCP SR needs to be sent
  259. rtp_send_ctrl_2(m_audioRtpSession, rtpTimestamp, ntpTimestamp, NULL);
  260. rtp_update(m_audioRtpSession);
  262. // create the iovec list
  263. u_int8_t i;
  265. // audio payload headers
  266. if (m_audioQueue[0]->GetType() == CMediaFrame::Mp3AudioFrame) {
  267. iov[0].iov_base = &zero32;
  268. iov[0].iov_len = 4;
  269. } else { // AAC
  270. u_int16_t numHdrBits = 16 * m_audioQueueCount;
  271. aacHeader[0] = numHdrBits >> 8;
  272. aacHeader[1] = numHdrBits & 0xFF;
  274. for (i = 0; i < m_audioQueueCount; i++) {
  275. aacHeader[2 + (i * 2)] = 
  276. m_audioQueue[i]->GetDataLength() >> 5;
  277. aacHeader[2 + (i * 2) + 1] = 
  278. (m_audioQueue[i]->GetDataLength() & 0x1F) << 3;
  279. }
  281. iov[0].iov_base = aacHeader;
  282. iov[0].iov_len = 2 + (m_audioQueueCount * 2);
  283. }
  285. // audio payload data
  286. for (i = 0; i < m_audioQueueCount; i++) {
  287. iov[i+1].iov_base = m_audioQueue[i]->GetData();
  288. iov[i+1].iov_len = m_audioQueue[i]->GetDataLength();
  289. }
  291. // send packet
  292. rtp_send_data_iov(
  293. m_audioRtpSession,
  294. rtpTimestamp,
  295. m_audioPayloadNumber, 1, 0, NULL,
  296. iov, m_audioQueueCount + 1,
  297. NULL, 0, 0);
  299. // delete all the pending media frames
  300. for (int i = 0; i < m_audioQueueCount; i++) {
  301. delete m_audioQueue[i];
  302. m_audioQueue[i] = NULL;
  303. }
  305. m_audioQueueCount = 0;
  306. m_audioQueueSize = 0;
  307. }
  309. void CRtpTransmitter::SendAudioJumboFrame(CMediaFrame* pFrame)
  310. {
  311. u_int32_t rtpTimestamp = 
  312. AudioTimestampToRtp(pFrame->GetTimestamp());
  313. u_int64_t ntpTimestamp =
  314. TimestampToNtp(pFrame->GetTimestamp());
  316. #if RTP_DEBUG
  317. debug_message("A ts %llu rtp %u ntp %u.%u",
  318. pFrame->GetTimestamp(),
  319. rtpTimestamp,
  320. (u_int32_t)(ntpTimestamp >> 32),
  321. (u_int32_t)ntpTimestamp);
  322. #endif
  324. // check if RTCP SR needs to be sent
  325. rtp_send_ctrl_2(m_audioRtpSession, rtpTimestamp, ntpTimestamp, NULL);
  326. rtp_update(m_audioRtpSession);
  328. u_int32_t dataOffset = 0;
  329. u_int32_t spaceAvailable = 
  330. m_pConfig->GetIntegerValue(CONFIG_RTP_PAYLOAD_SIZE)
  331. - (m_audioPayloadBytesPerPacket + m_audioPayloadBytesPerFrame);
  333. bool firstPacket = true;
  334. u_int8_t payloadHeader[4];
  336. struct iovec iov[2];
  337. iov[0].iov_base = &payloadHeader;
  338. iov[0].iov_len = 4;
  340. if (pFrame->GetType() == CMediaFrame::Mp3AudioFrame) {
  341. payloadHeader[0] = 0;
  342. payloadHeader[1] = 0;
  344. do {
  345. // update MP3 payload header
  346. payloadHeader[2] = (dataOffset >> 8);
  347. payloadHeader[3] = (dataOffset & 0xFF);
  349. iov[1].iov_base = (u_int8_t*)pFrame->GetData() + dataOffset;
  351. // figure out how much data we're sending
  352. u_int32_t dataPending = pFrame->GetDataLength() - dataOffset;
  353. iov[1].iov_len = MIN(dataPending, spaceAvailable); 
  355. // send packet
  356. rtp_send_data_iov(
  357. m_audioRtpSession,
  358. rtpTimestamp,
  359. m_audioPayloadNumber, firstPacket, 0, NULL,
  360. iov, 2,
  361. NULL, 0, 0);
  363. dataOffset += iov[1].iov_len;
  364. firstPacket = false;
  366. } while (dataOffset < pFrame->GetDataLength());
  368. } else { // AAC
  369. bool lastPacket = false;
  371. payloadHeader[0] = 0;
  372. payloadHeader[1] = 16;
  373. payloadHeader[2] = pFrame->GetDataLength() >> 5;
  374. payloadHeader[3] = (pFrame->GetDataLength() & 0x1F) << 3;
  376. do {
  377. iov[1].iov_base = (u_int8_t*)pFrame->GetData() + dataOffset;
  379. // figure out how much data we're sending
  380. u_int32_t dataPending = pFrame->GetDataLength() - dataOffset;
  381. if (dataPending <= spaceAvailable) {
  382. iov[1].iov_len = dataPending;
  383. lastPacket = true;
  384. } else {
  385. iov[1].iov_len = spaceAvailable;
  386. }
  388. // send packet
  389. if (firstPacket) {
  390. rtp_send_data_iov(
  391. m_audioRtpSession,
  392. rtpTimestamp,
  393. m_audioPayloadNumber, false, 0, NULL,
  394. &iov[0], 2,
  395. NULL, 0, 0);
  397. firstPacket = false;
  398. spaceAvailable += 
  399. m_audioPayloadBytesPerPacket 
  400. + m_audioPayloadBytesPerFrame;
  402. } else {
  403. rtp_send_data_iov(
  404. m_audioRtpSession,
  405. rtpTimestamp,
  406. m_audioPayloadNumber, lastPacket, 0, NULL,
  407. &iov[1], 1,
  408. NULL, 0, 0);
  409. }
  411. dataOffset += iov[1].iov_len;
  413. } while (dataOffset < pFrame->GetDataLength());
  414. }
  416. delete pFrame;
  417. }
  419. void CRtpTransmitter::SendMpeg4VideoWith3016(CMediaFrame* pFrame)
  420. {
  421. u_int32_t rtpTimestamp =
  422. VideoTimestampToRtp(pFrame->GetTimestamp());
  423. u_int64_t ntpTimestamp =
  424. TimestampToNtp(pFrame->GetTimestamp());
  426. #if RTP_DEBUG
  427. debug_message("V ts %llu rtp %u ntp %u.%u",
  428. pFrame->GetTimestamp(),
  429. rtpTimestamp,
  430. (u_int32_t)(ntpTimestamp >> 32),
  431. (u_int32_t)ntpTimestamp);
  432. #endif
  434. // check if RTCP SR needs to be sent
  435. rtp_send_ctrl_2(m_videoRtpSession, rtpTimestamp, ntpTimestamp, NULL);
  436. rtp_update(m_videoRtpSession);
  438. u_int8_t* pData = (u_int8_t*)pFrame->GetData();
  439. u_int32_t bytesToSend = pFrame->GetDataLength();
  440. struct iovec iov;
  442. while (bytesToSend) {
  443. u_int32_t payloadLength;
  444. bool lastPacket;
  446. if (bytesToSend 
  447.   <= m_pConfig->GetIntegerValue(CONFIG_RTP_PAYLOAD_SIZE)) {
  448. payloadLength = bytesToSend;
  449. lastPacket = true;
  450. } else {
  451. payloadLength = 
  452. m_pConfig->GetIntegerValue(CONFIG_RTP_PAYLOAD_SIZE);
  453. lastPacket = false;
  454. }
  456. iov.iov_base = pData;
  457. iov.iov_len = payloadLength;
  459. rtp_send_data_iov(
  460. m_videoRtpSession,
  461. rtpTimestamp,
  462. m_videoPayloadNumber, lastPacket, 0, NULL,
  463. &iov, 1,
  464.   NULL, 0, 0);
  466. pData += payloadLength;
  467. bytesToSend -= payloadLength;
  468. }
  470. delete pFrame;
  471. }