Wire up BitrateAllocation to be sent as RTCP TargetBitrate

webrtc/modules/rtp_rtcp/source/rtcp_sender.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.
  */
 
@@ skipping 24 matching lines @@
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sli.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h"
 #include "webrtc/modules/rtp_rtcp/source/tmmbr_help.h"
 
 namespace webrtc {
 
+namespace {
+const uint32_t kRtcpAnyExtendedReports =
+    kRtcpXrVoipMetric | kRtcpXrReceiverReferenceTime | kRtcpXrDlrrReportBlock |
+    kRtcpXrTargetBitrate;
+}
+
 NACKStringBuilder::NACKStringBuilder()
     : stream_(""), count_(0), prevNack_(0), consecutive_(false) {}
 
 NACKStringBuilder::~NACKStringBuilder() {}
 
 void NACKStringBuilder::PushNACK(uint16_t nack) {
   if (count_ == 0) {
     stream_ << nack;
   } else if (nack == prevNack_ + 1) {
     consecutive_ = true;
@@ skipping 135 matching lines @@
   builders_[kRtcpPli] = &RTCPSender::BuildPLI;
   builders_[kRtcpFir] = &RTCPSender::BuildFIR;
   builders_[kRtcpSli] = &RTCPSender::BuildSLI;
   builders_[kRtcpRpsi] = &RTCPSender::BuildRPSI;
   builders_[kRtcpRemb] = &RTCPSender::BuildREMB;
   builders_[kRtcpBye] = &RTCPSender::BuildBYE;
   builders_[kRtcpApp] = &RTCPSender::BuildAPP;
   builders_[kRtcpTmmbr] = &RTCPSender::BuildTMMBR;
   builders_[kRtcpTmmbn] = &RTCPSender::BuildTMMBN;
   builders_[kRtcpNack] = &RTCPSender::BuildNACK;
-  builders_[kRtcpXrVoipMetric] = &RTCPSender::BuildVoIPMetric;
-  builders_[kRtcpXrReceiverReferenceTime] =
-      &RTCPSender::BuildReceiverReferenceTime;
-  builders_[kRtcpXrDlrrReportBlock] = &RTCPSender::BuildDlrr;
+  builders_[kRtcpAnyExtendedReports] = &RTCPSender::BuildExtendedReports;
 }
 
 RTCPSender::~RTCPSender() {}
 
 RtcpMode RTCPSender::Status() const {
   rtc::CritScope lock(&critical_section_rtcp_sender_);
   return method_;
 }
 
 void RTCPSender::SetRTCPStatus(RtcpMode new_method) {
@@ skipping 471 matching lines @@
 }
 
 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildBYE(const RtcpContext& ctx) {
   rtcp::Bye* bye = new rtcp::Bye();
   bye->SetSenderSsrc(ssrc_);
   bye->SetCsrcs(csrcs_);
 
   return std::unique_ptr<rtcp::RtcpPacket>(bye);
 }
 
-std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildReceiverReferenceTime(
+std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildExtendedReports(
     const RtcpContext& ctx) {
-
-  rtcp::ExtendedReports* xr = new rtcp::ExtendedReports();
+  std::unique_ptr<rtcp::ExtendedReports> xr(new rtcp::ExtendedReports());
   xr->SetSenderSsrc(ssrc_);
 
-  rtcp::Rrtr rrtr;
-  rrtr.SetNtp(NtpTime(ctx.ntp_sec_, ctx.ntp_frac_));
+  if (!sending_ && xr_send_receiver_reference_time_enabled_) {
+    rtcp::Rrtr rrtr;
+    rrtr.SetNtp(NtpTime(ctx.ntp_sec_, ctx.ntp_frac_));
+    xr->SetRrtr(rrtr);
+  }
 
-  xr->SetRrtr(rrtr);
+  if (ctx.feedback_state_.has_last_xr_rr) {
+    xr->AddDlrrItem(ctx.feedback_state_.last_xr_rr);
+  }
 
-  // TODO(sprang): Merge XR report sending to contain all of RRTR, DLRR, VOIP?
+  if (video_bitrate_allocation_) {
+    rtcp::TargetBitrate target_bitrate;
 
-  return std::unique_ptr<rtcp::RtcpPacket>(xr);
-}
+    for (int sl = 0; sl < kMaxSpatialLayers; ++sl) {
+      for (int tl = 0; tl < kMaxTemporalStreams; ++tl) {
+        uint32_t layer_bitrate_bps =
+            video_bitrate_allocation_->GetBitrate(sl, tl);
+        if (layer_bitrate_bps > 0)
+          target_bitrate.AddTargetBitrate(sl, tl, layer_bitrate_bps / 1000);
+      }
+    }
 
-std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildDlrr(
-    const RtcpContext& ctx) {
-  rtcp::ExtendedReports* xr = new rtcp::ExtendedReports();
-  xr->SetSenderSsrc(ssrc_);
-  RTC_DCHECK(ctx.feedback_state_.has_last_xr_rr);
-  xr->AddDlrrItem(ctx.feedback_state_.last_xr_rr);
+    xr->SetTargetBitrate(target_bitrate);
+    video_bitrate_allocation_.reset();
+  }
 
-  return std::unique_ptr<rtcp::RtcpPacket>(xr);
-}
+  if (xr_voip_metric_) {
+    rtcp::VoipMetric voip;
+    voip.SetMediaSsrc(remote_ssrc_);
+    voip.SetVoipMetric(*xr_voip_metric_);
+    xr_voip_metric_.reset();
 
-std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildVoIPMetric(
-    const RtcpContext& context) {
-  rtcp::ExtendedReports* xr = new rtcp::ExtendedReports();
-  xr->SetSenderSsrc(ssrc_);
+    xr->SetVoipMetric(voip);
+  }
 
-  rtcp::VoipMetric voip;
-  voip.SetMediaSsrc(remote_ssrc_);
-  voip.SetVoipMetric(xr_voip_metric_);
-
-  xr->SetVoipMetric(voip);
-
-  return std::unique_ptr<rtcp::RtcpPacket>(xr);
+  return std::move(xr);
 }
 
 int32_t RTCPSender::SendRTCP(const FeedbackState& feedback_state,
                              RTCPPacketType packetType,
                              int32_t nack_size,
                              const uint16_t* nack_list,
                              bool repeat,
                              uint64_t pictureID) {
   return SendCompoundRTCP(
       feedback_state, std::set<RTCPPacketType>(&packetType, &packetType + 1),
@@ skipping 44 matching lines @@
     RtcpContext context(feedback_state, nack_size, nack_list, repeat, pictureID,
                         ntp_sec, ntp_frac);
 
     PrepareReport(feedback_state);
 
     std::unique_ptr<rtcp::RtcpPacket> packet_bye;
 
     auto it = report_flags_.begin();
     while (it != report_flags_.end()) {
       auto builder_it = builders_.find(it->type);
-      RTC_DCHECK(builder_it != builders_.end());
+      RTC_DCHECK(builder_it != builders_.end())
+          << "Could not find builder for packet type " << it->type;
       if (it->is_volatile) {
         report_flags_.erase(it++);
       } else {
         ++it;
       }
 
       BuilderFunc func = builder_it->second;
       std::unique_ptr<rtcp::RtcpPacket> packet = (this->*func)(context);
       if (packet.get() == nullptr)
         return -1;
@@ skipping 34 matching lines @@
         (ConsumeFlag(kRtcpReport) && method_ == RtcpMode::kReducedSize) ||
         method_ == RtcpMode::kCompound;
     if (generate_report)
       SetFlag(sending_ ? kRtcpSr : kRtcpRr, true);
   }
 
   if (IsFlagPresent(kRtcpSr) || (IsFlagPresent(kRtcpRr) && !cname_.empty()))
     SetFlag(kRtcpSdes, true);
 
   if (generate_report) {
-    if (!sending_ && xr_send_receiver_reference_time_enabled_)
-      SetFlag(kRtcpXrReceiverReferenceTime, true);
-    if (feedback_state.has_last_xr_rr)
-      SetFlag(kRtcpXrDlrrReportBlock, true);
+    if ((!sending_ && xr_send_receiver_reference_time_enabled_) ||
+        feedback_state.has_last_xr_rr || video_bitrate_allocation_) {
+      SetFlag(kRtcpAnyExtendedReports, true);
+    }
 
     // generate next time to send an RTCP report
     uint32_t minIntervalMs = RTCP_INTERVAL_AUDIO_MS;
 
     if (!audio_) {
       if (sending_) {
         // Calculate bandwidth for video; 360 / send bandwidth in kbit/s.
         uint32_t send_bitrate_kbit = feedback_state.send_bitrate / 1000;
         if (send_bitrate_kbit != 0)
           minIntervalMs = 360000 / send_bitrate_kbit;
@@ skipping 86 matching lines @@
   app_sub_type_ = subType;
   app_name_ = name;
   app_data_.reset(new uint8_t[length]);
   app_length_ = length;
   memcpy(app_data_.get(), data, length);
   return 0;
 }
 
 int32_t RTCPSender::SetRTCPVoIPMetrics(const RTCPVoIPMetric* VoIPMetric) {
   rtc::CritScope lock(&critical_section_rtcp_sender_);
-  memcpy(&xr_voip_metric_, VoIPMetric, sizeof(RTCPVoIPMetric));
+  xr_voip_metric_.emplace(*VoIPMetric);
 
-  SetFlag(kRtcpXrVoipMetric, true);
+  SetFlag(kRtcpAnyExtendedReports, true);
   return 0;
 }
 
 void RTCPSender::SendRtcpXrReceiverReferenceTime(bool enable) {
   rtc::CritScope lock(&critical_section_rtcp_sender_);
   xr_send_receiver_reference_time_enabled_ = enable;
 }
 
 bool RTCPSender::RtcpXrReceiverReferenceTime() const {
   rtc::CritScope lock(&critical_section_rtcp_sender_);
   return xr_send_receiver_reference_time_enabled_;
 }
 
 void RTCPSender::SetTmmbn(std::vector<rtcp::TmmbItem> bounding_set) {
   rtc::CritScope lock(&critical_section_rtcp_sender_);
   tmmbn_to_send_ = std::move(bounding_set);
   SetFlag(kRtcpTmmbn, true);
 }
 
-void RTCPSender::SetFlag(RTCPPacketType type, bool is_volatile) {
+void RTCPSender::SetFlag(uint32_t type, bool is_volatile) {
   report_flags_.insert(ReportFlag(type, is_volatile));
 }
 
 void RTCPSender::SetFlags(const std::set<RTCPPacketType>& types,
                           bool is_volatile) {
-  for (RTCPPacketType type : types)
-    SetFlag(type, is_volatile);
+  for (RTCPPacketType type : types) {
+    if (type & kRtcpAnyExtendedReports) {
+      SetFlag(kRtcpAnyExtendedReports, is_volatile);
+    } else {
+      SetFlag(type, is_volatile);
+    }
+  }
 }
 
-bool RTCPSender::IsFlagPresent(RTCPPacketType type) const {
+bool RTCPSender::IsFlagPresent(uint32_t type) const {
   return report_flags_.find(ReportFlag(type, false)) != report_flags_.end();
 }
 
-bool RTCPSender::ConsumeFlag(RTCPPacketType type, bool forced) {
+bool RTCPSender::ConsumeFlag(uint32_t type, bool forced) {
   auto it = report_flags_.find(ReportFlag(type, false));
   if (it == report_flags_.end())
     return false;
   if (it->is_volatile || forced)
     report_flags_.erase((it));
   return true;
 }
 
 bool RTCPSender::AllVolatileFlagsConsumed() const {
   for (const ReportFlag& flag : report_flags_) {
     if (flag.is_volatile)
       return false;
   }
   return true;
 }
 
+void RTCPSender::SetVideoBitrateAllocation(const BitrateAllocation& bitrate) {
+  rtc::CritScope lock(&critical_section_rtcp_sender_);
+  video_bitrate_allocation_.emplace(bitrate);
+}
+
 bool RTCPSender::SendFeedbackPacket(const rtcp::TransportFeedback& packet) {
   class Sender : public rtcp::RtcpPacket::PacketReadyCallback {
    public:
     Sender(Transport* transport, RtcEventLog* event_log)
         : transport_(transport), event_log_(event_log), send_failure_(false) {}
 
     void OnPacketReady(uint8_t* data, size_t length) override {
       if (transport_->SendRtcp(data, length)) {
         if (event_log_) {
           event_log_->LogRtcpPacket(kOutgoingPacket, MediaType::ANY, data,
@@ skipping 12 matching lines @@
     // but we can't because of an incorrect warning (C4822) in MVS 2013.
   } sender(transport_, event_log_);
 
   RTC_DCHECK_LE(max_payload_length_, IP_PACKET_SIZE);
   uint8_t buffer[IP_PACKET_SIZE];
   return packet.BuildExternalBuffer(buffer, max_payload_length_, &sender) &&
          !sender.send_failure_;
 }
 
 }  // namespace webrtc