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