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