Wire up BitrateAllocation to be sent as RTCP TargetBitrate

webrtc/modules/rtp_rtcp/source/rtcp_sender.h

 /*
  *  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 132 matching lines @@
                                      uint16_t length);
   int32_t SetRTCPVoIPMetrics(const RTCPVoIPMetric* VoIPMetric);
 
   void SendRtcpXrReceiverReferenceTime(bool enable);
 
   bool RtcpXrReceiverReferenceTime() const;
 
   void SetCsrcs(const std::vector<uint32_t>& csrcs);
 
   void SetTargetBitrate(unsigned int target_bitrate);
+  void SetVideoBitrateAllocation(const BitrateAllocation& bitrate);
   bool SendFeedbackPacket(const rtcp::TransportFeedback& packet);
 
  private:
   class RtcpContext;
 
   // Determine which RTCP messages should be sent and setup flags.
   void PrepareReport(const FeedbackState& feedback_state)
       EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
 
   bool AddReportBlock(const FeedbackState& feedback_state,
@@ skipping 27 matching lines @@
       EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
   std::unique_ptr<rtcp::RtcpPacket> BuildRPSI(const RtcpContext& context)
       EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
   std::unique_ptr<rtcp::RtcpPacket> BuildNACK(const RtcpContext& context)
       EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
   std::unique_ptr<rtcp::RtcpPacket> BuildReceiverReferenceTime(
       const RtcpContext& context)
       EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
   std::unique_ptr<rtcp::RtcpPacket> BuildDlrr(const RtcpContext& context)
       EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
+  std::unique_ptr<rtcp::RtcpPacket> BuildTargetBitrate(
+      const RtcpContext& context)
+      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
 
  private:
   const bool audio_;
   Clock* const clock_;
   Random random_ GUARDED_BY(critical_section_rtcp_sender_);
   RtcpMode method_ GUARDED_BY(critical_section_rtcp_sender_);
 
   RtcEventLog* const event_log_;
   Transport* const transport_;
 
@@ skipping 48 matching lines @@
 
   // XR VoIP metric
   RTCPVoIPMetric xr_voip_metric_ GUARDED_BY(critical_section_rtcp_sender_);
 
   RtcpPacketTypeCounterObserver* const packet_type_counter_observer_;
   RtcpPacketTypeCounter packet_type_counter_
       GUARDED_BY(critical_section_rtcp_sender_);
 
   RTCPUtility::NackStats nack_stats_ GUARDED_BY(critical_section_rtcp_sender_);
 
+  rtc::Optional<BitrateAllocation> video_bitrate_allocation_

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

#include "webrtc/base/optional.h"

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

Done.

+      GUARDED_BY(critical_section_rtcp_sender_);
+
   void SetFlag(RTCPPacketType type, bool is_volatile)
       EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
   void SetFlags(const std::set<RTCPPacketType>& types, bool is_volatile)
       EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
   bool IsFlagPresent(RTCPPacketType type) const
       EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
   bool ConsumeFlag(RTCPPacketType type, bool forced = false)
       EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
   bool AllVolatileFlagsConsumed() const
       EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
@@ skipping 10 matching lines @@
 
   typedef std::unique_ptr<rtcp::RtcpPacket> (RTCPSender::*BuilderFunc)(
       const RtcpContext&);
   std::map<RTCPPacketType, BuilderFunc> builders_;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(RTCPSender);
 };
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_SENDER_H_