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