RTP打包与发送


rtp传送开始于函数：MediaSink::startPlaying()。想想也有道理，应是sink跟source要数据，所以从sink上调用startplaying（嘿嘿，相当于directshow的拉模式）。


看一下这个函数：

[cpp] view plaincopy

  1. Boolean MediaSink::startPlaying(MediaSource& source,
  2. afterPlayingFunc* afterFunc, void* afterClientData)
  3. {
  4. //参数afterFunc是在播放结束时才被调用。
  5. // Make sure we're not already being played:
  6. if(fSource != NULL) {
  7. envir().setResultMsg("This sink is already being played");
  8. returnFalse;
  9. }
  10. // Make sure our source is compatible:
  11. if(!sourceIsCompatibleWithUs(source)) {
  12. envir().setResultMsg(
  13. "MediaSink::startPlaying(): source is not compatible!");
  14. returnFalse;
  15. }
  16. //记下一些要使用的对象
  17. fSource = (FramedSource*) &source;
  18. fAfterFunc = afterFunc;
  19. fAfterClientData = afterClientData;
  20. returncontinuePlaying();
  21. }

为了进一步封装（让继承类少写一些代码），搞出了一个虚函数continuePlaying()。让我们来看一下：

[cpp] view plaincopy

  1. Boolean MultiFramedRTPSink::continuePlaying() {
  2. // Send the first packet.
  3. // (This will also schedule any future sends.)
  4. buildAndSendPacket(True);
  5. returnTrue;
  6. }

MultiFramedRTPSink是与帧有关的类，其实它要求每次必须从source获得一个帧的数据，所以才叫这个name。可以看到continuePlaying()完全被buildAndSendPacket()代替。看一下buildAndSendPacket():

[cpp] view plaincopy

  1. voidMultiFramedRTPSink::buildAndSendPacket(Boolean isFirstPacket)
  2. {
  3. //此函数中主要是准备rtp包的头，为一些需要跟据实际数据改变的字段留出位置。
  4. fIsFirstPacket = isFirstPacket;
  5. // Set up the RTP header:
  6. unsigned rtpHdr = 0x80000000; // RTP version 2; marker ('M') bit not set (by default; it can be set later)
  7. rtpHdr |= (fRTPPayloadType << 16);
  8. rtpHdr |= fSeqNo; // sequence number
  9. fOutBuf->enqueueWord(rtpHdr);//向包中加入一个字
  10. // Note where the RTP timestamp will go.
  11. // (We can't fill this in until we start packing payload frames.)
  12. fTimestampPosition = fOutBuf->curPacketSize();
  13. fOutBuf->skipBytes(4); // leave a hole for the timestamp　在缓冲中空出时间戳的位置
  14. fOutBuf->enqueueWord(SSRC());
  15. // Allow for a special, payload-format-specific header following the
  16. // RTP header:
  17. fSpecialHeaderPosition = fOutBuf->curPacketSize();
  18. fSpecialHeaderSize = specialHeaderSize();
  19. fOutBuf->skipBytes(fSpecialHeaderSize);
  20. // Begin packing as many (complete) frames into the packet as we can:
  21. fTotalFrameSpecificHeaderSizes = 0;
  22. fNoFramesLeft = False;
  23. fNumFramesUsedSoFar = 0; // 一个包中已打入的帧数。
  24. //头准备好了，再打包帧数据
  25. packFrame();
  26. }

继续看packFrame()：

[cpp] view plaincopy

  1. voidMultiFramedRTPSink::packFrame()
  2. {
  3. // First, see if we have an overflow frame that was too big for the last pkt
  4. if(fOutBuf->haveOverflowData()) {
  5. //如果有帧数据，则使用之。OverflowData是指上次打包时剩下的帧数据，因为一个包可能容纳不了一个帧。
  6. // Use this frame before reading a new one from the source
  7. unsigned frameSize = fOutBuf->overflowDataSize();
  8. structtimeval presentationTime = fOutBuf->overflowPresentationTime();
  9. unsigned durationInMicroseconds =fOutBuf->overflowDurationInMicroseconds();
  10. fOutBuf->useOverflowData();
  11. afterGettingFrame1(frameSize, 0, presentationTime,durationInMicroseconds);
  12. } else{
  13. //一点帧数据都没有，跟source要吧。
  14. // Normal case: we need to read a new frame from the source
  15. if(fSource == NULL)
  16. return;
  17. //更新缓冲中的一些位置
  18. fCurFrameSpecificHeaderPosition = fOutBuf->curPacketSize();
  19. fCurFrameSpecificHeaderSize = frameSpecificHeaderSize();
  20. fOutBuf->skipBytes(fCurFrameSpecificHeaderSize);
  21. fTotalFrameSpecificHeaderSizes += fCurFrameSpecificHeaderSize;
  22. //从source获取下一帧
  23. fSource->getNextFrame(fOutBuf->curPtr(),//新数据存放开始的位置
  24. fOutBuf->totalBytesAvailable(),//缓冲中空余的空间大小
  25. afterGettingFrame,  //因为可能source中的读数据函数会被放在任务调度中，所以把获取帧后应调用的函数传给source
  26. this,
  27. ourHandleClosure, //这个是source结束时(比如文件读完了)要调用的函数。
  28. this);
  29. }
  30. }

可以想像下面就是source从文件（或某个设备）中读取一帧数据，读完后返回给sink，当然不是从函数返回了，而是以调用afterGettingFrame这个回调函数的方式。所以下面看一下afterGettingFrame():

[cpp] view plaincopy

  1. voidMultiFramedRTPSink::afterGettingFrame(void* clientData,
  2. unsigned numBytesRead, unsigned numTruncatedBytes,
  3. structtimeval presentationTime, unsigned durationInMicroseconds)
  4. {
  5. MultiFramedRTPSink* sink = (MultiFramedRTPSink*) clientData;
  6. sink->afterGettingFrame1(numBytesRead, numTruncatedBytes, presentationTime,
  7. durationInMicroseconds);
  8. }

没什么可看的，只是过度为调用成员函数，所以afterGettingFrame1()才是重点：

[cpp] view plaincopy

  1. voidMultiFramedRTPSink::afterGettingFrame1(
  2. unsigned frameSize,
  3. unsigned numTruncatedBytes,
  4. structtimeval presentationTime,
  5. unsigned durationInMicroseconds)
  6. {
  7. if(fIsFirstPacket) {
  8. // Record the fact that we're starting to play now:
  9. gettimeofday(&fNextSendTime, NULL);
  10. }
  11. //如果给予一帧的缓冲不够大，就会发生截断一帧数据的现象。但也只能提示一下用户
  12. if(numTruncatedBytes > 0) {
  13. unsigned constbufferSize = fOutBuf->totalBytesAvailable();
  14. envir()
  15. << "MultiFramedRTPSink::afterGettingFrame1(): The input frame data was too large for our buffer size ("
  16. << bufferSize
  17. << ").  "
  18. << numTruncatedBytes
  19. << " bytes of trailing data was dropped!  Correct this by increasing \"OutPacketBuffer::maxSize\" to at least "
  20. << OutPacketBuffer::maxSize + numTruncatedBytes
  21. << ", *before* creating this 'RTPSink'.  (Current value is "
  22. << OutPacketBuffer::maxSize << ".)\n";
  23. }
  24. unsigned curFragmentationOffset = fCurFragmentationOffset;
  25. unsigned numFrameBytesToUse = frameSize;
  26. unsigned overflowBytes = 0;
  27. //如果包只已经打入帧数据了，并且不能再向这个包中加数据了，则把新获得的帧数据保存下来。
  28. // If we have already packed one or more frames into this packet,
  29. // check whether this new frame is eligible to be packed after them.
  30. // (This is independent of whether the packet has enough room for this
  31. // new frame; that check comes later.)
  32. if(fNumFramesUsedSoFar > 0) {
  33. //如果包中已有了一个帧，并且不允许再打入新的帧了，则只记录下新的帧。
  34. if((fPreviousFrameEndedFragmentation && !allowOtherFramesAfterLastFragment())
  35. || !frameCanAppearAfterPacketStart(fOutBuf->curPtr(), frameSize))
  36. {
  37. // Save away this frame for next time:
  38. numFrameBytesToUse = 0;
  39. fOutBuf->setOverflowData(fOutBuf->curPacketSize(), frameSize,
  40. presentationTime, durationInMicroseconds);
  41. }
  42. }
  43. //表示当前打入的是否是上一个帧的最后一块数据。
  44. fPreviousFrameEndedFragmentation = False;
  45. //下面是计算获取的帧中有多少数据可以打到当前包中，剩下的数据就作为overflow数据保存下来。
  46. if(numFrameBytesToUse > 0) {
  47. // Check whether this frame overflows the packet
  48. if(fOutBuf->wouldOverflow(frameSize)) {
  49. // Don't use this frame now; instead, save it as overflow data, and
  50. // send it in the next packet instead.  However, if the frame is too
  51. // big to fit in a packet by itself, then we need to fragment it (and
  52. // use some of it in this packet, if the payload format permits this.)
  53. if(isTooBigForAPacket(frameSize)
  54. && (fNumFramesUsedSoFar == 0 || allowFragmentationAfterStart())) {
  55. // We need to fragment this frame, and use some of it now:
  56. overflowBytes = computeOverflowForNewFrame(frameSize);
  57. numFrameBytesToUse -= overflowBytes;
  58. fCurFragmentationOffset += numFrameBytesToUse;
  59. } else{
  60. // We don't use any of this frame now:
  61. overflowBytes = frameSize;
  62. numFrameBytesToUse = 0;
  63. }
  64. fOutBuf->setOverflowData(fOutBuf->curPacketSize() + numFrameBytesToUse,
  65. overflowBytes, presentationTime, durationInMicroseconds);
  66. } elseif(fCurFragmentationOffset > 0) {
  67. // This is the last fragment of a frame that was fragmented over
  68. // more than one packet.  Do any special handling for this case:
  69. fCurFragmentationOffset = 0;
  70. fPreviousFrameEndedFragmentation = True;
  71. }
  72. }
  73. if(numFrameBytesToUse == 0 && frameSize > 0) {
  74. //如果包中有数据并且没有新数据了，则发送之。（这种情况好像很难发生啊！）
  75. // Send our packet now, because we have filled it up:
  76. sendPacketIfNecessary();
  77. } else{
  78. //需要向包中打入数据。
  79. // Use this frame in our outgoing packet:
  80. unsigned char* frameStart = fOutBuf->curPtr();
  81. fOutBuf->increment(numFrameBytesToUse);
  82. // do this now, in case "doSpecialFrameHandling()" calls "setFramePadding()" to append padding bytes
  83. // Here's where any payload format specific processing gets done:
  84. doSpecialFrameHandling(curFragmentationOffset, frameStart,
  85. numFrameBytesToUse, presentationTime, overflowBytes);
  86. ++fNumFramesUsedSoFar;
  87. // Update the time at which the next packet should be sent, based
  88. // on the duration of the frame that we just packed into it.
  89. // However, if this frame has overflow data remaining, then don't
  90. // count its duration yet.
  91. if(overflowBytes == 0) {
  92. fNextSendTime.tv_usec += durationInMicroseconds;
  93. fNextSendTime.tv_sec += fNextSendTime.tv_usec / 1000000;
  94. fNextSendTime.tv_usec %= 1000000;
  95. }
  96. //如果需要，就发出包，否则继续打入数据。
  97. // Send our packet now if (i) it's already at our preferred size, or
  98. // (ii) (heuristic) another frame of the same size as the one we just
  99. //      read would overflow the packet, or
  100. // (iii) it contains the last fragment of a fragmented frame, and we
  101. //      don't allow anything else to follow this or
  102. // (iv) one frame per packet is allowed:
  103. if(fOutBuf->isPreferredSize()
  104. || fOutBuf->wouldOverflow(numFrameBytesToUse)
  105. || (fPreviousFrameEndedFragmentation
  106. && !allowOtherFramesAfterLastFragment())
  107. || !frameCanAppearAfterPacketStart(
  108. fOutBuf->curPtr() - frameSize, frameSize)) {
  109. // The packet is ready to be sent now
  110. sendPacketIfNecessary();
  111. } else{
  112. // There's room for more frames; try getting another:
  113. packFrame();
  114. }
  115. }
  116. }



看一下发送数据的函数：

[cpp] view plaincopy

  1. voidMultiFramedRTPSink::sendPacketIfNecessary()
  2. {
  3. //发送包
  4. if(fNumFramesUsedSoFar > 0) {
  5. // Send the packet:
  6. #ifdef TEST_LOSS
  7. if((our_random()%10) != 0)// simulate 10% packet loss #####
  8. #endif
  9. if(!fRTPInterface.sendPacket(fOutBuf->packet(),fOutBuf->curPacketSize())) {
  10. // if failure handler has been specified, call it
  11. if(fOnSendErrorFunc != NULL)
  12. (*fOnSendErrorFunc)(fOnSendErrorData);
  13. }
  14. ++fPacketCount;
  15. fTotalOctetCount += fOutBuf->curPacketSize();
  16. fOctetCount += fOutBuf->curPacketSize() - rtpHeaderSize
  17. - fSpecialHeaderSize - fTotalFrameSpecificHeaderSizes;
  18. ++fSeqNo; // for next time
  19. }
  20. //如果还有剩余数据，则调整缓冲区
  21. if(fOutBuf->haveOverflowData()
  22. && fOutBuf->totalBytesAvailable() > fOutBuf->totalBufferSize() / 2) {
  23. // Efficiency hack: Reset the packet start pointer to just in front of
  24. // the overflow data (allowing for the RTP header and special headers),
  25. // so that we probably don't have to "memmove()" the overflow data
  26. // into place when building the next packet:
  27. unsigned newPacketStart = fOutBuf->curPacketSize()-
  28. (rtpHeaderSize + fSpecialHeaderSize + frameSpecificHeaderSize());
  29. fOutBuf->adjustPacketStart(newPacketStart);
  30. } else{
  31. // Normal case: Reset the packet start pointer back to the start:
  32. fOutBuf->resetPacketStart();
  33. }
  34. fOutBuf->resetOffset();
  35. fNumFramesUsedSoFar = 0;
  36. if(fNoFramesLeft) {
  37. //如果再没有数据了，则结束之
  38. // We're done:
  39. onSourceClosure(this);
  40. } else{
  41. //如果还有数据，则在下一次需要发送的时间再次打包发送。
  42. // We have more frames left to send.  Figure out when the next frame
  43. // is due to start playing, then make sure that we wait this long before
  44. // sending the next packet.
  45. structtimeval timeNow;
  46. gettimeofday(&timeNow, NULL);
  47. intsecsDiff = fNextSendTime.tv_sec - timeNow.tv_sec;
  48. int64_t uSecondsToGo = secsDiff * 1000000
  49. + (fNextSendTime.tv_usec - timeNow.tv_usec);
  50. if(uSecondsToGo < 0 || secsDiff < 0) {// sanity check: Make sure that the time-to-delay is non-negative:
  51. uSecondsToGo = 0;
  52. }
  53. // Delay this amount of time:
  54. nextTask() = envir().taskScheduler().scheduleDelayedTask(uSecondsToGo,
  55. (TaskFunc*) sendNext, this);
  56. }
  57. }



可以看到为了延迟包的发送，使用了delay task来执行下次打包发送任务。

sendNext()中又调用了buildAndSendPacket()函数，呵呵，又是一个圈圈。

总结一下调用过程：

最后，再说明一下包缓冲区的使用：

MultiFramedRTPSink中的帧数据和包缓冲区共用一个，只是用一些额外的变量指明缓冲区中属于包的部分以及属于帧数据的部分（包以外的数据叫做overflow data）。它有时会把overflow data以mem move的方式移到包开始的位置，有时把包的开始位置直接设置到overflow data开始的地方。那么这个缓冲的大小是怎样确定的呢？是跟据调用者指定的的一个最大的包的大小+60000算出的。这个地方把我搞胡涂了：如果一次从source获取一个帧的话，那这个缓冲应设为不小于最大的一个帧的大小才是，为何是按包的大小设置呢？可以看到，当缓冲不够时只是提示一下：

[cpp] view plaincopy

  1. if(numTruncatedBytes > 0) {
  2. unsigned constbufferSize = fOutBuf->totalBytesAvailable();
  3. envir()
  4. << "MultiFramedRTPSink::afterGettingFrame1(): The input frame data was too large for our buffer size ("
  5. << bufferSize
  6. << ").  "
  7. << numTruncatedBytes
  8. << " bytes of trailing data was dropped!  Correct this by increasing \"OutPacketBuffer::maxSize\" to at least "
  9. << OutPacketBuffer::maxSize + numTruncatedBytes
  10. << ", *before* creating this 'RTPSink'.  (Current value is "
  11. << OutPacketBuffer::maxSize << ".)\n";
  12. }

当然此时不会出错，但有可能导致时间戳计算不准，或增加时间戳计算与source端处理的复杂性(因为一次取一帧时间戳是很好计算的)。

原文地址：http://blog.csdn.net/niu_gao/article/details/6921145

live555源代码（VC6）：http://download.csdn.net/detail/leixiaohua1020/6374387

live555学习笔记－RTP打包与发送相关推荐

  1. live555学习笔记7－RTP打包与发送

    七 RTP打包与发送 rtp传送开始于函数:MediaSink::startPlaying().想想也有道理,应是sink跟source要数据,所以从sink上调用startplaying(嘿嘿,相当 ...

  2. live555 学习笔记-建立RTSP连接的过程（RTSP服务器端）

    live555 学习笔记-建立RTSP连接的过程(RTSP服务器端) 监听 创建rtsp server,rtspserver的构造函数中,创建监听socket,添加到调度管理器BasicTaskSch ...

  3. Sencha学习笔记2:打包您的第一个Sencha安卓应用apk安装包

    通过上一篇翻译的官方文章的介绍我们对sencha有了初步的印象,同时我们也通过该向导生成了第一个示例应用代码框架,那么下一步可能很多人都觉得应该根据该向导所提示的去看一下一个应用是如何建立起来的详细信 ...

  4. linux下h.264码流实时rtp打包与发送,Linux下H.264码流实时RTP打包与发送

    由于项目要求在DM6467T平台上添加实时RTP打包发送模块,这才找了找有没有人分享 这方面的经验.这里需要感谢网友:yanyuan9527,他写的文章对我帮助很大,可以说让一个完全小白的人了解了RT ...

  5. live555学习笔记【3】---RTSP服务器（一）

    Live555库是一个使用开放标准协议如RTP/RTCP.RTSP.SIP等实现多媒体流式传输的开源C 库集.这些函数库可以在Unix.Windows.QNX等操作系统下编译使用,基于此建立RTSP/ ...

  6. live555学习笔记－RTSPClient分析

    八 RTSPClient分析 有RTSPServer,当然就要有RTSPClient. 如果按照Server端的架构,想一下Client端各部分的组成可能是这样: 因为要连接RTSP server,所 ...

  7. live555学习笔记－RTSP服务运作

    RTSP服务运作 基础基本搞明白了,那么RTSP,RTP等这些协议又是如何利用这些基础机制运作的呢? 首先来看RTSP. RTSP首先需建立TCP侦听socket.可见于此函数: [cpp] view ...

  8. Live555学习笔记（一）—— live555概述

    IVE555是为流媒体提供解决方案的跨平台C++开源项目. 一.各库简要介绍 LIVE555下包含LiveMedia.UsageEnvironment.BasicUsageEnvironment.Gr ...

  9. live555学习笔记2－基础类

    二 基础类 讲几个重要的基础类: BasicUsageEnvironment和UsageEnvironment中的类都是用于整个系统的基础功能类．比如UsageEnvironment代表了整个系统运行 ...

最新文章

  1. window resize和scroll事件的基本优化
  2. 深入分析Linux内核源码oss.org.cn/kernel-book/
  3. LaTeX去掉默认显示日期时间
  4. java线程池_Java多线程并发：线程基本方法+线程池原理+阻塞队列原理技术分享...
  5. 使用sklearn来处理类别数据
  6. php member limit,php 安全有关问题
  7. html和css知识,html和 css基础知识
  8. linux centos 分区,linux centos 分区
  9. 制作centos安装u盘
  10. lua 去除小数点有效数字后面的0_【物联网学习番外篇】Lua脚本编程扫盲
  11. SQLserver nText和varchar 不兼容
  12. 【渝粤教育】国家开放大学2018年春季 0551-22T素描（二） 参考试题
  13. mysqlinnodb教程_mysql系列教程 - innodb锁
  14. xftp6成功安装教程（踩坑系列）
  15. Modbus转Profinet网关与ARX-MA100微型空气质量监测系统配置案例
  16. 看图猜成语小程序设计与实现（小程序+PHP）
  17. Selenium与phantomjs安装与环境配置，以及易班网站模拟登陆操作
  18. 谈谈 2020 年程序员收入报告
  19. ManualResetEvent，AutoResetEvent 学习
  20. 看了下大厂程序员的工资表，我酸了.....

热门文章

  1. 马化腾：卓越领导者的五种习惯（作出表率尤为重要）
  2. Bailian2925 大整数的因子【模除】
  3. HDU2148 Score【序列处理】
  4. B00012 C++算法库的sort()函数
  5. 经典卷积神经网络的学习（一）—— AlexNet
  6. 概率论经典问题 —— 三个事件 A、B、C 独立 ≠ 三个事件两两独立
  7. 计算机的组成 —— 显卡
  8. Python 标准库 —— xml
  9. 自学python能学成吗-没有任何编程基础可以直接学习python语言吗？学会后能够做什么？...
  10. python爬虫教程-Python爬虫全集