Wire up send-side bandwidth estimation.

webrtc/modules/rtp_rtcp/source/rtcp_utility.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include "webrtc/base/checks.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 
 #include <assert.h>
 #include <math.h>   // ceil
 #include <string.h> // memcpy
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 
 namespace webrtc {
@@ skipping 51 matching lines @@
 {
     return _packetType;
 }
 
 const RTCPUtility::RTCPPacket&
 RTCPUtility::RTCPParserV2::Packet() const
 {
     return _packet;
 }
 
+rtcp::RtcpPacket* RTCPUtility::RTCPParserV2::ReleaseRtcpPacket() {
+  return rtcp_packet_.release();
+}
 RTCPUtility::RTCPPacketTypes
 RTCPUtility::RTCPParserV2::Begin()
 {
     _ptrRTCPData = _ptrRTCPDataBegin;
 
     return Iterate();
 }
 
 RTCPUtility::RTCPPacketTypes
 RTCPUtility::RTCPParserV2::Iterate()
@@ skipping 1136 matching lines @@
         case 5:
          {
             // RTCP-SR-REQ Rapid Synchronisation of RTP Flows
             // draft-perkins-avt-rapid-rtp-sync-03.txt
             // trigger a new RTCP SR
           _packetType = RTCPPacketTypes::kRtpfbSrReq;
 
             // Note: No state transition, SR REQ is empty!
             return true;
         }
+        case 15: {
+          _packetType = RTCPPacketTypes::kTransportFeedback;
+          rtcp_packet_ =
+              rtcp::TransportFeedback::ParseFrom(_ptrRTCPData - 12, length);
+          // Since we parse the whole packet here, keep the TopLevel state and
+          // just end the current block.
+          EndCurrentBlock();
+
+          return rtcp_packet_.get() != nullptr;
+        }
         default:
             break;
         }
         EndCurrentBlock();
         return false;

[stefan-webrtc, 2015/09/18 10:57:23]

I think it would be easier to read if we to put an RTC_DCHECK(false) here and
move the EndCurrentBlock() and return false into each case, since most cases
have a return in them. Or the opposite, only have a single return here and none
inside the switch.

[sprang_webrtc, 2015/09/21 10:44:10]

All cases in this switch returns true. There is only one where the value isn't
supported anymore, I think we should just remove that case-block instead. An
RTC_DCHECK is probably not desired here, if it is a RTCP message we don't
recognize, we should perhaps warn but then skip that block and move to the next,
not crash. Right?

[stefan-webrtc, 2015/09/21 11:12:07]

Sounds good. log it once every 10 seconds maybe?

[sprang_webrtc, 2015/09/21 13:42:53]

Done.

     } else if (header.packet_type == PT_PSFB) {
         // Payload specific feedback
         switch (header.count_or_format) {
         case 1:
             // PLI
           _packetType = RTCPPacketTypes::kPsfbPli;
             _packet.PLI.SenderSSRC = senderSSRC;
             _packet.PLI.MediaSSRC  = mediaSSRC;
 
             // Note: No state transition, PLI FCI is empty!
@@ skipping 437 matching lines @@
 const RTCPUtility::RtcpCommonHeader*
 RTCPUtility::RTCPPacketIterator::Current() {
     if (!_ptrBlock)
     {
         return NULL;
     }
 
     return &_header;
 }
 }  // namespace webrtc