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

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

 /*
  *  Copyright (c) 2014 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.
  */
 
 #ifndef WEBRTC_MODULES_VIDEO_CODING_CODECS_VP8_SIMULCAST_UNITTEST_H_
 #define WEBRTC_MODULES_VIDEO_CODING_CODECS_VP8_SIMULCAST_UNITTEST_H_
 
 #include <algorithm>
+#include <map>
 #include <memory>
 #include <vector>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h"
 #include "webrtc/modules/video_coding/codecs/vp8/temporal_layers.h"
 #include "webrtc/modules/video_coding/include/mock/mock_video_codec_interface.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/video_frame.h"
@@ skipping 120 matching lines @@
 
  private:
   int decoded_frames_;
 };
 
 class SkipEncodingUnusedStreamsTest {
  public:
   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;
   }
 
   class SpyingTemporalLayers : public TemporalLayers {
    public:
     explicit SpyingTemporalLayers(TemporalLayers* layers)
         : configured_bitrate_(0), layers_(layers) {}
 
     virtual ~SpyingTemporalLayers() { delete layers_; }
 
     int EncodeFlags(uint32_t timestamp) override {
       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,
                                CodecSpecificInfoVP8* vp8_info,
                                uint32_t timestamp) override {
       layers_->PopulateCodecSpecific(base_layer_sync, vp8_info, timestamp);
     }
 
     void FrameEncoded(unsigned int size, uint32_t timestamp, int qp) override {
       layers_->FrameEncoded(size, timestamp, qp);
     }
 
     int CurrentLayerId() const override { return layers_->CurrentLayerId(); }
 
     bool UpdateConfiguration(vpx_codec_enc_cfg_t* cfg) override {
       return false;
     }
 
     int configured_bitrate_;
     TemporalLayers* layers_;
   };
 
   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_;
   };
 };
 
 class TestVp8Simulcast : public ::testing::Test {
  public:
   TestVp8Simulcast(VP8Encoder* encoder, VP8Decoder* decoder)
       : encoder_(encoder), decoder_(decoder) {}
 
   static void SetPlane(uint8_t* data,
                        uint8_t value,
@@ skipping 24 matching lines @@
              chroma_width, chroma_height,
              buffer->StrideU());
 
     SetPlane(buffer->MutableDataV(), plane_colors[2],
              chroma_width, chroma_height,
              buffer->StrideV());
   }
 
   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;
     // 96 to 127 dynamic payload types for video codecs
     settings->plType = 120;
     settings->startBitrate = 300;
     settings->minBitrate = 30;
     settings->maxBitrate = 0;
     settings->maxFramerate = 30;
     settings->width = kDefaultWidth;
@@ skipping 35 matching lines @@
     stream->qpMax = 45;
   }
 
  protected:
   virtual void SetUp() { SetUpCodec(kDefaultTemporalLayerProfile); }
 
   virtual void SetUpCodec(const int* temporal_layer_profile) {
     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;
     input_buffer_ = I420Buffer::Create(kDefaultWidth, kDefaultHeight,
                                        kDefaultWidth, half_width, half_width);
     input_buffer_->InitializeData();
     input_frame_.reset(
         new VideoFrame(input_buffer_, 0, 0, webrtc::kVideoRotation_0));
   }
 
@@ skipping 268 matching lines @@
                              Field(&EncodedImage::_encodedWidth, width),
                              Field(&EncodedImage::_encodedHeight, height)),
                        _, _))
         .Times(1)
         .WillRepeatedly(Return(
             EncodedImageCallback::Result(EncodedImageCallback::Result::OK, 0)));
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     // 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));
     encoder_->SetRates(settings_.startBitrate, 30);
     ExpectStreams(kVideoFrameKey, 1);
     // Resize |input_frame_| to the new resolution.
     half_width = (settings_.width + 1) / 2;
     input_buffer_ = I420Buffer::Create(settings_.width, settings_.height,
                                        settings_.width, half_width, half_width);
     input_buffer_->InitializeData();
@@ skipping 343 matching lines @@
     }
   }
 
   std::unique_ptr<VP8Encoder> encoder_;
   MockEncodedImageCallback encoder_callback_;
   std::unique_ptr<VP8Decoder> decoder_;
   MockDecodedImageCallback decoder_callback_;
   VideoCodec settings_;
   rtc::scoped_refptr<I420Buffer> input_buffer_;
   std::unique_ptr<VideoFrame> input_frame_;
+  TemporalLayersFactory tl_factory_;
 };
 
 }  // namespace testing
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_VIDEO_CODING_CODECS_VP8_SIMULCAST_UNITTEST_H_