2 * Copyright (c) 2018 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 ScalePartitionOnePassCbrSvc
39 : public OnePassCbrSvc,
40 public ::testing::TestWithParam<const ::libvpx_test::CodecFactory *> {
42 ScalePartitionOnePassCbrSvc()
43 : OnePassCbrSvc(GetParam()), mismatch_nframes_(0), num_nonref_frames_(0) {
44 SetMode(::libvpx_test::kRealTime);
48 virtual ~ScalePartitionOnePassCbrSvc() {}
50 virtual void SetUp() {
55 virtual void PreEncodeFrameHook(::libvpx_test::VideoSource *video,
56 ::libvpx_test::Encoder *encoder) {
57 PreEncodeFrameHookSetup(video, encoder);
60 virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
61 // Keep track of number of non-reference frames, needed for mismatch check.
62 // Non-reference frames are top spatial and temporal layer frames,
64 if (temporal_layer_id_ == number_temporal_layers_ - 1 &&
65 temporal_layer_id_ > 0 &&
66 pkt->data.frame.spatial_layer_encoded[number_spatial_layers_ - 1])
70 virtual void MismatchHook(const vpx_image_t * /*img1*/,
71 const vpx_image_t * /*img2*/) {
75 virtual void SetConfig(const int /*num_temporal_layer*/) {}
77 unsigned int GetMismatchFrames() const { return mismatch_nframes_; }
78 unsigned int GetNonRefFrames() const { return num_nonref_frames_; }
81 unsigned int mismatch_nframes_;
82 unsigned int num_nonref_frames_;
85 TEST_P(ScalePartitionOnePassCbrSvc, OnePassCbrSvc3SL3TL1080P) {
87 cfg_.rc_buf_initial_sz = 500;
88 cfg_.rc_buf_optimal_sz = 500;
89 cfg_.rc_buf_sz = 1000;
90 cfg_.rc_min_quantizer = 0;
91 cfg_.rc_max_quantizer = 63;
93 cfg_.rc_dropframe_thresh = 10;
94 cfg_.rc_target_bitrate = 800;
95 cfg_.kf_max_dist = 9999;
96 cfg_.rc_end_usage = VPX_CBR;
97 cfg_.g_lag_in_frames = 0;
98 cfg_.g_error_resilient = 1;
99 cfg_.ts_rate_decimator[0] = 4;
100 cfg_.ts_rate_decimator[1] = 2;
101 cfg_.ts_rate_decimator[2] = 1;
102 cfg_.temporal_layering_mode = 3;
103 ::libvpx_test::I420VideoSource video(
104 "slides_code_term_web_plot.1920_1080.yuv", 1920, 1080, 30, 1, 0, 100);
105 // For this 3 temporal layer case, pattern repeats every 4 frames, so choose
106 // 4 key neighboring key frame periods (so key frame will land on 0-2-1-2).
107 AssignLayerBitrates();
108 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
109 #if CONFIG_VP9_DECODER
110 // The non-reference frames are expected to be mismatched frames as the
111 // encoder will avoid loopfilter on these frames.
112 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
116 // Params: Inter layer prediction modes.
117 class SyncFrameOnePassCbrSvc : public OnePassCbrSvc,
118 public ::libvpx_test::CodecTestWithParam<int> {
120 SyncFrameOnePassCbrSvc()
121 : OnePassCbrSvc(GET_PARAM(0)), current_video_frame_(0),
122 frame_to_start_decode_(0), frame_to_sync_(0),
123 inter_layer_pred_mode_(GET_PARAM(1)), decode_to_layer_before_sync_(-1),
124 decode_to_layer_after_sync_(-1), denoiser_on_(0),
125 intra_only_test_(false), loopfilter_off_(0), mismatch_nframes_(0),
126 num_nonref_frames_(0) {
127 SetMode(::libvpx_test::kRealTime);
128 memset(&svc_layer_sync_, 0, sizeof(svc_layer_sync_));
132 virtual ~SyncFrameOnePassCbrSvc() {}
134 virtual void SetUp() {
139 virtual bool DoDecode() const {
140 return current_video_frame_ >= frame_to_start_decode_;
143 // Example pattern for spatial layers and 2 temporal layers used in the
144 // bypass/flexible mode. The pattern corresponds to the pattern
145 // VP9E_TEMPORAL_LAYERING_MODE_0101 (temporal_layering_mode == 2) used in
146 // non-flexible mode.
147 void set_frame_flags_bypass_mode(
148 int tl, int num_spatial_layers, int is_key_frame,
149 vpx_svc_ref_frame_config_t *ref_frame_config) {
151 for (sl = 0; sl < num_spatial_layers; ++sl)
152 ref_frame_config->update_buffer_slot[sl] = 0;
154 for (sl = 0; sl < num_spatial_layers; ++sl) {
155 // Set the buffer idx.
157 ref_frame_config->lst_fb_idx[sl] = sl;
160 ref_frame_config->lst_fb_idx[sl] = sl - 1;
161 ref_frame_config->gld_fb_idx[sl] = sl;
163 ref_frame_config->gld_fb_idx[sl] = sl - 1;
166 ref_frame_config->gld_fb_idx[sl] = 0;
168 ref_frame_config->alt_fb_idx[sl] = 0;
169 } else if (tl == 1) {
170 ref_frame_config->lst_fb_idx[sl] = sl;
171 ref_frame_config->gld_fb_idx[sl] =
172 (sl == 0) ? 0 : num_spatial_layers + sl - 1;
173 ref_frame_config->alt_fb_idx[sl] = num_spatial_layers + sl;
175 // Set the reference and update flags.
178 // Base spatial and base temporal (sl = 0, tl = 0)
179 ref_frame_config->reference_last[sl] = 1;
180 ref_frame_config->reference_golden[sl] = 0;
181 ref_frame_config->reference_alt_ref[sl] = 0;
182 ref_frame_config->update_buffer_slot[sl] |=
183 1 << ref_frame_config->lst_fb_idx[sl];
186 ref_frame_config->reference_last[sl] = 1;
187 ref_frame_config->reference_golden[sl] = 0;
188 ref_frame_config->reference_alt_ref[sl] = 0;
189 ref_frame_config->update_buffer_slot[sl] |=
190 1 << ref_frame_config->gld_fb_idx[sl];
192 // Non-zero spatiall layer.
193 ref_frame_config->reference_last[sl] = 1;
194 ref_frame_config->reference_golden[sl] = 1;
195 ref_frame_config->reference_alt_ref[sl] = 1;
196 ref_frame_config->update_buffer_slot[sl] |=
197 1 << ref_frame_config->lst_fb_idx[sl];
200 } else if (tl == 1) {
202 // Base spatial and top temporal (tl = 1)
203 ref_frame_config->reference_last[sl] = 1;
204 ref_frame_config->reference_golden[sl] = 0;
205 ref_frame_config->reference_alt_ref[sl] = 0;
206 ref_frame_config->update_buffer_slot[sl] |=
207 1 << ref_frame_config->alt_fb_idx[sl];
210 if (sl < num_spatial_layers - 1) {
211 ref_frame_config->reference_last[sl] = 1;
212 ref_frame_config->reference_golden[sl] = 1;
213 ref_frame_config->reference_alt_ref[sl] = 0;
214 ref_frame_config->update_buffer_slot[sl] |=
215 1 << ref_frame_config->alt_fb_idx[sl];
216 } else if (sl == num_spatial_layers - 1) {
217 // Top spatial and top temporal (non-reference -- doesn't
218 // update any reference buffers).
219 ref_frame_config->reference_last[sl] = 1;
220 ref_frame_config->reference_golden[sl] = 1;
221 ref_frame_config->reference_alt_ref[sl] = 0;
228 virtual void PreEncodeFrameHook(::libvpx_test::VideoSource *video,
229 ::libvpx_test::Encoder *encoder) {
230 current_video_frame_ = video->frame();
231 PreEncodeFrameHookSetup(video, encoder);
232 if (video->frame() == 0) {
233 // Do not turn off inter-layer pred completely because simulcast mode
235 if (inter_layer_pred_mode_ != INTER_LAYER_PRED_OFF)
236 encoder->Control(VP9E_SET_SVC_INTER_LAYER_PRED, inter_layer_pred_mode_);
237 encoder->Control(VP9E_SET_NOISE_SENSITIVITY, denoiser_on_);
238 if (intra_only_test_)
239 // Decoder sets the color_space for Intra-only frames
240 // to BT_601 (see line 1810 in vp9_decodeframe.c).
241 // So set it here in these tess to avoid encoder-decoder
242 // mismatch check on color space setting.
243 encoder->Control(VP9E_SET_COLOR_SPACE, VPX_CS_BT_601);
245 encoder->Control(VP9E_SET_DISABLE_LOOPFILTER, loopfilter_off_);
247 if (flexible_mode_) {
248 vpx_svc_layer_id_t layer_id;
249 layer_id.spatial_layer_id = 0;
250 layer_id.temporal_layer_id = (video->frame() % 2 != 0);
251 temporal_layer_id_ = layer_id.temporal_layer_id;
252 for (int i = 0; i < number_spatial_layers_; i++) {
253 layer_id.temporal_layer_id_per_spatial[i] = temporal_layer_id_;
254 ref_frame_config_.duration[i] = 1;
256 encoder->Control(VP9E_SET_SVC_LAYER_ID, &layer_id);
257 set_frame_flags_bypass_mode(layer_id.temporal_layer_id,
258 number_spatial_layers_, 0,
260 encoder->Control(VP9E_SET_SVC_REF_FRAME_CONFIG, &ref_frame_config_);
262 if (video->frame() == frame_to_sync_) {
263 encoder->Control(VP9E_SET_SVC_SPATIAL_LAYER_SYNC, &svc_layer_sync_);
267 #if CONFIG_VP9_DECODER
268 virtual void PreDecodeFrameHook(::libvpx_test::VideoSource *video,
269 ::libvpx_test::Decoder *decoder) {
270 if (video->frame() < frame_to_sync_) {
271 if (decode_to_layer_before_sync_ >= 0)
272 decoder->Control(VP9_DECODE_SVC_SPATIAL_LAYER,
273 decode_to_layer_before_sync_);
275 if (decode_to_layer_after_sync_ >= 0) {
276 int decode_to_layer = decode_to_layer_after_sync_;
277 // Overlay frame is additional layer for intra-only.
278 if (video->frame() == frame_to_sync_ && intra_only_test_ &&
279 decode_to_layer_after_sync_ == 0 && number_spatial_layers_ > 1)
280 decode_to_layer += 1;
281 decoder->Control(VP9_DECODE_SVC_SPATIAL_LAYER, decode_to_layer);
287 virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
288 // Keep track of number of non-reference frames, needed for mismatch check.
289 // Non-reference frames are top spatial and temporal layer frames,
291 if (temporal_layer_id_ == number_temporal_layers_ - 1 &&
292 temporal_layer_id_ > 0 &&
293 pkt->data.frame.spatial_layer_encoded[number_spatial_layers_ - 1] &&
294 current_video_frame_ >= frame_to_sync_)
295 num_nonref_frames_++;
297 if (intra_only_test_ && current_video_frame_ == frame_to_sync_) {
298 // Intra-only frame is only generated for spatial layers > 1 and <= 3,
299 // among other conditions (see constraint in set_intra_only_frame(). If
300 // intra-only is no allowed then encoder will insert key frame instead.
301 const bool key_frame =
302 (pkt->data.frame.flags & VPX_FRAME_IS_KEY) ? true : false;
303 if (number_spatial_layers_ == 1 || number_spatial_layers_ > 3)
304 ASSERT_TRUE(key_frame);
306 ASSERT_FALSE(key_frame);
310 virtual void MismatchHook(const vpx_image_t * /*img1*/,
311 const vpx_image_t * /*img2*/) {
312 if (current_video_frame_ >= frame_to_sync_) ++mismatch_nframes_;
315 unsigned int GetMismatchFrames() const { return mismatch_nframes_; }
316 unsigned int GetNonRefFrames() const { return num_nonref_frames_; }
318 unsigned int current_video_frame_;
319 unsigned int frame_to_start_decode_;
320 unsigned int frame_to_sync_;
321 int inter_layer_pred_mode_;
322 int decode_to_layer_before_sync_;
323 int decode_to_layer_after_sync_;
325 bool intra_only_test_;
327 vpx_svc_spatial_layer_sync_t svc_layer_sync_;
328 unsigned int mismatch_nframes_;
329 unsigned int num_nonref_frames_;
331 vpx_svc_ref_frame_config_t ref_frame_config_;
334 virtual void SetConfig(const int num_temporal_layer) {
335 cfg_.rc_buf_initial_sz = 500;
336 cfg_.rc_buf_optimal_sz = 500;
337 cfg_.rc_buf_sz = 1000;
338 cfg_.rc_min_quantizer = 0;
339 cfg_.rc_max_quantizer = 63;
340 cfg_.rc_end_usage = VPX_CBR;
341 cfg_.g_lag_in_frames = 0;
342 cfg_.g_error_resilient = 1;
344 cfg_.rc_dropframe_thresh = 30;
345 cfg_.kf_max_dist = 9999;
346 if (num_temporal_layer == 3) {
347 cfg_.ts_rate_decimator[0] = 4;
348 cfg_.ts_rate_decimator[1] = 2;
349 cfg_.ts_rate_decimator[2] = 1;
350 cfg_.temporal_layering_mode = 3;
351 } else if (num_temporal_layer == 2) {
352 cfg_.ts_rate_decimator[0] = 2;
353 cfg_.ts_rate_decimator[1] = 1;
354 cfg_.temporal_layering_mode = 2;
355 } else if (num_temporal_layer == 1) {
356 cfg_.ts_rate_decimator[0] = 1;
357 cfg_.temporal_layering_mode = 0;
362 // Test for sync layer for 1 pass CBR SVC: 3 spatial layers and
363 // 3 temporal layers. Only start decoding on the sync layer.
364 // Full sync: insert key frame on base layer.
365 TEST_P(SyncFrameOnePassCbrSvc, OnePassCbrSvc3SL3TLFullSync) {
367 // Sync is on base layer so the frame to sync and the frame to start decoding
369 frame_to_start_decode_ = 20;
371 decode_to_layer_before_sync_ = -1;
372 decode_to_layer_after_sync_ = 2;
374 // Set up svc layer sync structure.
375 svc_layer_sync_.base_layer_intra_only = 0;
376 svc_layer_sync_.spatial_layer_sync[0] = 1;
378 ::libvpx_test::Y4mVideoSource video("niklas_1280_720_30.y4m", 0, 60);
380 cfg_.rc_target_bitrate = 600;
381 flexible_mode_ = false;
382 AssignLayerBitrates();
383 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
384 #if CONFIG_VP9_DECODER
385 // The non-reference frames are expected to be mismatched frames as the
386 // encoder will avoid loopfilter on these frames.
387 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
391 // Test for sync layer for 1 pass CBR SVC: 2 spatial layers and
392 // 3 temporal layers. Decoding QVGA before sync frame and decode up to
393 // VGA on and after sync.
394 TEST_P(SyncFrameOnePassCbrSvc, OnePassCbrSvc2SL3TLSyncToVGA) {
396 frame_to_start_decode_ = 0;
397 frame_to_sync_ = 100;
398 decode_to_layer_before_sync_ = 0;
399 decode_to_layer_after_sync_ = 1;
401 // Set up svc layer sync structure.
402 svc_layer_sync_.base_layer_intra_only = 0;
403 svc_layer_sync_.spatial_layer_sync[0] = 0;
404 svc_layer_sync_.spatial_layer_sync[1] = 1;
406 ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
408 cfg_.rc_target_bitrate = 400;
409 flexible_mode_ = false;
410 AssignLayerBitrates();
411 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
412 #if CONFIG_VP9_DECODER
413 // The non-reference frames are expected to be mismatched frames as the
414 // encoder will avoid loopfilter on these frames.
415 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
419 // Test for sync layer for 1 pass CBR SVC: 3 spatial layers and
420 // 3 temporal layers. Decoding QVGA and VGA before sync frame and decode up to
421 // HD on and after sync.
422 TEST_P(SyncFrameOnePassCbrSvc, OnePassCbrSvc3SL3TLSyncToHD) {
424 frame_to_start_decode_ = 0;
426 decode_to_layer_before_sync_ = 1;
427 decode_to_layer_after_sync_ = 2;
429 // Set up svc layer sync structure.
430 svc_layer_sync_.base_layer_intra_only = 0;
431 svc_layer_sync_.spatial_layer_sync[0] = 0;
432 svc_layer_sync_.spatial_layer_sync[1] = 0;
433 svc_layer_sync_.spatial_layer_sync[2] = 1;
435 ::libvpx_test::Y4mVideoSource video("niklas_1280_720_30.y4m", 0, 60);
436 cfg_.rc_target_bitrate = 600;
437 flexible_mode_ = false;
438 AssignLayerBitrates();
439 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
440 #if CONFIG_VP9_DECODER
441 // The non-reference frames are expected to be mismatched frames as the
442 // encoder will avoid loopfilter on these frames.
443 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
447 // Test for sync layer for 1 pass CBR SVC: 3 spatial layers and
448 // 3 temporal layers. Decoding QVGA before sync frame and decode up to
449 // HD on and after sync.
450 TEST_P(SyncFrameOnePassCbrSvc, OnePassCbrSvc3SL3TLSyncToVGAHD) {
452 frame_to_start_decode_ = 0;
454 decode_to_layer_before_sync_ = 0;
455 decode_to_layer_after_sync_ = 2;
457 // Set up svc layer sync structure.
458 svc_layer_sync_.base_layer_intra_only = 0;
459 svc_layer_sync_.spatial_layer_sync[0] = 0;
460 svc_layer_sync_.spatial_layer_sync[1] = 1;
461 svc_layer_sync_.spatial_layer_sync[2] = 1;
463 ::libvpx_test::Y4mVideoSource video("niklas_1280_720_30.y4m", 0, 60);
464 cfg_.rc_target_bitrate = 600;
465 flexible_mode_ = false;
466 AssignLayerBitrates();
467 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
468 #if CONFIG_VP9_DECODER
469 // The non-reference frames are expected to be mismatched frames as the
470 // encoder will avoid loopfilter on these frames.
471 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
475 #if CONFIG_VP9_TEMPORAL_DENOISING
476 // Test for sync layer for 1 pass CBR SVC: 2 spatial layers and
477 // 3 temporal layers. Decoding QVGA before sync frame and decode up to
478 // VGA on and after sync.
479 TEST_P(SyncFrameOnePassCbrSvc, OnePassCbrSvc2SL3TLSyncFrameVGADenoise) {
481 frame_to_start_decode_ = 0;
482 frame_to_sync_ = 100;
483 decode_to_layer_before_sync_ = 0;
484 decode_to_layer_after_sync_ = 1;
487 // Set up svc layer sync structure.
488 svc_layer_sync_.base_layer_intra_only = 0;
489 svc_layer_sync_.spatial_layer_sync[0] = 0;
490 svc_layer_sync_.spatial_layer_sync[1] = 1;
492 ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
494 cfg_.rc_target_bitrate = 400;
495 flexible_mode_ = false;
496 AssignLayerBitrates();
497 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
498 #if CONFIG_VP9_DECODER
499 // The non-reference frames are expected to be mismatched frames as the
500 // encoder will avoid loopfilter on these frames.
501 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
506 // Encode 3 spatial, 2 temporal layer in flexible mode but don't
507 // start decoding. During the sequence insert intra-only on base/qvga
508 // layer at frame 20 and start decoding only QVGA layer from there.
509 TEST_P(SyncFrameOnePassCbrSvc,
510 OnePassCbrSvc3SL3TLSyncFrameStartDecodeOnIntraOnlyQVGAFlex) {
512 frame_to_start_decode_ = 20;
514 decode_to_layer_before_sync_ = 2;
515 decode_to_layer_after_sync_ = 0;
516 intra_only_test_ = true;
518 // Set up svc layer sync structure.
519 svc_layer_sync_.base_layer_intra_only = 1;
520 svc_layer_sync_.spatial_layer_sync[0] = 1;
521 svc_layer_sync_.spatial_layer_sync[1] = 0;
522 svc_layer_sync_.spatial_layer_sync[2] = 0;
524 ::libvpx_test::Y4mVideoSource video("niklas_1280_720_30.y4m", 0, 60);
525 cfg_.rc_target_bitrate = 600;
526 flexible_mode_ = true;
527 AssignLayerBitrates();
528 cfg_.temporal_layering_mode = VP9E_TEMPORAL_LAYERING_MODE_BYPASS;
529 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
530 // Can't check mismatch here because only base is decoded at
531 // frame sync, whereas encoder continues encoding all layers.
534 // Encode 3 spatial, 3 temporal layer but don't start decoding.
535 // During the sequence insert intra-only on base/qvga layer at frame 20
536 // and start decoding only QVGA layer from there.
537 TEST_P(SyncFrameOnePassCbrSvc,
538 OnePassCbrSvc3SL3TLSyncFrameStartDecodeOnIntraOnlyQVGA) {
540 frame_to_start_decode_ = 20;
542 decode_to_layer_before_sync_ = 2;
543 decode_to_layer_after_sync_ = 0;
544 intra_only_test_ = true;
546 // Set up svc layer sync structure.
547 svc_layer_sync_.base_layer_intra_only = 1;
548 svc_layer_sync_.spatial_layer_sync[0] = 1;
549 svc_layer_sync_.spatial_layer_sync[1] = 0;
550 svc_layer_sync_.spatial_layer_sync[2] = 0;
552 ::libvpx_test::Y4mVideoSource video("niklas_1280_720_30.y4m", 0, 60);
553 cfg_.rc_target_bitrate = 600;
554 flexible_mode_ = false;
555 AssignLayerBitrates();
556 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
557 // Can't check mismatch here because only base is decoded at
558 // frame sync, whereas encoder continues encoding all layers.
561 // Start decoding from beginning of sequence, during sequence insert intra-only
562 // on base/qvga layer. Decode all layers.
563 TEST_P(SyncFrameOnePassCbrSvc, OnePassCbrSvc3SL3TLSyncFrameIntraOnlyQVGA) {
565 frame_to_start_decode_ = 0;
567 decode_to_layer_before_sync_ = 2;
568 // The superframe containing intra-only layer will have +1 frames. Thus set
569 // the layer to decode after sync frame to +1 from
570 // decode_to_layer_before_sync.
571 decode_to_layer_after_sync_ = 3;
572 intra_only_test_ = true;
574 // Set up svc layer sync structure.
575 svc_layer_sync_.base_layer_intra_only = 1;
576 svc_layer_sync_.spatial_layer_sync[0] = 1;
577 svc_layer_sync_.spatial_layer_sync[1] = 0;
578 svc_layer_sync_.spatial_layer_sync[2] = 0;
580 ::libvpx_test::Y4mVideoSource video("niklas_1280_720_30.y4m", 0, 60);
581 cfg_.rc_target_bitrate = 600;
582 flexible_mode_ = false;
583 AssignLayerBitrates();
584 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
585 #if CONFIG_VP9_DECODER
586 // The non-reference frames are expected to be mismatched frames as the
587 // encoder will avoid loopfilter on these frames.
588 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
592 // Start decoding from beginning of sequence, during sequence insert intra-only
593 // on base/qvga layer and sync_layer on middle/VGA layer. Decode all layers.
594 TEST_P(SyncFrameOnePassCbrSvc, OnePassCbrSvc3SL3TLSyncFrameIntraOnlyVGA) {
596 frame_to_start_decode_ = 0;
598 decode_to_layer_before_sync_ = 2;
599 // The superframe containing intra-only layer will have +1 frames. Thus set
600 // the layer to decode after sync frame to +1 from
601 // decode_to_layer_before_sync.
602 decode_to_layer_after_sync_ = 3;
603 intra_only_test_ = true;
605 // Set up svc layer sync structure.
606 svc_layer_sync_.base_layer_intra_only = 1;
607 svc_layer_sync_.spatial_layer_sync[0] = 1;
608 svc_layer_sync_.spatial_layer_sync[1] = 1;
609 svc_layer_sync_.spatial_layer_sync[2] = 0;
611 ::libvpx_test::Y4mVideoSource video("niklas_1280_720_30.y4m", 0, 60);
612 cfg_.rc_target_bitrate = 600;
613 flexible_mode_ = false;
614 AssignLayerBitrates();
615 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
616 #if CONFIG_VP9_DECODER
617 // The non-reference frames are expected to be mismatched frames as the
618 // encoder will avoid loopfilter on these frames.
619 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
623 // Start decoding from sync frame, insert intra-only on base/qvga layer. Decode
624 // all layers. For 1 spatial layer, it inserts a key frame.
625 TEST_P(SyncFrameOnePassCbrSvc, OnePassCbrSvc1SL3TLSyncFrameIntraOnlyQVGA) {
627 frame_to_start_decode_ = 20;
629 decode_to_layer_before_sync_ = 0;
630 decode_to_layer_after_sync_ = 0;
631 intra_only_test_ = true;
633 // Set up svc layer sync structure.
634 svc_layer_sync_.base_layer_intra_only = 1;
635 svc_layer_sync_.spatial_layer_sync[0] = 1;
637 ::libvpx_test::Y4mVideoSource video("niklas_1280_720_30.y4m", 0, 60);
638 cfg_.rc_target_bitrate = 600;
639 flexible_mode_ = false;
640 AssignLayerBitrates();
641 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
642 #if CONFIG_VP9_DECODER
643 // The non-reference frames are expected to be mismatched frames as the
644 // encoder will avoid loopfilter on these frames.
645 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
649 // Params: Loopfilter modes.
650 class LoopfilterOnePassCbrSvc : public OnePassCbrSvc,
651 public ::libvpx_test::CodecTestWithParam<int> {
653 LoopfilterOnePassCbrSvc()
654 : OnePassCbrSvc(GET_PARAM(0)), loopfilter_off_(GET_PARAM(1)),
655 mismatch_nframes_(0), num_nonref_frames_(0) {
656 SetMode(::libvpx_test::kRealTime);
660 virtual ~LoopfilterOnePassCbrSvc() {}
662 virtual void SetUp() {
667 virtual void PreEncodeFrameHook(::libvpx_test::VideoSource *video,
668 ::libvpx_test::Encoder *encoder) {
669 PreEncodeFrameHookSetup(video, encoder);
670 if (number_temporal_layers_ > 1 || number_spatial_layers_ > 1) {
672 if (loopfilter_off_ == 0) {
673 // loopfilter is on for all spatial layers on every superrframe.
674 for (int i = 0; i < VPX_SS_MAX_LAYERS; ++i) {
675 svc_params_.loopfilter_ctrl[i] = 0;
677 } else if (loopfilter_off_ == 1) {
678 // loopfilter is off for non-reference frames for all spatial layers.
679 for (int i = 0; i < VPX_SS_MAX_LAYERS; ++i) {
680 svc_params_.loopfilter_ctrl[i] = 1;
683 // loopfilter is off for all SL0 frames, and off only for non-reference
684 // frames for SL > 0.
685 svc_params_.loopfilter_ctrl[0] = 2;
686 for (int i = 1; i < VPX_SS_MAX_LAYERS; ++i) {
687 svc_params_.loopfilter_ctrl[i] = 1;
690 encoder->Control(VP9E_SET_SVC_PARAMETERS, &svc_params_);
691 } else if (number_temporal_layers_ == 1 && number_spatial_layers_ == 1) {
692 // For non-SVC mode use the single layer control.
693 encoder->Control(VP9E_SET_DISABLE_LOOPFILTER, loopfilter_off_);
697 virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
698 // Keep track of number of non-reference frames, needed for mismatch check.
699 // Non-reference frames are top spatial and temporal layer frames,
701 if (temporal_layer_id_ == number_temporal_layers_ - 1 &&
702 temporal_layer_id_ > 0 &&
703 pkt->data.frame.spatial_layer_encoded[number_spatial_layers_ - 1])
704 num_nonref_frames_++;
707 virtual void MismatchHook(const vpx_image_t * /*img1*/,
708 const vpx_image_t * /*img2*/) {
712 virtual void SetConfig(const int /*num_temporal_layer*/) {}
714 int GetMismatchFrames() const { return mismatch_nframes_; }
715 int GetNonRefFrames() const { return num_nonref_frames_; }
720 int mismatch_nframes_;
721 int num_nonref_frames_;
724 TEST_P(LoopfilterOnePassCbrSvc, OnePassCbrSvc1SL1TLLoopfilterOff) {
726 cfg_.rc_buf_initial_sz = 500;
727 cfg_.rc_buf_optimal_sz = 500;
728 cfg_.rc_buf_sz = 1000;
729 cfg_.rc_min_quantizer = 0;
730 cfg_.rc_max_quantizer = 63;
732 cfg_.rc_dropframe_thresh = 0;
733 cfg_.rc_target_bitrate = 800;
734 cfg_.kf_max_dist = 9999;
735 cfg_.rc_end_usage = VPX_CBR;
736 cfg_.g_lag_in_frames = 0;
737 cfg_.g_error_resilient = 1;
738 cfg_.ts_rate_decimator[0] = 1;
739 cfg_.temporal_layering_mode = 0;
740 ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
742 cfg_.rc_target_bitrate = 600;
743 AssignLayerBitrates();
744 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
745 #if CONFIG_VP9_DECODER
746 if (loopfilter_off_ == 0)
747 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
749 EXPECT_EQ(GetMismatchFrames(), 0);
753 TEST_P(LoopfilterOnePassCbrSvc, OnePassCbrSvc1SL3TLLoopfilterOff) {
755 cfg_.rc_buf_initial_sz = 500;
756 cfg_.rc_buf_optimal_sz = 500;
757 cfg_.rc_buf_sz = 1000;
758 cfg_.rc_min_quantizer = 0;
759 cfg_.rc_max_quantizer = 63;
761 cfg_.rc_dropframe_thresh = 0;
762 cfg_.rc_target_bitrate = 800;
763 cfg_.kf_max_dist = 9999;
764 cfg_.rc_end_usage = VPX_CBR;
765 cfg_.g_lag_in_frames = 0;
766 cfg_.g_error_resilient = 1;
767 cfg_.ts_rate_decimator[0] = 4;
768 cfg_.ts_rate_decimator[1] = 2;
769 cfg_.ts_rate_decimator[2] = 1;
770 cfg_.temporal_layering_mode = 3;
771 ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
773 cfg_.rc_target_bitrate = 600;
774 AssignLayerBitrates();
775 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
776 #if CONFIG_VP9_DECODER
777 if (loopfilter_off_ == 0)
778 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
780 EXPECT_EQ(GetMismatchFrames(), 0);
784 TEST_P(LoopfilterOnePassCbrSvc, OnePassCbrSvc3SL3TLLoopfilterOff) {
786 cfg_.rc_buf_initial_sz = 500;
787 cfg_.rc_buf_optimal_sz = 500;
788 cfg_.rc_buf_sz = 1000;
789 cfg_.rc_min_quantizer = 0;
790 cfg_.rc_max_quantizer = 63;
792 cfg_.rc_dropframe_thresh = 0;
793 cfg_.rc_target_bitrate = 800;
794 cfg_.kf_max_dist = 9999;
795 cfg_.rc_end_usage = VPX_CBR;
796 cfg_.g_lag_in_frames = 0;
797 cfg_.g_error_resilient = 1;
798 cfg_.ts_rate_decimator[0] = 4;
799 cfg_.ts_rate_decimator[1] = 2;
800 cfg_.ts_rate_decimator[2] = 1;
801 cfg_.temporal_layering_mode = 3;
802 ::libvpx_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30, 1,
804 cfg_.rc_target_bitrate = 600;
805 AssignLayerBitrates();
806 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
807 #if CONFIG_VP9_DECODER
808 if (loopfilter_off_ == 0)
809 EXPECT_EQ(GetNonRefFrames(), GetMismatchFrames());
811 EXPECT_EQ(GetMismatchFrames(), 0);
815 VP9_INSTANTIATE_TEST_SUITE(SyncFrameOnePassCbrSvc, ::testing::Range(0, 3));
817 VP9_INSTANTIATE_TEST_SUITE(LoopfilterOnePassCbrSvc, ::testing::Range(0, 3));
819 INSTANTIATE_TEST_SUITE_P(
820 VP9, ScalePartitionOnePassCbrSvc,
822 static_cast<const libvpx_test::CodecFactory *>(&libvpx_test::kVP9)));
825 } // namespace svc_test