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

webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h

Index: webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h
diff --git a/webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h b/webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h
index e2d5bb87384fbbca678e00584162ebe2a7586dbd..dacfe8fa62c6ce6f3fe24d2ce3623e541b7b42b5 100644
--- a/webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h
+++ b/webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h
@@ -12,6 +12,7 @@
 #define WEBRTC_MODULES_VIDEO_CODING_CODECS_VP8_SIMULCAST_UNITTEST_H_
 
 #include <algorithm>
+#include <map>
 #include <memory>
 #include <vector>
 
@@ -152,18 +153,32 @@ class SkipEncodingUnusedStreamsTest {
   std::vector<unsigned int> RunTest(VP8Encoder* encoder,
                                     VideoCodec* settings,
                                     uint32_t target_bitrate) {
+    class TemporalLayersIndex : public TemporalLayersListener {
+     public:
+      TemporalLayersIndex() {}
+      ~TemporalLayersIndex() override {}
+
+      void OnTemporalLayersCreated(int simulcast_id,
+                                   TemporalLayers* layers) override {
+        temporal_layers_[simulcast_id] = layers;
+      }
+
+      std::map<int, TemporalLayers*> temporal_layers_;
+    } tl_index;
+
     SpyingTemporalLayersFactory spy_factory;
+    spy_factory.SetListener(&tl_index);
     settings->codecSpecific.VP8.tl_factory = &spy_factory;
     EXPECT_EQ(0, encoder->InitEncode(settings, 1, 1200));
 
     encoder->SetRates(target_bitrate, 30);
 
+    int expected_index = 0;
     std::vector<unsigned int> configured_bitrates;
-    for (std::vector<TemporalLayers*>::const_iterator it =
-             spy_factory.spying_layers_.begin();
-         it != spy_factory.spying_layers_.end(); ++it) {
+    for (auto it : tl_index.temporal_layers_) {
+      EXPECT_EQ(expected_index++, it.first);
       configured_bitrates.push_back(
-          static_cast<SpyingTemporalLayers*>(*it)->configured_bitrate_);
+          static_cast<SpyingTemporalLayers*>(it.second)->configured_bitrate_);
     }
     return configured_bitrates;
   }
@@ -179,13 +194,11 @@ class SkipEncodingUnusedStreamsTest {
       return layers_->EncodeFlags(timestamp);
     }
 
-    bool ConfigureBitrates(int bitrate_kbit,
-                           int max_bitrate_kbit,
-                           int framerate,
-                           vpx_codec_enc_cfg_t* cfg) override {
+    std::vector<uint32_t> OnRatesUpdated(int bitrate_kbit,
+                                         int max_bitrate_kbit,
+                                         int framerate) override {
       configured_bitrate_ = bitrate_kbit;
-      return layers_->ConfigureBitrates(bitrate_kbit, max_bitrate_kbit,
-                                        framerate, cfg);
+      return layers_->OnRatesUpdated(bitrate_kbit, max_bitrate_kbit, framerate);
     }
 
     void PopulateCodecSpecific(bool base_layer_sync,
@@ -210,17 +223,18 @@ class SkipEncodingUnusedStreamsTest {
 
   class SpyingTemporalLayersFactory : public TemporalLayersFactory {
    public:
+    SpyingTemporalLayersFactory() {}
     virtual ~SpyingTemporalLayersFactory() {}
-    TemporalLayers* Create(int temporal_layers,
+    TemporalLayers* Create(int simulcast_id,
+                           int temporal_layers,
                            uint8_t initial_tl0_pic_idx) const override {
       SpyingTemporalLayers* layers =
           new SpyingTemporalLayers(TemporalLayersFactory::Create(
-              temporal_layers, initial_tl0_pic_idx));
-      spying_layers_.push_back(layers);
+              simulcast_id, temporal_layers, initial_tl0_pic_idx));
+      if (listener_)
+        listener_->OnTemporalLayersCreated(simulcast_id, layers);
       return layers;
     }
-
-    mutable std::vector<TemporalLayers*> spying_layers_;
   };
 };
 
@@ -265,7 +279,7 @@ class TestVp8Simulcast : public ::testing::Test {
 
   static void DefaultSettings(VideoCodec* settings,
                               const int* temporal_layer_profile) {
-    assert(settings);
+    ASSERT_TRUE(settings);

[perkj_webrtc, 2016/10/21 08:24:28]

DCHECK or CHECK

[sprang_webrtc, 2016/10/25 10:44:25]

Done.

     memset(settings, 0, sizeof(VideoCodec));
     strncpy(settings->plName, "VP8", 4);
     settings->codecType = kVideoCodecVP8;
@@ -321,6 +335,7 @@ class TestVp8Simulcast : public ::testing::Test {
     encoder_->RegisterEncodeCompleteCallback(&encoder_callback_);
     decoder_->RegisterDecodeCompleteCallback(&decoder_callback_);
     DefaultSettings(&settings_, temporal_layer_profile);
+    settings_.codecSpecific.VP8.tl_factory = &tl_factory_;
     EXPECT_EQ(0, encoder_->InitEncode(&settings_, 1, 1200));
     EXPECT_EQ(0, decoder_->InitDecode(&settings_, 1));
     int half_width = (kDefaultWidth + 1) / 2;
@@ -609,6 +624,7 @@ class TestVp8Simulcast : public ::testing::Test {
 
     // Switch back.
     DefaultSettings(&settings_, kDefaultTemporalLayerProfile);
+    settings_.codecSpecific.VP8.tl_factory = &tl_factory_;
     // Start at the lowest bitrate for enabling base stream.
     settings_.startBitrate = kMinBitrates[0];
     EXPECT_EQ(0, encoder_->InitEncode(&settings_, 1, 1200));
@@ -972,6 +988,7 @@ class TestVp8Simulcast : public ::testing::Test {
   VideoCodec settings_;
   rtc::scoped_refptr<I420Buffer> input_buffer_;
   std::unique_ptr<VideoFrame> input_frame_;
+  TemporalLayersFactory tl_factory_;
 };
 
 }  // namespace testing