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