granicus.if.org Git - libvpx/blob - test/svc_datarate_test.cc

   1 /*
   2  *  Copyright (c) 2012 The WebM project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10 #include "./vpx_config.h"
  11 #include "third_party/googletest/src/include/gtest/gtest.h"
  12 #include "test/codec_factory.h"
  13 #include "test/encode_test_driver.h"
  14 #include "test/i420_video_source.h"
  15 #include "test/svc_test.h"
  16 #include "test/util.h"
  17 #include "test/y4m_video_source.h"
  18 #include "vp9/common/vp9_onyxc_int.h"
  19 #include "vpx/vpx_codec.h"
  20 #include "vpx_ports/bitops.h"
  21
  22 namespace {
  23
  24 class DatarateOnePassCbrSvc : public ::svc_test::OnePassCbrSvc {
  25  public:
  26   explicit DatarateOnePassCbrSvc(const ::libvpx_test::CodecFactory *codec)
  27       : OnePassCbrSvc(codec) {
  28     inter_layer_pred_mode_ = 0;
  29   }
  30
  31  protected:
  32   virtual ~DatarateOnePassCbrSvc() {}
  33
  34   virtual void ResetModel() {
  35     last_pts_ = 0;
  36     duration_ = 0.0;
  37     mismatch_psnr_ = 0.0;
  38     mismatch_nframes_ = 0;
  39     denoiser_on_ = 0;
  40     tune_content_ = 0;
  41     base_speed_setting_ = 5;
  42     spatial_layer_id_ = 0;
  43     temporal_layer_id_ = 0;
  44     update_pattern_ = 0;
  45     memset(bits_in_buffer_model_, 0, sizeof(bits_in_buffer_model_));
  46     memset(bits_total_, 0, sizeof(bits_total_));
  47     memset(layer_target_avg_bandwidth_, 0, sizeof(layer_target_avg_bandwidth_));
  48     dynamic_drop_layer_ = false;
  49     change_bitrate_ = false;
  50     last_pts_ref_ = 0;
  51     middle_bitrate_ = 0;
  52     top_bitrate_ = 0;
  53     superframe_count_ = -1;
  54     key_frame_spacing_ = 9999;
  55     num_nonref_frames_ = 0;
  56     layer_framedrop_ = 0;
  57     force_key_ = 0;
  58     force_key_test_ = 0;
  59     insert_layer_sync_ = 0;
  60     layer_sync_on_base_ = 0;
  61     force_intra_only_frame_ = 0;
  62     superframe_has_intra_only_ = 0;
  63     use_post_encode_drop_ = 0;
  64   }
  65   virtual void BeginPassHook(unsigned int /*pass*/) {}
  66
  67   // Example pattern for spatial layers and 2 temporal layers used in the
  68   // bypass/flexible mode. The pattern corresponds to the pattern
  69   // VP9E_TEMPORAL_LAYERING_MODE_0101 (temporal_layering_mode == 2) used in
  70   // non-flexible mode, except that we disable inter-layer prediction.
  71   void set_frame_flags_bypass_mode(
  72       int tl, int num_spatial_layers, int is_key_frame,
  73       vpx_svc_ref_frame_config_t *ref_frame_config) {
  74     for (int sl = 0; sl < num_spatial_layers; ++sl)
  75       ref_frame_config->update_buffer_slot[sl] = 0;
  76
  77     for (int sl = 0; sl < num_spatial_layers; ++sl) {
  78       if (tl == 0) {
  79         ref_frame_config->lst_fb_idx[sl] = sl;
  80         if (sl) {
  81           if (is_key_frame) {
  82             ref_frame_config->lst_fb_idx[sl] = sl - 1;
  83             ref_frame_config->gld_fb_idx[sl] = sl;
  84           } else {
  85             ref_frame_config->gld_fb_idx[sl] = sl - 1;
  86           }
  87         } else {
  88           ref_frame_config->gld_fb_idx[sl] = 0;
  89         }
  90         ref_frame_config->alt_fb_idx[sl] = 0;
  91       } else if (tl == 1) {
  92         ref_frame_config->lst_fb_idx[sl] = sl;
  93         ref_frame_config->gld_fb_idx[sl] =
  94             VPXMIN(REF_FRAMES - 1, num_spatial_layers + sl - 1);
  95         ref_frame_config->alt_fb_idx[sl] =
  96             VPXMIN(REF_FRAMES - 1, num_spatial_layers + sl);
  97       }
  98       if (!tl) {
  99         if (!sl) {
 100           ref_frame_config->reference_last[sl] = 1;
 101           ref_frame_config->reference_golden[sl] = 0;
 102           ref_frame_config->reference_alt_ref[sl] = 0;
 103           ref_frame_config->update_buffer_slot[sl] |=
 104               1 << ref_frame_config->lst_fb_idx[sl];
 105         } else {
 106           if (is_key_frame) {
 107             ref_frame_config->reference_last[sl] = 1;
 108             ref_frame_config->reference_golden[sl] = 0;
 109             ref_frame_config->reference_alt_ref[sl] = 0;
 110             ref_frame_config->update_buffer_slot[sl] |=
 111                 1 << ref_frame_config->gld_fb_idx[sl];
 112           } else {
 113             ref_frame_config->reference_last[sl] = 1;
 114             ref_frame_config->reference_golden[sl] = 0;
 115             ref_frame_config->reference_alt_ref[sl] = 0;
 116             ref_frame_config->update_buffer_slot[sl] |=
 117                 1 << ref_frame_config->lst_fb_idx[sl];
 118           }
 119         }
 120       } else if (tl == 1) {
 121         if (!sl) {
 122           ref_frame_config->reference_last[sl] = 1;
 123           ref_frame_config->reference_golden[sl] = 0;
 124           ref_frame_config->reference_alt_ref[sl] = 0;
 125           ref_frame_config->update_buffer_slot[sl] |=
 126               1 << ref_frame_config->alt_fb_idx[sl];
 127         } else {
 128           ref_frame_config->reference_last[sl] = 1;
 129           ref_frame_config->reference_golden[sl] = 0;
 130           ref_frame_config->reference_alt_ref[sl] = 0;
 131           ref_frame_config->update_buffer_slot[sl] |=
 132               1 << ref_frame_config->alt_fb_idx[sl];
 133         }
 134       }
 135     }
 136   }
 137
 138   void CheckLayerRateTargeting(int num_spatial_layers, int num_temporal_layers,
 139                                double thresh_overshoot,
 140                                double thresh_undershoot) const {
 141     for (int sl = 0; sl < num_spatial_layers; ++sl)
 142       for (int tl = 0; tl < num_temporal_layers; ++tl) {
 143         const int layer = sl * num_temporal_layers + tl;
 144         ASSERT_GE(cfg_.layer_target_bitrate[layer],
 145                   file_datarate_[layer] * thresh_overshoot)
 146             << " The datarate for the file exceeds the target by too much!";
 147         ASSERT_LE(cfg_.layer_target_bitrate[layer],
 148                   file_datarate_[layer] * thresh_undershoot)
 149             << " The datarate for the file is lower than the target by too "
 150                "much!";
 151       }
 152   }
 153
 154   virtual void PreEncodeFrameHook(::libvpx_test::VideoSource *video,
 155                                   ::libvpx_test::Encoder *encoder) {
 156     PreEncodeFrameHookSetup(video, encoder);
 157
 158     if (video->frame() == 0) {
 159       if (force_intra_only_frame_) {
 160         // Decoder sets the color_space for Intra-only frames
 161         // to BT_601 (see line 1810 in vp9_decodeframe.c).
 162         // So set it here in these tess to avoid encoder-decoder
 163         // mismatch check on color space setting.
 164         encoder->Control(VP9E_SET_COLOR_SPACE, VPX_CS_BT_601);
 165       }
 166       encoder->Control(VP9E_SET_NOISE_SENSITIVITY, denoiser_on_);
 167       encoder->Control(VP9E_SET_TUNE_CONTENT, tune_content_);
 168       encoder->Control(VP9E_SET_SVC_INTER_LAYER_PRED, inter_layer_pred_mode_);
 169
 170       if (layer_framedrop_) {
 171         vpx_svc_frame_drop_t svc_drop_frame;
 172         svc_drop_frame.framedrop_mode = LAYER_DROP;
 173         for (int i = 0; i < number_spatial_layers_; i++)
 174           svc_drop_frame.framedrop_thresh[i] = 30;
 175         svc_drop_frame.max_consec_drop = 30;
 176         encoder->Control(VP9E_SET_SVC_FRAME_DROP_LAYER, &svc_drop_frame);
 177       }
 178
 179       if (use_post_encode_drop_) {
 180         encoder->Control(VP9E_SET_POSTENCODE_DROP, use_post_encode_drop_);
 181       }
 182     }
 183
 184     if (update_pattern_ && video->frame() >= 100) {
 185       vpx_svc_layer_id_t layer_id;
 186       if (video->frame() == 100) {
 187         cfg_.temporal_layering_mode = VP9E_TEMPORAL_LAYERING_MODE_BYPASS;
 188         encoder->Config(&cfg_);
 189       }
 190       // Set layer id since the pattern changed.
 191       layer_id.spatial_layer_id = 0;
 192       layer_id.temporal_layer_id = (video->frame() % 2 != 0);
 193       temporal_layer_id_ = layer_id.temporal_layer_id;
 194       for (int i = 0; i < number_spatial_layers_; i++)
 195         layer_id.temporal_layer_id_per_spatial[i] = temporal_layer_id_;
 196       encoder->Control(VP9E_SET_SVC_LAYER_ID, &layer_id);
 197       set_frame_flags_bypass_mode(layer_id.temporal_layer_id,
 198                                   number_spatial_layers_, 0, &ref_frame_config);
 199       encoder->Control(VP9E_SET_SVC_REF_FRAME_CONFIG, &ref_frame_config);
 200     }
 201
 202     if (change_bitrate_ && video->frame() == 200) {
 203       duration_ = (last_pts_ + 1) * timebase_;
 204       for (int sl = 0; sl < number_spatial_layers_; ++sl) {
 205         for (int tl = 0; tl < number_temporal_layers_; ++tl) {
 206           const int layer = sl * number_temporal_layers_ + tl;
 207           const double file_size_in_kb = bits_total_[layer] / 1000.;
 208           file_datarate_[layer] = file_size_in_kb / duration_;
 209         }
 210       }
 211
 212       CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_,
 213                               0.78, 1.15);
 214
 215       memset(file_datarate_, 0, sizeof(file_datarate_));
 216       memset(bits_total_, 0, sizeof(bits_total_));
 217       int64_t bits_in_buffer_model_tmp[VPX_MAX_LAYERS];
 218       last_pts_ref_ = last_pts_;
 219       // Set new target bitarate.
 220       cfg_.rc_target_bitrate = cfg_.rc_target_bitrate >> 1;
 221       // Buffer level should not reset on dynamic bitrate change.
 222       memcpy(bits_in_buffer_model_tmp, bits_in_buffer_model_,
 223              sizeof(bits_in_buffer_model_));
 224       AssignLayerBitrates();
 225       memcpy(bits_in_buffer_model_, bits_in_buffer_model_tmp,
 226              sizeof(bits_in_buffer_model_));
 227
 228       // Change config to update encoder with new bitrate configuration.
 229       encoder->Config(&cfg_);
 230     }
 231
 232     if (dynamic_drop_layer_) {
 233       // TODO(jian): Disable AQ Mode for this test for now.
 234       encoder->Control(VP9E_SET_AQ_MODE, 0);
 235       if (video->frame() == 0) {
 236         // Change layer bitrates to set top layers to 0. This will trigger skip
 237         // encoding/dropping of top two spatial layers.
 238         cfg_.rc_target_bitrate -=
 239             (cfg_.layer_target_bitrate[1] + cfg_.layer_target_bitrate[2]);
 240         middle_bitrate_ = cfg_.layer_target_bitrate[1];
 241         top_bitrate_ = cfg_.layer_target_bitrate[2];
 242         cfg_.layer_target_bitrate[1] = 0;
 243         cfg_.layer_target_bitrate[2] = 0;
 244         encoder->Config(&cfg_);
 245       } else if (video->frame() == 50) {
 246         // Change layer bitrates to non-zero on two top spatial layers.
 247         // This will trigger skip encoding of top two spatial layers.
 248         cfg_.layer_target_bitrate[1] = middle_bitrate_;
 249         cfg_.layer_target_bitrate[2] = top_bitrate_;
 250         cfg_.rc_target_bitrate +=
 251             cfg_.layer_target_bitrate[2] + cfg_.layer_target_bitrate[1];
 252         encoder->Config(&cfg_);
 253       } else if (video->frame() == 100) {
 254         // Change layer bitrates to set top layers to 0. This will trigger skip
 255         // encoding/dropping of top two spatial layers.
 256         cfg_.rc_target_bitrate -=
 257             (cfg_.layer_target_bitrate[1] + cfg_.layer_target_bitrate[2]);
 258         middle_bitrate_ = cfg_.layer_target_bitrate[1];
 259         top_bitrate_ = cfg_.layer_target_bitrate[2];
 260         cfg_.layer_target_bitrate[1] = 0;
 261         cfg_.layer_target_bitrate[2] = 0;
 262         encoder->Config(&cfg_);
 263       } else if (video->frame() == 150) {
 264         // Change layer bitrate on second layer to non-zero to start
 265         // encoding it again.
 266         cfg_.layer_target_bitrate[1] = middle_bitrate_;
 267         cfg_.rc_target_bitrate += cfg_.layer_target_bitrate[1];
 268         encoder->Config(&cfg_);
 269       } else if (video->frame() == 200) {
 270         // Change layer bitrate on top layer to non-zero to start
 271         // encoding it again.
 272         cfg_.layer_target_bitrate[2] = top_bitrate_;
 273         cfg_.rc_target_bitrate += cfg_.layer_target_bitrate[2];
 274         encoder->Config(&cfg_);
 275       }
 276     }
 277
 278     if (force_key_test_ && force_key_) frame_flags_ = VPX_EFLAG_FORCE_KF;
 279
 280     if (insert_layer_sync_) {
 281       vpx_svc_spatial_layer_sync_t svc_layer_sync;
 282       svc_layer_sync.base_layer_intra_only = 0;
 283       for (int i = 0; i < number_spatial_layers_; i++)
 284         svc_layer_sync.spatial_layer_sync[i] = 0;
 285       if (force_intra_only_frame_) {
 286         superframe_has_intra_only_ = 0;
 287         if (video->frame() == 0) {
 288           svc_layer_sync.base_layer_intra_only = 1;
 289           svc_layer_sync.spatial_layer_sync[0] = 1;
 290           encoder->Control(VP9E_SET_SVC_SPATIAL_LAYER_SYNC, &svc_layer_sync);
 291           superframe_has_intra_only_ = 1;
 292         } else if (video->frame() == 100) {
 293           svc_layer_sync.base_layer_intra_only = 1;
 294           svc_layer_sync.spatial_layer_sync[0] = 1;
 295           encoder->Control(VP9E_SET_SVC_SPATIAL_LAYER_SYNC, &svc_layer_sync);
 296           superframe_has_intra_only_ = 1;
 297         }
 298       } else {
 299         layer_sync_on_base_ = 0;
 300         if (video->frame() == 150) {
 301           svc_layer_sync.spatial_layer_sync[1] = 1;
 302           encoder->Control(VP9E_SET_SVC_SPATIAL_LAYER_SYNC, &svc_layer_sync);
 303         } else if (video->frame() == 240) {
 304           svc_layer_sync.spatial_layer_sync[2] = 1;
 305           encoder->Control(VP9E_SET_SVC_SPATIAL_LAYER_SYNC, &svc_layer_sync);
 306         } else if (video->frame() == 320) {
 307           svc_layer_sync.spatial_layer_sync[0] = 1;
 308           layer_sync_on_base_ = 1;
 309           encoder->Control(VP9E_SET_SVC_SPATIAL_LAYER_SYNC, &svc_layer_sync);
 310         }
 311       }
 312     }
 313
 314     const vpx_rational_t tb = video->timebase();
 315     timebase_ = static_cast<double>(tb.num) / tb.den;
 316     duration_ = 0;
 317   }
 318
 319   vpx_codec_err_t parse_superframe_index(const uint8_t *data, size_t data_sz,
 320                                          uint32_t sizes[8], int *count) {
 321     uint8_t marker;
 322     marker = *(data + data_sz - 1);
 323     *count = 0;
 324     if ((marker & 0xe0) == 0xc0) {
 325       const uint32_t frames = (marker & 0x7) + 1;
 326       const uint32_t mag = ((marker >> 3) & 0x3) + 1;
 327       const size_t index_sz = 2 + mag * frames;
 328       // This chunk is marked as having a superframe index but doesn't have
 329       // enough data for it, thus it's an invalid superframe index.
 330       if (data_sz < index_sz) return VPX_CODEC_CORRUPT_FRAME;
 331       {
 332         const uint8_t marker2 = *(data + data_sz - index_sz);
 333         // This chunk is marked as having a superframe index but doesn't have
 334         // the matching marker byte at the front of the index therefore it's an
 335         // invalid chunk.
 336         if (marker != marker2) return VPX_CODEC_CORRUPT_FRAME;
 337       }
 338       {
 339         uint32_t i, j;
 340         const uint8_t *x = &data[data_sz - index_sz + 1];
 341         for (i = 0; i < frames; ++i) {
 342           uint32_t this_sz = 0;
 343
 344           for (j = 0; j < mag; ++j) this_sz |= (*x++) << (j * 8);
 345           sizes[i] = this_sz;
 346         }
 347         *count = frames;
 348       }
 349     }
 350     return VPX_CODEC_OK;
 351   }
 352
 353   virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
 354     uint32_t sizes[8] = { 0 };
 355     uint32_t sizes_parsed[8] = { 0 };
 356     int count = 0;
 357     int num_layers_encoded = 0;
 358     last_pts_ = pkt->data.frame.pts;
 359     const bool key_frame =
 360         (pkt->data.frame.flags & VPX_FRAME_IS_KEY) ? true : false;
 361     if (key_frame) {
 362       // For test that inserts layer sync frames: requesting a layer_sync on
 363       // the base layer must force key frame. So if any key frame occurs after
 364       // first superframe it must due to layer sync on base spatial layer.
 365       if (superframe_count_ > 0 && insert_layer_sync_ &&
 366           !force_intra_only_frame_) {
 367         ASSERT_EQ(layer_sync_on_base_, 1);
 368       }
 369       temporal_layer_id_ = 0;
 370       superframe_count_ = 0;
 371     }
 372     parse_superframe_index(static_cast<const uint8_t *>(pkt->data.frame.buf),
 373                            pkt->data.frame.sz, sizes_parsed, &count);
 374     // Count may be less than number of spatial layers because of frame drops.
 375     for (int sl = 0; sl < number_spatial_layers_; ++sl) {
 376       if (pkt->data.frame.spatial_layer_encoded[sl]) {
 377         sizes[sl] = sizes_parsed[num_layers_encoded];
 378         num_layers_encoded++;
 379       }
 380     }
 381     // For superframe with Intra-only count will be +1 larger
 382     // because of no-show frame.
 383     if (force_intra_only_frame_ && superframe_has_intra_only_)
 384       ASSERT_EQ(count, num_layers_encoded + 1);
 385     else
 386       ASSERT_EQ(count, num_layers_encoded);
 387
 388     // In the constrained frame drop mode, if a given spatial is dropped all
 389     // upper layers must be dropped too.
 390     if (!layer_framedrop_) {
 391       int num_layers_dropped = 0;
 392       for (int sl = 0; sl < number_spatial_layers_; ++sl) {
 393         if (!pkt->data.frame.spatial_layer_encoded[sl]) {
 394           // Check that all upper layers are dropped.
 395           num_layers_dropped++;
 396           for (int sl2 = sl + 1; sl2 < number_spatial_layers_; ++sl2)
 397             ASSERT_EQ(pkt->data.frame.spatial_layer_encoded[sl2], 0);
 398         }
 399       }
 400       if (num_layers_dropped == number_spatial_layers_ - 1)
 401         force_key_ = 1;
 402       else
 403         force_key_ = 0;
 404     }
 405     // Keep track of number of non-reference frames, needed for mismatch check.
 406     // Non-reference frames are top spatial and temporal layer frames,
 407     // for TL > 0.
 408     if (temporal_layer_id_ == number_temporal_layers_ - 1 &&
 409         temporal_layer_id_ > 0 &&
 410         pkt->data.frame.spatial_layer_encoded[number_spatial_layers_ - 1])
 411       num_nonref_frames_++;
 412     for (int sl = 0; sl < number_spatial_layers_; ++sl) {
 413       sizes[sl] = sizes[sl] << 3;
 414       // Update the total encoded bits per layer.
 415       // For temporal layers, update the cumulative encoded bits per layer.
 416       for (int tl = temporal_layer_id_; tl < number_temporal_layers_; ++tl) {
 417         const int layer = sl * number_temporal_layers_ + tl;
 418         bits_total_[layer] += static_cast<int64_t>(sizes[sl]);
 419         // Update the per-layer buffer level with the encoded frame size.
 420         bits_in_buffer_model_[layer] -= static_cast<int64_t>(sizes[sl]);
 421         // There should be no buffer underrun, except on the base
 422         // temporal layer, since there may be key frames there.
 423         // Fo short key frame spacing, buffer can underrun on individual frames.
 424         if (!key_frame && tl > 0 && key_frame_spacing_ < 100) {
 425           ASSERT_GE(bits_in_buffer_model_[layer], 0)
 426               << "Buffer Underrun at frame " << pkt->data.frame.pts;
 427         }
 428       }
 429
 430       ASSERT_EQ(pkt->data.frame.width[sl],
 431                 top_sl_width_ * svc_params_.scaling_factor_num[sl] /
 432                     svc_params_.scaling_factor_den[sl]);
 433
 434       ASSERT_EQ(pkt->data.frame.height[sl],
 435                 top_sl_height_ * svc_params_.scaling_factor_num[sl] /
 436                     svc_params_.scaling_factor_den[sl]);
 437     }
 438   }
 439
 440   virtual void EndPassHook(void) {
 441     if (change_bitrate_) last_pts_ = last_pts_ - last_pts_ref_;
 442     duration_ = (last_pts_ + 1) * timebase_;
 443     for (int sl = 0; sl < number_spatial_layers_; ++sl) {
 444       for (int tl = 0; tl < number_temporal_layers_; ++tl) {
 445         const int layer = sl * number_temporal_layers_ + tl;
 446         const double file_size_in_kb = bits_total_[layer] / 1000.;
 447         file_datarate_[layer] = file_size_in_kb / duration_;
 448       }
 449     }
 450   }
 451
 452   virtual void MismatchHook(const vpx_image_t *img1, const vpx_image_t *img2) {
 453     double mismatch_psnr = compute_psnr(img1, img2);
 454     mismatch_psnr_ += mismatch_psnr;
 455     ++mismatch_nframes_;
 456   }
 457
 458   unsigned int GetMismatchFrames() { return mismatch_nframes_; }
 459
 460   vpx_codec_pts_t last_pts_;
 461   double timebase_;
 462   int64_t bits_total_[VPX_MAX_LAYERS];
 463   double duration_;
 464   double file_datarate_[VPX_MAX_LAYERS];
 465   size_t bits_in_last_frame_;
 466   double mismatch_psnr_;
 467   int mismatch_nframes_;
 468   int denoiser_on_;
 469   int tune_content_;
 470   int spatial_layer_id_;
 471   bool dynamic_drop_layer_;
 472   unsigned int top_sl_width_;
 473   unsigned int top_sl_height_;
 474   vpx_svc_ref_frame_config_t ref_frame_config;
 475   int update_pattern_;
 476   bool change_bitrate_;
 477   vpx_codec_pts_t last_pts_ref_;
 478   int middle_bitrate_;
 479   int top_bitrate_;
 480   int key_frame_spacing_;
 481   unsigned int num_nonref_frames_;
 482   int layer_framedrop_;
 483   int force_key_;
 484   int force_key_test_;
 485   int inter_layer_pred_mode_;
 486   int insert_layer_sync_;
 487   int layer_sync_on_base_;
 488   int force_intra_only_frame_;
 489   int superframe_has_intra_only_;
 490   int use_post_encode_drop_;
 491 };
 492
 493 // Params: speed setting.
 494 class DatarateOnePassCbrSvcSingleBR
 495     : public DatarateOnePassCbrSvc,
 496       public ::libvpx_test::CodecTestWithParam<int> {
 497  public:
 498   DatarateOnePassCbrSvcSingleBR() : DatarateOnePassCbrSvc(GET_PARAM(0)) {
 499     memset(&svc_params_, 0, sizeof(svc_params_));
 500   }
 501   virtual ~DatarateOnePassCbrSvcSingleBR() {}
 502
 503  protected:
 504   virtual void SetUp() {
 505     InitializeConfig();
 506     SetMode(::libvpx_test::kRealTime);
 507     speed_setting_ = GET_PARAM(1);
 508     ResetModel();
 509   }
 510 };
 511
 512 // Check basic rate targeting for 1 pass CBR SVC: 2 spatial layers and 1
 513 // temporal layer, with screen content mode on and same speed setting for all
 514 // layers.
 515 TEST_P(DatarateOnePassCbrSvcSingleBR, OnePassCbrSvc2SL1TLScreenContent1) {
 516   cfg_.rc_buf_initial_sz = 500;
 517   cfg_.rc_buf_optimal_sz = 500;
 518   cfg_.rc_buf_sz = 1000;
 519   cfg_.rc_min_quantizer = 0;
 520   cfg_.rc_max_quantizer = 63;
 521   cfg_.rc_end_usage = VPX_CBR;
 522   cfg_.g_lag_in_frames = 0;
 523   cfg_.ss_number_layers = 2;
 524   cfg_.ts_number_layers = 1;
 525   cfg_.ts_rate_decimator[0] = 1;
 526   cfg_.g_error_resilient = 1;
 527   cfg_.g_threads = 1;
 528   cfg_.temporal_layering_mode = 0;
 529   svc_params_.scaling_factor_num[0] = 144;
 530   svc_params_.scaling_factor_den[0] = 288;
 531   svc_params_.scaling_factor_num[1] = 288;
 532   svc_params_.scaling_factor_den[1] = 288;
 533   cfg_.rc_dropframe_thresh = 10;
 534   cfg_.kf_max_dist = 9999;
 535   number_spatial_layers_ = cfg_.ss_number_layers;
 536   number_temporal_layers_ = cfg_.ts_number_layers;
 537   ::libvpx_test::Y4mVideoSource video("niklas_1280_720_30.y4m", 0, 60);
 538   top_sl_width_ = 1280;
 539   top_sl_height_ = 720;
 540   cfg_.rc_target_bitrate = 500;
 541   ResetModel();
 542   tune_content_ = 1;
 543   AssignLayerBitrates();
 544   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 545   CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.78,
 546                           1.15);
 547 #if CONFIG_VP9_DECODER
 548   // The non-reference frames are expected to be mismatched frames as the
 549   // encoder will avoid loopfilter on these frames.
 550   EXPECT_EQ(num_nonref_frames_, GetMismatchFrames());
 551 #endif
 552 }
 553
 554 // Check basic rate targeting for 1 pass CBR SVC: 3 spatial layers and
 555 // 3 temporal layers, with force key frame after frame drop
 556 TEST_P(DatarateOnePassCbrSvcSingleBR, OnePassCbrSvc3SL3TLForceKey) {
 557   cfg_.rc_buf_initial_sz = 500;
 558   cfg_.rc_buf_optimal_sz = 500;
 559   cfg_.rc_buf_sz = 1000;
 560   cfg_.rc_min_quantizer = 0;
 561   cfg_.rc_max_quantizer = 63;
 562   cfg_.rc_end_usage = VPX_CBR;
 563   cfg_.g_lag_in_frames = 0;
 564   cfg_.ss_number_layers = 3;
 565   cfg_.ts_number_layers = 3;
 566   cfg_.ts_rate_decimator[0] = 4;
 567   cfg_.ts_rate_decimator[1] = 2;
 568   cfg_.ts_rate_decimator[2] = 1;
 569   cfg_.g_error_resilient = 1;
 570   cfg_.g_threads = 1;
 571   cfg_.temporal_layering_mode = 3;
 572   svc_params_.scaling_factor_num[0] = 72;
 573   svc_params_.scaling_factor_den[0] = 288;
 574   svc_params_.scaling_factor_num[1] = 144;
 575   svc_params_.scaling_factor_den[1] = 288;
 576   svc_params_.scaling_factor_num[2] = 288;
 577   svc_params_.scaling_factor_den[2] = 288;
 578   cfg_.rc_dropframe_thresh = 30;
 579   cfg_.kf_max_dist = 9999;
 580   number_spatial_layers_ = cfg_.ss_number_layers;
 581   number_temporal_layers_ = cfg_.ts_number_layers;
 582   ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
 583                                        0, 400);
 584   top_sl_width_ = 640;
 585   top_sl_height_ = 480;
 586   cfg_.rc_target_bitrate = 100;
 587   ResetModel();
 588   AssignLayerBitrates();
 589   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 590   CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.78,
 591                           1.25);
 592 #if CONFIG_VP9_DECODER
 593   // The non-reference frames are expected to be mismatched frames as the
 594   // encoder will avoid loopfilter on these frames.
 595   EXPECT_EQ(num_nonref_frames_, GetMismatchFrames());
 596 #endif
 597 }
 598
 599 // Check basic rate targeting for 1 pass CBR SVC: 3 spatial layers and
 600 // 2 temporal layers, with a change on the fly from the fixed SVC pattern to one
 601 // generate via SVC_SET_REF_FRAME_CONFIG. The new pattern also disables
 602 // inter-layer prediction.
 603 TEST_P(DatarateOnePassCbrSvcSingleBR, OnePassCbrSvc3SL2TLDynamicPatternChange) {
 604   cfg_.rc_buf_initial_sz = 500;
 605   cfg_.rc_buf_optimal_sz = 500;
 606   cfg_.rc_buf_sz = 1000;
 607   cfg_.rc_min_quantizer = 0;
 608   cfg_.rc_max_quantizer = 63;
 609   cfg_.rc_end_usage = VPX_CBR;
 610   cfg_.g_lag_in_frames = 0;
 611   cfg_.ss_number_layers = 3;
 612   cfg_.ts_number_layers = 2;
 613   cfg_.ts_rate_decimator[0] = 2;
 614   cfg_.ts_rate_decimator[1] = 1;
 615   cfg_.g_error_resilient = 1;
 616   cfg_.g_threads = 1;
 617   cfg_.temporal_layering_mode = 2;
 618   svc_params_.scaling_factor_num[0] = 72;
 619   svc_params_.scaling_factor_den[0] = 288;
 620   svc_params_.scaling_factor_num[1] = 144;
 621   svc_params_.scaling_factor_den[1] = 288;
 622   svc_params_.scaling_factor_num[2] = 288;
 623   svc_params_.scaling_factor_den[2] = 288;
 624   cfg_.rc_dropframe_thresh = 30;
 625   cfg_.kf_max_dist = 9999;
 626   number_spatial_layers_ = cfg_.ss_number_layers;
 627   number_temporal_layers_ = cfg_.ts_number_layers;
 628   // Change SVC pattern on the fly.
 629   update_pattern_ = 1;
 630   ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
 631                                        0, 400);
 632   top_sl_width_ = 640;
 633   top_sl_height_ = 480;
 634   cfg_.rc_target_bitrate = 800;
 635   ResetModel();
 636   AssignLayerBitrates();
 637   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 638   CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.78,
 639                           1.15);
 640 #if CONFIG_VP9_DECODER
 641   // The non-reference frames are expected to be mismatched frames as the
 642   // encoder will avoid loopfilter on these frames.
 643   EXPECT_EQ(num_nonref_frames_, GetMismatchFrames());
 644 #endif
 645 }
 646
 647 // Check basic rate targeting for 1 pass CBR SVC with 3 spatial layers and on
 648 // the fly switching to 1 and then 2 and back to 3 spatial layers. This switch
 649 // is done by setting spatial layer bitrates to 0, and then back to non-zero,
 650 // during the sequence.
 651 TEST_P(DatarateOnePassCbrSvcSingleBR, OnePassCbrSvc3SL_DisableEnableLayers) {
 652   cfg_.rc_buf_initial_sz = 500;
 653   cfg_.rc_buf_optimal_sz = 500;
 654   cfg_.rc_buf_sz = 1000;
 655   cfg_.rc_min_quantizer = 0;
 656   cfg_.rc_max_quantizer = 63;
 657   cfg_.rc_end_usage = VPX_CBR;
 658   cfg_.g_lag_in_frames = 0;
 659   cfg_.ss_number_layers = 3;
 660   cfg_.ts_number_layers = 1;
 661   cfg_.ts_rate_decimator[0] = 1;
 662   cfg_.g_error_resilient = 1;
 663   cfg_.g_threads = 1;
 664   cfg_.temporal_layering_mode = 0;
 665   svc_params_.scaling_factor_num[0] = 72;
 666   svc_params_.scaling_factor_den[0] = 288;
 667   svc_params_.scaling_factor_num[1] = 144;
 668   svc_params_.scaling_factor_den[1] = 288;
 669   svc_params_.scaling_factor_num[2] = 288;
 670   svc_params_.scaling_factor_den[2] = 288;
 671   cfg_.rc_dropframe_thresh = 30;
 672   cfg_.kf_max_dist = 9999;
 673   number_spatial_layers_ = cfg_.ss_number_layers;
 674   number_temporal_layers_ = cfg_.ts_number_layers;
 675   ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
 676                                        0, 400);
 677   top_sl_width_ = 640;
 678   top_sl_height_ = 480;
 679   cfg_.rc_target_bitrate = 800;
 680   ResetModel();
 681   dynamic_drop_layer_ = true;
 682   AssignLayerBitrates();
 683   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 684   // Don't check rate targeting on two top spatial layer since they will be
 685   // skipped for part of the sequence.
 686   CheckLayerRateTargeting(number_spatial_layers_ - 2, number_temporal_layers_,
 687                           0.78, 1.15);
 688 #if CONFIG_VP9_DECODER
 689   // The non-reference frames are expected to be mismatched frames as the
 690   // encoder will avoid loopfilter on these frames.
 691   EXPECT_EQ(num_nonref_frames_, GetMismatchFrames());
 692 #endif
 693 }
 694
 695 // Run SVC encoder for 1 temporal layer, 2 spatial layers, with spatial
 696 // downscale 5x5.
 697 TEST_P(DatarateOnePassCbrSvcSingleBR, OnePassCbrSvc2SL1TL5x5MultipleRuns) {
 698   cfg_.rc_buf_initial_sz = 500;
 699   cfg_.rc_buf_optimal_sz = 500;
 700   cfg_.rc_buf_sz = 1000;
 701   cfg_.rc_min_quantizer = 0;
 702   cfg_.rc_max_quantizer = 63;
 703   cfg_.rc_end_usage = VPX_CBR;
 704   cfg_.g_lag_in_frames = 0;
 705   cfg_.ss_number_layers = 2;
 706   cfg_.ts_number_layers = 1;
 707   cfg_.ts_rate_decimator[0] = 1;
 708   cfg_.g_error_resilient = 1;
 709   cfg_.g_threads = 3;
 710   cfg_.temporal_layering_mode = 0;
 711   svc_params_.scaling_factor_num[0] = 256;
 712   svc_params_.scaling_factor_den[0] = 1280;
 713   svc_params_.scaling_factor_num[1] = 1280;
 714   svc_params_.scaling_factor_den[1] = 1280;
 715   cfg_.rc_dropframe_thresh = 10;
 716   cfg_.kf_max_dist = 999999;
 717   cfg_.kf_min_dist = 0;
 718   cfg_.ss_target_bitrate[0] = 300;
 719   cfg_.ss_target_bitrate[1] = 1400;
 720   cfg_.layer_target_bitrate[0] = 300;
 721   cfg_.layer_target_bitrate[1] = 1400;
 722   cfg_.rc_target_bitrate = 1700;
 723   number_spatial_layers_ = cfg_.ss_number_layers;
 724   number_temporal_layers_ = cfg_.ts_number_layers;
 725   ResetModel();
 726   layer_target_avg_bandwidth_[0] = cfg_.layer_target_bitrate[0] * 1000 / 30;
 727   bits_in_buffer_model_[0] =
 728       cfg_.layer_target_bitrate[0] * cfg_.rc_buf_initial_sz;
 729   layer_target_avg_bandwidth_[1] = cfg_.layer_target_bitrate[1] * 1000 / 30;
 730   bits_in_buffer_model_[1] =
 731       cfg_.layer_target_bitrate[1] * cfg_.rc_buf_initial_sz;
 732   ::libvpx_test::Y4mVideoSource video("niklas_1280_720_30.y4m", 0, 60);
 733   top_sl_width_ = 1280;
 734   top_sl_height_ = 720;
 735   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 736   CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.78,
 737                           1.15);
 738 #if CONFIG_VP9_DECODER
 739   // The non-reference frames are expected to be mismatched frames as the
 740   // encoder will avoid loopfilter on these frames.
 741   EXPECT_EQ(num_nonref_frames_, GetMismatchFrames());
 742 #endif
 743 }
 744
 745 // Params: speed setting and index for bitrate array.
 746 class DatarateOnePassCbrSvcMultiBR
 747     : public DatarateOnePassCbrSvc,
 748       public ::libvpx_test::CodecTestWith2Params<int, int> {
 749  public:
 750   DatarateOnePassCbrSvcMultiBR() : DatarateOnePassCbrSvc(GET_PARAM(0)) {
 751     memset(&svc_params_, 0, sizeof(svc_params_));
 752   }
 753   virtual ~DatarateOnePassCbrSvcMultiBR() {}
 754
 755  protected:
 756   virtual void SetUp() {
 757     InitializeConfig();
 758     SetMode(::libvpx_test::kRealTime);
 759     speed_setting_ = GET_PARAM(1);
 760     ResetModel();
 761   }
 762 };
 763
 764 // Check basic rate targeting for 1 pass CBR SVC: 2 spatial layers and
 765 // 3 temporal layers. Run CIF clip with 1 thread.
 766 TEST_P(DatarateOnePassCbrSvcMultiBR, OnePassCbrSvc2SL3TL) {
 767   cfg_.rc_buf_initial_sz = 500;
 768   cfg_.rc_buf_optimal_sz = 500;
 769   cfg_.rc_buf_sz = 1000;
 770   cfg_.rc_min_quantizer = 0;
 771   cfg_.rc_max_quantizer = 63;
 772   cfg_.rc_end_usage = VPX_CBR;
 773   cfg_.g_lag_in_frames = 0;
 774   cfg_.ss_number_layers = 2;
 775   cfg_.ts_number_layers = 3;
 776   cfg_.ts_rate_decimator[0] = 4;
 777   cfg_.ts_rate_decimator[1] = 2;
 778   cfg_.ts_rate_decimator[2] = 1;
 779   cfg_.g_error_resilient = 1;
 780   cfg_.g_threads = 1;
 781   cfg_.temporal_layering_mode = 3;
 782   svc_params_.scaling_factor_num[0] = 144;
 783   svc_params_.scaling_factor_den[0] = 288;
 784   svc_params_.scaling_factor_num[1] = 288;
 785   svc_params_.scaling_factor_den[1] = 288;
 786   cfg_.rc_dropframe_thresh = 30;
 787   cfg_.kf_max_dist = 9999;
 788   number_spatial_layers_ = cfg_.ss_number_layers;
 789   number_temporal_layers_ = cfg_.ts_number_layers;
 790   ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
 791                                        0, 400);
 792   top_sl_width_ = 640;
 793   top_sl_height_ = 480;
 794   const int bitrates[3] = { 200, 400, 600 };
 795   // TODO(marpan): Check that effective_datarate for each layer hits the
 796   // layer target_bitrate.
 797   cfg_.rc_target_bitrate = bitrates[GET_PARAM(2)];
 798   ResetModel();
 799   AssignLayerBitrates();
 800   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 801   CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.75,
 802                           1.2);
 803 #if CONFIG_VP9_DECODER
 804   // The non-reference frames are expected to be mismatched frames as the
 805   // encoder will avoid loopfilter on these frames.
 806   EXPECT_EQ(num_nonref_frames_, GetMismatchFrames());
 807 #endif
 808 }
 809
 810 // Params: speed setting, layer framedrop control and index for bitrate array.
 811 class DatarateOnePassCbrSvcFrameDropMultiBR
 812     : public DatarateOnePassCbrSvc,
 813       public ::libvpx_test::CodecTestWith3Params<int, int, int> {
 814  public:
 815   DatarateOnePassCbrSvcFrameDropMultiBR()
 816       : DatarateOnePassCbrSvc(GET_PARAM(0)) {
 817     memset(&svc_params_, 0, sizeof(svc_params_));
 818   }
 819   virtual ~DatarateOnePassCbrSvcFrameDropMultiBR() {}
 820
 821  protected:
 822   virtual void SetUp() {
 823     InitializeConfig();
 824     SetMode(::libvpx_test::kRealTime);
 825     speed_setting_ = GET_PARAM(1);
 826     ResetModel();
 827   }
 828 };
 829
 830 // Check basic rate targeting for 1 pass CBR SVC: 2 spatial layers and
 831 // 3 temporal layers. Run HD clip with 4 threads.
 832 TEST_P(DatarateOnePassCbrSvcFrameDropMultiBR, OnePassCbrSvc2SL3TL4Threads) {
 833   cfg_.rc_buf_initial_sz = 500;
 834   cfg_.rc_buf_optimal_sz = 500;
 835   cfg_.rc_buf_sz = 1000;
 836   cfg_.rc_min_quantizer = 0;
 837   cfg_.rc_max_quantizer = 63;
 838   cfg_.rc_end_usage = VPX_CBR;
 839   cfg_.g_lag_in_frames = 0;
 840   cfg_.ss_number_layers = 2;
 841   cfg_.ts_number_layers = 3;
 842   cfg_.ts_rate_decimator[0] = 4;
 843   cfg_.ts_rate_decimator[1] = 2;
 844   cfg_.ts_rate_decimator[2] = 1;
 845   cfg_.g_error_resilient = 1;
 846   cfg_.g_threads = 4;
 847   cfg_.temporal_layering_mode = 3;
 848   svc_params_.scaling_factor_num[0] = 144;
 849   svc_params_.scaling_factor_den[0] = 288;
 850   svc_params_.scaling_factor_num[1] = 288;
 851   svc_params_.scaling_factor_den[1] = 288;
 852   cfg_.rc_dropframe_thresh = 30;
 853   cfg_.kf_max_dist = 9999;
 854   number_spatial_layers_ = cfg_.ss_number_layers;
 855   number_temporal_layers_ = cfg_.ts_number_layers;
 856   ::libvpx_test::Y4mVideoSource video("niklas_1280_720_30.y4m", 0, 60);
 857   top_sl_width_ = 1280;
 858   top_sl_height_ = 720;
 859   layer_framedrop_ = 0;
 860   const int bitrates[3] = { 200, 400, 600 };
 861   cfg_.rc_target_bitrate = bitrates[GET_PARAM(3)];
 862   ResetModel();
 863   layer_framedrop_ = GET_PARAM(2);
 864   AssignLayerBitrates();
 865   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 866   CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.71,
 867                           1.45);
 868 #if CONFIG_VP9_DECODER
 869   // The non-reference frames are expected to be mismatched frames as the
 870   // encoder will avoid loopfilter on these frames.
 871   EXPECT_EQ(num_nonref_frames_, GetMismatchFrames());
 872 #endif
 873 }
 874
 875 // Check basic rate targeting for 1 pass CBR SVC: 3 spatial layers and
 876 // 3 temporal layers. Run HD clip with 4 threads.
 877 TEST_P(DatarateOnePassCbrSvcFrameDropMultiBR, OnePassCbrSvc3SL3TL4Threads) {
 878   cfg_.rc_buf_initial_sz = 500;
 879   cfg_.rc_buf_optimal_sz = 500;
 880   cfg_.rc_buf_sz = 1000;
 881   cfg_.rc_min_quantizer = 0;
 882   cfg_.rc_max_quantizer = 63;
 883   cfg_.rc_end_usage = VPX_CBR;
 884   cfg_.g_lag_in_frames = 0;
 885   cfg_.ss_number_layers = 3;
 886   cfg_.ts_number_layers = 3;
 887   cfg_.ts_rate_decimator[0] = 4;
 888   cfg_.ts_rate_decimator[1] = 2;
 889   cfg_.ts_rate_decimator[2] = 1;
 890   cfg_.g_error_resilient = 1;
 891   cfg_.g_threads = 4;
 892   cfg_.temporal_layering_mode = 3;
 893   svc_params_.scaling_factor_num[0] = 72;
 894   svc_params_.scaling_factor_den[0] = 288;
 895   svc_params_.scaling_factor_num[1] = 144;
 896   svc_params_.scaling_factor_den[1] = 288;
 897   svc_params_.scaling_factor_num[2] = 288;
 898   svc_params_.scaling_factor_den[2] = 288;
 899   cfg_.rc_dropframe_thresh = 30;
 900   cfg_.kf_max_dist = 9999;
 901   number_spatial_layers_ = cfg_.ss_number_layers;
 902   number_temporal_layers_ = cfg_.ts_number_layers;
 903   ::libvpx_test::Y4mVideoSource video("niklas_1280_720_30.y4m", 0, 60);
 904   top_sl_width_ = 1280;
 905   top_sl_height_ = 720;
 906   layer_framedrop_ = 0;
 907   const int bitrates[3] = { 200, 400, 600 };
 908   cfg_.rc_target_bitrate = bitrates[GET_PARAM(3)];
 909   ResetModel();
 910   layer_framedrop_ = GET_PARAM(2);
 911   AssignLayerBitrates();
 912   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 913   CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.58,
 914                           1.2);
 915 #if CONFIG_VP9_DECODER
 916   // The non-reference frames are expected to be mismatched frames as the
 917   // encoder will avoid loopfilter on these frames.
 918   EXPECT_EQ(num_nonref_frames_, GetMismatchFrames());
 919 #endif
 920 }
 921
 922 // Params: speed setting, inter-layer prediction mode.
 923 class DatarateOnePassCbrSvcInterLayerPredSingleBR
 924     : public DatarateOnePassCbrSvc,
 925       public ::libvpx_test::CodecTestWith2Params<int, int> {
 926  public:
 927   DatarateOnePassCbrSvcInterLayerPredSingleBR()
 928       : DatarateOnePassCbrSvc(GET_PARAM(0)) {
 929     memset(&svc_params_, 0, sizeof(svc_params_));
 930   }
 931   virtual ~DatarateOnePassCbrSvcInterLayerPredSingleBR() {}
 932
 933  protected:
 934   virtual void SetUp() {
 935     InitializeConfig();
 936     SetMode(::libvpx_test::kRealTime);
 937     speed_setting_ = GET_PARAM(1);
 938     inter_layer_pred_mode_ = GET_PARAM(2);
 939     ResetModel();
 940   }
 941 };
 942
 943 // Check basic rate targeting with different inter-layer prediction modes for 1
 944 // pass CBR SVC: 3 spatial layers and 3 temporal layers. Run CIF clip with 1
 945 // thread.
 946 TEST_P(DatarateOnePassCbrSvcInterLayerPredSingleBR, OnePassCbrSvc3SL3TL) {
 947   cfg_.rc_buf_initial_sz = 500;
 948   cfg_.rc_buf_optimal_sz = 500;
 949   cfg_.rc_buf_sz = 1000;
 950   cfg_.rc_min_quantizer = 0;
 951   cfg_.rc_max_quantizer = 63;
 952   cfg_.rc_end_usage = VPX_CBR;
 953   cfg_.g_lag_in_frames = 0;
 954   cfg_.ss_number_layers = 3;
 955   cfg_.ts_number_layers = 3;
 956   cfg_.ts_rate_decimator[0] = 4;
 957   cfg_.ts_rate_decimator[1] = 2;
 958   cfg_.ts_rate_decimator[2] = 1;
 959   cfg_.g_error_resilient = 1;
 960   cfg_.g_threads = 1;
 961   cfg_.temporal_layering_mode = 3;
 962   svc_params_.scaling_factor_num[0] = 72;
 963   svc_params_.scaling_factor_den[0] = 288;
 964   svc_params_.scaling_factor_num[1] = 144;
 965   svc_params_.scaling_factor_den[1] = 288;
 966   svc_params_.scaling_factor_num[2] = 288;
 967   svc_params_.scaling_factor_den[2] = 288;
 968   cfg_.rc_dropframe_thresh = 30;
 969   cfg_.kf_max_dist = 9999;
 970   number_spatial_layers_ = cfg_.ss_number_layers;
 971   number_temporal_layers_ = cfg_.ts_number_layers;
 972   ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
 973                                        0, 400);
 974   top_sl_width_ = 640;
 975   top_sl_height_ = 480;
 976   cfg_.rc_target_bitrate = 800;
 977   ResetModel();
 978   AssignLayerBitrates();
 979   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 980   CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.78,
 981                           1.15);
 982 #if CONFIG_VP9_DECODER
 983   // The non-reference frames are expected to be mismatched frames as the
 984   // encoder will avoid loopfilter on these frames.
 985   EXPECT_EQ(num_nonref_frames_, GetMismatchFrames());
 986 #endif
 987 }
 988
 989 // Check rate targeting with different inter-layer prediction modes for 1 pass
 990 // CBR SVC: 3 spatial layers and 3 temporal layers, changing the target bitrate
 991 // at the middle of encoding.
 992 TEST_P(DatarateOnePassCbrSvcSingleBR, OnePassCbrSvc3SL3TLDynamicBitrateChange) {
 993   cfg_.rc_buf_initial_sz = 500;
 994   cfg_.rc_buf_optimal_sz = 500;
 995   cfg_.rc_buf_sz = 1000;
 996   cfg_.rc_min_quantizer = 0;
 997   cfg_.rc_max_quantizer = 63;
 998   cfg_.rc_end_usage = VPX_CBR;
 999   cfg_.g_lag_in_frames = 0;
1000   cfg_.ss_number_layers = 3;
1001   cfg_.ts_number_layers = 3;
1002   cfg_.ts_rate_decimator[0] = 4;
1003   cfg_.ts_rate_decimator[1] = 2;
1004   cfg_.ts_rate_decimator[2] = 1;
1005   cfg_.g_error_resilient = 1;
1006   cfg_.g_threads = 1;
1007   cfg_.temporal_layering_mode = 3;
1008   svc_params_.scaling_factor_num[0] = 72;
1009   svc_params_.scaling_factor_den[0] = 288;
1010   svc_params_.scaling_factor_num[1] = 144;
1011   svc_params_.scaling_factor_den[1] = 288;
1012   svc_params_.scaling_factor_num[2] = 288;
1013   svc_params_.scaling_factor_den[2] = 288;
1014   cfg_.rc_dropframe_thresh = 30;
1015   cfg_.kf_max_dist = 9999;
1016   number_spatial_layers_ = cfg_.ss_number_layers;
1017   number_temporal_layers_ = cfg_.ts_number_layers;
1018   ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
1019                                        0, 400);
1020   top_sl_width_ = 640;
1021   top_sl_height_ = 480;
1022   cfg_.rc_target_bitrate = 800;
1023   ResetModel();
1024   change_bitrate_ = true;
1025   AssignLayerBitrates();
1026   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
1027   CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.78,
1028                           1.15);
1029 #if CONFIG_VP9_DECODER
1030   // The non-reference frames are expected to be mismatched frames as the
1031   // encoder will avoid loopfilter on these frames.
1032   EXPECT_EQ(num_nonref_frames_, GetMismatchFrames());
1033 #endif
1034 }
1035
1036 #if CONFIG_VP9_TEMPORAL_DENOISING
1037 // Params: speed setting, noise sensitivity and index for bitrate array.
1038 class DatarateOnePassCbrSvcDenoiser
1039     : public DatarateOnePassCbrSvc,
1040       public ::libvpx_test::CodecTestWith3Params<int, int, int> {
1041  public:
1042   DatarateOnePassCbrSvcDenoiser() : DatarateOnePassCbrSvc(GET_PARAM(0)) {
1043     memset(&svc_params_, 0, sizeof(svc_params_));
1044   }
1045   virtual ~DatarateOnePassCbrSvcDenoiser() {}
1046
1047  protected:
1048   virtual void SetUp() {
1049     InitializeConfig();
1050     SetMode(::libvpx_test::kRealTime);
1051     speed_setting_ = GET_PARAM(1);
1052     ResetModel();
1053   }
1054 };
1055
1056 // Check basic rate targeting for 1 pass CBR SVC with denoising.
1057 // 2 spatial layers and 3 temporal layer. Run HD clip with 2 threads.
1058 TEST_P(DatarateOnePassCbrSvcDenoiser, OnePassCbrSvc2SL3TLDenoiserOn) {
1059   cfg_.rc_buf_initial_sz = 500;
1060   cfg_.rc_buf_optimal_sz = 500;
1061   cfg_.rc_buf_sz = 1000;
1062   cfg_.rc_min_quantizer = 0;
1063   cfg_.rc_max_quantizer = 63;
1064   cfg_.rc_end_usage = VPX_CBR;
1065   cfg_.g_lag_in_frames = 0;
1066   cfg_.ss_number_layers = 2;
1067   cfg_.ts_number_layers = 3;
1068   cfg_.ts_rate_decimator[0] = 4;
1069   cfg_.ts_rate_decimator[1] = 2;
1070   cfg_.ts_rate_decimator[2] = 1;
1071   cfg_.g_error_resilient = 1;
1072   cfg_.g_threads = 2;
1073   cfg_.temporal_layering_mode = 3;
1074   svc_params_.scaling_factor_num[0] = 144;
1075   svc_params_.scaling_factor_den[0] = 288;
1076   svc_params_.scaling_factor_num[1] = 288;
1077   svc_params_.scaling_factor_den[1] = 288;
1078   cfg_.rc_dropframe_thresh = 30;
1079   cfg_.kf_max_dist = 9999;
1080   number_spatial_layers_ = cfg_.ss_number_layers;
1081   number_temporal_layers_ = cfg_.ts_number_layers;
1082   ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
1083                                        0, 400);
1084   top_sl_width_ = 640;
1085   top_sl_height_ = 480;
1086   const int bitrates[3] = { 600, 800, 1000 };
1087   // TODO(marpan): Check that effective_datarate for each layer hits the
1088   // layer target_bitrate.
1089   // For SVC, noise_sen = 1 means denoising only the top spatial layer
1090   // noise_sen = 2 means denoising the two top spatial layers.
1091   cfg_.rc_target_bitrate = bitrates[GET_PARAM(3)];
1092   ResetModel();
1093   denoiser_on_ = GET_PARAM(2);
1094   AssignLayerBitrates();
1095   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
1096   CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.78,
1097                           1.15);
1098 #if CONFIG_VP9_DECODER
1099   // The non-reference frames are expected to be mismatched frames as the
1100   // encoder will avoid loopfilter on these frames.
1101   EXPECT_EQ(num_nonref_frames_, GetMismatchFrames());
1102 #endif
1103 }
1104 #endif
1105
1106 // Params: speed setting, key frame dist.
1107 class DatarateOnePassCbrSvcSmallKF
1108     : public DatarateOnePassCbrSvc,
1109       public ::libvpx_test::CodecTestWith2Params<int, int> {
1110  public:
1111   DatarateOnePassCbrSvcSmallKF() : DatarateOnePassCbrSvc(GET_PARAM(0)) {
1112     memset(&svc_params_, 0, sizeof(svc_params_));
1113   }
1114   virtual ~DatarateOnePassCbrSvcSmallKF() {}
1115
1116  protected:
1117   virtual void SetUp() {
1118     InitializeConfig();
1119     SetMode(::libvpx_test::kRealTime);
1120     speed_setting_ = GET_PARAM(1);
1121     ResetModel();
1122   }
1123 };
1124
1125 // Check basic rate targeting for 1 pass CBR SVC: 3 spatial layers and 3
1126 // temporal layers. Run CIF clip with 1 thread, and few short key frame periods.
1127 TEST_P(DatarateOnePassCbrSvcSmallKF, OnePassCbrSvc3SL3TLSmallKf) {
1128   cfg_.rc_buf_initial_sz = 500;
1129   cfg_.rc_buf_optimal_sz = 500;
1130   cfg_.rc_buf_sz = 1000;
1131   cfg_.rc_min_quantizer = 0;
1132   cfg_.rc_max_quantizer = 63;
1133   cfg_.rc_end_usage = VPX_CBR;
1134   cfg_.g_lag_in_frames = 0;
1135   cfg_.ss_number_layers = 3;
1136   cfg_.ts_number_layers = 3;
1137   cfg_.ts_rate_decimator[0] = 4;
1138   cfg_.ts_rate_decimator[1] = 2;
1139   cfg_.ts_rate_decimator[2] = 1;
1140   cfg_.g_error_resilient = 1;
1141   cfg_.g_threads = 1;
1142   cfg_.temporal_layering_mode = 3;
1143   svc_params_.scaling_factor_num[0] = 72;
1144   svc_params_.scaling_factor_den[0] = 288;
1145   svc_params_.scaling_factor_num[1] = 144;
1146   svc_params_.scaling_factor_den[1] = 288;
1147   svc_params_.scaling_factor_num[2] = 288;
1148   svc_params_.scaling_factor_den[2] = 288;
1149   cfg_.rc_dropframe_thresh = 10;
1150   cfg_.rc_target_bitrate = 800;
1151   number_spatial_layers_ = cfg_.ss_number_layers;
1152   number_temporal_layers_ = cfg_.ts_number_layers;
1153   ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
1154                                        0, 400);
1155   top_sl_width_ = 640;
1156   top_sl_height_ = 480;
1157   // For this 3 temporal layer case, pattern repeats every 4 frames, so choose
1158   // 4 key neighboring key frame periods (so key frame will land on 0-2-1-2).
1159   const int kf_dist = GET_PARAM(2);
1160   cfg_.kf_max_dist = kf_dist;
1161   key_frame_spacing_ = kf_dist;
1162   ResetModel();
1163   AssignLayerBitrates();
1164   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
1165   // TODO(jianj): webm:1554
1166   CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.76,
1167                           1.15);
1168 #if CONFIG_VP9_DECODER
1169   // The non-reference frames are expected to be mismatched frames as the
1170   // encoder will avoid loopfilter on these frames.
1171   EXPECT_EQ(num_nonref_frames_, GetMismatchFrames());
1172 #endif
1173 }
1174
1175 // Check basic rate targeting for 1 pass CBR SVC: 2 spatial layers and 3
1176 // temporal layers. Run CIF clip with 1 thread, and few short key frame periods.
1177 TEST_P(DatarateOnePassCbrSvcSmallKF, OnePassCbrSvc2SL3TLSmallKf) {
1178   cfg_.rc_buf_initial_sz = 500;
1179   cfg_.rc_buf_optimal_sz = 500;
1180   cfg_.rc_buf_sz = 1000;
1181   cfg_.rc_min_quantizer = 0;
1182   cfg_.rc_max_quantizer = 63;
1183   cfg_.rc_end_usage = VPX_CBR;
1184   cfg_.g_lag_in_frames = 0;
1185   cfg_.ss_number_layers = 2;
1186   cfg_.ts_number_layers = 3;
1187   cfg_.ts_rate_decimator[0] = 4;
1188   cfg_.ts_rate_decimator[1] = 2;
1189   cfg_.ts_rate_decimator[2] = 1;
1190   cfg_.g_error_resilient = 1;
1191   cfg_.g_threads = 1;
1192   cfg_.temporal_layering_mode = 3;
1193   svc_params_.scaling_factor_num[0] = 144;
1194   svc_params_.scaling_factor_den[0] = 288;
1195   svc_params_.scaling_factor_num[1] = 288;
1196   svc_params_.scaling_factor_den[1] = 288;
1197   cfg_.rc_dropframe_thresh = 10;
1198   cfg_.rc_target_bitrate = 400;
1199   number_spatial_layers_ = cfg_.ss_number_layers;
1200   number_temporal_layers_ = cfg_.ts_number_layers;
1201   ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
1202                                        0, 400);
1203   top_sl_width_ = 640;
1204   top_sl_height_ = 480;
1205   // For this 3 temporal layer case, pattern repeats every 4 frames, so choose
1206   // 4 key neighboring key frame periods (so key frame will land on 0-2-1-2).
1207   const int kf_dist = GET_PARAM(2) + 32;
1208   cfg_.kf_max_dist = kf_dist;
1209   key_frame_spacing_ = kf_dist;
1210   ResetModel();
1211   AssignLayerBitrates();
1212   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
1213   CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.78,
1214                           1.15);
1215 #if CONFIG_VP9_DECODER
1216   // The non-reference frames are expected to be mismatched frames as the
1217   // encoder will avoid loopfilter on these frames.
1218   EXPECT_EQ(num_nonref_frames_, GetMismatchFrames());
1219 #endif
1220 }
1221
1222 // Check basic rate targeting for 1 pass CBR SVC: 3 spatial layers and 3
1223 // temporal layers. Run VGA clip with 1 thread, and place layer sync frames:
1224 // one at middle layer first, then another one for top layer, and another
1225 // insert for base spatial layer (which forces key frame).
1226 TEST_P(DatarateOnePassCbrSvcSingleBR, OnePassCbrSvc3SL3TLSyncFrames) {
1227   cfg_.rc_buf_initial_sz = 500;
1228   cfg_.rc_buf_optimal_sz = 500;
1229   cfg_.rc_buf_sz = 1000;
1230   cfg_.rc_min_quantizer = 0;
1231   cfg_.rc_max_quantizer = 63;
1232   cfg_.rc_end_usage = VPX_CBR;
1233   cfg_.g_lag_in_frames = 0;
1234   cfg_.ss_number_layers = 3;
1235   cfg_.ts_number_layers = 3;
1236   cfg_.ts_rate_decimator[0] = 4;
1237   cfg_.ts_rate_decimator[1] = 2;
1238   cfg_.ts_rate_decimator[2] = 1;
1239   cfg_.g_error_resilient = 1;
1240   cfg_.g_threads = 1;
1241   cfg_.temporal_layering_mode = 3;
1242   svc_params_.scaling_factor_num[0] = 72;
1243   svc_params_.scaling_factor_den[0] = 288;
1244   svc_params_.scaling_factor_num[1] = 144;
1245   svc_params_.scaling_factor_den[1] = 288;
1246   svc_params_.scaling_factor_num[2] = 288;
1247   svc_params_.scaling_factor_den[2] = 288;
1248   cfg_.kf_max_dist = 9999;
1249   cfg_.rc_dropframe_thresh = 10;
1250   cfg_.rc_target_bitrate = 400;
1251   number_spatial_layers_ = cfg_.ss_number_layers;
1252   number_temporal_layers_ = cfg_.ts_number_layers;
1253   ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
1254                                        0, 400);
1255   top_sl_width_ = 640;
1256   top_sl_height_ = 480;
1257   ResetModel();
1258   insert_layer_sync_ = 1;
1259   AssignLayerBitrates();
1260   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
1261   CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.78,
1262                           1.15);
1263 #if CONFIG_VP9_DECODER
1264   // The non-reference frames are expected to be mismatched frames as the
1265   // encoder will avoid loopfilter on these frames.
1266   EXPECT_EQ(num_nonref_frames_, GetMismatchFrames());
1267 #endif
1268 }
1269
1270 // Run SVC encoder for 3 spatial layers, 1 temporal layer, with
1271 // intra-only frame as sync frame on base spatial layer.
1272 // Intra_only is inserted at start and in middle of sequence.
1273 TEST_P(DatarateOnePassCbrSvcSingleBR, OnePassCbrSvc3SL1TLSyncWithIntraOnly) {
1274   cfg_.rc_buf_initial_sz = 500;
1275   cfg_.rc_buf_optimal_sz = 500;
1276   cfg_.rc_buf_sz = 1000;
1277   cfg_.rc_min_quantizer = 0;
1278   cfg_.rc_max_quantizer = 63;
1279   cfg_.rc_end_usage = VPX_CBR;
1280   cfg_.g_lag_in_frames = 0;
1281   cfg_.ss_number_layers = 3;
1282   cfg_.ts_number_layers = 1;
1283   cfg_.ts_rate_decimator[0] = 1;
1284   cfg_.temporal_layering_mode = 0;
1285   cfg_.g_error_resilient = 1;
1286   cfg_.g_threads = 4;
1287   svc_params_.scaling_factor_num[0] = 72;
1288   svc_params_.scaling_factor_den[0] = 288;
1289   svc_params_.scaling_factor_num[1] = 144;
1290   svc_params_.scaling_factor_den[1] = 288;
1291   svc_params_.scaling_factor_num[2] = 288;
1292   svc_params_.scaling_factor_den[2] = 288;
1293   cfg_.rc_dropframe_thresh = 30;
1294   cfg_.kf_max_dist = 9999;
1295   cfg_.rc_target_bitrate = 400;
1296   number_spatial_layers_ = cfg_.ss_number_layers;
1297   number_temporal_layers_ = cfg_.ts_number_layers;
1298   ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
1299                                        0, 400);
1300   top_sl_width_ = 640;
1301   top_sl_height_ = 480;
1302   ResetModel();
1303   insert_layer_sync_ = 1;
1304   // Use intra_only frame for sync on base layer.
1305   force_intra_only_frame_ = 1;
1306   AssignLayerBitrates();
1307   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
1308   CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.73,
1309                           1.2);
1310 #if CONFIG_VP9_DECODER
1311   // The non-reference frames are expected to be mismatched frames as the
1312   // encoder will avoid loopfilter on these frames.
1313   EXPECT_EQ(num_nonref_frames_, GetMismatchFrames());
1314 #endif
1315 }
1316
1317 // Run SVC encoder for 2 quality layers (same resolution different,
1318 // bitrates), 1 temporal layer, with screen content mode.
1319 TEST_P(DatarateOnePassCbrSvcSingleBR, OnePassCbrSvc2QL1TLScreen) {
1320   cfg_.rc_buf_initial_sz = 500;
1321   cfg_.rc_buf_optimal_sz = 500;
1322   cfg_.rc_buf_sz = 1000;
1323   cfg_.rc_min_quantizer = 0;
1324   cfg_.rc_max_quantizer = 56;
1325   cfg_.rc_end_usage = VPX_CBR;
1326   cfg_.g_lag_in_frames = 0;
1327   cfg_.ss_number_layers = 2;
1328   cfg_.ts_number_layers = 1;
1329   cfg_.ts_rate_decimator[0] = 1;
1330   cfg_.temporal_layering_mode = 0;
1331   cfg_.g_error_resilient = 1;
1332   cfg_.g_threads = 2;
1333   svc_params_.scaling_factor_num[0] = 1;
1334   svc_params_.scaling_factor_den[0] = 1;
1335   svc_params_.scaling_factor_num[1] = 1;
1336   svc_params_.scaling_factor_den[1] = 1;
1337   cfg_.rc_dropframe_thresh = 30;
1338   cfg_.kf_max_dist = 9999;
1339   number_spatial_layers_ = cfg_.ss_number_layers;
1340   number_temporal_layers_ = cfg_.ts_number_layers;
1341   ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
1342                                        0, 400);
1343   top_sl_width_ = 640;
1344   top_sl_height_ = 480;
1345   ResetModel();
1346   tune_content_ = 1;
1347   // Set the layer bitrates, for 2 spatial layers, 1 temporal.
1348   cfg_.rc_target_bitrate = 400;
1349   cfg_.ss_target_bitrate[0] = 100;
1350   cfg_.ss_target_bitrate[1] = 300;
1351   cfg_.layer_target_bitrate[0] = 100;
1352   cfg_.layer_target_bitrate[1] = 300;
1353   for (int sl = 0; sl < 2; ++sl) {
1354     float layer_framerate = 30.0;
1355     layer_target_avg_bandwidth_[sl] = static_cast<int>(
1356         cfg_.layer_target_bitrate[sl] * 1000.0 / layer_framerate);
1357     bits_in_buffer_model_[sl] =
1358         cfg_.layer_target_bitrate[sl] * cfg_.rc_buf_initial_sz;
1359   }
1360   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
1361   CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.73,
1362                           1.25);
1363 #if CONFIG_VP9_DECODER
1364   // The non-reference frames are expected to be mismatched frames as the
1365   // encoder will avoid loopfilter on these frames.
1366   EXPECT_EQ(num_nonref_frames_, GetMismatchFrames());
1367 #endif
1368 }
1369
1370 // Params: speed setting.
1371 class DatarateOnePassCbrSvcPostencodeDrop
1372     : public DatarateOnePassCbrSvc,
1373       public ::libvpx_test::CodecTestWithParam<int> {
1374  public:
1375   DatarateOnePassCbrSvcPostencodeDrop() : DatarateOnePassCbrSvc(GET_PARAM(0)) {
1376     memset(&svc_params_, 0, sizeof(svc_params_));
1377   }
1378   virtual ~DatarateOnePassCbrSvcPostencodeDrop() {}
1379
1380  protected:
1381   virtual void SetUp() {
1382     InitializeConfig();
1383     SetMode(::libvpx_test::kRealTime);
1384     speed_setting_ = GET_PARAM(1);
1385     ResetModel();
1386   }
1387 };
1388
1389 // Run SVC encoder for 2 quality layers (same resolution different,
1390 // bitrates), 1 temporal layer, with screen content mode.
1391 TEST_P(DatarateOnePassCbrSvcPostencodeDrop, OnePassCbrSvc2QL1TLScreen) {
1392   cfg_.rc_buf_initial_sz = 200;
1393   cfg_.rc_buf_optimal_sz = 200;
1394   cfg_.rc_buf_sz = 400;
1395   cfg_.rc_min_quantizer = 0;
1396   cfg_.rc_max_quantizer = 52;
1397   cfg_.rc_end_usage = VPX_CBR;
1398   cfg_.g_lag_in_frames = 0;
1399   cfg_.ss_number_layers = 2;
1400   cfg_.ts_number_layers = 1;
1401   cfg_.ts_rate_decimator[0] = 1;
1402   cfg_.temporal_layering_mode = 0;
1403   cfg_.g_error_resilient = 1;
1404   cfg_.g_threads = 2;
1405   svc_params_.scaling_factor_num[0] = 1;
1406   svc_params_.scaling_factor_den[0] = 1;
1407   svc_params_.scaling_factor_num[1] = 1;
1408   svc_params_.scaling_factor_den[1] = 1;
1409   cfg_.rc_dropframe_thresh = 30;
1410   cfg_.kf_max_dist = 9999;
1411   number_spatial_layers_ = cfg_.ss_number_layers;
1412   number_temporal_layers_ = cfg_.ts_number_layers;
1413   ::libvpx_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
1414                                        30, 1, 0, 300);
1415   top_sl_width_ = 352;
1416   top_sl_height_ = 288;
1417   ResetModel();
1418   base_speed_setting_ = speed_setting_;
1419   tune_content_ = 1;
1420   use_post_encode_drop_ = 1;
1421   // Set the layer bitrates, for 2 spatial layers, 1 temporal.
1422   cfg_.rc_target_bitrate = 400;
1423   cfg_.ss_target_bitrate[0] = 100;
1424   cfg_.ss_target_bitrate[1] = 300;
1425   cfg_.layer_target_bitrate[0] = 100;
1426   cfg_.layer_target_bitrate[1] = 300;
1427   for (int sl = 0; sl < 2; ++sl) {
1428     float layer_framerate = 30.0;
1429     layer_target_avg_bandwidth_[sl] = static_cast<int>(
1430         cfg_.layer_target_bitrate[sl] * 1000.0 / layer_framerate);
1431     bits_in_buffer_model_[sl] =
1432         cfg_.layer_target_bitrate[sl] * cfg_.rc_buf_initial_sz;
1433   }
1434   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
1435   CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.73,
1436                           1.25);
1437 #if CONFIG_VP9_DECODER
1438   // The non-reference frames are expected to be mismatched frames as the
1439   // encoder will avoid loopfilter on these frames.
1440   EXPECT_EQ(num_nonref_frames_, GetMismatchFrames());
1441 #endif
1442 }
1443
1444 VP9_INSTANTIATE_TEST_CASE(DatarateOnePassCbrSvcSingleBR,
1445                           ::testing::Range(5, 10));
1446
1447 VP9_INSTANTIATE_TEST_CASE(DatarateOnePassCbrSvcPostencodeDrop,
1448                           ::testing::Range(4, 5));
1449
1450 VP9_INSTANTIATE_TEST_CASE(DatarateOnePassCbrSvcInterLayerPredSingleBR,
1451                           ::testing::Range(5, 10), ::testing::Range(0, 3));
1452
1453 VP9_INSTANTIATE_TEST_CASE(DatarateOnePassCbrSvcMultiBR, ::testing::Range(5, 10),
1454                           ::testing::Range(0, 3));
1455
1456 VP9_INSTANTIATE_TEST_CASE(DatarateOnePassCbrSvcFrameDropMultiBR,
1457                           ::testing::Range(5, 10), ::testing::Range(0, 2),
1458                           ::testing::Range(0, 3));
1459
1460 #if CONFIG_VP9_TEMPORAL_DENOISING
1461 VP9_INSTANTIATE_TEST_CASE(DatarateOnePassCbrSvcDenoiser,
1462                           ::testing::Range(5, 10), ::testing::Range(1, 3),
1463                           ::testing::Range(0, 3));
1464 #endif
1465
1466 VP9_INSTANTIATE_TEST_CASE(DatarateOnePassCbrSvcSmallKF, ::testing::Range(5, 10),
1467                           ::testing::Range(32, 36));
1468 }  // namespace