七 RTP打包与发送

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

看一下这个函数:

  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. return False;
  9. }
  10. // Make sure our source is compatible:
  11. if (!sourceIsCompatibleWithUs(source)) {
  12. envir().setResultMsg(
  13. "MediaSink::startPlaying(): source is not compatible!");
  14. return False;
  15. }
  16. //记下一些要使用的对象
  17. fSource = (FramedSource*) &source;
  18. fAfterFunc = afterFunc;
  19. fAfterClientData = afterClientData;
  20. return continuePlaying();
  21. }

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

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

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

  1. void MultiFramedRTPSink::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():

  1. void MultiFramedRTPSink::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. struct timeval 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():

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

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

  1. void MultiFramedRTPSink::afterGettingFrame1(
  2. unsigned frameSize,
  3. unsigned numTruncatedBytes,
  4. struct timeval 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 const bufferSize = 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. } else if (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. }

看一下发送数据的函数:

  1. void MultiFramedRTPSink::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. struct timeval timeNow;
  46. gettimeofday(&timeNow, NULL);
  47. int secsDiff = 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获取一个帧的话,那这个缓冲应设为不小于最大的一个帧的大小才是,为何是按包的大小设置呢?可以看到,当缓冲不够时只是提示一下:

  1. if (numTruncatedBytes > 0) {
  2. unsigned const bufferSize = 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学习笔记7-RTP打包与发送的更多相关文章

  1. (转)live555学习笔记10-h264 RTP传输详解(2)

    参考: 1,live555学习笔记10-h264 RTP传输详解(2) http://blog.csdn.net/niu_gao/article/details/6936108 2,H264 sps ...

  2. cocos2d-x学习笔记(18)--游戏打包(windows平台)

    cocos2d-x学习笔记(18)--游戏打包(windows平台)           之前做好的游戏,都是在vs2008下编译执行的.假设说想把游戏公布到网上或者和其它人一起分享游戏,那就得对游戏 ...

  3. (转)live555学习笔记-UsageEnvironment和TaskScheduler

    2011-12-6阅读1264 评论1 一直想学习流媒体服务器的设计,这几天有点时间,看了一下live555的源代码.live555是一个开源的跨平台流媒体服务器,使用编程语言是C++.将现阶段学习笔 ...

  4. (转)live555学习笔记9-h264 RTP传输详解(1)

    九 h264 RTP传输详解(1) 前几章对Server端的介绍中有个比较重要的问题没有仔细探究:如何打开文件并获得其SDP信息.我们就从这里入手吧. 当RTSPServer收到对某个媒体的DESCR ...

  5. Maven学习笔记-02-Maven项目打包配置与测试

    一 Maven项目打包配置 1 为整个项目统一指定字符集 <properties> <project.build.sourceEncoding>UTF-</project ...

  6. [python学习笔记] python程序打包成exe文件

    安装 pyinstaller pip3 install pyinstaller 命令 pyinstaller -F -w -i ../ui/icon.ico --clean ../Login.py 参 ...

  7. android菜鸟学习笔记16----Android项目打包安装过程(Run as Android Application)

    右击项目名称,Run as Android Appication之后,Android项目打包安装过程: 1.打包生成.apk文件: 1)把源码中的.java文件编译生成.class文件 2)将所有的. ...

  8. Python学习笔记:py2exe打包Python程序

    使用py2exe将一个Python程序打包成一个exe程序,这样Python程序也可以在没有安装Python的环境中运行Python程序了.使用这个工具需要写一个用于打包的setup.py文件(名称可 ...

  9. Android(java)学习笔记80:UDP协议发送数据

    UDP协议发送数据:我们总是先运行接收端,再运行发送端发送端: 1 package cn.itcast_02; import java.io.IOException; import java.net. ...

随机推荐

  1. python List使用

    1.enumerate 用在遍历中,返回下标和数据 name_arr = ["shijingjing", "renjiangfeng", "anqi& ...

  2. 【Bootloader】探究bootloader,分析u-boot源码

    Preface 之前也发表过关于<Bootloader启动过程分析>的文章,但是内容表达得比较抽象,大多是文字叙述,所以这里从系统和代码的角度来深入分析bootloader的启动过程. 工 ...

  3. Asp.Net支付宝手机网站支付接口API之C#版

    一.准备工作 1.使用企业支付宝签约手机网站支付 2.下载支付宝官方demo 文档地址:https://doc.open.alipay.com/doc2/detail?treeId=60&ar ...

  4. 安装Python2.7出现configure: error: no acceptable C compiler found in $PATH错误

    安装Python2.7出现configure: error: no acceptable C compiler found in $PATH错误 安装步骤: 安装依赖 yum groupinstall ...

  5. Django admin 继承user表后密码为明文,继承UserAdmin,重写其方法

    Django用户继承AbstractUser后密码为明文 其实本不应该有这个问题,却花了我很久的时间,因为还是初学阶段. 造成这个原因是因为在admin注册的生活没有指定Admin 在app的admi ...

  6. 【GitHub】常用命令

    克隆项目 git clone http://*git 把本地项目提交到远程 git add --all git commit -m "Initail commit" git pus ...

  7. java基础篇---网络编程(TCP程序设计)

    TCP程序设计 在Java中使用Socket(即套接字)完成TCP程序的开发,使用此类可以方便的建立可靠地,双向的,持续的,点对点的通讯连接. 在Socket的程序开发中,服务器端使用serverSo ...

  8. Android TabHost的使用 顶部选项卡

    用TabHost 来实现顶部选项卡,上代码:activity_main.xml <?xml version="1.0" encoding="utf-8"? ...

  9. 【Unity Shader】五、Shader纹理映射,及纹理的缩放和偏移

    将漫反射的颜色改为从纹理贴图中获取,逐像素计算. Shader "Custom/11-Texture" { // 纹理贴图,BlinnPhong光照模型 Properties{ / ...

  10. if 语句练习 身高体重问题

    public class d { /** * @param args */ public static void main(String[] args) { // TODO 自动生成的方法存根 int ...