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 632 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;
 }
 
+std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildTargetBitrate(

[danilchap, 2016/11/29 10:39:31]

move this methods to other Builders, after BuildDlrr
(function order in .h and .cc mismatch a lot, but better try to have them same)

[sprang_webrtc, 2016/11/29 12:24:01]

Done.

+    const RtcpContext& ctx) {
+  RTC_DCHECK(video_bitrate_allocation_);
+

[danilchap, 2016/11/29 10:39:31]

It became more important now to merge different XR blocks into single XR.
Dlrr and Rrtr shouldn't be in same report since one is used by sender, another
one - by receiver.
but target_bitrate and dlrr can be in same report.

Better not to do it in this CL, but add a TODO.

[sprang_webrtc, 2016/11/29 12:24:01]

Agree. I actually had a todo about that here but removed it for some reason I
can't remember.

+  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_ = rtc::Optional<BitrateAllocation>();

[danilchap, 2016/11/29 10:39:31]

may be video_bitrate_allocation_.reset();

[sprang_webrtc, 2016/11/29 12:24:01]

Done.
Nice, haven't seen that you added this and emplace. Did you send anything out
about this? :)

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

nope, nothing except cl https://codereview.webrtc.org/2378113002/ where I used
reset and emplace

+  return std::unique_ptr<rtcp::RtcpPacket>(xr.release());

[danilchap, 2016/11/29 10:39:31]

return std::move(xr); should work
alternatively make xr a raw pointer

[sprang_webrtc, 2016/11/29 12:24:01]

Done.

+}
+
+void RTCPSender::SetVideoBitrateAllocation(const BitrateAllocation& bitrate) {
+  rtc::CritScope lock(&critical_section_rtcp_sender_);
+  video_bitrate_allocation_ = rtc::Optional<BitrateAllocation>(bitrate);

[danilchap, 2016/11/29 10:39:31]

video_bitrate_allocation_.emplace(bitrate); will work too.

[sprang_webrtc, 2016/11/29 12:24:01]

Done.

+}
+
 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