VP9: Add automaticeResize to codec setting.

webrtc/modules/video_coding/codecs/test/videoprocessor_integrationtest.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 60 matching lines @@
 // rate update is made to the encoder, for the encoder to reach within
 // |kPercTargetvsActualMismatch| of new target rate. The metrics are defined for
 // each rate update sequence.
 struct RateControlMetrics {
   int max_num_dropped_frames;
   int max_key_frame_size_mismatch;
   int max_delta_frame_size_mismatch;
   int max_encoding_rate_mismatch;
   int max_time_hit_target;
   int num_spatial_resizes;
+  int num_key_frames;
 };
 
 
 // Sequence used is foreman (CIF): may be better to use VGA for resize test.
 const int kCIFWidth = 352;
 const int kCIFHeight = 288;
 const int kNbrFramesShort = 100;  // Some tests are run for shorter sequence.
 const int kNbrFramesLong = 299;
 
 // Parameters from VP8 wrapper, which control target size of key frames.
@@ skipping 110 matching lines @@
        config_.codec_settings->codecSpecific.VP8.keyFrameInterval =
            kBaseKeyFrameInterval;
        break;
      case kVideoCodecVP9:
        config_.codec_settings->codecSpecific.VP9.denoisingOn =
            denoising_on_;
        config_.codec_settings->codecSpecific.VP9.numberOfTemporalLayers =
            num_temporal_layers_;
        config_.codec_settings->codecSpecific.VP9.frameDroppingOn =
            frame_dropper_on_;
+       config_.codec_settings->codecSpecific.VP9.automaticResizeOn =
+           spatial_resize_on_;
        config_.codec_settings->codecSpecific.VP9.keyFrameInterval =
            kBaseKeyFrameInterval;
        break;
      default:
        assert(false);
        break;
      }
     frame_reader_ =
         new webrtc::test::FrameReaderImpl(config_.input_filename,
                                           config_.frame_length_in_bytes);
@@ skipping 79 matching lines @@
     }
   }
 
   // Verify expected behavior of rate control and print out data.
   void VerifyRateControl(int update_index,
                          int max_key_frame_size_mismatch,
                          int max_delta_frame_size_mismatch,
                          int max_encoding_rate_mismatch,
                          int max_time_hit_target,
                          int max_num_dropped_frames,
-                         int num_spatial_resizes) {
+                         int num_spatial_resizes,
+                         int num_key_frames) {
     int num_dropped_frames = processor_->NumberDroppedFrames();
     int num_resize_actions = processor_->NumberSpatialResizes();
     printf("For update #: %d,\n "
         " Target Bitrate: %d,\n"
         " Encoding bitrate: %f,\n"
         " Frame rate: %d \n",
         update_index, bit_rate_, encoding_bitrate_total_, frame_rate_);
     printf(" Number of frames to approach target rate = %d, \n"
            " Number of dropped frames = %d, \n"
            " Number of spatial resizes = %d, \n",
@@ skipping 26 matching lines @@
           bit_rate_layer_[i], frame_rate_layer_[i], per_frame_bandwidth_[i],
           encoding_bitrate_[i], perc_frame_size_mismatch,
           perc_encoding_rate_mismatch, num_frames_per_update_[i]);
       EXPECT_LE(perc_frame_size_mismatch, max_delta_frame_size_mismatch);
       EXPECT_LE(perc_encoding_rate_mismatch, max_encoding_rate_mismatch);
     }
     printf("\n");
     EXPECT_LE(num_frames_to_hit_target_, max_time_hit_target);
     EXPECT_LE(num_dropped_frames, max_num_dropped_frames);
     EXPECT_EQ(num_resize_actions, num_spatial_resizes);
+    EXPECT_EQ(num_key_frames_, num_key_frames);
   }
 
   // Layer index corresponding to frame number, for up to 3 layers.
   void LayerIndexForFrame(int frame_number) {
     if (num_temporal_layers_ == 1) {
       layer_ = 0;
     } else if (num_temporal_layers_ == 2) {
         // layer 0:  0     2     4 ...
         // layer 1:     1     3
         if (frame_number % 2 == 0) {
@@ skipping 32 matching lines @@
         bit_rate_layer_[i] = bit_rate_ * bit_rate_ratio;
       }
       frame_rate_layer_[i] = frame_rate_ / static_cast<float>(
           1 << (num_temporal_layers_ - 1));
     }
     if (num_temporal_layers_ == 3) {
       frame_rate_layer_[2] = frame_rate_ / 2.0f;
     }
   }
 
-  VideoFrameType FrameType(int frame_number) {
-    if (frame_number == 0 || ((frame_number) % key_frame_interval_ == 0 &&
-        key_frame_interval_ > 0)) {
-      return kKeyFrame;
-    } else {
-      return kDeltaFrame;
-    }
-  }
-
   void TearDown() {
     delete processor_;
     delete packet_manipulator_;
     delete frame_writer_;
     delete frame_reader_;
     delete decoder_;
     delete encoder_;
   }
 
   // Processes all frames in the clip and verifies the result.
@@ skipping 19 matching lines @@
     // Set the initial target size for key frame.
     target_size_key_frame_initial_ = 0.5 * kInitialBufferSize *
         bit_rate_layer_[0];
     processor_->SetRates(bit_rate_, frame_rate_);
     // Process each frame, up to |num_frames|.
     int num_frames = rate_profile.num_frames;
     int update_index = 0;
     ResetRateControlMetrics(
         rate_profile.frame_index_rate_update[update_index + 1]);
     int frame_number = 0;
     VideoFrameType frame_type = kDeltaFrame;

[stefan-webrtc, 2015/09/05 10:45:49]

I would move this declaration into the loop instead as it isn't used outside.

     while (processor_->ProcessFrame(frame_number) &&
         frame_number < num_frames) {
       // Get the layer index for the frame |frame_number|.
       LayerIndexForFrame(frame_number);
-      frame_type = FrameType(frame_number);
+      // Get the frame_type.
+      frame_type = processor_->EncodedFrameType();
       // Counter for whole sequence run.
       ++frame_number;
       // Counters for each rate update.
       ++num_frames_per_update_[layer_];
       ++num_frames_total_;
       UpdateRateControlMetrics(frame_number, frame_type);
       // If we hit another/next update, verify stats for current state and
       // update layers and codec with new rates.
       if (frame_number ==
           rate_profile.frame_index_rate_update[update_index + 1]) {
         VerifyRateControl(
             update_index,
             rc_metrics[update_index].max_key_frame_size_mismatch,
             rc_metrics[update_index].max_delta_frame_size_mismatch,
             rc_metrics[update_index].max_encoding_rate_mismatch,
             rc_metrics[update_index].max_time_hit_target,
             rc_metrics[update_index].max_num_dropped_frames,
-            rc_metrics[update_index].num_spatial_resizes);
+            rc_metrics[update_index].num_spatial_resizes,
+            rc_metrics[update_index].num_key_frames);
         // Update layer rates and the codec with new rates.
         ++update_index;
         bit_rate_ =  rate_profile.target_bit_rate[update_index];
         frame_rate_ = rate_profile.input_frame_rate[update_index];
         SetLayerRates();
         ResetRateControlMetrics(rate_profile.
                                 frame_index_rate_update[update_index + 1]);
         processor_->SetRates(bit_rate_, frame_rate_);
       }
     }
     VerifyRateControl(
         update_index,
         rc_metrics[update_index].max_key_frame_size_mismatch,
         rc_metrics[update_index].max_delta_frame_size_mismatch,
         rc_metrics[update_index].max_encoding_rate_mismatch,
         rc_metrics[update_index].max_time_hit_target,
         rc_metrics[update_index].max_num_dropped_frames,
-        rc_metrics[update_index].num_spatial_resizes);
+        rc_metrics[update_index].num_spatial_resizes,
+        rc_metrics[update_index].num_key_frames);
     EXPECT_EQ(num_frames, frame_number);
     EXPECT_EQ(num_frames + 1, static_cast<int>(stats_.stats_.size()));
 
     // Release encoder and decoder to make sure they have finished processing:
     EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, encoder_->Release());
     EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, decoder_->Release());
     // Close the files before we start using them for SSIM/PSNR calculations.
     frame_reader_->Close();
     frame_writer_->Close();
 
@@ skipping 60 matching lines @@
   quality_metrics->minimum_min_ssim = minimum_min_ssim;
 }
 
 void SetRateControlMetrics(RateControlMetrics* rc_metrics,
                            int update_index,
                            int max_num_dropped_frames,
                            int max_key_frame_size_mismatch,
                            int max_delta_frame_size_mismatch,
                            int max_encoding_rate_mismatch,
                            int max_time_hit_target,
-                           int num_spatial_resizes) {
+                           int num_spatial_resizes,
+                           int num_key_frames) {
   rc_metrics[update_index].max_num_dropped_frames = max_num_dropped_frames;
   rc_metrics[update_index].max_key_frame_size_mismatch =
       max_key_frame_size_mismatch;
   rc_metrics[update_index].max_delta_frame_size_mismatch =
       max_delta_frame_size_mismatch;
   rc_metrics[update_index].max_encoding_rate_mismatch =
       max_encoding_rate_mismatch;
   rc_metrics[update_index].max_time_hit_target = max_time_hit_target;
   rc_metrics[update_index].num_spatial_resizes = num_spatial_resizes;
+  rc_metrics[update_index].num_key_frames = num_key_frames;
 }
 
 // VP9: Run with no packet loss and fixed bitrate. Quality should be very high.
 // One key frame (first frame only) in sequence. Setting |key_frame_interval|
 // to -1 below means no periodic key frames in test.
 TEST_F(VideoProcessorIntegrationTest, Process0PercentPacketLossVP9) {
   // Bitrate and frame rate profile.
   RateProfile rate_profile;
   SetRateProfilePars(&rate_profile, 0, 500, 30, 0);
   rate_profile.frame_index_rate_update[1] = kNbrFramesShort + 1;
   rate_profile.num_frames = kNbrFramesShort;
   // Codec/network settings.
   CodecConfigPars process_settings;
   SetCodecParameters(&process_settings, kVideoCodecVP9, 0.0f, -1, 1, false,
                      false, true, false);
   // Metrics for expected quality.
   QualityMetrics quality_metrics;
   SetQualityMetrics(&quality_metrics, 37.0, 36.0, 0.93, 0.92);
   // Metrics for rate control.
   RateControlMetrics rc_metrics[1];
-  SetRateControlMetrics(rc_metrics, 0, 0, 40, 20, 10, 20, 0);
+  SetRateControlMetrics(rc_metrics, 0, 0, 40, 20, 10, 20, 0, 1);
   ProcessFramesAndVerify(quality_metrics,
                          rate_profile,
                          process_settings,
                          rc_metrics);
 }
 
 // VP9: Run with 5% packet loss and fixed bitrate. Quality should be a bit
 // lower. One key frame (first frame only) in sequence.
 TEST_F(VideoProcessorIntegrationTest, Process5PercentPacketLossVP9) {
   // Bitrate and frame rate profile.
   RateProfile rate_profile;
   SetRateProfilePars(&rate_profile, 0, 500, 30, 0);
   rate_profile.frame_index_rate_update[1] = kNbrFramesShort + 1;
   rate_profile.num_frames = kNbrFramesShort;
   // Codec/network settings.
   CodecConfigPars process_settings;
   SetCodecParameters(&process_settings, kVideoCodecVP9, 0.05f, -1, 1, false,
                      false, true, false);
   // Metrics for expected quality.
   QualityMetrics quality_metrics;
   SetQualityMetrics(&quality_metrics, 17.0, 14.0, 0.45, 0.36);
   // Metrics for rate control.
   RateControlMetrics rc_metrics[1];
-  SetRateControlMetrics(rc_metrics, 0, 0, 40, 20, 10, 20, 0);
+  SetRateControlMetrics(rc_metrics, 0, 0, 40, 20, 10, 20, 0, 1);
   ProcessFramesAndVerify(quality_metrics,
                          rate_profile,
                          process_settings,
                          rc_metrics);
 }
 
 
 // VP9: Run with no packet loss, with varying bitrate (3 rate updates):
 // low to high to medium. Check that quality and encoder response to the new
 // target rate/per-frame bandwidth (for each rate update) is within limits.
 // One key frame (first frame only) in sequence.
 TEST_F(VideoProcessorIntegrationTest, ProcessNoLossChangeBitRateVP9) {
   // Bitrate and frame rate profile.
   RateProfile rate_profile;
   SetRateProfilePars(&rate_profile, 0, 200, 30, 0);
   SetRateProfilePars(&rate_profile, 1, 700, 30, 100);
   SetRateProfilePars(&rate_profile, 2, 500, 30, 200);
   rate_profile.frame_index_rate_update[3] = kNbrFramesLong + 1;
   rate_profile.num_frames = kNbrFramesLong;
   // Codec/network settings.
   CodecConfigPars process_settings;
   SetCodecParameters(&process_settings, kVideoCodecVP9, 0.0f, -1, 1, false,
                      false, true, false);
   // Metrics for expected quality.
   QualityMetrics quality_metrics;
   SetQualityMetrics(&quality_metrics, 35.9, 30.0, 0.90, 0.85);
   // Metrics for rate control.
   RateControlMetrics rc_metrics[3];
-  SetRateControlMetrics(rc_metrics, 0, 0, 30, 20, 20, 30, 0);
-  SetRateControlMetrics(rc_metrics, 1, 2, 0, 20, 20, 60, 0);
-  SetRateControlMetrics(rc_metrics, 2, 0, 0, 25, 20, 40, 0);
+  SetRateControlMetrics(rc_metrics, 0, 0, 30, 20, 20, 30, 0, 1);
+  SetRateControlMetrics(rc_metrics, 1, 2, 0, 20, 20, 60, 0, 0);
+  SetRateControlMetrics(rc_metrics, 2, 0, 0, 25, 20, 40, 0, 0);
   ProcessFramesAndVerify(quality_metrics,
                          rate_profile,
                          process_settings,
                          rc_metrics);
 }
 
 // VP9: Run with no packet loss, with an update (decrease) in frame rate.
 // Lower frame rate means higher per-frame-bandwidth, so easier to encode.
 // At the low bitrate in this test, this means better rate control after the
 // update(s) to lower frame rate. So expect less frame drops, and max values
@@ skipping 12 matching lines @@
   rate_profile.num_frames = kNbrFramesLong;
   // Codec/network settings.
   CodecConfigPars process_settings;
   SetCodecParameters(&process_settings, kVideoCodecVP9, 0.0f, -1, 1, false,
                      false, true, false);
   // Metrics for expected quality.
   QualityMetrics quality_metrics;
   SetQualityMetrics(&quality_metrics, 31.5, 18.0, 0.80, 0.44);
   // Metrics for rate control.
   RateControlMetrics rc_metrics[3];
-  SetRateControlMetrics(rc_metrics, 0, 35, 50, 70, 15, 45, 0);
-  SetRateControlMetrics(rc_metrics, 1, 10, 0, 40, 10, 30, 0);
-  SetRateControlMetrics(rc_metrics, 2, 5, 0, 30, 5, 20, 0);
+  SetRateControlMetrics(rc_metrics, 0, 35, 50, 70, 15, 45, 0, 1);
+  SetRateControlMetrics(rc_metrics, 1, 10, 0, 40, 10, 30, 0, 0);
+  SetRateControlMetrics(rc_metrics, 2, 5, 0, 30, 5, 20, 0, 0);
   ProcessFramesAndVerify(quality_metrics,
                          rate_profile,
                          process_settings,
                          rc_metrics);
 }
 
 // VP9: Run with no packet loss and denoiser on. One key frame (first frame).
 TEST_F(VideoProcessorIntegrationTest, ProcessNoLossDenoiserOnVP9) {
   // Bitrate and frame rate profile.
   RateProfile rate_profile;
   SetRateProfilePars(&rate_profile, 0, 500, 30, 0);
   rate_profile.frame_index_rate_update[1] = kNbrFramesShort + 1;
   rate_profile.num_frames = kNbrFramesShort;
   // Codec/network settings.
   CodecConfigPars process_settings;
   SetCodecParameters(&process_settings, kVideoCodecVP9, 0.0f, -1, 1, false,
                      true, true, false);
   // Metrics for expected quality.
   QualityMetrics quality_metrics;
   SetQualityMetrics(&quality_metrics, 36.8, 35.8, 0.92, 0.91);
   // Metrics for rate control.
   RateControlMetrics rc_metrics[1];
-  SetRateControlMetrics(rc_metrics, 0, 0, 40, 20, 10, 20, 0);
+  SetRateControlMetrics(rc_metrics, 0, 0, 40, 20, 10, 20, 0, 1);
   ProcessFramesAndVerify(quality_metrics,
                          rate_profile,
                          process_settings,
+                         rc_metrics);
+}
+
+// Run with no packet loss, at low bitrate.
+// spatial_resize is on, so expect one resize during the sequence,
+// resize happens on delta frame. Expect only one key frame (first frame).
+TEST_F(VideoProcessorIntegrationTest, ProcessNoLossSpatialResizeFrameDropVP9) {
+  config_.networking_config.packet_loss_probability = 0;
+  // Bitrate and frame rate profile.
+  RateProfile rate_profile;
+  SetRateProfilePars(&rate_profile, 0, 50, 30, 0);
+  rate_profile.frame_index_rate_update[1] = kNbrFramesLong + 1;
+  rate_profile.num_frames = kNbrFramesLong;
+  // Codec/network settings.
+  CodecConfigPars process_settings;
+  SetCodecParameters(&process_settings, kVideoCodecVP9, 0.0f, -1,
+                     1, false, false, true, true);
+  // Metrics for expected quality.
+  QualityMetrics quality_metrics;
+  SetQualityMetrics(&quality_metrics, 25.0, 13.0, 0.70, 0.40);
+  // Metrics for rate control.
+  RateControlMetrics rc_metrics[1];
+  SetRateControlMetrics(rc_metrics, 0, 160, 70, 120, 10, 80, 1, 1);
+  ProcessFramesAndVerify(quality_metrics,
+                         rate_profile,
+                         process_settings,
                          rc_metrics);
 }
 
 // TODO(marpan): Add temporal layer test for VP9, once changes are in
 // vp9 wrapper for this.
 
 // VP8: Run with no packet loss and fixed bitrate. Quality should be very high.
 // One key frame (first frame only) in sequence. Setting |key_frame_interval|
 // to -1 below means no periodic key frames in test.
 TEST_F(VideoProcessorIntegrationTest, ProcessZeroPacketLoss) {
   // Bitrate and frame rate profile.
   RateProfile rate_profile;
   SetRateProfilePars(&rate_profile, 0, 500, 30, 0);
   rate_profile.frame_index_rate_update[1] = kNbrFramesShort + 1;
   rate_profile.num_frames = kNbrFramesShort;
   // Codec/network settings.
   CodecConfigPars process_settings;
   SetCodecParameters(&process_settings, kVideoCodecVP8, 0.0f, -1, 1, false,
                      true, true, false);
   // Metrics for expected quality.
   QualityMetrics quality_metrics;
   SetQualityMetrics(&quality_metrics, 34.95, 33.0, 0.90, 0.89);
   // Metrics for rate control.
   RateControlMetrics rc_metrics[1];
-  SetRateControlMetrics(rc_metrics, 0, 0, 40, 20, 10, 15, 0);
+  SetRateControlMetrics(rc_metrics, 0, 0, 40, 20, 10, 15, 0, 1);
   ProcessFramesAndVerify(quality_metrics,
                          rate_profile,
                          process_settings,
                          rc_metrics);
 }
 
 // VP8: Run with 5% packet loss and fixed bitrate. Quality should be a bit
 // lower. One key frame (first frame only) in sequence.
 TEST_F(VideoProcessorIntegrationTest, Process5PercentPacketLoss) {
   // Bitrate and frame rate profile.
   RateProfile rate_profile;
   SetRateProfilePars(&rate_profile, 0, 500, 30, 0);
   rate_profile.frame_index_rate_update[1] = kNbrFramesShort + 1;
   rate_profile.num_frames = kNbrFramesShort;
   // Codec/network settings.
   CodecConfigPars process_settings;
   SetCodecParameters(&process_settings, kVideoCodecVP8, 0.05f, -1, 1, false,
                      true, true, false);
   // Metrics for expected quality.
   QualityMetrics quality_metrics;
   SetQualityMetrics(&quality_metrics, 20.0, 16.0, 0.60, 0.40);
   // Metrics for rate control.
   RateControlMetrics rc_metrics[1];
-  SetRateControlMetrics(rc_metrics, 0, 0, 40, 20, 10, 15, 0);
+  SetRateControlMetrics(rc_metrics, 0, 0, 40, 20, 10, 15, 0, 1);
   ProcessFramesAndVerify(quality_metrics,
                          rate_profile,
                          process_settings,
                          rc_metrics);
 }
 
 // VP8: Run with 10% packet loss and fixed bitrate. Quality should be lower.
 // One key frame (first frame only) in sequence.
 TEST_F(VideoProcessorIntegrationTest, Process10PercentPacketLoss) {
   // Bitrate and frame rate profile.
   RateProfile rate_profile;
   SetRateProfilePars(&rate_profile, 0, 500, 30, 0);
   rate_profile.frame_index_rate_update[1] = kNbrFramesShort + 1;
   rate_profile.num_frames = kNbrFramesShort;
   // Codec/network settings.
   CodecConfigPars process_settings;
   SetCodecParameters(&process_settings, kVideoCodecVP8, 0.1f, -1, 1, false,
                      true, true, false);
   // Metrics for expected quality.
   QualityMetrics quality_metrics;
   SetQualityMetrics(&quality_metrics, 19.0, 16.0, 0.50, 0.35);
   // Metrics for rate control.
   RateControlMetrics rc_metrics[1];
-  SetRateControlMetrics(rc_metrics, 0, 0, 40, 20, 10, 15, 0);
+  SetRateControlMetrics(rc_metrics, 0, 0, 40, 20, 10, 15, 0, 1);
   ProcessFramesAndVerify(quality_metrics,
                          rate_profile,
                          process_settings,
                          rc_metrics);
 }
 
 // The tests below are currently disabled for Android. For ARM, the encoder
 // uses |cpu_speed| = 12, as opposed to default |cpu_speed| <= 6 for x86,
 // which leads to significantly different quality. The quality and rate control
 // settings in the tests below are defined for encoder speed setting
@@ skipping 17 matching lines @@
   rate_profile.num_frames = kNbrFramesLong;
   // Codec/network settings.
   CodecConfigPars process_settings;
   SetCodecParameters(&process_settings, kVideoCodecVP8, 0.0f, -1, 1, false,
                      true, true, false);
   // Metrics for expected quality.
   QualityMetrics quality_metrics;
   SetQualityMetrics(&quality_metrics, 34.0, 32.0, 0.85, 0.80);
   // Metrics for rate control.
   RateControlMetrics rc_metrics[3];
-  SetRateControlMetrics(rc_metrics, 0, 0, 45, 20, 10, 15, 0);
-  SetRateControlMetrics(rc_metrics, 1, 0, 0, 25, 20, 10, 0);
-  SetRateControlMetrics(rc_metrics, 2, 0, 0, 25, 15, 10, 0);
+  SetRateControlMetrics(rc_metrics, 0, 0, 45, 20, 10, 15, 0, 1);
+  SetRateControlMetrics(rc_metrics, 1, 0, 0, 25, 20, 10, 0, 0);
+  SetRateControlMetrics(rc_metrics, 2, 0, 0, 25, 15, 10, 0, 0);
   ProcessFramesAndVerify(quality_metrics,
                          rate_profile,
                          process_settings,
                          rc_metrics);
 }
 
 // VP8: Run with no packet loss, with an update (decrease) in frame rate.
 // Lower frame rate means higher per-frame-bandwidth, so easier to encode.
 // At the bitrate in this test, this means better rate control after the
 // update(s) to lower frame rate. So expect less frame drops, and max values
@@ skipping 12 matching lines @@
   rate_profile.num_frames = kNbrFramesLong;
   // Codec/network settings.
   CodecConfigPars process_settings;
   SetCodecParameters(&process_settings, kVideoCodecVP8, 0.0f, -1, 1, false,
                      true, true, false);
   // Metrics for expected quality.
   QualityMetrics quality_metrics;
   SetQualityMetrics(&quality_metrics, 31.0, 22.0, 0.80, 0.65);
   // Metrics for rate control.
   RateControlMetrics rc_metrics[3];
-  SetRateControlMetrics(rc_metrics, 0, 40, 20, 75, 15, 60, 0);
-  SetRateControlMetrics(rc_metrics, 1, 10, 0, 25, 10, 35, 0);
-  SetRateControlMetrics(rc_metrics, 2, 0, 0, 20, 10, 15, 0);
+  SetRateControlMetrics(rc_metrics, 0, 40, 20, 75, 15, 60, 0, 1);
+  SetRateControlMetrics(rc_metrics, 1, 10, 0, 25, 10, 35, 0, 0);
+  SetRateControlMetrics(rc_metrics, 2, 0, 0, 20, 10, 15, 0, 0);
   ProcessFramesAndVerify(quality_metrics,
                          rate_profile,
                          process_settings,
                          rc_metrics);
 }
 
 // Run with no packet loss, at low bitrate. During this time we should've
-// resized once.
+// resized once. Expect 2 key frames generated (first and one for resize).
 TEST_F(VideoProcessorIntegrationTest,
        DISABLED_ON_ANDROID(ProcessNoLossSpatialResizeFrameDropVP8)) {
   config_.networking_config.packet_loss_probability = 0;
   // Bitrate and frame rate profile.
   RateProfile rate_profile;
   SetRateProfilePars(&rate_profile, 0, 50, 30, 0);
   rate_profile.frame_index_rate_update[1] = kNbrFramesLong + 1;
   rate_profile.num_frames = kNbrFramesLong;
   // Codec/network settings.
   CodecConfigPars process_settings;
-  SetCodecParameters(&process_settings, kVideoCodecVP8, 0.0f, kNbrFramesLong,
+  SetCodecParameters(&process_settings, kVideoCodecVP8, 0.0f, -1,
                      1, false, true, true, true);
   // Metrics for expected quality.
   QualityMetrics quality_metrics;
   SetQualityMetrics(&quality_metrics, 25.0, 15.0, 0.70, 0.40);
   // Metrics for rate control.
   RateControlMetrics rc_metrics[1];
-  SetRateControlMetrics(rc_metrics, 0, 160, 60, 120, 20, 70, 1);
+  SetRateControlMetrics(rc_metrics, 0, 160, 60, 120, 20, 70, 1, 2);
   ProcessFramesAndVerify(quality_metrics,
                          rate_profile,
                          process_settings,
                          rc_metrics);
 }
 
 // VP8: Run with no packet loss, with 3 temporal layers, with a rate update in
 // the middle of the sequence. The max values for the frame size mismatch and
 // encoding rate mismatch are applied to each layer.
 // No dropped frames in this test, and internal spatial resizer is off.
 // One key frame (first frame only) in sequence, so no spatial resizing.
 TEST_F(VideoProcessorIntegrationTest,
        DISABLED_ON_ANDROID(ProcessNoLossTemporalLayersVP8)) {
   config_.networking_config.packet_loss_probability = 0;
   // Bitrate and frame rate profile.
   RateProfile rate_profile;
   SetRateProfilePars(&rate_profile, 0, 200, 30, 0);
   SetRateProfilePars(&rate_profile, 1, 400, 30, 150);
   rate_profile.frame_index_rate_update[2] = kNbrFramesLong + 1;
   rate_profile.num_frames = kNbrFramesLong;
   // Codec/network settings.
   CodecConfigPars process_settings;
   SetCodecParameters(&process_settings, kVideoCodecVP8, 0.0f, -1, 3, false,
                      true, true, false);
   // Metrics for expected quality.
   QualityMetrics quality_metrics;
   SetQualityMetrics(&quality_metrics, 32.5, 30.0, 0.85, 0.80);
   // Metrics for rate control.
   RateControlMetrics rc_metrics[2];
-  SetRateControlMetrics(rc_metrics, 0, 0, 20, 30, 10, 10, 0);
-  SetRateControlMetrics(rc_metrics, 1, 0, 0, 30, 15, 10, 0);
+  SetRateControlMetrics(rc_metrics, 0, 0, 20, 30, 10, 10, 0, 1);
+  SetRateControlMetrics(rc_metrics, 1, 0, 0, 30, 15, 10, 0, 0);
   ProcessFramesAndVerify(quality_metrics,
                          rate_profile,
                          process_settings,
                          rc_metrics);
 }
 }  // namespace webrtc