Wire up rtcp xr target bitrate on receive side.

webrtc/modules/rtp_rtcp/source/rtcp_receiver.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/modules/rtp_rtcp/source/rtcp_receiver.h"
 
 #include <assert.h>
 #include <string.h>
 
 #include <limits>
 #include <map>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/trace_event.h"
+#include "webrtc/common_video/include/video_bitrate_allocator.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/common_header.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/compound_packet.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/fir.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/pli.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.h"
@@ skipping 25 matching lines @@
   uint32_t packet_type_flags = 0;  // RTCPPacketTypeFlags bit field.
 
   uint32_t remote_ssrc = 0;
   std::vector<uint16_t> nack_sequence_numbers;
   ReportBlockList report_blocks;
   int64_t rtt_ms = 0;
   uint8_t sli_picture_id = 0;
   uint64_t rpsi_picture_id = 0;
   uint32_t receiver_estimated_max_bitrate_bps = 0;
   std::unique_ptr<rtcp::TransportFeedback> transport_feedback;
+  rtc::Optional<BitrateAllocation> target_bitrate_allocation;
 };
 
 struct RTCPReceiver::ReceiveInformation {
   struct TimedTmmbrItem {
     rtcp::TmmbItem tmmbr_item;
     int64_t last_updated_ms;
   };
 
   int64_t last_time_received_ms = 0;
 
@@ skipping 16 matching lines @@
   size_t num_rtts = 0;
 };
 
 RTCPReceiver::RTCPReceiver(
     Clock* clock,
     bool receiver_only,
     RtcpPacketTypeCounterObserver* packet_type_counter_observer,
     RtcpBandwidthObserver* rtcp_bandwidth_observer,
     RtcpIntraFrameObserver* rtcp_intra_frame_observer,
     TransportFeedbackObserver* transport_feedback_observer,
+    VideoBitrateAllocationObserver* bitrate_allocation_observer,
     ModuleRtpRtcp* owner)
     : _clock(clock),
       receiver_only_(receiver_only),
       _rtpRtcp(*owner),
-      _cbRtcpBandwidthObserver(rtcp_bandwidth_observer),
-      _cbRtcpIntraFrameObserver(rtcp_intra_frame_observer),
-      _cbTransportFeedbackObserver(transport_feedback_observer),
+      rtcp_bandwidth_observer_(rtcp_bandwidth_observer),
+      rtcp_intra_frame_observer_(rtcp_intra_frame_observer),
+      transport_feedback_observer_(transport_feedback_observer),
+      bitrate_allocation_observer_(bitrate_allocation_observer),
       main_ssrc_(0),
       _remoteSSRC(0),
       _remoteSenderInfo(),
       xr_rrtr_status_(false),
       xr_rr_rtt_ms_(0),
       _lastReceivedRrMs(0),
       _lastIncreasedSequenceNumberMs(0),
-      stats_callback_(NULL),
+      stats_callback_(nullptr),
       packet_type_counter_observer_(packet_type_counter_observer),
       num_skipped_packets_(0),
       last_skipped_packets_warning_(clock->TimeInMilliseconds()) {
   memset(&_remoteSenderInfo, 0, sizeof(_remoteSenderInfo));
 }
 
 RTCPReceiver::~RTCPReceiver() {}
 
 bool RTCPReceiver::IncomingPacket(const uint8_t* packet, size_t packet_size) {
   if (packet_size == 0) {
@@ skipping 489 matching lines @@
                               PacketInformation* packet_information) {
   rtcp::Sdes sdes;
   if (!sdes.Parse(rtcp_block)) {
     ++num_skipped_packets_;
     return;
   }
 
   for (const rtcp::Sdes::Chunk& chunk : sdes.chunks()) {
     received_cnames_[chunk.ssrc] = chunk.cname;
     {
-      rtc::CritScope lock(&_criticalSectionFeedbacks);
+      rtc::CritScope lock(&feedbacks_lock_);
       if (stats_callback_)
         stats_callback_->CNameChanged(chunk.cname.c_str(), chunk.ssrc);
     }
   }
   packet_information->packet_type_flags |= kRtcpSdes;
 }
 
 void RTCPReceiver::HandleNACK(const CommonHeader& rtcp_block,
                               PacketInformation* packet_information) {
   rtcp::Nack nack;
@@ skipping 43 matching lines @@
                             PacketInformation* packet_information) {
   rtcp::ExtendedReports xr;
   if (!xr.Parse(rtcp_block)) {
     ++num_skipped_packets_;
     return;
   }
 
   if (xr.rrtr())
     HandleXrReceiveReferenceTime(xr.sender_ssrc(), *xr.rrtr());
 
-  for (const rtcp::ReceiveTimeInfo& time_info : xr.dlrr().sub_blocks())
-    HandleXrDlrrReportBlock(time_info);
+  if (!xr.dlrr().sub_blocks().empty()) {

[danilchap, 2016/12/02 11:01:14]

can remove back if (!empty()) block too

[sprang_webrtc, 2016/12/02 12:20:11]

Done.

+    for (const rtcp::ReceiveTimeInfo& time_info : xr.dlrr().sub_blocks())
+      HandleXrDlrrReportBlock(time_info);
+  }
+
+  if (xr.target_bitrate())
+    HandleXrTargetBitrate(*xr.target_bitrate(), packet_information);
 }
 
 void RTCPReceiver::HandleXrReceiveReferenceTime(
     uint32_t sender_ssrc,
     const rtcp::Rrtr& rrtr) {
   remote_time_info_.ssrc = sender_ssrc;
   remote_time_info_.last_rr = CompactNtp(rrtr.ntp());
   last_received_xr_ntp_.SetCurrent(*_clock);
 }
 
@@ skipping 12 matching lines @@
   if (send_time == 0)
     return;
 
   uint32_t delay_rr = rti.delay_since_last_rr;
   uint32_t now = CompactNtp(NtpTime(*_clock));
 
   uint32_t rtt_ntp = now - delay_rr - send_time;
   xr_rr_rtt_ms_ = CompactNtpRttToMs(rtt_ntp);
 }
 
+void RTCPReceiver::HandleXrTargetBitrate(
+    const rtcp::TargetBitrate& target_bitrate,
+    PacketInformation* packet_information) {
+  BitrateAllocation bitrate_allocation;
+  for (const auto& item : target_bitrate.GetTargetBitrates()) {
+    bitrate_allocation.SetBitrate(item.spatial_layer, item.temporal_layer,
+                                  item.target_bitrate_kbps * 1000);
+  }
+  packet_information->target_bitrate_allocation.emplace(bitrate_allocation);
+}
+
 void RTCPReceiver::HandlePLI(const CommonHeader& rtcp_block,
                              PacketInformation* packet_information) {
   rtcp::Pli pli;
   if (!pli.Parse(rtcp_block)) {
     ++num_skipped_packets_;
     return;
   }
 
   if (main_ssrc_ == pli.media_ssrc()) {
     TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PLI");
@@ skipping 153 matching lines @@
 
   packet_information->packet_type_flags |= kRtcpTransportFeedback;
   packet_information->transport_feedback = std::move(transport_feedback);
 }
 
 void RTCPReceiver::UpdateTmmbr() {
   // Find bounding set.
   std::vector<rtcp::TmmbItem> bounding =
       TMMBRHelp::FindBoundingSet(TmmbrReceived());
 
-  if (!bounding.empty() && _cbRtcpBandwidthObserver) {
+  if (!bounding.empty() && rtcp_bandwidth_observer_) {
     // We have a new bandwidth estimate on this channel.
     uint64_t bitrate_bps = TMMBRHelp::CalcMinBitrateBps(bounding);
     if (bitrate_bps <= std::numeric_limits<uint32_t>::max())
-      _cbRtcpBandwidthObserver->OnReceivedEstimatedBitrate(bitrate_bps);
+      rtcp_bandwidth_observer_->OnReceivedEstimatedBitrate(bitrate_bps);
   }
 
   // Set bounding set: inform remote clients about the new bandwidth.
   _rtpRtcp.SetTmmbn(std::move(bounding));
 }
 
 void RTCPReceiver::RegisterRtcpStatisticsCallback(
     RtcpStatisticsCallback* callback) {
-  rtc::CritScope cs(&_criticalSectionFeedbacks);
+  rtc::CritScope cs(&feedbacks_lock_);
   stats_callback_ = callback;
 }
 
 RtcpStatisticsCallback* RTCPReceiver::GetRtcpStatisticsCallback() {
-  rtc::CritScope cs(&_criticalSectionFeedbacks);
+  rtc::CritScope cs(&feedbacks_lock_);
   return stats_callback_;
 }
 
 // Holding no Critical section
 void RTCPReceiver::TriggerCallbacksFromRTCPPacket(
     const PacketInformation& packet_information) {
   // Process TMMBR and REMB first to avoid multiple callbacks
   // to OnNetworkChanged.
   if (packet_information.packet_type_flags & kRtcpTmmbr) {
     // Might trigger a OnReceivedBandwidthEstimateUpdate.
@@ skipping 10 matching lines @@
   if (!receiver_only_ && (packet_information.packet_type_flags & kRtcpSrReq)) {
     _rtpRtcp.OnRequestSendReport();
   }
   if (!receiver_only_ && (packet_information.packet_type_flags & kRtcpNack)) {
     if (!packet_information.nack_sequence_numbers.empty()) {
       LOG(LS_VERBOSE) << "Incoming NACK length: "
                       << packet_information.nack_sequence_numbers.size();
       _rtpRtcp.OnReceivedNack(packet_information.nack_sequence_numbers);
     }
   }
-  {
-    // We need feedback that we have received a report block(s) so that we
-    // can generate a new packet in a conference relay scenario, one received
-    // report can generate several RTCP packets, based on number relayed/mixed
-    // a send report block should go out to all receivers.
-    if (_cbRtcpIntraFrameObserver) {
-      RTC_DCHECK(!receiver_only_);
-      if ((packet_information.packet_type_flags & kRtcpPli) ||
-          (packet_information.packet_type_flags & kRtcpFir)) {
-        if (packet_information.packet_type_flags & kRtcpPli) {
-          LOG(LS_VERBOSE) << "Incoming PLI from SSRC "
-                          << packet_information.remote_ssrc;
-        } else {
-          LOG(LS_VERBOSE) << "Incoming FIR from SSRC "
-                          << packet_information.remote_ssrc;
-        }
-        _cbRtcpIntraFrameObserver->OnReceivedIntraFrameRequest(local_ssrc);
+
+  // We need feedback that we have received a report block(s) so that we
+  // can generate a new packet in a conference relay scenario, one received
+  // report can generate several RTCP packets, based on number relayed/mixed
+  // a send report block should go out to all receivers.
+  if (rtcp_intra_frame_observer_) {
+    RTC_DCHECK(!receiver_only_);
+    if ((packet_information.packet_type_flags & kRtcpPli) ||
+        (packet_information.packet_type_flags & kRtcpFir)) {
+      if (packet_information.packet_type_flags & kRtcpPli) {
+        LOG(LS_VERBOSE) << "Incoming PLI from SSRC "
+                        << packet_information.remote_ssrc;
+      } else {
+        LOG(LS_VERBOSE) << "Incoming FIR from SSRC "
+                        << packet_information.remote_ssrc;
       }
-      if (packet_information.packet_type_flags & kRtcpSli) {
-        _cbRtcpIntraFrameObserver->OnReceivedSLI(
-            local_ssrc, packet_information.sli_picture_id);
-      }
-      if (packet_information.packet_type_flags & kRtcpRpsi) {
-        _cbRtcpIntraFrameObserver->OnReceivedRPSI(
-            local_ssrc, packet_information.rpsi_picture_id);
-      }
+      rtcp_intra_frame_observer_->OnReceivedIntraFrameRequest(local_ssrc);
     }
-    if (_cbRtcpBandwidthObserver) {
-      RTC_DCHECK(!receiver_only_);
-      if (packet_information.packet_type_flags & kRtcpRemb) {
-        LOG(LS_VERBOSE)
-            << "Incoming REMB: "
-            << packet_information.receiver_estimated_max_bitrate_bps;
-        _cbRtcpBandwidthObserver->OnReceivedEstimatedBitrate(
-            packet_information.receiver_estimated_max_bitrate_bps);
-      }
-      if ((packet_information.packet_type_flags & kRtcpSr) ||
-          (packet_information.packet_type_flags & kRtcpRr)) {
-        int64_t now = _clock->TimeInMilliseconds();
-        _cbRtcpBandwidthObserver->OnReceivedRtcpReceiverReport(
-            packet_information.report_blocks, packet_information.rtt_ms, now);
-      }
+    if (packet_information.packet_type_flags & kRtcpSli) {
+      rtcp_intra_frame_observer_->OnReceivedSLI(
+          local_ssrc, packet_information.sli_picture_id);
+    }
+    if (packet_information.packet_type_flags & kRtcpRpsi) {
+      rtcp_intra_frame_observer_->OnReceivedRPSI(
+          local_ssrc, packet_information.rpsi_picture_id);
+    }
+  }
+  if (rtcp_bandwidth_observer_) {
+    RTC_DCHECK(!receiver_only_);
+    if (packet_information.packet_type_flags & kRtcpRemb) {
+      LOG(LS_VERBOSE) << "Incoming REMB: "
+                      << packet_information.receiver_estimated_max_bitrate_bps;
+      rtcp_bandwidth_observer_->OnReceivedEstimatedBitrate(
+          packet_information.receiver_estimated_max_bitrate_bps);
     }
     if ((packet_information.packet_type_flags & kRtcpSr) ||
         (packet_information.packet_type_flags & kRtcpRr)) {
-      _rtpRtcp.OnReceivedRtcpReportBlocks(packet_information.report_blocks);
+      int64_t now = _clock->TimeInMilliseconds();
+      rtcp_bandwidth_observer_->OnReceivedRtcpReceiverReport(
+          packet_information.report_blocks, packet_information.rtt_ms, now);
     }
+  }
+  if ((packet_information.packet_type_flags & kRtcpSr) ||
+      (packet_information.packet_type_flags & kRtcpRr)) {
+    _rtpRtcp.OnReceivedRtcpReportBlocks(packet_information.report_blocks);
+  }
 
-    if (_cbTransportFeedbackObserver &&
-        (packet_information.packet_type_flags & kRtcpTransportFeedback)) {
-      uint32_t media_source_ssrc =
-          packet_information.transport_feedback->media_ssrc();
-      if (media_source_ssrc == local_ssrc ||
-          registered_ssrcs.find(media_source_ssrc) != registered_ssrcs.end()) {
-        _cbTransportFeedbackObserver->OnTransportFeedback(
-            *packet_information.transport_feedback);
-      }
+  if (transport_feedback_observer_ &&
+      (packet_information.packet_type_flags & kRtcpTransportFeedback)) {
+    uint32_t media_source_ssrc =
+        packet_information.transport_feedback->media_ssrc();
+    if (media_source_ssrc == local_ssrc ||
+        registered_ssrcs.find(media_source_ssrc) != registered_ssrcs.end()) {
+      transport_feedback_observer_->OnTransportFeedback(
+          *packet_information.transport_feedback);
     }
   }
 
+  if (bitrate_allocation_observer_ &&
+      packet_information.target_bitrate_allocation) {
+    bitrate_allocation_observer_->OnBitrateAllocationUpdated(
+        *packet_information.target_bitrate_allocation);
+  }
+
   if (!receiver_only_) {
-    rtc::CritScope cs(&_criticalSectionFeedbacks);
+    rtc::CritScope cs(&feedbacks_lock_);
     if (stats_callback_) {
       for (const auto& report_block : packet_information.report_blocks) {
         RtcpStatistics stats;
         stats.cumulative_lost = report_block.cumulativeLost;
         stats.extended_max_sequence_number = report_block.extendedHighSeqNum;
         stats.fraction_lost = report_block.fractionLost;
         stats.jitter = report_block.jitter;
 
         stats_callback_->StatisticsUpdated(stats, report_block.sourceSSRC);
       }
@@ skipping 31 matching lines @@
       } else {
         candidates.push_back(it->second.tmmbr_item);
         ++it;
       }
     }
   }
   return candidates;
 }
 
 }  // namespace webrtc