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 183 matching lines @@
   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_[kRtcpTargetBitrate] = &RTCPSender::BuildTargetBitrate;
 }
 
 RTCPSender::~RTCPSender() {}
 
 RtcpMode RTCPSender::Status() const {
   rtc::CritScope lock(&critical_section_rtcp_sender_);
   return method_;
 }
 
 void RTCPSender::SetRTCPStatus(RtcpMode new_method) {
@@ skipping 497 matching lines @@
 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);
 
   return std::unique_ptr<rtcp::RtcpPacket>(xr);
 }
 
+std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildTargetBitrate(
+    const RtcpContext& ctx) {
+  RTC_DCHECK(video_bitrate_allocation_);
+
+  // TODO(sprang): DLRR and TargetBitrate should be sent in the same XR, if
+  // possible.
+  std::unique_ptr<rtcp::ExtendedReports> xr(new rtcp::ExtendedReports());
+  xr->SetSenderSsrc(ssrc_);
+  rtcp::TargetBitrate target_bitrate;
+
+  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);
+    }
+  }
+
+  xr->SetTargetBitrate(target_bitrate);
+  video_bitrate_allocation_.reset();
+  return std::unique_ptr<rtcp::RtcpPacket>(std::move(xr));

[danilchap, 2016/11/29 13:13:14]

return std::move(xr);  should work,
no need for explicit cast to std::unique_ptr<rtcp::RtcpPacket> after the
std::move

[sprang_webrtc, 2016/11/29 13:34:54]

Done.

+}
+
 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildVoIPMetric(
     const RtcpContext& context) {
   rtcp::ExtendedReports* xr = new rtcp::ExtendedReports();
   xr->SetSenderSsrc(ssrc_);
 
   rtcp::VoipMetric voip;
   voip.SetMediaSsrc(remote_ssrc_);
   voip.SetVoipMetric(xr_voip_metric_);
 
   xr->SetVoipMetric(voip);
@@ skipping 115 matching lines @@
   }
 
   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 (video_bitrate_allocation_)
+      SetFlag(kRtcpTargetBitrate, 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 139 matching lines @@
 }
 
 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_, static_cast<size_t>(IP_PACKET_SIZE));
   uint8_t buffer[IP_PACKET_SIZE];
   return packet.BuildExternalBuffer(buffer, max_payload_length_, &sender) &&
          !sender.send_failure_;
 }
 
 }  // namespace webrtc