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"
26 // Inter-layer prediction is on on all frames.
28 // Inter-layer prediction is off on all frames.
30 // Inter-layer prediction is off on non-key frames and non-sync frames.
31 INTER_LAYER_PRED_OFF_NONKEY,
32 // Inter-layer prediction is on on all frames, but constrained such
33 // that any layer S (> 0) can only predict from previous spatial
34 // layer S-1, from the same superframe.
35 INTER_LAYER_PRED_ON_CONSTRAINED
38 class DatarateOnePassCbrSvc : public OnePassCbrSvc {
40 explicit DatarateOnePassCbrSvc(const ::libvpx_test::CodecFactory *codec)
41 : OnePassCbrSvc(codec) {
42 inter_layer_pred_mode_ = 0;
46 virtual ~DatarateOnePassCbrSvc() {}
48 virtual void ResetModel() {
52 mismatch_nframes_ = 0;
55 base_speed_setting_ = 5;
56 spatial_layer_id_ = 0;
57 temporal_layer_id_ = 0;
59 memset(bits_in_buffer_model_, 0, sizeof(bits_in_buffer_model_));
60 memset(bits_total_, 0, sizeof(bits_total_));
61 memset(layer_target_avg_bandwidth_, 0, sizeof(layer_target_avg_bandwidth_));
62 dynamic_drop_layer_ = false;
63 change_bitrate_ = false;
67 superframe_count_ = -1;
68 key_frame_spacing_ = 9999;
69 num_nonref_frames_ = 0;
73 insert_layer_sync_ = 0;
74 layer_sync_on_base_ = 0;
75 force_intra_only_frame_ = 0;
76 superframe_has_intra_only_ = 0;
77 use_post_encode_drop_ = 0;
78 denoiser_off_on_ = false;
79 denoiser_enable_layers_ = false;
81 virtual void BeginPassHook(unsigned int /*pass*/) {}
83 // Example pattern for spatial layers and 2 temporal layers used in the
84 // bypass/flexible mode. The pattern corresponds to the pattern
85 // VP9E_TEMPORAL_LAYERING_MODE_0101 (temporal_layering_mode == 2) used in
86 // non-flexible mode, except that we disable inter-layer prediction.
87 void set_frame_flags_bypass_mode(
88 int tl, int num_spatial_layers, int is_key_frame,
89 vpx_svc_ref_frame_config_t *ref_frame_config) {
90 for (int sl = 0; sl < num_spatial_layers; ++sl)
91 ref_frame_config->update_buffer_slot[sl] = 0;
93 for (int sl = 0; sl < num_spatial_layers; ++sl) {
95 ref_frame_config->lst_fb_idx[sl] = sl;
98 ref_frame_config->lst_fb_idx[sl] = sl - 1;
99 ref_frame_config->gld_fb_idx[sl] = sl;
101 ref_frame_config->gld_fb_idx[sl] = sl - 1;
104 ref_frame_config->gld_fb_idx[sl] = 0;
106 ref_frame_config->alt_fb_idx[sl] = 0;
107 } else if (tl == 1) {
108 ref_frame_config->lst_fb_idx[sl] = sl;
109 ref_frame_config->gld_fb_idx[sl] =
110 VPXMIN(REF_FRAMES - 1, num_spatial_layers + sl - 1);
111 ref_frame_config->alt_fb_idx[sl] =
112 VPXMIN(REF_FRAMES - 1, num_spatial_layers + sl);
116 ref_frame_config->reference_last[sl] = 1;
117 ref_frame_config->reference_golden[sl] = 0;
118 ref_frame_config->reference_alt_ref[sl] = 0;
119 ref_frame_config->update_buffer_slot[sl] |=
120 1 << ref_frame_config->lst_fb_idx[sl];
123 ref_frame_config->reference_last[sl] = 1;
124 ref_frame_config->reference_golden[sl] = 0;
125 ref_frame_config->reference_alt_ref[sl] = 0;
126 ref_frame_config->update_buffer_slot[sl] |=
127 1 << ref_frame_config->gld_fb_idx[sl];
129 ref_frame_config->reference_last[sl] = 1;
130 ref_frame_config->reference_golden[sl] = 0;
131 ref_frame_config->reference_alt_ref[sl] = 0;
132 ref_frame_config->update_buffer_slot[sl] |=
133 1 << ref_frame_config->lst_fb_idx[sl];
136 } else if (tl == 1) {
138 ref_frame_config->reference_last[sl] = 1;
139 ref_frame_config->reference_golden[sl] = 0;
140 ref_frame_config->reference_alt_ref[sl] = 0;
141 ref_frame_config->update_buffer_slot[sl] |=
142 1 << ref_frame_config->alt_fb_idx[sl];
144 ref_frame_config->reference_last[sl] = 1;
145 ref_frame_config->reference_golden[sl] = 0;
146 ref_frame_config->reference_alt_ref[sl] = 0;
147 ref_frame_config->update_buffer_slot[sl] |=
148 1 << ref_frame_config->alt_fb_idx[sl];
154 void CheckLayerRateTargeting(int num_spatial_layers, int num_temporal_layers,
155 double thresh_overshoot,
156 double thresh_undershoot) const {
157 for (int sl = 0; sl < num_spatial_layers; ++sl)
158 for (int tl = 0; tl < num_temporal_layers; ++tl) {
159 const int layer = sl * num_temporal_layers + tl;
160 ASSERT_GE(cfg_.layer_target_bitrate[layer],
161 file_datarate_[layer] * thresh_overshoot)
162 << " The datarate for the file exceeds the target by too much!";
163 ASSERT_LE(cfg_.layer_target_bitrate[layer],
164 file_datarate_[layer] * thresh_undershoot)
165 << " The datarate for the file is lower than the target by too "
170 virtual void PreEncodeFrameHook(::libvpx_test::VideoSource *video,
171 ::libvpx_test::Encoder *encoder) {
172 PreEncodeFrameHookSetup(video, encoder);
174 if (video->frame() == 0) {
175 if (force_intra_only_frame_) {
176 // Decoder sets the color_space for Intra-only frames
177 // to BT_601 (see line 1810 in vp9_decodeframe.c).
178 // So set it here in these tess to avoid encoder-decoder
179 // mismatch check on color space setting.
180 encoder->Control(VP9E_SET_COLOR_SPACE, VPX_CS_BT_601);
182 encoder->Control(VP9E_SET_NOISE_SENSITIVITY, denoiser_on_);
183 encoder->Control(VP9E_SET_TUNE_CONTENT, tune_content_);
184 encoder->Control(VP9E_SET_SVC_INTER_LAYER_PRED, inter_layer_pred_mode_);
186 if (layer_framedrop_) {
187 vpx_svc_frame_drop_t svc_drop_frame;
188 svc_drop_frame.framedrop_mode = LAYER_DROP;
189 for (int i = 0; i < number_spatial_layers_; i++)
190 svc_drop_frame.framedrop_thresh[i] = 30;
191 svc_drop_frame.max_consec_drop = 30;
192 encoder->Control(VP9E_SET_SVC_FRAME_DROP_LAYER, &svc_drop_frame);
195 if (use_post_encode_drop_) {
196 encoder->Control(VP9E_SET_POSTENCODE_DROP, use_post_encode_drop_);
200 if (denoiser_off_on_) {
201 encoder->Control(VP9E_SET_AQ_MODE, 3);
202 // Set inter_layer_pred to INTER_LAYER_PRED_OFF_NONKEY (K-SVC).
203 encoder->Control(VP9E_SET_SVC_INTER_LAYER_PRED, 2);
204 if (!denoiser_enable_layers_) {
205 if (video->frame() == 0)
206 encoder->Control(VP9E_SET_NOISE_SENSITIVITY, 0);
207 else if (video->frame() == 100)
208 encoder->Control(VP9E_SET_NOISE_SENSITIVITY, 1);
210 // Cumulative bitrates for top spatial layers, for
211 // 3 temporal layers.
212 if (video->frame() == 0) {
213 encoder->Control(VP9E_SET_NOISE_SENSITIVITY, 0);
214 // Change layer bitrates to set top spatial layer to 0.
215 // This is for 3 spatial 3 temporal layers.
216 // This will trigger skip encoding/dropping of top spatial layer.
217 cfg_.rc_target_bitrate -= cfg_.layer_target_bitrate[8];
218 for (int i = 0; i < 3; i++)
219 bitrate_sl3_[i] = cfg_.layer_target_bitrate[i + 6];
220 cfg_.layer_target_bitrate[6] = 0;
221 cfg_.layer_target_bitrate[7] = 0;
222 cfg_.layer_target_bitrate[8] = 0;
223 encoder->Config(&cfg_);
224 } else if (video->frame() == 100) {
225 // Change layer bitrates to non-zero on top spatial layer.
226 // This will trigger skip encoding of top spatial layer
227 // on key frame (period = 100).
228 for (int i = 0; i < 3; i++)
229 cfg_.layer_target_bitrate[i + 6] = bitrate_sl3_[i];
230 cfg_.rc_target_bitrate += cfg_.layer_target_bitrate[8];
231 encoder->Config(&cfg_);
232 } else if (video->frame() == 120) {
233 // Enable denoiser and top spatial layer after key frame (period is
235 encoder->Control(VP9E_SET_NOISE_SENSITIVITY, 1);
240 if (update_pattern_ && video->frame() >= 100) {
241 vpx_svc_layer_id_t layer_id;
242 if (video->frame() == 100) {
243 cfg_.temporal_layering_mode = VP9E_TEMPORAL_LAYERING_MODE_BYPASS;
244 encoder->Config(&cfg_);
246 // Set layer id since the pattern changed.
247 layer_id.spatial_layer_id = 0;
248 layer_id.temporal_layer_id = (video->frame() % 2 != 0);
249 temporal_layer_id_ = layer_id.temporal_layer_id;
250 for (int i = 0; i < number_spatial_layers_; i++)
251 layer_id.temporal_layer_id_per_spatial[i] = temporal_layer_id_;
252 encoder->Control(VP9E_SET_SVC_LAYER_ID, &layer_id);
253 set_frame_flags_bypass_mode(layer_id.temporal_layer_id,
254 number_spatial_layers_, 0, &ref_frame_config);
255 encoder->Control(VP9E_SET_SVC_REF_FRAME_CONFIG, &ref_frame_config);
258 if (change_bitrate_ && video->frame() == 200) {
259 duration_ = (last_pts_ + 1) * timebase_;
260 for (int sl = 0; sl < number_spatial_layers_; ++sl) {
261 for (int tl = 0; tl < number_temporal_layers_; ++tl) {
262 const int layer = sl * number_temporal_layers_ + tl;
263 const double file_size_in_kb = bits_total_[layer] / 1000.;
264 file_datarate_[layer] = file_size_in_kb / duration_;
268 CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_,
271 memset(file_datarate_, 0, sizeof(file_datarate_));
272 memset(bits_total_, 0, sizeof(bits_total_));
273 int64_t bits_in_buffer_model_tmp[VPX_MAX_LAYERS];
274 last_pts_ref_ = last_pts_;
275 // Set new target bitarate.
276 cfg_.rc_target_bitrate = cfg_.rc_target_bitrate >> 1;
277 // Buffer level should not reset on dynamic bitrate change.
278 memcpy(bits_in_buffer_model_tmp, bits_in_buffer_model_,
279 sizeof(bits_in_buffer_model_));
280 AssignLayerBitrates();
281 memcpy(bits_in_buffer_model_, bits_in_buffer_model_tmp,
282 sizeof(bits_in_buffer_model_));
284 // Change config to update encoder with new bitrate configuration.
285 encoder->Config(&cfg_);
288 if (dynamic_drop_layer_) {
289 // TODO(jian): Disable AQ Mode for this test for now.
290 encoder->Control(VP9E_SET_AQ_MODE, 0);
291 if (video->frame() == 0) {
292 // Change layer bitrates to set top layers to 0. This will trigger skip
293 // encoding/dropping of top two spatial layers.
294 cfg_.rc_target_bitrate -=
295 (cfg_.layer_target_bitrate[1] + cfg_.layer_target_bitrate[2]);
296 middle_bitrate_ = cfg_.layer_target_bitrate[1];
297 top_bitrate_ = cfg_.layer_target_bitrate[2];
298 cfg_.layer_target_bitrate[1] = 0;
299 cfg_.layer_target_bitrate[2] = 0;
300 encoder->Config(&cfg_);
301 } else if (video->frame() == 50) {
302 // Change layer bitrates to non-zero on two top spatial layers.
303 // This will trigger skip encoding of top two spatial layers.
304 cfg_.layer_target_bitrate[1] = middle_bitrate_;
305 cfg_.layer_target_bitrate[2] = top_bitrate_;
306 cfg_.rc_target_bitrate +=
307 cfg_.layer_target_bitrate[2] + cfg_.layer_target_bitrate[1];
308 encoder->Config(&cfg_);
309 } else if (video->frame() == 100) {
310 // Change layer bitrates to set top layers to 0. This will trigger skip
311 // encoding/dropping of top two spatial layers.
312 cfg_.rc_target_bitrate -=
313 (cfg_.layer_target_bitrate[1] + cfg_.layer_target_bitrate[2]);
314 middle_bitrate_ = cfg_.layer_target_bitrate[1];
315 top_bitrate_ = cfg_.layer_target_bitrate[2];
316 cfg_.layer_target_bitrate[1] = 0;
317 cfg_.layer_target_bitrate[2] = 0;
318 encoder->Config(&cfg_);
319 } else if (video->frame() == 150) {
320 // Change layer bitrate on second layer to non-zero to start
321 // encoding it again.
322 cfg_.layer_target_bitrate[1] = middle_bitrate_;
323 cfg_.rc_target_bitrate += cfg_.layer_target_bitrate[1];
324 encoder->Config(&cfg_);
325 } else if (video->frame() == 200) {
326 // Change layer bitrate on top layer to non-zero to start
327 // encoding it again.
328 cfg_.layer_target_bitrate[2] = top_bitrate_;
329 cfg_.rc_target_bitrate += cfg_.layer_target_bitrate[2];
330 encoder->Config(&cfg_);
334 if (force_key_test_ && force_key_) frame_flags_ = VPX_EFLAG_FORCE_KF;
336 if (insert_layer_sync_) {
337 vpx_svc_spatial_layer_sync_t svc_layer_sync;
338 svc_layer_sync.base_layer_intra_only = 0;
339 for (int i = 0; i < number_spatial_layers_; i++)
340 svc_layer_sync.spatial_layer_sync[i] = 0;
341 if (force_intra_only_frame_) {
342 superframe_has_intra_only_ = 0;
343 if (video->frame() == 0) {
344 svc_layer_sync.base_layer_intra_only = 1;
345 svc_layer_sync.spatial_layer_sync[0] = 1;
346 encoder->Control(VP9E_SET_SVC_SPATIAL_LAYER_SYNC, &svc_layer_sync);
347 superframe_has_intra_only_ = 1;
348 } else if (video->frame() == 100) {
349 svc_layer_sync.base_layer_intra_only = 1;
350 svc_layer_sync.spatial_layer_sync[0] = 1;
351 encoder->Control(VP9E_SET_SVC_SPATIAL_LAYER_SYNC, &svc_layer_sync);
352 superframe_has_intra_only_ = 1;
355 layer_sync_on_base_ = 0;
356 if (video->frame() == 150) {
357 svc_layer_sync.spatial_layer_sync[1] = 1;
358 encoder->Control(VP9E_SET_SVC_SPATIAL_LAYER_SYNC, &svc_layer_sync);
359 } else if (video->frame() == 240) {
360 svc_layer_sync.spatial_layer_sync[2] = 1;
361 encoder->Control(VP9E_SET_SVC_SPATIAL_LAYER_SYNC, &svc_layer_sync);
362 } else if (video->frame() == 320) {
363 svc_layer_sync.spatial_layer_sync[0] = 1;
364 layer_sync_on_base_ = 1;
365 encoder->Control(VP9E_SET_SVC_SPATIAL_LAYER_SYNC, &svc_layer_sync);
370 const vpx_rational_t tb = video->timebase();
371 timebase_ = static_cast<double>(tb.num) / tb.den;
375 vpx_codec_err_t parse_superframe_index(const uint8_t *data, size_t data_sz,
376 uint32_t sizes[8], int *count) {
378 marker = *(data + data_sz - 1);
380 if ((marker & 0xe0) == 0xc0) {
381 const uint32_t frames = (marker & 0x7) + 1;
382 const uint32_t mag = ((marker >> 3) & 0x3) + 1;
383 const size_t index_sz = 2 + mag * frames;
384 // This chunk is marked as having a superframe index but doesn't have
385 // enough data for it, thus it's an invalid superframe index.
386 if (data_sz < index_sz) return VPX_CODEC_CORRUPT_FRAME;
388 const uint8_t marker2 = *(data + data_sz - index_sz);
389 // This chunk is marked as having a superframe index but doesn't have
390 // the matching marker byte at the front of the index therefore it's an
392 if (marker != marker2) return VPX_CODEC_CORRUPT_FRAME;
396 const uint8_t *x = &data[data_sz - index_sz + 1];
397 for (i = 0; i < frames; ++i) {
398 uint32_t this_sz = 0;
400 for (j = 0; j < mag; ++j) this_sz |= (*x++) << (j * 8);
409 virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
410 uint32_t sizes[8] = { 0 };
411 uint32_t sizes_parsed[8] = { 0 };
413 int num_layers_encoded = 0;
414 last_pts_ = pkt->data.frame.pts;
415 const bool key_frame =
416 (pkt->data.frame.flags & VPX_FRAME_IS_KEY) ? true : false;
418 // For test that inserts layer sync frames: requesting a layer_sync on
419 // the base layer must force key frame. So if any key frame occurs after
420 // first superframe it must due to layer sync on base spatial layer.
421 if (superframe_count_ > 0 && insert_layer_sync_ &&
422 !force_intra_only_frame_) {
423 ASSERT_EQ(layer_sync_on_base_, 1);
425 temporal_layer_id_ = 0;
426 superframe_count_ = 0;
428 parse_superframe_index(static_cast<const uint8_t *>(pkt->data.frame.buf),
429 pkt->data.frame.sz, sizes_parsed, &count);
430 // Count may be less than number of spatial layers because of frame drops.
431 for (int sl = 0; sl < number_spatial_layers_; ++sl) {
432 if (pkt->data.frame.spatial_layer_encoded[sl]) {
433 sizes[sl] = sizes_parsed[num_layers_encoded];
434 num_layers_encoded++;
437 // For superframe with Intra-only count will be +1 larger
438 // because of no-show frame.
439 if (force_intra_only_frame_ && superframe_has_intra_only_)
440 ASSERT_EQ(count, num_layers_encoded + 1);
442 ASSERT_EQ(count, num_layers_encoded);
444 // In the constrained frame drop mode, if a given spatial is dropped all
445 // upper layers must be dropped too.
446 if (!layer_framedrop_) {
447 int num_layers_dropped = 0;
448 for (int sl = 0; sl < number_spatial_layers_; ++sl) {
449 if (!pkt->data.frame.spatial_layer_encoded[sl]) {
450 // Check that all upper layers are dropped.
451 num_layers_dropped++;
452 for (int sl2 = sl + 1; sl2 < number_spatial_layers_; ++sl2)
453 ASSERT_EQ(pkt->data.frame.spatial_layer_encoded[sl2], 0);
456 if (num_layers_dropped == number_spatial_layers_ - 1)
461 // Keep track of number of non-reference frames, needed for mismatch check.
462 // Non-reference frames are top spatial and temporal layer frames,
464 if (temporal_layer_id_ == number_temporal_layers_ - 1 &&
465 temporal_layer_id_ > 0 &&
466 pkt->data.frame.spatial_layer_encoded[number_spatial_layers_ - 1])
467 num_nonref_frames_++;
468 for (int sl = 0; sl < number_spatial_layers_; ++sl) {
469 sizes[sl] = sizes[sl] << 3;
470 // Update the total encoded bits per layer.
471 // For temporal layers, update the cumulative encoded bits per layer.
472 for (int tl = temporal_layer_id_; tl < number_temporal_layers_; ++tl) {
473 const int layer = sl * number_temporal_layers_ + tl;
474 bits_total_[layer] += static_cast<int64_t>(sizes[sl]);
475 // Update the per-layer buffer level with the encoded frame size.
476 bits_in_buffer_model_[layer] -= static_cast<int64_t>(sizes[sl]);
477 // There should be no buffer underrun, except on the base
478 // temporal layer, since there may be key frames there.
479 // Fo short key frame spacing, buffer can underrun on individual frames.
480 if (!key_frame && tl > 0 && key_frame_spacing_ < 100) {
481 ASSERT_GE(bits_in_buffer_model_[layer], 0)
482 << "Buffer Underrun at frame " << pkt->data.frame.pts;
486 ASSERT_EQ(pkt->data.frame.width[sl],
487 top_sl_width_ * svc_params_.scaling_factor_num[sl] /
488 svc_params_.scaling_factor_den[sl]);
490 ASSERT_EQ(pkt->data.frame.height[sl],
491 top_sl_height_ * svc_params_.scaling_factor_num[sl] /
492 svc_params_.scaling_factor_den[sl]);
496 virtual void EndPassHook(void) {
497 if (change_bitrate_) last_pts_ = last_pts_ - last_pts_ref_;
498 duration_ = (last_pts_ + 1) * timebase_;
499 for (int sl = 0; sl < number_spatial_layers_; ++sl) {
500 for (int tl = 0; tl < number_temporal_layers_; ++tl) {
501 const int layer = sl * number_temporal_layers_ + tl;
502 const double file_size_in_kb = bits_total_[layer] / 1000.;
503 file_datarate_[layer] = file_size_in_kb / duration_;
508 virtual void MismatchHook(const vpx_image_t *img1, const vpx_image_t *img2) {
509 double mismatch_psnr = compute_psnr(img1, img2);
510 mismatch_psnr_ += mismatch_psnr;
514 unsigned int GetMismatchFrames() { return mismatch_nframes_; }
515 unsigned int GetNonRefFrames() { return num_nonref_frames_; }
517 vpx_codec_pts_t last_pts_;
519 int64_t bits_total_[VPX_MAX_LAYERS];
521 double file_datarate_[VPX_MAX_LAYERS];
522 size_t bits_in_last_frame_;
523 double mismatch_psnr_;
526 int spatial_layer_id_;
527 bool dynamic_drop_layer_;
528 unsigned int top_sl_width_;
529 unsigned int top_sl_height_;
530 vpx_svc_ref_frame_config_t ref_frame_config;
532 bool change_bitrate_;
533 vpx_codec_pts_t last_pts_ref_;
536 int key_frame_spacing_;
537 int layer_framedrop_;
540 int inter_layer_pred_mode_;
541 int insert_layer_sync_;
542 int layer_sync_on_base_;
543 int force_intra_only_frame_;
544 int superframe_has_intra_only_;
545 int use_post_encode_drop_;
547 // Denoiser switched on the fly.
548 bool denoiser_off_on_;
549 // Top layer enabled on the fly.
550 bool denoiser_enable_layers_;
553 virtual void SetConfig(const int num_temporal_layer) {
554 cfg_.rc_end_usage = VPX_CBR;
555 cfg_.g_lag_in_frames = 0;
556 cfg_.g_error_resilient = 1;
557 if (num_temporal_layer == 3) {
558 cfg_.ts_rate_decimator[0] = 4;
559 cfg_.ts_rate_decimator[1] = 2;
560 cfg_.ts_rate_decimator[2] = 1;
561 cfg_.temporal_layering_mode = 3;
562 } else if (num_temporal_layer == 2) {
563 cfg_.ts_rate_decimator[0] = 2;
564 cfg_.ts_rate_decimator[1] = 1;
565 cfg_.temporal_layering_mode = 2;
566 } else if (num_temporal_layer == 1) {
567 cfg_.ts_rate_decimator[0] = 1;
568 cfg_.temporal_layering_mode = 0;
572 unsigned int num_nonref_frames_;
573 unsigned int mismatch_nframes_;
576 // Params: speed setting.
577 class DatarateOnePassCbrSvcSingleBR
578 : public DatarateOnePassCbrSvc,
579 public ::libvpx_test::CodecTestWithParam<int> {
581 DatarateOnePassCbrSvcSingleBR() : DatarateOnePassCbrSvc(GET_PARAM(0)) {
582 memset(&svc_params_, 0, sizeof(svc_params_));
584 virtual ~DatarateOnePassCbrSvcSingleBR() {}
587 virtual void SetUp() {
589 SetMode(::libvpx_test::kRealTime);
590 speed_setting_ = GET_PARAM(1);
595 // Check basic rate targeting for 1 pass CBR SVC: 2 spatial layers and 1
596 // temporal layer, with screen content mode on and same speed setting for all
598 TEST_P(DatarateOnePassCbrSvcSingleBR, OnePassCbrSvc2SL1TLScreenContent1) {
600 cfg_.rc_buf_initial_sz = 500;
601 cfg_.rc_buf_optimal_sz = 500;
602 cfg_.rc_buf_sz = 1000;
603 cfg_.rc_min_quantizer = 0;
604 cfg_.rc_max_quantizer = 63;
606 cfg_.rc_dropframe_thresh = 10;
607 cfg_.kf_max_dist = 9999;
609 ::libvpx_test::Y4mVideoSource video("niklas_1280_720_30.y4m", 0, 60);
610 top_sl_width_ = 1280;
611 top_sl_height_ = 720;
612 cfg_.rc_target_bitrate = 500;
615 AssignLayerBitrates();
616 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
617 CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.78,
619 #if CONFIG_VP9_DECODER
620 // The non-reference frames are expected to be mismatched frames as the
621 // encoder will avoid loopfilter on these frames.
622 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
626 // Check basic rate targeting for 1 pass CBR SVC: 3 spatial layers and
627 // 3 temporal layers, with force key frame after frame drop
628 TEST_P(DatarateOnePassCbrSvcSingleBR, OnePassCbrSvc3SL3TLForceKey) {
630 cfg_.rc_buf_initial_sz = 500;
631 cfg_.rc_buf_optimal_sz = 500;
632 cfg_.rc_buf_sz = 1000;
633 cfg_.rc_min_quantizer = 0;
634 cfg_.rc_max_quantizer = 63;
636 cfg_.rc_dropframe_thresh = 30;
637 cfg_.kf_max_dist = 9999;
638 ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
641 top_sl_height_ = 480;
642 cfg_.rc_target_bitrate = 100;
644 AssignLayerBitrates();
645 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
646 CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.78,
648 #if CONFIG_VP9_DECODER
649 // The non-reference frames are expected to be mismatched frames as the
650 // encoder will avoid loopfilter on these frames.
651 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
655 // Check basic rate targeting for 1 pass CBR SVC: 3 spatial layers and
656 // 2 temporal layers, with a change on the fly from the fixed SVC pattern to one
657 // generate via SVC_SET_REF_FRAME_CONFIG. The new pattern also disables
658 // inter-layer prediction.
659 TEST_P(DatarateOnePassCbrSvcSingleBR, OnePassCbrSvc3SL2TLDynamicPatternChange) {
661 cfg_.rc_buf_initial_sz = 500;
662 cfg_.rc_buf_optimal_sz = 500;
663 cfg_.rc_buf_sz = 1000;
664 cfg_.rc_min_quantizer = 0;
665 cfg_.rc_max_quantizer = 63;
667 cfg_.rc_dropframe_thresh = 30;
668 cfg_.kf_max_dist = 9999;
669 // Change SVC pattern on the fly.
671 ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
674 top_sl_height_ = 480;
675 cfg_.rc_target_bitrate = 800;
677 AssignLayerBitrates();
678 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
679 CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.78,
681 #if CONFIG_VP9_DECODER
682 // The non-reference frames are expected to be mismatched frames as the
683 // encoder will avoid loopfilter on these frames.
684 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
688 // Check basic rate targeting for 1 pass CBR SVC with 3 spatial and 3 temporal
689 // layers, for inter_layer_pred=OffKey (K-SVC) and on the fly switching
690 // of denoiser from off to on (on at frame = 100). Key frame period is set to
691 // 1000 so denoise is enabled on non-key.
692 TEST_P(DatarateOnePassCbrSvcSingleBR,
693 OnePassCbrSvc3SL3TL_DenoiserOffOnFixedLayers) {
695 cfg_.rc_buf_initial_sz = 500;
696 cfg_.rc_buf_optimal_sz = 500;
697 cfg_.rc_buf_sz = 1000;
698 cfg_.rc_min_quantizer = 0;
699 cfg_.rc_max_quantizer = 63;
701 cfg_.rc_dropframe_thresh = 30;
702 cfg_.kf_max_dist = 1000;
703 ::libvpx_test::I420VideoSource video("desktop_office1.1280_720-020.yuv", 1280,
705 top_sl_width_ = 1280;
706 top_sl_height_ = 720;
707 cfg_.rc_target_bitrate = 1000;
709 denoiser_off_on_ = true;
710 denoiser_enable_layers_ = false;
711 AssignLayerBitrates();
712 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
713 // Don't check rate targeting on two top spatial layer since they will be
714 // skipped for part of the sequence.
715 CheckLayerRateTargeting(number_spatial_layers_ - 2, number_temporal_layers_,
717 #if CONFIG_VP9_DECODER
718 // The non-reference frames are expected to be mismatched frames as the
719 // encoder will avoid loopfilter on these frames.
720 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
724 // Check basic rate targeting for 1 pass CBR SVC with 3 spatial and 3 temporal
725 // layers, for inter_layer_pred=OffKey (K-SVC) and on the fly switching
726 // of denoiser from off to on, for dynamic layers. Start at 2 spatial layers
727 // and enable 3rd spatial layer at frame = 100. Use periodic key frame with
728 // period 100 so enabling of spatial layer occurs at key frame. Enable denoiser
729 // at frame > 100, after the key frame sync.
730 TEST_P(DatarateOnePassCbrSvcSingleBR,
731 OnePassCbrSvc3SL3TL_DenoiserOffOnEnableLayers) {
733 cfg_.rc_buf_initial_sz = 500;
734 cfg_.rc_buf_optimal_sz = 500;
735 cfg_.rc_buf_sz = 1000;
736 cfg_.rc_min_quantizer = 0;
737 cfg_.rc_max_quantizer = 63;
739 cfg_.rc_dropframe_thresh = 0;
740 cfg_.kf_max_dist = 100;
741 ::libvpx_test::I420VideoSource video("desktop_office1.1280_720-020.yuv", 1280,
743 top_sl_width_ = 1280;
744 top_sl_height_ = 720;
745 cfg_.rc_target_bitrate = 1000;
747 denoiser_off_on_ = true;
748 denoiser_enable_layers_ = true;
749 AssignLayerBitrates();
750 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
751 // Don't check rate targeting on two top spatial layer since they will be
752 // skipped for part of the sequence.
753 CheckLayerRateTargeting(number_spatial_layers_ - 2, number_temporal_layers_,
755 #if CONFIG_VP9_DECODER
756 // The non-reference frames are expected to be mismatched frames as the
757 // encoder will avoid loopfilter on these frames.
758 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
762 // Check basic rate targeting for 1 pass CBR SVC with 3 spatial layers and on
763 // the fly switching to 1 and then 2 and back to 3 spatial layers. This switch
764 // is done by setting spatial layer bitrates to 0, and then back to non-zero,
765 // during the sequence.
766 TEST_P(DatarateOnePassCbrSvcSingleBR, OnePassCbrSvc3SL_DisableEnableLayers) {
768 cfg_.rc_buf_initial_sz = 500;
769 cfg_.rc_buf_optimal_sz = 500;
770 cfg_.rc_buf_sz = 1000;
771 cfg_.rc_min_quantizer = 0;
772 cfg_.rc_max_quantizer = 63;
774 cfg_.temporal_layering_mode = 0;
775 cfg_.rc_dropframe_thresh = 30;
776 cfg_.kf_max_dist = 9999;
777 ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
780 top_sl_height_ = 480;
781 cfg_.rc_target_bitrate = 800;
783 dynamic_drop_layer_ = true;
784 AssignLayerBitrates();
785 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
786 // Don't check rate targeting on two top spatial layer since they will be
787 // skipped for part of the sequence.
788 CheckLayerRateTargeting(number_spatial_layers_ - 2, number_temporal_layers_,
790 #if CONFIG_VP9_DECODER
791 // The non-reference frames are expected to be mismatched frames as the
792 // encoder will avoid loopfilter on these frames.
793 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
797 // Run SVC encoder for 1 temporal layer, 2 spatial layers, with spatial
799 TEST_P(DatarateOnePassCbrSvcSingleBR, OnePassCbrSvc2SL1TL5x5MultipleRuns) {
800 cfg_.rc_buf_initial_sz = 500;
801 cfg_.rc_buf_optimal_sz = 500;
802 cfg_.rc_buf_sz = 1000;
803 cfg_.rc_min_quantizer = 0;
804 cfg_.rc_max_quantizer = 63;
805 cfg_.rc_end_usage = VPX_CBR;
806 cfg_.g_lag_in_frames = 0;
807 cfg_.ss_number_layers = 2;
808 cfg_.ts_number_layers = 1;
809 cfg_.ts_rate_decimator[0] = 1;
810 cfg_.g_error_resilient = 1;
812 cfg_.temporal_layering_mode = 0;
813 svc_params_.scaling_factor_num[0] = 256;
814 svc_params_.scaling_factor_den[0] = 1280;
815 svc_params_.scaling_factor_num[1] = 1280;
816 svc_params_.scaling_factor_den[1] = 1280;
817 cfg_.rc_dropframe_thresh = 10;
818 cfg_.kf_max_dist = 999999;
819 cfg_.kf_min_dist = 0;
820 cfg_.ss_target_bitrate[0] = 300;
821 cfg_.ss_target_bitrate[1] = 1400;
822 cfg_.layer_target_bitrate[0] = 300;
823 cfg_.layer_target_bitrate[1] = 1400;
824 cfg_.rc_target_bitrate = 1700;
825 number_spatial_layers_ = cfg_.ss_number_layers;
826 number_temporal_layers_ = cfg_.ts_number_layers;
828 layer_target_avg_bandwidth_[0] = cfg_.layer_target_bitrate[0] * 1000 / 30;
829 bits_in_buffer_model_[0] =
830 cfg_.layer_target_bitrate[0] * cfg_.rc_buf_initial_sz;
831 layer_target_avg_bandwidth_[1] = cfg_.layer_target_bitrate[1] * 1000 / 30;
832 bits_in_buffer_model_[1] =
833 cfg_.layer_target_bitrate[1] * cfg_.rc_buf_initial_sz;
834 ::libvpx_test::Y4mVideoSource video("niklas_1280_720_30.y4m", 0, 60);
835 top_sl_width_ = 1280;
836 top_sl_height_ = 720;
837 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
838 CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.78,
840 #if CONFIG_VP9_DECODER
841 // The non-reference frames are expected to be mismatched frames as the
842 // encoder will avoid loopfilter on these frames.
843 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
847 // Params: speed setting and index for bitrate array.
848 class DatarateOnePassCbrSvcMultiBR
849 : public DatarateOnePassCbrSvc,
850 public ::libvpx_test::CodecTestWith2Params<int, int> {
852 DatarateOnePassCbrSvcMultiBR() : DatarateOnePassCbrSvc(GET_PARAM(0)) {
853 memset(&svc_params_, 0, sizeof(svc_params_));
855 virtual ~DatarateOnePassCbrSvcMultiBR() {}
858 virtual void SetUp() {
860 SetMode(::libvpx_test::kRealTime);
861 speed_setting_ = GET_PARAM(1);
866 // Check basic rate targeting for 1 pass CBR SVC: 2 spatial layers and
867 // 3 temporal layers. Run CIF clip with 1 thread.
868 TEST_P(DatarateOnePassCbrSvcMultiBR, OnePassCbrSvc2SL3TL) {
870 cfg_.rc_buf_initial_sz = 500;
871 cfg_.rc_buf_optimal_sz = 500;
872 cfg_.rc_buf_sz = 1000;
873 cfg_.rc_min_quantizer = 0;
874 cfg_.rc_max_quantizer = 63;
876 cfg_.rc_dropframe_thresh = 30;
877 cfg_.kf_max_dist = 9999;
878 ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
881 top_sl_height_ = 480;
882 const int bitrates[3] = { 200, 400, 600 };
883 // TODO(marpan): Check that effective_datarate for each layer hits the
884 // layer target_bitrate.
885 cfg_.rc_target_bitrate = bitrates[GET_PARAM(2)];
887 AssignLayerBitrates();
888 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
889 CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.75,
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(GetNonRefFrames(), GetMismatchFrames());
898 // Params: speed setting, layer framedrop control and index for bitrate array.
899 class DatarateOnePassCbrSvcFrameDropMultiBR
900 : public DatarateOnePassCbrSvc,
901 public ::libvpx_test::CodecTestWith3Params<int, int, int> {
903 DatarateOnePassCbrSvcFrameDropMultiBR()
904 : DatarateOnePassCbrSvc(GET_PARAM(0)) {
905 memset(&svc_params_, 0, sizeof(svc_params_));
907 virtual ~DatarateOnePassCbrSvcFrameDropMultiBR() {}
910 virtual void SetUp() {
912 SetMode(::libvpx_test::kRealTime);
913 speed_setting_ = GET_PARAM(1);
918 // Check basic rate targeting for 1 pass CBR SVC: 2 spatial layers and
919 // 3 temporal layers. Run HD clip with 4 threads.
920 TEST_P(DatarateOnePassCbrSvcFrameDropMultiBR, OnePassCbrSvc2SL3TL4Threads) {
922 cfg_.rc_buf_initial_sz = 500;
923 cfg_.rc_buf_optimal_sz = 500;
924 cfg_.rc_buf_sz = 1000;
925 cfg_.rc_min_quantizer = 0;
926 cfg_.rc_max_quantizer = 63;
928 cfg_.rc_dropframe_thresh = 30;
929 cfg_.kf_max_dist = 9999;
930 ::libvpx_test::Y4mVideoSource video("niklas_1280_720_30.y4m", 0, 60);
931 top_sl_width_ = 1280;
932 top_sl_height_ = 720;
933 layer_framedrop_ = 0;
934 const int bitrates[3] = { 200, 400, 600 };
935 cfg_.rc_target_bitrate = bitrates[GET_PARAM(3)];
937 layer_framedrop_ = GET_PARAM(2);
938 AssignLayerBitrates();
939 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
940 CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.64,
942 #if CONFIG_VP9_DECODER
943 // The non-reference frames are expected to be mismatched frames as the
944 // encoder will avoid loopfilter on these frames.
945 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
949 // Check basic rate targeting for 1 pass CBR SVC: 3 spatial layers and
950 // 3 temporal layers. Run HD clip with 4 threads.
951 TEST_P(DatarateOnePassCbrSvcFrameDropMultiBR, OnePassCbrSvc3SL3TL4Threads) {
953 cfg_.rc_buf_initial_sz = 500;
954 cfg_.rc_buf_optimal_sz = 500;
955 cfg_.rc_buf_sz = 1000;
956 cfg_.rc_min_quantizer = 0;
957 cfg_.rc_max_quantizer = 63;
959 cfg_.rc_dropframe_thresh = 30;
960 cfg_.kf_max_dist = 9999;
961 ::libvpx_test::Y4mVideoSource video("niklas_1280_720_30.y4m", 0, 60);
962 top_sl_width_ = 1280;
963 top_sl_height_ = 720;
964 layer_framedrop_ = 0;
965 const int bitrates[3] = { 200, 400, 600 };
966 cfg_.rc_target_bitrate = bitrates[GET_PARAM(3)];
968 layer_framedrop_ = GET_PARAM(2);
969 AssignLayerBitrates();
970 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
971 CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.58,
973 #if CONFIG_VP9_DECODER
974 // The non-reference frames are expected to be mismatched frames as the
975 // encoder will avoid loopfilter on these frames.
976 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
980 // Params: speed setting, inter-layer prediction mode.
981 class DatarateOnePassCbrSvcInterLayerPredSingleBR
982 : public DatarateOnePassCbrSvc,
983 public ::libvpx_test::CodecTestWith2Params<int, int> {
985 DatarateOnePassCbrSvcInterLayerPredSingleBR()
986 : DatarateOnePassCbrSvc(GET_PARAM(0)) {
987 memset(&svc_params_, 0, sizeof(svc_params_));
989 virtual ~DatarateOnePassCbrSvcInterLayerPredSingleBR() {}
992 virtual void SetUp() {
994 SetMode(::libvpx_test::kRealTime);
995 speed_setting_ = GET_PARAM(1);
996 inter_layer_pred_mode_ = GET_PARAM(2);
1001 // Check basic rate targeting with different inter-layer prediction modes for 1
1002 // pass CBR SVC: 3 spatial layers and 3 temporal layers. Run CIF clip with 1
1004 TEST_P(DatarateOnePassCbrSvcInterLayerPredSingleBR, OnePassCbrSvc3SL3TL) {
1005 // Disable test for inter-layer pred off for now since simulcast_mode fails.
1006 if (inter_layer_pred_mode_ == INTER_LAYER_PRED_OFF) return;
1008 cfg_.rc_buf_initial_sz = 500;
1009 cfg_.rc_buf_optimal_sz = 500;
1010 cfg_.rc_buf_sz = 1000;
1011 cfg_.rc_min_quantizer = 0;
1012 cfg_.rc_max_quantizer = 63;
1014 cfg_.temporal_layering_mode = 3;
1015 cfg_.rc_dropframe_thresh = 30;
1016 cfg_.kf_max_dist = 9999;
1017 ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
1019 top_sl_width_ = 640;
1020 top_sl_height_ = 480;
1021 cfg_.rc_target_bitrate = 800;
1023 AssignLayerBitrates();
1024 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
1025 CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.78,
1027 #if CONFIG_VP9_DECODER
1028 // The non-reference frames are expected to be mismatched frames as the
1029 // encoder will avoid loopfilter on these frames.
1030 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
1034 // Check rate targeting with different inter-layer prediction modes for 1 pass
1035 // CBR SVC: 3 spatial layers and 3 temporal layers, changing the target bitrate
1036 // at the middle of encoding.
1037 TEST_P(DatarateOnePassCbrSvcSingleBR, OnePassCbrSvc3SL3TLDynamicBitrateChange) {
1039 cfg_.rc_buf_initial_sz = 500;
1040 cfg_.rc_buf_optimal_sz = 500;
1041 cfg_.rc_buf_sz = 1000;
1042 cfg_.rc_min_quantizer = 0;
1043 cfg_.rc_max_quantizer = 63;
1045 cfg_.rc_dropframe_thresh = 30;
1046 cfg_.kf_max_dist = 9999;
1047 ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
1049 top_sl_width_ = 640;
1050 top_sl_height_ = 480;
1051 cfg_.rc_target_bitrate = 800;
1053 change_bitrate_ = true;
1054 AssignLayerBitrates();
1055 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
1056 CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.78,
1058 #if CONFIG_VP9_DECODER
1059 // The non-reference frames are expected to be mismatched frames as the
1060 // encoder will avoid loopfilter on these frames.
1061 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
1065 #if CONFIG_VP9_TEMPORAL_DENOISING
1066 // Params: speed setting, noise sensitivity, index for bitrate array and inter
1068 class DatarateOnePassCbrSvcDenoiser
1069 : public DatarateOnePassCbrSvc,
1070 public ::libvpx_test::CodecTestWith4Params<int, int, int, int> {
1072 DatarateOnePassCbrSvcDenoiser() : DatarateOnePassCbrSvc(GET_PARAM(0)) {
1073 memset(&svc_params_, 0, sizeof(svc_params_));
1075 virtual ~DatarateOnePassCbrSvcDenoiser() {}
1078 virtual void SetUp() {
1080 SetMode(::libvpx_test::kRealTime);
1081 speed_setting_ = GET_PARAM(1);
1082 inter_layer_pred_mode_ = GET_PARAM(3);
1087 // Check basic rate targeting for 1 pass CBR SVC with denoising.
1088 // 2 spatial layers and 3 temporal layer. Run HD clip with 2 threads.
1089 TEST_P(DatarateOnePassCbrSvcDenoiser, OnePassCbrSvc2SL3TLDenoiserOn) {
1091 cfg_.rc_buf_initial_sz = 500;
1092 cfg_.rc_buf_optimal_sz = 500;
1093 cfg_.rc_buf_sz = 1000;
1094 cfg_.rc_min_quantizer = 0;
1095 cfg_.rc_max_quantizer = 63;
1097 cfg_.rc_dropframe_thresh = 30;
1098 cfg_.kf_max_dist = 9999;
1099 number_spatial_layers_ = cfg_.ss_number_layers;
1100 number_temporal_layers_ = cfg_.ts_number_layers;
1101 ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
1103 top_sl_width_ = 640;
1104 top_sl_height_ = 480;
1105 const int bitrates[3] = { 600, 800, 1000 };
1106 // TODO(marpan): Check that effective_datarate for each layer hits the
1107 // layer target_bitrate.
1108 // For SVC, noise_sen = 1 means denoising only the top spatial layer
1109 // noise_sen = 2 means denoising the two top spatial layers.
1110 cfg_.rc_target_bitrate = bitrates[GET_PARAM(3)];
1112 denoiser_on_ = GET_PARAM(2);
1113 AssignLayerBitrates();
1114 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
1115 CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.78,
1117 #if CONFIG_VP9_DECODER
1118 // The non-reference frames are expected to be mismatched frames as the
1119 // encoder will avoid loopfilter on these frames.
1120 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
1125 // Params: speed setting, key frame dist.
1126 class DatarateOnePassCbrSvcSmallKF
1127 : public DatarateOnePassCbrSvc,
1128 public ::libvpx_test::CodecTestWith2Params<int, int> {
1130 DatarateOnePassCbrSvcSmallKF() : DatarateOnePassCbrSvc(GET_PARAM(0)) {
1131 memset(&svc_params_, 0, sizeof(svc_params_));
1133 virtual ~DatarateOnePassCbrSvcSmallKF() {}
1136 virtual void SetUp() {
1138 SetMode(::libvpx_test::kRealTime);
1139 speed_setting_ = GET_PARAM(1);
1144 // Check basic rate targeting for 1 pass CBR SVC: 3 spatial layers and 3
1145 // temporal layers. Run CIF clip with 1 thread, and few short key frame periods.
1146 TEST_P(DatarateOnePassCbrSvcSmallKF, OnePassCbrSvc3SL3TLSmallKf) {
1148 cfg_.rc_buf_initial_sz = 500;
1149 cfg_.rc_buf_optimal_sz = 500;
1150 cfg_.rc_buf_sz = 1000;
1151 cfg_.rc_min_quantizer = 0;
1152 cfg_.rc_max_quantizer = 63;
1154 cfg_.rc_dropframe_thresh = 10;
1155 cfg_.rc_target_bitrate = 800;
1156 ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
1158 top_sl_width_ = 640;
1159 top_sl_height_ = 480;
1160 // For this 3 temporal layer case, pattern repeats every 4 frames, so choose
1161 // 4 key neighboring key frame periods (so key frame will land on 0-2-1-2).
1162 const int kf_dist = GET_PARAM(2);
1163 cfg_.kf_max_dist = kf_dist;
1164 key_frame_spacing_ = kf_dist;
1166 AssignLayerBitrates();
1167 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
1168 // TODO(jianj): webm:1554
1169 CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.70,
1171 #if CONFIG_VP9_DECODER
1172 // The non-reference frames are expected to be mismatched frames as the
1173 // encoder will avoid loopfilter on these frames.
1174 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
1178 // Check basic rate targeting for 1 pass CBR SVC: 2 spatial layers and 3
1179 // temporal layers. Run CIF clip with 1 thread, and few short key frame periods.
1180 TEST_P(DatarateOnePassCbrSvcSmallKF, OnePassCbrSvc2SL3TLSmallKf) {
1182 cfg_.rc_buf_initial_sz = 500;
1183 cfg_.rc_buf_optimal_sz = 500;
1184 cfg_.rc_buf_sz = 1000;
1185 cfg_.rc_min_quantizer = 0;
1186 cfg_.rc_max_quantizer = 63;
1188 cfg_.rc_dropframe_thresh = 10;
1189 cfg_.rc_target_bitrate = 400;
1190 ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
1192 top_sl_width_ = 640;
1193 top_sl_height_ = 480;
1194 // For this 3 temporal layer case, pattern repeats every 4 frames, so choose
1195 // 4 key neighboring key frame periods (so key frame will land on 0-2-1-2).
1196 const int kf_dist = GET_PARAM(2) + 32;
1197 cfg_.kf_max_dist = kf_dist;
1198 key_frame_spacing_ = kf_dist;
1200 AssignLayerBitrates();
1201 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
1202 CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.78,
1204 #if CONFIG_VP9_DECODER
1205 // The non-reference frames are expected to be mismatched frames as the
1206 // encoder will avoid loopfilter on these frames.
1207 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
1211 // Check basic rate targeting for 1 pass CBR SVC: 3 spatial layers and 3
1212 // temporal layers. Run VGA clip with 1 thread, and place layer sync frames:
1213 // one at middle layer first, then another one for top layer, and another
1214 // insert for base spatial layer (which forces key frame).
1215 TEST_P(DatarateOnePassCbrSvcSingleBR, OnePassCbrSvc3SL3TLSyncFrames) {
1217 cfg_.rc_buf_initial_sz = 500;
1218 cfg_.rc_buf_optimal_sz = 500;
1219 cfg_.rc_buf_sz = 1000;
1220 cfg_.rc_min_quantizer = 0;
1221 cfg_.rc_max_quantizer = 63;
1223 cfg_.kf_max_dist = 9999;
1224 cfg_.rc_dropframe_thresh = 10;
1225 cfg_.rc_target_bitrate = 400;
1226 ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
1228 top_sl_width_ = 640;
1229 top_sl_height_ = 480;
1231 insert_layer_sync_ = 1;
1232 AssignLayerBitrates();
1233 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
1234 CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.78,
1236 #if CONFIG_VP9_DECODER
1237 // The non-reference frames are expected to be mismatched frames as the
1238 // encoder will avoid loopfilter on these frames.
1239 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
1243 // Run SVC encoder for 3 spatial layers, 1 temporal layer, with
1244 // intra-only frame as sync frame on base spatial layer.
1245 // Intra_only is inserted at start and in middle of sequence.
1246 TEST_P(DatarateOnePassCbrSvcSingleBR, OnePassCbrSvc3SL1TLSyncWithIntraOnly) {
1248 cfg_.rc_buf_initial_sz = 500;
1249 cfg_.rc_buf_optimal_sz = 500;
1250 cfg_.rc_buf_sz = 1000;
1251 cfg_.rc_min_quantizer = 0;
1252 cfg_.rc_max_quantizer = 63;
1254 cfg_.rc_dropframe_thresh = 30;
1255 cfg_.kf_max_dist = 9999;
1256 cfg_.rc_target_bitrate = 400;
1257 ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
1259 top_sl_width_ = 640;
1260 top_sl_height_ = 480;
1262 insert_layer_sync_ = 1;
1263 // Use intra_only frame for sync on base layer.
1264 force_intra_only_frame_ = 1;
1265 AssignLayerBitrates();
1266 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
1267 CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.73,
1269 #if CONFIG_VP9_DECODER
1270 // The non-reference frames are expected to be mismatched frames as the
1271 // encoder will avoid loopfilter on these frames.
1272 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
1276 // Run SVC encoder for 2 quality layers (same resolution different,
1277 // bitrates), 1 temporal layer, with screen content mode.
1278 TEST_P(DatarateOnePassCbrSvcSingleBR, OnePassCbrSvc2QL1TLScreen) {
1279 cfg_.rc_buf_initial_sz = 500;
1280 cfg_.rc_buf_optimal_sz = 500;
1281 cfg_.rc_buf_sz = 1000;
1282 cfg_.rc_min_quantizer = 0;
1283 cfg_.rc_max_quantizer = 56;
1284 cfg_.rc_end_usage = VPX_CBR;
1285 cfg_.g_lag_in_frames = 0;
1286 cfg_.ss_number_layers = 2;
1287 cfg_.ts_number_layers = 1;
1288 cfg_.ts_rate_decimator[0] = 1;
1289 cfg_.temporal_layering_mode = 0;
1290 cfg_.g_error_resilient = 1;
1292 svc_params_.scaling_factor_num[0] = 1;
1293 svc_params_.scaling_factor_den[0] = 1;
1294 svc_params_.scaling_factor_num[1] = 1;
1295 svc_params_.scaling_factor_den[1] = 1;
1296 cfg_.rc_dropframe_thresh = 30;
1297 cfg_.kf_max_dist = 9999;
1298 number_spatial_layers_ = cfg_.ss_number_layers;
1299 number_temporal_layers_ = cfg_.ts_number_layers;
1300 ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
1302 top_sl_width_ = 640;
1303 top_sl_height_ = 480;
1306 // Set the layer bitrates, for 2 spatial layers, 1 temporal.
1307 cfg_.rc_target_bitrate = 400;
1308 cfg_.ss_target_bitrate[0] = 100;
1309 cfg_.ss_target_bitrate[1] = 300;
1310 cfg_.layer_target_bitrate[0] = 100;
1311 cfg_.layer_target_bitrate[1] = 300;
1312 for (int sl = 0; sl < 2; ++sl) {
1313 float layer_framerate = 30.0;
1314 layer_target_avg_bandwidth_[sl] = static_cast<int>(
1315 cfg_.layer_target_bitrate[sl] * 1000.0 / layer_framerate);
1316 bits_in_buffer_model_[sl] =
1317 cfg_.layer_target_bitrate[sl] * cfg_.rc_buf_initial_sz;
1319 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
1320 CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.73,
1322 #if CONFIG_VP9_DECODER
1323 // The non-reference frames are expected to be mismatched frames as the
1324 // encoder will avoid loopfilter on these frames.
1325 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
1329 // Params: speed setting.
1330 class DatarateOnePassCbrSvcPostencodeDrop
1331 : public DatarateOnePassCbrSvc,
1332 public ::libvpx_test::CodecTestWithParam<int> {
1334 DatarateOnePassCbrSvcPostencodeDrop() : DatarateOnePassCbrSvc(GET_PARAM(0)) {
1335 memset(&svc_params_, 0, sizeof(svc_params_));
1337 virtual ~DatarateOnePassCbrSvcPostencodeDrop() {}
1340 virtual void SetUp() {
1342 SetMode(::libvpx_test::kRealTime);
1343 speed_setting_ = GET_PARAM(1);
1348 // Run SVC encoder for 2 quality layers (same resolution different,
1349 // bitrates), 1 temporal layer, with screen content mode.
1350 TEST_P(DatarateOnePassCbrSvcPostencodeDrop, OnePassCbrSvc2QL1TLScreen) {
1351 cfg_.rc_buf_initial_sz = 200;
1352 cfg_.rc_buf_optimal_sz = 200;
1353 cfg_.rc_buf_sz = 400;
1354 cfg_.rc_min_quantizer = 0;
1355 cfg_.rc_max_quantizer = 52;
1356 cfg_.rc_end_usage = VPX_CBR;
1357 cfg_.g_lag_in_frames = 0;
1358 cfg_.ss_number_layers = 2;
1359 cfg_.ts_number_layers = 1;
1360 cfg_.ts_rate_decimator[0] = 1;
1361 cfg_.temporal_layering_mode = 0;
1362 cfg_.g_error_resilient = 1;
1364 svc_params_.scaling_factor_num[0] = 1;
1365 svc_params_.scaling_factor_den[0] = 1;
1366 svc_params_.scaling_factor_num[1] = 1;
1367 svc_params_.scaling_factor_den[1] = 1;
1368 cfg_.rc_dropframe_thresh = 30;
1369 cfg_.kf_max_dist = 9999;
1370 number_spatial_layers_ = cfg_.ss_number_layers;
1371 number_temporal_layers_ = cfg_.ts_number_layers;
1372 ::libvpx_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
1374 top_sl_width_ = 352;
1375 top_sl_height_ = 288;
1377 base_speed_setting_ = speed_setting_;
1379 use_post_encode_drop_ = 1;
1380 // Set the layer bitrates, for 2 spatial layers, 1 temporal.
1381 cfg_.rc_target_bitrate = 400;
1382 cfg_.ss_target_bitrate[0] = 100;
1383 cfg_.ss_target_bitrate[1] = 300;
1384 cfg_.layer_target_bitrate[0] = 100;
1385 cfg_.layer_target_bitrate[1] = 300;
1386 for (int sl = 0; sl < 2; ++sl) {
1387 float layer_framerate = 30.0;
1388 layer_target_avg_bandwidth_[sl] = static_cast<int>(
1389 cfg_.layer_target_bitrate[sl] * 1000.0 / layer_framerate);
1390 bits_in_buffer_model_[sl] =
1391 cfg_.layer_target_bitrate[sl] * cfg_.rc_buf_initial_sz;
1393 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
1394 CheckLayerRateTargeting(number_spatial_layers_, number_temporal_layers_, 0.73,
1396 #if CONFIG_VP9_DECODER
1397 // The non-reference frames are expected to be mismatched frames as the
1398 // encoder will avoid loopfilter on these frames.
1399 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
1403 VP9_INSTANTIATE_TEST_CASE(DatarateOnePassCbrSvcSingleBR,
1404 ::testing::Range(5, 10));
1406 VP9_INSTANTIATE_TEST_CASE(DatarateOnePassCbrSvcPostencodeDrop,
1407 ::testing::Range(5, 6));
1409 VP9_INSTANTIATE_TEST_CASE(DatarateOnePassCbrSvcInterLayerPredSingleBR,
1410 ::testing::Range(5, 10), ::testing::Range(0, 3));
1412 VP9_INSTANTIATE_TEST_CASE(DatarateOnePassCbrSvcMultiBR, ::testing::Range(5, 10),
1413 ::testing::Range(0, 3));
1415 VP9_INSTANTIATE_TEST_CASE(DatarateOnePassCbrSvcFrameDropMultiBR,
1416 ::testing::Range(5, 10), ::testing::Range(0, 2),
1417 ::testing::Range(0, 3));
1419 #if CONFIG_VP9_TEMPORAL_DENOISING
1420 VP9_INSTANTIATE_TEST_CASE(DatarateOnePassCbrSvcDenoiser,
1421 ::testing::Range(5, 10), ::testing::Range(1, 3),
1422 ::testing::Range(0, 3), ::testing::Range(0, 4));
1425 VP9_INSTANTIATE_TEST_CASE(DatarateOnePassCbrSvcSmallKF, ::testing::Range(5, 10),
1426 ::testing::Range(32, 36));
1428 } // namespace svc_test