Reland #2 of Issue 2434073003: Extract bitrate allocation ...

webrtc/video/video_send_stream_tests.cc

 /*
  *  Copyright (c) 2013 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 <algorithm>  // max
@@ skipping 1309 matching lines @@
 
   RunBaseTest(&test);
 }
 
 TEST_F(VideoSendStreamTest, ChangingTransportOverhead) {
   class ChangingTransportOverheadTest : public test::EndToEndTest {
    public:
     ChangingTransportOverheadTest()
         : EndToEndTest(test::CallTest::kDefaultTimeoutMs),
           call_(nullptr),
-          packets_sent_(0) {}
+          packets_sent_(0),
+          transport_overhead_(0) {}
 
     void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
       call_ = sender_call;
     }
 
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
       EXPECT_LE(length,
                 IP_PACKET_SIZE - static_cast<size_t>(transport_overhead_));
       if (++packets_sent_ < 100)
         return SEND_PACKET;
@@ skipping 130 matching lines @@
           last_initialized_frame_height_(0) {}
 
     void WaitForResolution(int width, int height) {
       {
         rtc::CritScope lock(&crit_);
         if (last_initialized_frame_width_ == width &&
             last_initialized_frame_height_ == height) {
           return;
         }
       }
-      init_encode_called_.Wait(VideoSendStreamTest::kDefaultTimeoutMs);
+      EXPECT_TRUE(
+          init_encode_called_.Wait(VideoSendStreamTest::kDefaultTimeoutMs));
       {
         rtc::CritScope lock(&crit_);
         EXPECT_EQ(width, last_initialized_frame_width_);
         EXPECT_EQ(height, last_initialized_frame_height_);
       }
     }
 
    private:
     int32_t InitEncode(const VideoCodec* config,
                        int32_t number_of_cores,
                        size_t max_payload_size) override {
       rtc::CritScope lock(&crit_);
       last_initialized_frame_width_ = config->width;
       last_initialized_frame_height_ = config->height;
       ++number_of_initializations_;
-      // First time InitEncode is called, the frame size is unknown.
-      if (number_of_initializations_ > 1)
-        init_encode_called_.Set();
+      init_encode_called_.Set();
       return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size);
     }
 
     int32_t Encode(const VideoFrame& input_image,
                    const CodecSpecificInfo* codec_specific_info,
                    const std::vector<FrameType>* frame_types) override {
       ADD_FAILURE()
           << "Unexpected Encode call since the send stream is not started";
       return 0;
     }
@@ skipping 98 matching lines @@
 // This test that if the encoder use an internal source, VideoEncoder::SetRates
 // will be called with zero bitrate during initialization and that
 // VideoSendStream::Stop also triggers VideoEncoder::SetRates Start to be called
 // with zero bitrate.
 TEST_F(VideoSendStreamTest, VideoSendStreamStopSetEncoderRateToZero) {
   class StartStopBitrateObserver : public test::FakeEncoder {
    public:
     StartStopBitrateObserver()
         : FakeEncoder(Clock::GetRealTimeClock()),
           encoder_init_(false, false),
-          bitrate_changed_(false, false),
-          bitrate_kbps_(0) {}
+          bitrate_changed_(false, false) {}
     int32_t InitEncode(const VideoCodec* config,
                        int32_t number_of_cores,
                        size_t max_payload_size) override {
       rtc::CritScope lock(&crit_);
-      bitrate_kbps_ = config->startBitrate;
       encoder_init_.Set();
       return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size);
     }
 
-    int32_t SetRates(uint32_t new_target_bitrate, uint32_t framerate) override {
+    int32_t SetRateAllocation(const BitrateAllocation& bitrate,
+                              uint32_t framerate) override {
       rtc::CritScope lock(&crit_);
-      bitrate_kbps_ = new_target_bitrate;
+      bitrate_kbps_ = rtc::Optional<int>(bitrate.get_sum_kbps());
       bitrate_changed_.Set();
-      return FakeEncoder::SetRates(new_target_bitrate, framerate);
-    }
-
-    int GetBitrateKbps() const {
-      rtc::CritScope lock(&crit_);
-      return bitrate_kbps_;
+      return FakeEncoder::SetRateAllocation(bitrate, framerate);
     }
 
     bool WaitForEncoderInit() {
       return encoder_init_.Wait(VideoSendStreamTest::kDefaultTimeoutMs);
     }
-    bool WaitBitrateChanged() {
-      return bitrate_changed_.Wait(VideoSendStreamTest::kDefaultTimeoutMs);
+
+    bool WaitBitrateChanged(bool non_zero) {
+      do {
+        rtc::Optional<int> bitrate_kbps;
+        {
+          rtc::CritScope lock(&crit_);
+          bitrate_kbps = bitrate_kbps_;
+        }
+        if (bitrate_kbps && !(non_zero ^ (*bitrate_kbps > 0)))

[stefan-webrtc, 2016/11/16 14:55:08]

This is really hard to read. Must be possible to simplify... :)

[sprang_webrtc, 2016/11/16 15:01:43]

Done.

+          return true;
+      } while (bitrate_changed_.Wait(VideoSendStreamTest::kDefaultTimeoutMs));
+      return false;
     }
 
    private:
     rtc::CriticalSection crit_;
     rtc::Event encoder_init_;
     rtc::Event bitrate_changed_;
-    int bitrate_kbps_ GUARDED_BY(crit_);
+    rtc::Optional<int> bitrate_kbps_ GUARDED_BY(crit_);
   };
 
   CreateSenderCall(Call::Config(&event_log_));
 
   test::NullTransport transport;
   CreateSendConfig(1, 0, 0, &transport);
 
   StartStopBitrateObserver encoder;
   video_send_config_.encoder_settings.encoder = &encoder;
   video_send_config_.encoder_settings.internal_source = true;
 
   CreateVideoStreams();
 
   EXPECT_TRUE(encoder.WaitForEncoderInit());
-  EXPECT_GT(encoder.GetBitrateKbps(), 0);
+
   video_send_stream_->Start();
-  EXPECT_TRUE(encoder.WaitBitrateChanged());
-  EXPECT_GT(encoder.GetBitrateKbps(), 0);
+  EXPECT_TRUE(encoder.WaitBitrateChanged(true));
+
   video_send_stream_->Stop();
-  EXPECT_TRUE(encoder.WaitBitrateChanged());
-  EXPECT_EQ(0, encoder.GetBitrateKbps());
+  EXPECT_TRUE(encoder.WaitBitrateChanged(false));
+
   video_send_stream_->Start();
-  EXPECT_TRUE(encoder.WaitBitrateChanged());
-  EXPECT_GT(encoder.GetBitrateKbps(), 0);
+  EXPECT_TRUE(encoder.WaitBitrateChanged(true));
 
   DestroyStreams();
 }
 
 TEST_F(VideoSendStreamTest, CapturesTextureAndVideoFrames) {
   class FrameObserver : public rtc::VideoSinkInterface<VideoFrame> {
    public:
     FrameObserver() : output_frame_event_(false, false) {}
 
     void OnFrame(const VideoFrame& video_frame) override {
@@ skipping 391 matching lines @@
   // VideoCodec.
   EXPECT_EQ(kVideoCodecConfigObserverNumberOfTemporalLayers,
             config.VP8().numberOfTemporalLayers);
 
   for (unsigned char i = 0; i < config.numberOfSimulcastStreams; ++i) {
     EXPECT_EQ(kVideoCodecConfigObserverNumberOfTemporalLayers,
               config.simulcastStream[i].numberOfTemporalLayers);
   }
 
   // Set expected temporal layers as they should have been set when
-  // reconfiguring the encoder and not match the set config.
+  // reconfiguring the encoder and not match the set config. Also copy the
+  // TemporalLayersFactory pointer that has been injected by ViEEncoder.
   VideoCodecVP8 encoder_settings = encoder_settings_;
   encoder_settings.numberOfTemporalLayers =
       kVideoCodecConfigObserverNumberOfTemporalLayers;
+  encoder_settings.tl_factory = config.VP8().tl_factory;
   EXPECT_EQ(
       0, memcmp(&config.VP8(), &encoder_settings, sizeof(encoder_settings_)));
 }
 
 template <>
 rtc::scoped_refptr<VideoEncoderConfig::EncoderSpecificSettings>
 VideoCodecConfigObserver<VideoCodecVP8>::GetEncoderSpecificSettings() const {
   return new rtc::RefCountedObject<
       VideoEncoderConfig::Vp8EncoderSpecificSettings>(encoder_settings_);
 }
@@ skipping 201 matching lines @@
         // has currently configured but in the span of the set max and min
         // bitrate.
       }
       ++num_initializations_;
       init_encode_event_.Set();
 
       return FakeEncoder::InitEncode(codecSettings, numberOfCores,
                                      maxPayloadSize);
     }
 
-    int32_t SetRates(uint32_t newBitRate, uint32_t frameRate) override {
+    int32_t SetRateAllocation(const BitrateAllocation& bitrate,
+                              uint32_t frameRate) override {
       {
         rtc::CritScope lock(&crit_);
-        if (target_bitrate_ == newBitRate) {
-          return FakeEncoder::SetRates(newBitRate, frameRate);
+        if (target_bitrate_ == bitrate.get_sum_kbps()) {
+          return FakeEncoder::SetRateAllocation(bitrate, frameRate);
         }
-        target_bitrate_ = newBitRate;
+        target_bitrate_ = bitrate.get_sum_kbps();
       }
       bitrate_changed_event_.Set();
-      return FakeEncoder::SetRates(newBitRate, frameRate);
+      return FakeEncoder::SetRateAllocation(bitrate, frameRate);
     }
 
     void WaitForSetRates(uint32_t expected_bitrate) {
       EXPECT_TRUE(
           bitrate_changed_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs))
           << "Timed out while waiting encoder rate to be set.";
       rtc::CritScope lock(&crit_);
       EXPECT_EQ(expected_bitrate, target_bitrate_);
     }
 
@@ skipping 654 matching lines @@
        RequestSourceRotateIfVideoOrientationExtensionNotSupported) {
   TestRequestSourceRotateVideo(false);
 }
 
 TEST_F(VideoSendStreamTest,
        DoNotRequestsRotationIfVideoOrientationExtensionSupported) {
   TestRequestSourceRotateVideo(true);
 }
 
 }  // namespace webrtc