Extract common simulcast logic from VP8 wrapper and simulcast adapter

webrtc/modules/video_coding/codecs/vp8/vp8_impl.cc

 /*
  *  Copyright (c) 2012 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.
  */
 
@@ skipping 10 matching lines @@
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/common_types.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8_common_types.h"
 #include "webrtc/modules/video_coding/codecs/vp8/screenshare_layers.h"
 #include "webrtc/modules/video_coding/codecs/vp8/temporal_layers.h"
+#include "webrtc/modules/video_coding/utility/simulcast_state.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/tick_util.h"
 
 namespace webrtc {
 namespace {
 
 enum { kVp8ErrorPropagationTh = 30 };
 enum { kVp832ByteAlign = 32 };
 
 // VP8 denoiser states.
@@ skipping 11 matching lines @@
 int GCD(int a, int b) {
   int c = a % b;
   while (c != 0) {
     a = b;
     b = c;
     c = a % b;
   }
   return b;
 }
 
-std::vector<int> GetStreamBitratesKbps(const VideoCodec& codec,
-                                       int bitrate_to_allocate_kbps) {
-  if (codec.numberOfSimulcastStreams <= 1) {
-    return std::vector<int>(1, bitrate_to_allocate_kbps);
-  }
-
-  std::vector<int> bitrates_kbps(codec.numberOfSimulcastStreams);
-  // Allocate min -> target bitrates as long as we have bitrate to spend.
-  size_t last_active_stream = 0;
-  for (size_t i = 0; i < static_cast<size_t>(codec.numberOfSimulcastStreams) &&
-                     bitrate_to_allocate_kbps >=
-                         static_cast<int>(codec.simulcastStream[i].minBitrate);
-       ++i) {
-    last_active_stream = i;
-    int allocated_bitrate_kbps =
-        std::min(static_cast<int>(codec.simulcastStream[i].targetBitrate),
-                 bitrate_to_allocate_kbps);
-    bitrates_kbps[i] = allocated_bitrate_kbps;
-    bitrate_to_allocate_kbps -= allocated_bitrate_kbps;
-  }
-
-  // Spend additional bits on the highest-quality active layer, up to max
-  // bitrate.
-  // TODO(pbos): Consider spending additional bits on last_active_stream-1 down
-  // to 0 and not just the top layer when we have additional bitrate to spend.
-  int allocated_bitrate_kbps = std::min(
-      static_cast<int>(codec.simulcastStream[last_active_stream].maxBitrate -
-                       bitrates_kbps[last_active_stream]),
-      bitrate_to_allocate_kbps);
-  bitrates_kbps[last_active_stream] += allocated_bitrate_kbps;
-  bitrate_to_allocate_kbps -= allocated_bitrate_kbps;
-
-  // Make sure we can always send something. Suspending below min bitrate is
-  // controlled outside the codec implementation and is not overriden by this.
-  if (bitrates_kbps[0] < static_cast<int>(codec.simulcastStream[0].minBitrate))
-    bitrates_kbps[0] = static_cast<int>(codec.simulcastStream[0].minBitrate);
-
-  return bitrates_kbps;
-}
-
-uint32_t SumStreamMaxBitrate(int streams, const VideoCodec& codec) {
-  uint32_t bitrate_sum = 0;
-  for (int i = 0; i < streams; ++i) {
-    bitrate_sum += codec.simulcastStream[i].maxBitrate;
-  }
-  return bitrate_sum;
-}
-
-int NumberOfStreams(const VideoCodec& codec) {
-  int streams =
-      codec.numberOfSimulcastStreams < 1 ? 1 : codec.numberOfSimulcastStreams;
-  uint32_t simulcast_max_bitrate = SumStreamMaxBitrate(streams, codec);
-  if (simulcast_max_bitrate == 0) {
-    streams = 1;
-  }
-  return streams;
-}
-
 bool ValidSimulcastResolutions(const VideoCodec& codec, int num_streams) {
   if (codec.width != codec.simulcastStream[num_streams - 1].width ||
       codec.height != codec.simulcastStream[num_streams - 1].height) {
     return false;
   }
   for (int i = 0; i < num_streams; ++i) {
     if (codec.width * codec.simulcastStream[i].height !=
         codec.height * codec.simulcastStream[i].width) {
       return false;
     }
   }
   return true;
 }
 
-int NumStreamsDisabled(const std::vector<bool>& streams) {
-  int num_disabled = 0;
-  for (bool stream : streams) {
-    if (!stream)
-      ++num_disabled;
-  }
-  return num_disabled;
-}
 }  // namespace
 
 VP8Encoder* VP8Encoder::Create() {
   return new VP8EncoderImpl();
 }
 
 VP8Decoder* VP8Decoder::Create() {
   return new VP8DecoderImpl();
 }
 
-const float kTl1MaxTimeToDropFrames = 20.0f;
-
 VP8EncoderImpl::VP8EncoderImpl()
     : encoded_complete_callback_(NULL),
       inited_(false),
       timestamp_(0),
       feedback_mode_(false),
       qp_max_(56),  // Setting for max quantizer.
       cpu_speed_default_(-6),
       rc_max_intra_target_(0),
       token_partitions_(VP8_ONE_TOKENPARTITION),
       down_scale_requested_(false),
       down_scale_bitrate_(0),
-      tl0_frame_dropper_(),
-      tl1_frame_dropper_(kTl1MaxTimeToDropFrames),
-      key_frame_request_(kMaxSimulcastStreams, false),
       quality_scaler_enabled_(false) {
   uint32_t seed = static_cast<uint32_t>(TickTime::MillisecondTimestamp());
   srand(seed);
 
   picture_id_.reserve(kMaxSimulcastStreams);
   last_key_frame_picture_id_.reserve(kMaxSimulcastStreams);
   temporal_layers_.reserve(kMaxSimulcastStreams);
   raw_images_.reserve(kMaxSimulcastStreams);
   encoded_images_.reserve(kMaxSimulcastStreams);
-  send_stream_.reserve(kMaxSimulcastStreams);
   cpu_speed_.assign(kMaxSimulcastStreams, -6);  // Set default to -6.
   encoders_.reserve(kMaxSimulcastStreams);
   configurations_.reserve(kMaxSimulcastStreams);
   downsampling_factors_.reserve(kMaxSimulcastStreams);
 }
 
 VP8EncoderImpl::~VP8EncoderImpl() {
   Release();
 }
 
 int VP8EncoderImpl::Release() {
   int ret_val = WEBRTC_VIDEO_CODEC_OK;
 
   while (!encoded_images_.empty()) {
     EncodedImage& image = encoded_images_.back();
     delete[] image._buffer;
     encoded_images_.pop_back();
   }
   while (!encoders_.empty()) {
     vpx_codec_ctx_t& encoder = encoders_.back();
     if (vpx_codec_destroy(&encoder)) {
       ret_val = WEBRTC_VIDEO_CODEC_MEMORY;
     }
     encoders_.pop_back();
   }
   configurations_.clear();
-  send_stream_.clear();
+  simulcast_state_.reset();
   cpu_speed_.clear();
   while (!raw_images_.empty()) {
     vpx_img_free(&raw_images_.back());
     raw_images_.pop_back();
   }
   while (!temporal_layers_.empty()) {
     delete temporal_layers_.back();
     temporal_layers_.pop_back();
   }
   inited_ = false;
@@ skipping 28 matching lines @@
     // Calculate a rough limit for when to trigger a potental down scale.
     uint32_t k_pixels_per_frame = codec_.width * codec_.height / 1000;
     // TODO(pwestin): we currently lack CAMA, this is a temporary fix to work
     // around the current limitations.
     // Only trigger keyframes if we are allowed to scale down.
     if (configurations_[0].rc_resize_allowed) {
       if (!down_scale_requested_) {
         if (k_pixels_per_frame > new_bitrate_kbit) {
           down_scale_requested_ = true;
           down_scale_bitrate_ = new_bitrate_kbit;
-          key_frame_request_[0] = true;
+          simulcast_state_->RequestKeyFrame(0);
         }
       } else {
         if (new_bitrate_kbit > (2 * down_scale_bitrate_) ||
             new_bitrate_kbit < (down_scale_bitrate_ / 2)) {
           down_scale_requested_ = false;
         }
       }
     }
   } else {
     // If we have more than 1 stream, reduce the qp_max for the low resolution
     // stream if frame rate is not too low. The trade-off with lower qp_max is
     // possibly more dropped frames, so we only do this if the frame rate is
     // above some threshold (base temporal layer is down to 1/4 for 3 layers).
     // We may want to condition this on bitrate later.
     if (new_framerate > 20) {
       configurations_[encoders_.size() - 1].rc_max_quantizer = 45;
     } else {
       // Go back to default value set in InitEncode.
       configurations_[encoders_.size() - 1].rc_max_quantizer = qp_max_;
     }
   }
 
-  std::vector<int> stream_bitrates =
-      GetStreamBitratesKbps(codec_, new_bitrate_kbit);
-  size_t stream_idx = encoders_.size() - 1;
-  for (size_t i = 0; i < encoders_.size(); ++i, --stream_idx) {
-    if (encoders_.size() > 1)
-      SetStreamState(stream_bitrates[stream_idx] > 0, stream_idx);
-
-    unsigned int target_bitrate = stream_bitrates[stream_idx];
+  simulcast_state_->AllocateBitrate(new_bitrate_kbit);
+  for (const SimulcastState::Stream& stream : *simulcast_state_) {
+    unsigned int target_bitrate = stream.allocated_rate_kbps;
     unsigned int max_bitrate = codec_.maxBitrate;
-    int framerate = new_framerate;
     // TODO(holmer): This is a temporary hack for screensharing, where we
     // interpret the startBitrate as the encoder target bitrate. This is
     // to allow for a different max bitrate, so if the codec can't meet
     // the target we still allow it to overshoot up to the max before dropping
     // frames. This hack should be improved.
-    if (codec_.targetBitrate > 0 &&
+    if (codec_.targetBitrate > 0 && simulcast_state_->NumStreams() == 1 &&
         (codec_.codecSpecific.VP8.numberOfTemporalLayers == 2 ||
          codec_.simulcastStream[0].numberOfTemporalLayers == 2)) {
       int tl0_bitrate = std::min(codec_.targetBitrate, target_bitrate);
       max_bitrate = std::min(codec_.maxBitrate, target_bitrate);
       target_bitrate = tl0_bitrate;
     }
+    int i = simulcast_state_->NumStreams() - stream.idx - 1;
     configurations_[i].rc_target_bitrate = target_bitrate;
-    temporal_layers_[stream_idx]->ConfigureBitrates(
-        target_bitrate, max_bitrate, framerate, &configurations_[i]);
+    temporal_layers_[stream.idx]->ConfigureBitrates(
+        target_bitrate, max_bitrate, new_framerate, &configurations_[i]);
     if (vpx_codec_enc_config_set(&encoders_[i], &configurations_[i])) {
       return WEBRTC_VIDEO_CODEC_ERROR;
     }
   }
   quality_scaler_.ReportFramerate(new_framerate);
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 const char* VP8EncoderImpl::ImplementationName() const {
   return "libvpx";
 }
 
-void VP8EncoderImpl::SetStreamState(bool send_stream,
-                                            int stream_idx) {
-  if (send_stream && !send_stream_[stream_idx]) {
-    // Need a key frame if we have not sent this stream before.
-    key_frame_request_[stream_idx] = true;
-  }
-  send_stream_[stream_idx] = send_stream;
-}
-
 void VP8EncoderImpl::SetupTemporalLayers(int num_streams,
                                          int num_temporal_layers,
                                          const VideoCodec& codec) {
   TemporalLayersFactory default_factory;
   const TemporalLayersFactory* tl_factory = codec.codecSpecific.VP8.tl_factory;
   if (!tl_factory)
     tl_factory = &default_factory;
   if (num_streams == 1) {
     if (codec.mode == kScreensharing) {
       // Special mode when screensharing on a single stream.
@@ skipping 39 matching lines @@
   }
   if (inst->codecSpecific.VP8.automaticResizeOn &&
       inst->numberOfSimulcastStreams > 1) {
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
   int retVal = Release();
   if (retVal < 0) {
     return retVal;
   }
 
-  int number_of_streams = NumberOfStreams(*inst);
+  std::unique_ptr<SimulcastState> new_simulcast_state(
+      new SimulcastState(*inst));
+
+  int number_of_streams = new_simulcast_state->NumStreams();
   bool doing_simulcast = (number_of_streams > 1);
 
   if (doing_simulcast && !ValidSimulcastResolutions(*inst, number_of_streams)) {
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
 
   int num_temporal_layers =
       doing_simulcast ? inst->simulcastStream[0].numberOfTemporalLayers
                       : inst->codecSpecific.VP8.numberOfTemporalLayers;
 
   // TODO(andresp): crash if num temporal layers is bananas.
   if (num_temporal_layers < 1)
     num_temporal_layers = 1;
   SetupTemporalLayers(number_of_streams, num_temporal_layers, *inst);
 
   feedback_mode_ = inst->codecSpecific.VP8.feedbackModeOn;
 
   timestamp_ = 0;
   codec_ = *inst;
+  simulcast_state_ = std::move(new_simulcast_state);
 
   // Code expects simulcastStream resolutions to be correct, make sure they are
   // filled even when there are no simulcast layers.
   if (codec_.numberOfSimulcastStreams == 0) {
     codec_.simulcastStream[0].width = codec_.width;
     codec_.simulcastStream[0].height = codec_.height;
   }
 
   picture_id_.resize(number_of_streams);
   last_key_frame_picture_id_.resize(number_of_streams);
   encoded_images_.resize(number_of_streams);
   encoders_.resize(number_of_streams);
   configurations_.resize(number_of_streams);
   downsampling_factors_.resize(number_of_streams);
   raw_images_.resize(number_of_streams);
-  send_stream_.resize(number_of_streams);
-  send_stream_[0] = true;  // For non-simulcast case.
   cpu_speed_.resize(number_of_streams);
-  std::fill(key_frame_request_.begin(), key_frame_request_.end(), false);
 
   int idx = number_of_streams - 1;
   for (int i = 0; i < (number_of_streams - 1); ++i, --idx) {
     int gcd = GCD(inst->simulcastStream[idx].width,
                   inst->simulcastStream[idx - 1].width);
     downsampling_factors_[i].num = inst->simulcastStream[idx].width / gcd;
     downsampling_factors_[i].den = inst->simulcastStream[idx - 1].width / gcd;
-    send_stream_[i] = false;
+    simulcast_state_->SetSending(i, false);
   }
   if (number_of_streams > 1) {
-    send_stream_[number_of_streams - 1] = false;
+    simulcast_state_->SetSending(number_of_streams - 1, false);
     downsampling_factors_[number_of_streams - 1].num = 1;
     downsampling_factors_[number_of_streams - 1].den = 1;
   }
   for (int i = 0; i < number_of_streams; ++i) {
     // Random start, 16 bits is enough.
     picture_id_[i] = static_cast<uint16_t>(rand()) & 0x7FFF;  // NOLINT
     last_key_frame_picture_id_[i] = -1;
     // allocate memory for encoded image
     if (encoded_images_[i]._buffer != NULL) {
       delete[] encoded_images_[i]._buffer;
@@ skipping 114 matching lines @@
   // is meaningless (no memory allocation is done here).
   vpx_img_wrap(&raw_images_[0], VPX_IMG_FMT_I420, inst->width, inst->height, 1,
                NULL);
 
   if (encoders_.size() == 1) {
     configurations_[0].rc_target_bitrate = inst->startBitrate;
     temporal_layers_[0]->ConfigureBitrates(inst->startBitrate, inst->maxBitrate,
                                            inst->maxFramerate,
                                            &configurations_[0]);
   } else {
+    simulcast_state_->AllocateBitrate(inst->startBitrate);
     // Note the order we use is different from webm, we have lowest resolution
     // at position 0 and they have highest resolution at position 0.
     int stream_idx = encoders_.size() - 1;
-    std::vector<int> stream_bitrates =
-        GetStreamBitratesKbps(codec_, inst->startBitrate);
-    SetStreamState(stream_bitrates[stream_idx] > 0, stream_idx);
-    configurations_[0].rc_target_bitrate = stream_bitrates[stream_idx];
+    int stream_bitrate_kbps = simulcast_state_->AllocatedRate(stream_idx);
+    configurations_[0].rc_target_bitrate = stream_bitrate_kbps;
     temporal_layers_[stream_idx]->ConfigureBitrates(
-        stream_bitrates[stream_idx], inst->maxBitrate, inst->maxFramerate,
+        stream_bitrate_kbps, inst->maxBitrate, inst->maxFramerate,
         &configurations_[0]);
     --stream_idx;
     for (size_t i = 1; i < encoders_.size(); ++i, --stream_idx) {
       memcpy(&configurations_[i], &configurations_[0],
              sizeof(configurations_[0]));
 
       configurations_[i].g_w = inst->simulcastStream[stream_idx].width;
       configurations_[i].g_h = inst->simulcastStream[stream_idx].height;
 
       // Use 1 thread for lower resolutions.
       configurations_[i].g_threads = 1;
 
       // Setting alignment to 32 - as that ensures at least 16 for all
       // planes (32 for Y, 16 for U,V). Libvpx sets the requested stride for
       // the y plane, but only half of it to the u and v planes.
       vpx_img_alloc(&raw_images_[i], VPX_IMG_FMT_I420,
                     inst->simulcastStream[stream_idx].width,
                     inst->simulcastStream[stream_idx].height, kVp832ByteAlign);
-      SetStreamState(stream_bitrates[stream_idx] > 0, stream_idx);
-      configurations_[i].rc_target_bitrate = stream_bitrates[stream_idx];
+      stream_bitrate_kbps = simulcast_state_->AllocatedRate(stream_idx);
+      configurations_[i].rc_target_bitrate = stream_bitrate_kbps;
       temporal_layers_[stream_idx]->ConfigureBitrates(
-          stream_bitrates[stream_idx], inst->maxBitrate, inst->maxFramerate,
+          stream_bitrate_kbps, inst->maxBitrate, inst->maxFramerate,
           &configurations_[i]);
     }
   }
 
   rps_.Init();
   // Disable both high-QP limits and framedropping. Both are handled by libvpx
   // internally.
   // QP thresholds are chosen to be high enough to be hit in practice when
   // quality is good, but also low enough to not cause a flip-flop behavior
   // (e.g. going up in resolution shouldn't give so bad quality that we should
@@ skipping 176 matching lines @@
   vpx_enc_frame_flags_t flags[kMaxSimulcastStreams];
   for (size_t i = 0; i < encoders_.size(); ++i) {
     int ret = temporal_layers_[i]->EncodeFlags(input_image.timestamp());
     if (ret < 0) {
       // Drop this frame.
       return WEBRTC_VIDEO_CODEC_OK;
     }
     flags[i] = ret;
   }
   bool send_key_frame = false;
-  for (size_t i = 0; i < key_frame_request_.size() && i < send_stream_.size();
-       ++i) {
-    if (key_frame_request_[i] && send_stream_[i]) {
-      send_key_frame = true;
-      break;
-    }
+  size_t num_entries = std::min(frame_types ? frame_types->size() : 0,
+                                simulcast_state_->NumStreams());
+  for (size_t i = 0; i < num_entries; ++i) {
+    send_key_frame |= simulcast_state_->GetAndResetKeyFrameRequest(i) ||
+                      (frame_types && (*frame_types)[i] == kVideoFrameKey);
   }
-  if (!send_key_frame && frame_types) {
-    for (size_t i = 0; i < frame_types->size() && i < send_stream_.size();
-         ++i) {
-      if ((*frame_types)[i] == kVideoFrameKey && send_stream_[i]) {
-        send_key_frame = true;
-        break;
-      }
-    }
-  }
+
   // The flag modification below (due to forced key frame, RPS, etc.,) for now
   // will be the same for all encoders/spatial layers.
   // TODO(marpan/holmer): Allow for key frame request to be set per encoder.
   bool only_predict_from_key_frame = false;
   if (send_key_frame) {
     // Adapt the size of the key frame when in screenshare with 1 temporal
     // layer.
     if (encoders_.size() == 1 && codec_.mode == kScreensharing &&
         codec_.codecSpecific.VP8.numberOfTemporalLayers <= 1) {
       const uint32_t forceKeyFrameIntraTh = 100;
       vpx_codec_control(&(encoders_[0]), VP8E_SET_MAX_INTRA_BITRATE_PCT,
                         forceKeyFrameIntraTh);
     }
     // Key frame request from caller.
     // Will update both golden and alt-ref.
     for (size_t i = 0; i < encoders_.size(); ++i) {
       flags[i] = VPX_EFLAG_FORCE_KF;
     }
-    std::fill(key_frame_request_.begin(), key_frame_request_.end(), false);
   } else if (codec_specific_info &&
              codec_specific_info->codecType == kVideoCodecVP8) {
     if (feedback_mode_) {
       // Handle RPSI and SLI messages and set up the appropriate encode flags.
       bool sendRefresh = false;
       if (codec_specific_info->codecSpecific.VP8.hasReceivedRPSI) {
         rps_.ReceivedRPSI(codec_specific_info->codecSpecific.VP8.pictureIdRPSI);
       }
       if (codec_specific_info->codecSpecific.VP8.hasReceivedSLI) {
         sendRefresh = rps_.ReceivedSLI(input_image.timestamp());
@@ skipping 120 matching lines @@
                                only_predicting_from_key_frame;
   temporal_layers_[stream_idx]->PopulateCodecSpecific(base_layer_sync_point,
                                                       vp8Info, timestamp);
   // Prepare next.
   picture_id_[stream_idx] = (picture_id_[stream_idx] + 1) & 0x7FFF;
 }
 
 int VP8EncoderImpl::GetEncodedPartitions(const VideoFrame& input_image,
                                          bool only_predicting_from_key_frame) {
   int bw_resolutions_disabled =
-      (encoders_.size() > 1) ? NumStreamsDisabled(send_stream_) : -1;
+      (encoders_.size() > 1) ? simulcast_state_->NumSendingStreams() : -1;

[pbos-webrtc, 2016/04/29 21:23:27]

This is not NumStreamsDisabled? Why are tests not exploding?

 
   int stream_idx = static_cast<int>(encoders_.size()) - 1;
   int result = WEBRTC_VIDEO_CODEC_OK;
   for (size_t encoder_idx = 0; encoder_idx < encoders_.size();
        ++encoder_idx, --stream_idx) {
     vpx_codec_iter_t iter = NULL;
     int part_idx = 0;
     encoded_images_[encoder_idx]._length = 0;
     encoded_images_[encoder_idx]._frameType = kVideoFrameDelta;
     RTPFragmentationHeader frag_info;
@@ skipping 45 matching lines @@
     encoded_images_[encoder_idx]._timeStamp = input_image.timestamp();
     encoded_images_[encoder_idx].capture_time_ms_ =
         input_image.render_time_ms();
     encoded_images_[encoder_idx].rotation_ = input_image.rotation();
 
     int qp = -1;
     vpx_codec_control(&encoders_[encoder_idx], VP8E_GET_LAST_QUANTIZER_64, &qp);
     temporal_layers_[stream_idx]->FrameEncoded(
         encoded_images_[encoder_idx]._length,
         encoded_images_[encoder_idx]._timeStamp, qp);
-    if (send_stream_[stream_idx]) {
+    if (simulcast_state_->IsSending(stream_idx)) {
       if (encoded_images_[encoder_idx]._length > 0) {
         TRACE_COUNTER_ID1("webrtc", "EncodedFrameSize", encoder_idx,
                           encoded_images_[encoder_idx]._length);
         encoded_images_[encoder_idx]._encodedHeight =
             codec_.simulcastStream[stream_idx].height;
         encoded_images_[encoder_idx]._encodedWidth =
             codec_.simulcastStream[stream_idx].width;
         encoded_images_[encoder_idx]
             .adapt_reason_.quality_resolution_downscales =
             quality_scaler_enabled_ ? quality_scaler_.downscale_shift() : -1;
         // Report once per frame (lowest stream always sent).
         encoded_images_[encoder_idx].adapt_reason_.bw_resolutions_disabled =
             (stream_idx == 0) ? bw_resolutions_disabled : -1;
         int qp_128 = -1;
         vpx_codec_control(&encoders_[encoder_idx], VP8E_GET_LAST_QUANTIZER,
                           &qp_128);
         encoded_images_[encoder_idx].qp_ = qp_128;
         encoded_complete_callback_->Encoded(encoded_images_[encoder_idx],
                                             &codec_specific, &frag_info);
       } else if (codec_.mode == kScreensharing) {
         result = WEBRTC_VIDEO_CODEC_TARGET_BITRATE_OVERSHOOT;
       }
     }
   }
-  if (encoders_.size() == 1 && send_stream_[0]) {
+  if (encoders_.size() == 1 && simulcast_state_->IsSending(0)) {
     if (encoded_images_[0]._length > 0) {
       int qp_128;
       vpx_codec_control(&encoders_[0], VP8E_GET_LAST_QUANTIZER, &qp_128);
       quality_scaler_.ReportQP(qp_128);
     } else {
       quality_scaler_.ReportDroppedFrame();
     }
   }
   return result;
 }
@@ skipping 344 matching lines @@
     return -1;
   }
   if (vpx_codec_control(copy->decoder_, VP8_SET_REFERENCE, ref_frame_) !=
       VPX_CODEC_OK) {
     return -1;
   }
   return 0;
 }
 
 }  // namespace webrtc