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