Wire up rtcp xr target bitrate on receive side.

webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.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 <memory>
 
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/array_view.h"
 #include "webrtc/base/random.h"
 #include "webrtc/common_types.h"
+#include "webrtc/common_video/include/video_bitrate_allocator.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/compound_packet.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.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"
@@ skipping 62 matching lines @@
 };
 
 class MockModuleRtpRtcp : public RTCPReceiver::ModuleRtpRtcp {
  public:
   MOCK_METHOD1(SetTmmbn, void(std::vector<rtcp::TmmbItem>));
   MOCK_METHOD0(OnRequestSendReport, void());
   MOCK_METHOD1(OnReceivedNack, void(const std::vector<uint16_t>&));
   MOCK_METHOD1(OnReceivedRtcpReportBlocks, void(const ReportBlockList&));
 };
 
+class MockVideoBitrateAllocationObserver
+    : public VideoBitrateAllocationObserver {
+ public:
+  MOCK_METHOD1(OnBitrateAllocationUpdated,
+               void(const BitrateAllocation& allocation));
+};
+
 // SSRC of remote peer, that sends rtcp packet to the rtcp receiver under test.
 constexpr uint32_t kSenderSsrc = 0x10203;
 // SSRCs of local peer, that rtcp packet addressed to.
 constexpr uint32_t kReceiverMainSsrc = 0x123456;
 // RtcpReceiver can accept several ssrc, e.g. regular and rtx streams.
 constexpr uint32_t kReceiverExtraSsrc = 0x1234567;
 // SSRCs to ignore (i.e. not configured in RtcpReceiver).
 constexpr uint32_t kNotToUsSsrc = 0x654321;
 constexpr uint32_t kUnknownSenderSsrc = 0x54321;
 
 }  // namespace
 
 class RtcpReceiverTest : public ::testing::Test {
  protected:
   RtcpReceiverTest()
       : system_clock_(1335900000),
         rtcp_receiver_(&system_clock_,
                        false,
                        &packet_type_counter_observer_,
                        &bandwidth_observer_,
                        &intra_frame_observer_,
                        &transport_feedback_observer_,
+                       &bitrate_allocation_observer_,
                        &rtp_rtcp_impl_) {}
   void SetUp() {
     std::set<uint32_t> ssrcs = {kReceiverMainSsrc, kReceiverExtraSsrc};
     rtcp_receiver_.SetSsrcs(kReceiverMainSsrc, ssrcs);
 
     rtcp_receiver_.SetRemoteSSRC(kSenderSsrc);
   }
 
   void InjectRtcpPacket(rtc::ArrayView<const uint8_t> raw) {
     rtcp_receiver_.IncomingPacket(raw.data(), raw.size());
   }
 
   void InjectRtcpPacket(const rtcp::RtcpPacket& packet) {
     rtc::Buffer raw = packet.Build();
     rtcp_receiver_.IncomingPacket(raw.data(), raw.size());
   }
 
   SimulatedClock system_clock_;
   // Callbacks to packet_type_counter_observer are frequent but most of the time
   // are not interesting.
   NiceMock<MockRtcpPacketTypeCounterObserver> packet_type_counter_observer_;
   StrictMock<MockRtcpBandwidthObserver> bandwidth_observer_;
   StrictMock<MockRtcpIntraFrameObserver> intra_frame_observer_;
   StrictMock<MockTransportFeedbackObserver> transport_feedback_observer_;
+  StrictMock<MockVideoBitrateAllocationObserver> bitrate_allocation_observer_;
   StrictMock<MockModuleRtpRtcp> rtp_rtcp_impl_;
 
   RTCPReceiver rtcp_receiver_;
 };
 
 TEST_F(RtcpReceiverTest, BrokenPacketIsIgnored) {
   const uint8_t bad_packet[] = {0, 0, 0, 0};
   EXPECT_CALL(packet_type_counter_observer_,
               RtcpPacketTypesCounterUpdated(_, _))
       .Times(0);
@@ skipping 1104 matching lines @@
 
 TEST_F(RtcpReceiverTest, ForceSenderReport) {
   rtcp::RapidResyncRequest rr;
   rr.SetSenderSsrc(kSenderSsrc);
   rr.SetMediaSsrc(kReceiverMainSsrc);
 
   EXPECT_CALL(rtp_rtcp_impl_, OnRequestSendReport());
   InjectRtcpPacket(rr);
 }
 
+TEST_F(RtcpReceiverTest, ReceivesTargetBitrate) {
+  BitrateAllocation expected_allocation;
+  expected_allocation.SetBitrate(0, 0, 10000);
+  expected_allocation.SetBitrate(0, 1, 20000);
+  expected_allocation.SetBitrate(1, 0, 40000);
+  expected_allocation.SetBitrate(1, 1, 80000);
+
+  rtcp::TargetBitrate bitrate;
+  bitrate.AddTargetBitrate(0, 0, expected_allocation.GetBitrate(0, 0) / 1000);
+  bitrate.AddTargetBitrate(0, 1, expected_allocation.GetBitrate(0, 1) / 1000);
+  bitrate.AddTargetBitrate(1, 0, expected_allocation.GetBitrate(1, 0) / 1000);
+  bitrate.AddTargetBitrate(1, 1, expected_allocation.GetBitrate(1, 1) / 1000);
+
+  rtcp::ExtendedReports xr;
+  xr.SetTargetBitrate(bitrate);
+
+  EXPECT_CALL(bitrate_allocation_observer_,
+              OnBitrateAllocationUpdated(expected_allocation));
+  InjectRtcpPacket(xr);
+}
+
 }  // namespace webrtc