Extract bitrate allocation of spatial/temporal layers out of codec impl.

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 1529 matching lines @@
           bitrate_kbps_(0) {}
     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_ = bitrate.get_sum_kbps();
       bitrate_changed_.Set();
-      return FakeEncoder::SetRates(new_target_bitrate, framerate);
+      return FakeEncoder::SetRateAllocation(bitrate, framerate);
     }
 
     int GetBitrateKbps() const {
       rtc::CritScope lock(&crit_);
       return bitrate_kbps_;
     }
 
     bool WaitForEncoderInit() {
       return encoder_init_.Wait(VideoSendStreamTest::kDefaultTimeoutMs);
     }
@@ skipping 445 matching lines @@
   // VideoCodec.
   EXPECT_EQ(kVideoCodecConfigObserverNumberOfTemporalLayers,
             config.codecSpecific.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.codecSpecific.VP8.tl_factory;
   EXPECT_EQ(0, memcmp(&config.codecSpecific.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 205 matching lines @@
         // bitrate.
       }
       ++num_initializations_;
       if (num_initializations_ > 1) {
         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 619 matching lines @@
         observation_complete_.Set();
       }
     }
   } test;
 
   RunBaseTest(&test);
 }
 #endif  // !defined(RTC_DISABLE_VP9)
 
 }  // namespace webrtc