Revert of 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/modules/video_coding/utility/simulcast_rate_allocator.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/video_frame.h"
 
 using ::testing::_;
 using ::testing::AllOf;
 using ::testing::Field;
 using ::testing::Return;
 
 namespace webrtc {
 namespace testing {
@@ skipping 107 matching lines @@
   int32_t Decoded(VideoFrame& decoded_image, int64_t decode_time_ms) override {
     RTC_NOTREACHED();
     return -1;
   }
   int DecodedFrames() { return decoded_frames_; }
 
  private:
   int decoded_frames_;
 };
 
+class SkipEncodingUnusedStreamsTest {
+ public:
+  std::vector<unsigned int> RunTest(VP8Encoder* encoder,
+                                    VideoCodec* settings,
+                                    uint32_t target_bitrate) {
+    SpyingTemporalLayersFactory spy_factory;
+    settings->VP8()->tl_factory = &spy_factory;
+    EXPECT_EQ(0, encoder->InitEncode(settings, 1, 1200));
+
+    encoder->SetRates(target_bitrate, 30);
+
+    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) {
+      configured_bitrates.push_back(
+          static_cast<SpyingTemporalLayers*>(*it)->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 {
+      configured_bitrate_ = bitrate_kbit;
+      return layers_->ConfigureBitrates(bitrate_kbit, max_bitrate_kbit,
+                                        framerate, cfg);
+    }
+
+    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:
+    virtual ~SpyingTemporalLayersFactory() {}
+    TemporalLayers* Create(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);
+      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,
                        int width,
                        int height,
                        int stride) {
@@ skipping 21 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) {
-    RTC_CHECK(settings);
+    assert(settings);
     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 29 matching lines @@
     stream->width = width;
     stream->height = height;
     stream->maxBitrate = max_bitrate;
     stream->minBitrate = min_bitrate;
     stream->targetBitrate = target_bitrate;
     stream->numberOfTemporalLayers = num_temporal_layers;
     stream->qpMax = 45;
   }
 
  protected:
-  void SetUp() override { SetUpCodec(kDefaultTemporalLayerProfile); }
+  virtual void SetUp() { SetUpCodec(kDefaultTemporalLayerProfile); }
 
-  void TearDown() override {
-    encoder_->Release();
-    decoder_->Release();
-  }
-
-  void SetUpCodec(const int* temporal_layer_profile) {
+  virtual void SetUpCodec(const int* temporal_layer_profile) {
     encoder_->RegisterEncodeCompleteCallback(&encoder_callback_);
     decoder_->RegisterDecodeCompleteCallback(&decoder_callback_);
     DefaultSettings(&settings_, temporal_layer_profile);
-    SetUpRateAllocator();
     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));
   }
 
-  void SetUpRateAllocator() {
-    TemporalLayersFactory* tl_factory = new TemporalLayersFactory();
-    rate_allocator_.reset(new SimulcastRateAllocator(
-        settings_, std::unique_ptr<TemporalLayersFactory>(tl_factory)));
-    settings_.codecSpecific.VP8.tl_factory = tl_factory;
-  }
-
-  void SetRates(uint32_t bitrate_kbps, uint32_t fps) {
-    encoder_->SetRateAllocation(
-        rate_allocator_->GetAllocation(bitrate_kbps * 1000, fps), fps);
+  virtual void TearDown() {
+    encoder_->Release();
+    decoder_->Release();
   }
 
   void ExpectStreams(FrameType frame_type, int expected_video_streams) {
     ASSERT_GE(expected_video_streams, 0);
     ASSERT_LE(expected_video_streams, kNumberOfSimulcastStreams);
     if (expected_video_streams >= 1) {
       EXPECT_CALL(
           encoder_callback_,
           OnEncodedImage(
               AllOf(Field(&EncodedImage::_frameType, frame_type),
@@ skipping 42 matching lines @@
       encoder_callback->GetLastEncodedFrameInfo(&picture_id, &temporal_layer,
                                                 &layer_sync, i);
       EXPECT_EQ(expected_temporal_idx[i], temporal_layer);
       EXPECT_EQ(expected_layer_sync[i], layer_sync);
     }
   }
 
   // We currently expect all active streams to generate a key frame even though
   // a key frame was only requested for some of them.
   void TestKeyFrameRequestsOnAllStreams() {
-    SetRates(kMaxBitrates[2], 30);  // To get all three streams.
+    encoder_->SetRates(kMaxBitrates[2], 30);  // To get all three streams.
     std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
                                        kVideoFrameDelta);
     ExpectStreams(kVideoFrameKey, kNumberOfSimulcastStreams);
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     ExpectStreams(kVideoFrameDelta, kNumberOfSimulcastStreams);
     input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     frame_types[0] = kVideoFrameKey;
@@ skipping 14 matching lines @@
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     std::fill(frame_types.begin(), frame_types.end(), kVideoFrameDelta);
     ExpectStreams(kVideoFrameDelta, kNumberOfSimulcastStreams);
     input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
   }
 
   void TestPaddingAllStreams() {
     // We should always encode the base layer.
-    SetRates(kMinBitrates[0] - 1, 30);
+    encoder_->SetRates(kMinBitrates[0] - 1, 30);
     std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
                                        kVideoFrameDelta);
     ExpectStreams(kVideoFrameKey, 1);
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     ExpectStreams(kVideoFrameDelta, 1);
     input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
   }
 
   void TestPaddingTwoStreams() {
     // We have just enough to get only the first stream and padding for two.
-    SetRates(kMinBitrates[0], 30);
+    encoder_->SetRates(kMinBitrates[0], 30);
     std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
                                        kVideoFrameDelta);
     ExpectStreams(kVideoFrameKey, 1);
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     ExpectStreams(kVideoFrameDelta, 1);
     input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
   }
 
   void TestPaddingTwoStreamsOneMaxedOut() {
     // We are just below limit of sending second stream, so we should get
     // the first stream maxed out (at |maxBitrate|), and padding for two.
-    SetRates(kTargetBitrates[0] + kMinBitrates[1] - 1, 30);
+    encoder_->SetRates(kTargetBitrates[0] + kMinBitrates[1] - 1, 30);
     std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
                                        kVideoFrameDelta);
     ExpectStreams(kVideoFrameKey, 1);
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     ExpectStreams(kVideoFrameDelta, 1);
     input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
   }
 
   void TestPaddingOneStream() {
     // We have just enough to send two streams, so padding for one stream.
-    SetRates(kTargetBitrates[0] + kMinBitrates[1], 30);
+    encoder_->SetRates(kTargetBitrates[0] + kMinBitrates[1], 30);
     std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
                                        kVideoFrameDelta);
     ExpectStreams(kVideoFrameKey, 2);
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     ExpectStreams(kVideoFrameDelta, 2);
     input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
   }
 
   void TestPaddingOneStreamTwoMaxedOut() {
     // We are just below limit of sending third stream, so we should get
     // first stream's rate maxed out at |targetBitrate|, second at |maxBitrate|.
-    SetRates(kTargetBitrates[0] + kTargetBitrates[1] + kMinBitrates[2] - 1, 30);
+    encoder_->SetRates(
+        kTargetBitrates[0] + kTargetBitrates[1] + kMinBitrates[2] - 1, 30);
     std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
                                        kVideoFrameDelta);
     ExpectStreams(kVideoFrameKey, 2);
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     ExpectStreams(kVideoFrameDelta, 2);
     input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
   }
 
   void TestSendAllStreams() {
     // We have just enough to send all streams.
-    SetRates(kTargetBitrates[0] + kTargetBitrates[1] + kMinBitrates[2], 30);
+    encoder_->SetRates(
+        kTargetBitrates[0] + kTargetBitrates[1] + kMinBitrates[2], 30);
     std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
                                        kVideoFrameDelta);
     ExpectStreams(kVideoFrameKey, 3);
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     ExpectStreams(kVideoFrameDelta, 3);
     input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
   }
 
   void TestDisablingStreams() {
     // We should get three media streams.
-    SetRates(kMaxBitrates[0] + kMaxBitrates[1] + kMaxBitrates[2], 30);
+    encoder_->SetRates(kMaxBitrates[0] + kMaxBitrates[1] + kMaxBitrates[2], 30);
     std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
                                        kVideoFrameDelta);
     ExpectStreams(kVideoFrameKey, 3);
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     ExpectStreams(kVideoFrameDelta, 3);
     input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     // We should only get two streams and padding for one.
-    SetRates(kTargetBitrates[0] + kTargetBitrates[1] + kMinBitrates[2] / 2, 30);
+    encoder_->SetRates(
+        kTargetBitrates[0] + kTargetBitrates[1] + kMinBitrates[2] / 2, 30);
     ExpectStreams(kVideoFrameDelta, 2);
     input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     // We should only get the first stream and padding for two.
-    SetRates(kTargetBitrates[0] + kMinBitrates[1] / 2, 30);
+    encoder_->SetRates(kTargetBitrates[0] + kMinBitrates[1] / 2, 30);
     ExpectStreams(kVideoFrameDelta, 1);
     input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     // We don't have enough bitrate for the thumbnail stream, but we should get
     // it anyway with current configuration.
-    SetRates(kTargetBitrates[0] - 1, 30);
+    encoder_->SetRates(kTargetBitrates[0] - 1, 30);
     ExpectStreams(kVideoFrameDelta, 1);
     input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     // We should only get two streams and padding for one.
-    SetRates(kTargetBitrates[0] + kTargetBitrates[1] + kMinBitrates[2] / 2, 30);
+    encoder_->SetRates(
+        kTargetBitrates[0] + kTargetBitrates[1] + kMinBitrates[2] / 2, 30);
     // We get a key frame because a new stream is being enabled.
     ExpectStreams(kVideoFrameKey, 2);
     input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     // We should get all three streams.
-    SetRates(kTargetBitrates[0] + kTargetBitrates[1] + kTargetBitrates[2], 30);
+    encoder_->SetRates(
+        kTargetBitrates[0] + kTargetBitrates[1] + kTargetBitrates[2], 30);
     // We get a key frame because a new stream is being enabled.
     ExpectStreams(kVideoFrameKey, 3);
     input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
   }
 
   void SwitchingToOneStream(int width, int height) {
     // Disable all streams except the last and set the bitrate of the last to
     // 100 kbps. This verifies the way GTP switches to screenshare mode.
     settings_.VP8()->numberOfTemporalLayers = 1;
@@ skipping 16 matching lines @@
         new VideoFrame(input_buffer_, 0, 0, webrtc::kVideoRotation_0));
 
     // The for loop above did not set the bitrate of the highest layer.
     settings_.simulcastStream[settings_.numberOfSimulcastStreams - 1]
         .maxBitrate = 0;
     // The highest layer has to correspond to the non-simulcast resolution.
     settings_.simulcastStream[settings_.numberOfSimulcastStreams - 1].width =
         settings_.width;
     settings_.simulcastStream[settings_.numberOfSimulcastStreams - 1].height =
         settings_.height;
-    SetUpRateAllocator();
     EXPECT_EQ(0, encoder_->InitEncode(&settings_, 1, 1200));
 
     // Encode one frame and verify.
-    SetRates(kMaxBitrates[0] + kMaxBitrates[1], 30);
+    encoder_->SetRates(kMaxBitrates[0] + kMaxBitrates[1], 30);
     std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
                                        kVideoFrameDelta);
     EXPECT_CALL(
         encoder_callback_,
         OnEncodedImage(AllOf(Field(&EncodedImage::_frameType, kVideoFrameKey),
                              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);
     // Start at the lowest bitrate for enabling base stream.
     settings_.startBitrate = kMinBitrates[0];
-    SetUpRateAllocator();
     EXPECT_EQ(0, encoder_->InitEncode(&settings_, 1, 1200));
-    SetRates(settings_.startBitrate, 30);
+    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();
     input_frame_.reset(
         new VideoFrame(input_buffer_, 0, 0, webrtc::kVideoRotation_0));
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
   }
 
   void TestSwitchingToOneStream() { SwitchingToOneStream(1024, 768); }
 
   void TestSwitchingToOneOddStream() { SwitchingToOneStream(1023, 769); }
 
   void TestSwitchingToOneSmallStream() { SwitchingToOneStream(4, 4); }
 
   void TestRPSIEncoder() {
     Vp8TestEncodedImageCallback encoder_callback;
     encoder_->RegisterEncodeCompleteCallback(&encoder_callback);
 
-    SetRates(kMaxBitrates[2], 30);  // To get all three streams.
+    encoder_->SetRates(kMaxBitrates[2], 30);  // To get all three streams.
 
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
     int picture_id = -1;
     int temporal_layer = -1;
     bool layer_sync = false;
     encoder_callback.GetLastEncodedFrameInfo(&picture_id, &temporal_layer,
                                              &layer_sync, 0);
     EXPECT_EQ(0, temporal_layer);
     EXPECT_TRUE(layer_sync);
     int key_frame_picture_id = picture_id;
@@ skipping 48 matching lines @@
     // so this frame (the next one) must have |layer_sync| set to true.
     EXPECT_TRUE(layer_sync);
   }
 
   void TestRPSIEncodeDecode() {
     Vp8TestEncodedImageCallback encoder_callback;
     Vp8TestDecodedImageCallback decoder_callback;
     encoder_->RegisterEncodeCompleteCallback(&encoder_callback);
     decoder_->RegisterDecodeCompleteCallback(&decoder_callback);
 
-    SetRates(kMaxBitrates[2], 30);  // To get all three streams.
+    encoder_->SetRates(kMaxBitrates[2], 30);  // To get all three streams.
 
     // Set color.
     int plane_offset[kNumOfPlanes];
     plane_offset[kYPlane] = kColorY;
     plane_offset[kUPlane] = kColorU;
     plane_offset[kVPlane] = kColorV;
     CreateImage(input_buffer_, plane_offset);
 
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
     int picture_id = -1;
@@ skipping 53 matching lines @@
     decoder_->Decode(encoded_frame, false, NULL);
     EXPECT_EQ(2, decoder_callback.DecodedFrames());
   }
 
   // Test the layer pattern and sync flag for various spatial-temporal patterns.
   // 3-3-3 pattern: 3 temporal layers for all spatial streams, so same
   // temporal_layer id and layer_sync is expected for all streams.
   void TestSaptioTemporalLayers333PatternEncoder() {
     Vp8TestEncodedImageCallback encoder_callback;
     encoder_->RegisterEncodeCompleteCallback(&encoder_callback);
-    SetRates(kMaxBitrates[2], 30);  // To get all three streams.
+    encoder_->SetRates(kMaxBitrates[2], 30);  // To get all three streams.
 
     int expected_temporal_idx[3] = {-1, -1, -1};
     bool expected_layer_sync[3] = {false, false, false};
 
     // First frame: #0.
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
     SetExpectedValues3<int>(0, 0, 0, expected_temporal_idx);
     SetExpectedValues3<bool>(true, true, true, expected_layer_sync);
     VerifyTemporalIdxAndSyncForAllSpatialLayers(
         &encoder_callback, expected_temporal_idx, expected_layer_sync, 3);
@@ skipping 48 matching lines @@
   // 3rd stream: -1, -1, -1, -1, ....
   // Regarding the 3rd stream, note that a stream/encoder with 1 temporal layer
   // should always have temporal layer idx set to kNoTemporalIdx = -1.
   // Since CodecSpecificInfoVP8.temporalIdx is uint8_t, this will wrap to 255.
   // TODO(marpan): Although this seems safe for now, we should fix this.
   void TestSpatioTemporalLayers321PatternEncoder() {
     int temporal_layer_profile[3] = {3, 2, 1};
     SetUpCodec(temporal_layer_profile);
     Vp8TestEncodedImageCallback encoder_callback;
     encoder_->RegisterEncodeCompleteCallback(&encoder_callback);
-    SetRates(kMaxBitrates[2], 30);  // To get all three streams.
+    encoder_->SetRates(kMaxBitrates[2], 30);  // To get all three streams.
 
     int expected_temporal_idx[3] = {-1, -1, -1};
     bool expected_layer_sync[3] = {false, false, false};
 
     // First frame: #0.
     EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
     SetExpectedValues3<int>(0, 0, 255, expected_temporal_idx);
     SetExpectedValues3<bool>(true, true, false, expected_layer_sync);
     VerifyTemporalIdxAndSyncForAllSpatialLayers(
         &encoder_callback, expected_temporal_idx, expected_layer_sync, 3);
@@ skipping 38 matching lines @@
     VerifyTemporalIdxAndSyncForAllSpatialLayers(
         &encoder_callback, expected_temporal_idx, expected_layer_sync, 3);
   }
 
   void TestStrideEncodeDecode() {
     Vp8TestEncodedImageCallback encoder_callback;
     Vp8TestDecodedImageCallback decoder_callback;
     encoder_->RegisterEncodeCompleteCallback(&encoder_callback);
     decoder_->RegisterDecodeCompleteCallback(&decoder_callback);
 
-    SetRates(kMaxBitrates[2], 30);  // To get all three streams.
+    encoder_->SetRates(kMaxBitrates[2], 30);  // To get all three streams.
     // Setting two (possibly) problematic use cases for stride:
     // 1. stride > width 2. stride_y != stride_uv/2
     int stride_y = kDefaultWidth + 20;
     int stride_uv = ((kDefaultWidth + 1) / 2) + 5;
     input_buffer_ = I420Buffer::Create(kDefaultWidth, kDefaultHeight, stride_y,
                                        stride_uv, stride_uv);
     input_frame_.reset(
         new VideoFrame(input_buffer_, 0, 0, webrtc::kVideoRotation_0));
 
     // Set color.
@@ skipping 15 matching lines @@
 
     EncodedImage encoded_frame;
     // Only encoding one frame - so will be a key frame.
     encoder_callback.GetLastEncodedKeyFrame(&encoded_frame);
     EXPECT_EQ(0, decoder_->Decode(encoded_frame, false, NULL));
     encoder_callback.GetLastEncodedFrame(&encoded_frame);
     decoder_->Decode(encoded_frame, false, NULL);
     EXPECT_EQ(2, decoder_callback.DecodedFrames());
   }
 
+  void TestSkipEncodingUnusedStreams() {
+    SkipEncodingUnusedStreamsTest test;
+    std::vector<unsigned int> configured_bitrate =
+        test.RunTest(encoder_.get(), &settings_,
+                     1);  // Target bit rate 1, to force all streams but the
+                          // base one to be exceeding bandwidth constraints.
+    EXPECT_EQ(static_cast<size_t>(kNumberOfSimulcastStreams),
+              configured_bitrate.size());
+
+    unsigned int min_bitrate =
+        std::max(settings_.simulcastStream[0].minBitrate, settings_.minBitrate);
+    int stream = 0;
+    for (std::vector<unsigned int>::const_iterator it =
+             configured_bitrate.begin();
+         it != configured_bitrate.end(); ++it) {
+      if (stream == 0) {
+        EXPECT_EQ(min_bitrate, *it);
+      } else {
+        EXPECT_EQ(0u, *it);
+      }
+      ++stream;
+    }
+  }
+
   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_;
-  std::unique_ptr<SimulcastRateAllocator> rate_allocator_;
 };
 
 }  // namespace testing
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_VIDEO_CODING_CODECS_VP8_SIMULCAST_UNITTEST_H_