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