1 /*
2 * Copyright (c) 2021, Alliance for Open Media. All rights reserved
3 *
4 * This source code is subject to the terms of the BSD 2 Clause License and
5 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
6 * was not distributed with this source code in the LICENSE file, you can
7 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
8 * Media Patent License 1.0 was not distributed with this source code in the
9 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
10 */
11
12 #include "av1/ratectrl_rtc.h"
13
14 #include <memory>
15
16 #include "test/codec_factory.h"
17 #include "test/encode_test_driver.h"
18 #include "test/util.h"
19 #include "test/i420_video_source.h"
20 #include "third_party/googletest/src/googletest/include/gtest/gtest.h"
21
22 namespace {
23
24 constexpr size_t kNumFrames = 450;
25
26 const int kTemporalId3Layer[4] = { 0, 2, 1, 2 };
27 const int kTemporalId2Layer[2] = { 0, 1 };
28 const int kTemporalRateAllocation3Layer[3] = { 50, 70, 100 };
29 const int kTemporalRateAllocation2Layer[2] = { 60, 100 };
30 const int kSpatialLayerBitrate[3] = { 200, 500, 900 };
31
32 // Parameter: aq mode: 0 and 3
33 class RcInterfaceTest : public ::libaom_test::EncoderTest,
34 public ::libaom_test::CodecTestWithParam<int> {
35 public:
RcInterfaceTest()36 RcInterfaceTest()
37 : EncoderTest(GET_PARAM(0)), aq_mode_(GET_PARAM(1)), key_interval_(3000),
38 encoder_exit_(false), layer_frame_cnt_(0), superframe_cnt_(0),
39 frame_cnt_(0), dynamic_temporal_layers_(false),
40 dynamic_spatial_layers_(false), num_drops_(0), max_consec_drop_(0),
41 frame_drop_thresh_(0) {
42 memset(&svc_params_, 0, sizeof(svc_params_));
43 memset(&layer_id_, 0, sizeof(layer_id_));
44 }
45
46 ~RcInterfaceTest() override = default;
47
48 protected:
SetUp()49 void SetUp() override { InitializeConfig(::libaom_test::kRealTime); }
50
GetNumSpatialLayers()51 int GetNumSpatialLayers() override { return rc_cfg_.ss_number_layers; }
52
PreEncodeFrameHook(libaom_test::VideoSource * video,libaom_test::Encoder * encoder)53 void PreEncodeFrameHook(libaom_test::VideoSource *video,
54 libaom_test::Encoder *encoder) override {
55 int key_int = key_interval_;
56 const int use_svc =
57 rc_cfg_.ss_number_layers > 1 || rc_cfg_.ts_number_layers > 1;
58 encoder->Control(AV1E_SET_RTC_EXTERNAL_RC, 1);
59 if (video->frame() == 0 && layer_frame_cnt_ == 0) {
60 encoder->Control(AOME_SET_CPUUSED, 7);
61 encoder->Control(AV1E_SET_AQ_MODE, aq_mode_);
62 if (rc_cfg_.is_screen) {
63 encoder->Control(AV1E_SET_TUNE_CONTENT, AOM_CONTENT_SCREEN);
64 } else {
65 encoder->Control(AV1E_SET_TUNE_CONTENT, AOM_CONTENT_DEFAULT);
66 }
67 encoder->Control(AOME_SET_MAX_INTRA_BITRATE_PCT,
68 rc_cfg_.max_intra_bitrate_pct);
69 if (use_svc) encoder->Control(AV1E_SET_SVC_PARAMS, &svc_params_);
70 encoder->Control(AV1E_SET_MAX_CONSEC_FRAME_DROP_CBR, max_consec_drop_);
71 }
72 // SVC specific settings
73 if (use_svc) {
74 frame_params_.spatial_layer_id =
75 layer_frame_cnt_ % rc_cfg_.ss_number_layers;
76 if (rc_cfg_.ts_number_layers == 3)
77 frame_params_.temporal_layer_id =
78 kTemporalId3Layer[superframe_cnt_ % 4];
79 else if (rc_cfg_.ts_number_layers == 2)
80 frame_params_.temporal_layer_id =
81 kTemporalId2Layer[superframe_cnt_ % 2];
82 else
83 frame_params_.temporal_layer_id = 0;
84 layer_id_.spatial_layer_id = frame_params_.spatial_layer_id;
85 layer_id_.temporal_layer_id = frame_params_.temporal_layer_id;
86 encoder->Control(AV1E_SET_SVC_LAYER_ID, &layer_id_);
87 key_int = key_interval_ * rc_cfg_.ss_number_layers;
88 }
89 frame_params_.frame_type =
90 layer_frame_cnt_ % key_int == 0 ? aom::kKeyFrame : aom::kInterFrame;
91 encoder_exit_ = video->frame() == kNumFrames;
92 frame_flags_ = 0;
93
94 if (dynamic_temporal_layers_) {
95 if (superframe_cnt_ == 100 && layer_id_.spatial_layer_id == 0) {
96 // Go down to 2 temporal layers.
97 SetConfigSvc(3, 2);
98 encoder->Control(AV1E_SET_SVC_PARAMS, &svc_params_);
99 ASSERT_TRUE(rc_api_->UpdateRateControl(rc_cfg_));
100 } else if (superframe_cnt_ == 200 && layer_id_.spatial_layer_id == 0) {
101 // Go down to 1 temporal layer.
102 SetConfigSvc(3, 1);
103 encoder->Control(AV1E_SET_SVC_PARAMS, &svc_params_);
104 ASSERT_TRUE(rc_api_->UpdateRateControl(rc_cfg_));
105 } else if (superframe_cnt_ == 300 && layer_id_.spatial_layer_id == 0) {
106 // Go back up to 3 temporal layers.
107 SetConfigSvc(3, 3);
108 encoder->Control(AV1E_SET_SVC_PARAMS, &svc_params_);
109 ASSERT_TRUE(rc_api_->UpdateRateControl(rc_cfg_));
110 }
111 } else if (dynamic_spatial_layers_) {
112 // In this example the #spatial layers is modified on the fly,
113 // so we go from (120p,240p,480p) to (240p,480p), etc.
114 if (superframe_cnt_ == 100 && layer_id_.spatial_layer_id == 0) {
115 // Change to 2 spatial layers (240p, 480p).
116 SetConfigSvc(2, 3);
117 encoder->Control(AV1E_SET_SVC_PARAMS, &svc_params_);
118 ASSERT_TRUE(rc_api_->UpdateRateControl(rc_cfg_));
119 } else if (superframe_cnt_ == 200 && layer_id_.spatial_layer_id == 0) {
120 // Change to 1 spatial layer (480p).
121 SetConfigSvc(1, 3);
122 encoder->Control(AV1E_SET_SVC_PARAMS, &svc_params_);
123 ASSERT_TRUE(rc_api_->UpdateRateControl(rc_cfg_));
124 } else if (superframe_cnt_ == 300 && layer_id_.spatial_layer_id == 0) {
125 // Go back to 3 spatial layers (120p, 240p, 480p).
126 SetConfigSvc(3, 3);
127 encoder->Control(AV1E_SET_SVC_PARAMS, &svc_params_);
128 // In the fixed SVC mode (which is what is used in this test):
129 // Key frame is required here on SL0 since 120p will try to predict
130 // from LAST which was the 480p, so decoder will throw an error
131 // (reference must be smaller than 4x4). In the flexible mode
132 // (not used here) we can set the frame flags to predict off the 2x2
133 // reference instead,
134 frame_flags_ = AOM_EFLAG_FORCE_KF;
135 frame_params_.frame_type = aom::kKeyFrame;
136 ASSERT_TRUE(rc_api_->UpdateRateControl(rc_cfg_));
137 }
138 }
139 // TODO(marpan): Add dynamic spatial layers based on 0 layer bitrate.
140 // That is actual usage in SW where configuration (#spatial, #temporal)
141 // layers is fixed, but top layer is dropped or re-enabled based on
142 // bitrate. This requires external RC to handle dropped (zero-size) frames.
143 }
144
PostEncodeFrameHook(::libaom_test::Encoder * encoder)145 void PostEncodeFrameHook(::libaom_test::Encoder *encoder) override {
146 if (encoder_exit_) {
147 return;
148 }
149 layer_frame_cnt_++;
150 frame_cnt_++;
151 if (layer_id_.spatial_layer_id == rc_cfg_.ss_number_layers - 1)
152 superframe_cnt_++;
153 int qp;
154 encoder->Control(AOME_GET_LAST_QUANTIZER, &qp);
155 if (rc_api_->ComputeQP(frame_params_) == aom::FrameDropDecision::kOk) {
156 ASSERT_EQ(rc_api_->GetQP(), qp) << "at frame " << frame_cnt_ - 1;
157 int encoder_lpf_level;
158 encoder->Control(AOME_GET_LOOPFILTER_LEVEL, &encoder_lpf_level);
159 aom::AV1LoopfilterLevel loopfilter_level = rc_api_->GetLoopfilterLevel();
160 ASSERT_EQ(loopfilter_level.filter_level[0], encoder_lpf_level);
161 aom::AV1CdefInfo cdef_level = rc_api_->GetCdefInfo();
162 int cdef_y_strengths[16];
163 encoder->Control(AV1E_GET_LUMA_CDEF_STRENGTH, cdef_y_strengths);
164 ASSERT_EQ(cdef_level.cdef_strength_y, cdef_y_strengths[0]);
165 } else {
166 num_drops_++;
167 }
168 }
169
FramePktHook(const aom_codec_cx_pkt_t * pkt)170 void FramePktHook(const aom_codec_cx_pkt_t *pkt) override {
171 if (layer_id_.spatial_layer_id == 0)
172 rc_api_->PostEncodeUpdate(pkt->data.frame.sz - 2);
173 else
174 rc_api_->PostEncodeUpdate(pkt->data.frame.sz);
175 }
176
MismatchHook(const aom_image_t * img1,const aom_image_t * img2)177 void MismatchHook(const aom_image_t *img1, const aom_image_t *img2) override {
178 (void)img1;
179 (void)img2;
180 }
181
RunOneLayer()182 void RunOneLayer() {
183 key_interval_ = 10000;
184 SetConfig();
185 rc_api_ = aom::AV1RateControlRTC::Create(rc_cfg_);
186 frame_params_.spatial_layer_id = 0;
187 frame_params_.temporal_layer_id = 0;
188
189 ::libaom_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30,
190 1, 0, kNumFrames);
191
192 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
193 }
194
RunOneLayerScreen()195 void RunOneLayerScreen() {
196 key_interval_ = 10000;
197 SetConfig();
198 rc_cfg_.is_screen = true;
199 rc_cfg_.width = 352;
200 rc_cfg_.height = 288;
201 rc_api_ = aom::AV1RateControlRTC::Create(rc_cfg_);
202 frame_params_.spatial_layer_id = 0;
203 frame_params_.temporal_layer_id = 0;
204
205 ::libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352,
206 288, 30, 1, 0, 140);
207
208 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
209 }
210
RunOneLayerDropFramesCBR()211 void RunOneLayerDropFramesCBR() {
212 key_interval_ = 10000;
213 max_consec_drop_ = 8;
214 frame_drop_thresh_ = 30;
215 SetConfig();
216 rc_cfg_.target_bandwidth = 100;
217 cfg_.rc_target_bitrate = 100;
218 rc_cfg_.max_quantizer = 50;
219 cfg_.rc_max_quantizer = 50;
220 rc_api_ = aom::AV1RateControlRTC::Create(rc_cfg_);
221 frame_params_.spatial_layer_id = 0;
222 frame_params_.temporal_layer_id = 0;
223
224 ::libaom_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30,
225 1, 0, kNumFrames);
226
227 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
228 // Check that some frames were dropped, otherwise test has no value.
229 ASSERT_GE(num_drops_, 1);
230 }
231
RunOneLayerPeriodicKey()232 void RunOneLayerPeriodicKey() {
233 key_interval_ = 100;
234 SetConfig();
235 rc_api_ = aom::AV1RateControlRTC::Create(rc_cfg_);
236 frame_params_.spatial_layer_id = 0;
237 frame_params_.temporal_layer_id = 0;
238
239 ::libaom_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30,
240 1, 0, kNumFrames);
241
242 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
243 }
244
RunSvc()245 void RunSvc() {
246 key_interval_ = 10000;
247 SetConfigSvc(3, 3);
248 rc_api_ = aom::AV1RateControlRTC::Create(rc_cfg_);
249 frame_params_.spatial_layer_id = 0;
250 frame_params_.temporal_layer_id = 0;
251
252 ::libaom_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30,
253 1, 0, kNumFrames);
254
255 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
256 }
257
RunSvcPeriodicKey()258 void RunSvcPeriodicKey() {
259 key_interval_ = 100;
260 SetConfigSvc(3, 3);
261 rc_api_ = aom::AV1RateControlRTC::Create(rc_cfg_);
262 frame_params_.spatial_layer_id = 0;
263 frame_params_.temporal_layer_id = 0;
264
265 ::libaom_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30,
266 1, 0, kNumFrames);
267
268 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
269 }
270
RunSvcDynamicTemporal()271 void RunSvcDynamicTemporal() {
272 dynamic_temporal_layers_ = true;
273 key_interval_ = 10000;
274 SetConfigSvc(3, 3);
275 rc_api_ = aom::AV1RateControlRTC::Create(rc_cfg_);
276 frame_params_.spatial_layer_id = 0;
277 frame_params_.temporal_layer_id = 0;
278
279 ::libaom_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30,
280 1, 0, kNumFrames);
281
282 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
283 }
284
RunSvcDynamicSpatial()285 void RunSvcDynamicSpatial() {
286 dynamic_spatial_layers_ = true;
287 key_interval_ = 10000;
288 SetConfigSvc(3, 3);
289 rc_api_ = aom::AV1RateControlRTC::Create(rc_cfg_);
290 frame_params_.spatial_layer_id = 0;
291 frame_params_.temporal_layer_id = 0;
292
293 ::libaom_test::I420VideoSource video("niklas_640_480_30.yuv", 640, 480, 30,
294 1, 0, kNumFrames);
295
296 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
297 }
298
299 private:
SetConfig()300 void SetConfig() {
301 rc_cfg_.width = 640;
302 rc_cfg_.height = 480;
303 rc_cfg_.max_quantizer = 52;
304 rc_cfg_.min_quantizer = 2;
305 rc_cfg_.target_bandwidth = 1000;
306 rc_cfg_.buf_initial_sz = 600;
307 rc_cfg_.buf_optimal_sz = 600;
308 rc_cfg_.buf_sz = 1000;
309 rc_cfg_.undershoot_pct = 50;
310 rc_cfg_.overshoot_pct = 50;
311 rc_cfg_.max_intra_bitrate_pct = 1000;
312 rc_cfg_.framerate = 30.0;
313 rc_cfg_.ss_number_layers = 1;
314 rc_cfg_.ts_number_layers = 1;
315 rc_cfg_.scaling_factor_num[0] = 1;
316 rc_cfg_.scaling_factor_den[0] = 1;
317 rc_cfg_.layer_target_bitrate[0] = 1000;
318 rc_cfg_.max_quantizers[0] = 52;
319 rc_cfg_.min_quantizers[0] = 2;
320 rc_cfg_.aq_mode = aq_mode_;
321 rc_cfg_.frame_drop_thresh = frame_drop_thresh_;
322 rc_cfg_.max_consec_drop = max_consec_drop_;
323
324 // Encoder settings for ground truth.
325 cfg_.g_w = 640;
326 cfg_.g_h = 480;
327 cfg_.rc_undershoot_pct = 50;
328 cfg_.rc_overshoot_pct = 50;
329 cfg_.rc_buf_initial_sz = 600;
330 cfg_.rc_buf_optimal_sz = 600;
331 cfg_.rc_buf_sz = 1000;
332 cfg_.rc_dropframe_thresh = 0;
333 cfg_.rc_min_quantizer = 2;
334 cfg_.rc_max_quantizer = 52;
335 cfg_.rc_end_usage = AOM_CBR;
336 cfg_.g_lag_in_frames = 0;
337 cfg_.g_error_resilient = 0;
338 cfg_.rc_target_bitrate = 1000;
339 cfg_.kf_min_dist = key_interval_;
340 cfg_.kf_max_dist = key_interval_;
341 cfg_.rc_dropframe_thresh = frame_drop_thresh_;
342 }
343
SetConfigSvc(int number_spatial_layers,int number_temporal_layers)344 void SetConfigSvc(int number_spatial_layers, int number_temporal_layers) {
345 rc_cfg_.width = 640;
346 rc_cfg_.height = 480;
347 rc_cfg_.max_quantizer = 56;
348 rc_cfg_.min_quantizer = 2;
349 rc_cfg_.buf_initial_sz = 600;
350 rc_cfg_.buf_optimal_sz = 600;
351 rc_cfg_.buf_sz = 1000;
352 rc_cfg_.undershoot_pct = 50;
353 rc_cfg_.overshoot_pct = 50;
354 rc_cfg_.max_intra_bitrate_pct = 1000;
355 rc_cfg_.framerate = 30.0;
356 rc_cfg_.aq_mode = aq_mode_;
357 rc_cfg_.ss_number_layers = number_spatial_layers;
358 rc_cfg_.ts_number_layers = number_temporal_layers;
359
360 // Encoder settings for ground truth.
361 cfg_.g_w = 640;
362 cfg_.g_h = 480;
363 cfg_.rc_max_quantizer = 56;
364 cfg_.rc_min_quantizer = 2;
365 cfg_.rc_buf_initial_sz = 600;
366 cfg_.rc_buf_optimal_sz = 600;
367 cfg_.rc_buf_sz = 1000;
368 cfg_.rc_overshoot_pct = 50;
369 cfg_.rc_undershoot_pct = 50;
370 cfg_.g_threads = 1;
371 cfg_.kf_min_dist = key_interval_;
372 cfg_.kf_max_dist = key_interval_;
373 cfg_.g_timebase.num = 1;
374 cfg_.g_timebase.den = 30;
375 cfg_.rc_end_usage = AOM_CBR;
376 cfg_.g_lag_in_frames = 0;
377 cfg_.g_error_resilient = 0;
378 svc_params_.number_spatial_layers = number_spatial_layers;
379 svc_params_.number_temporal_layers = number_temporal_layers;
380
381 // Scale factors.
382 if (number_spatial_layers == 3) {
383 rc_cfg_.scaling_factor_num[0] = 1;
384 rc_cfg_.scaling_factor_den[0] = 4;
385 rc_cfg_.scaling_factor_num[1] = 2;
386 rc_cfg_.scaling_factor_den[1] = 4;
387 rc_cfg_.scaling_factor_num[2] = 4;
388 rc_cfg_.scaling_factor_den[2] = 4;
389 svc_params_.scaling_factor_num[0] = 1;
390 svc_params_.scaling_factor_den[0] = 4;
391 svc_params_.scaling_factor_num[1] = 2;
392 svc_params_.scaling_factor_den[1] = 4;
393 svc_params_.scaling_factor_num[2] = 4;
394 svc_params_.scaling_factor_den[2] = 4;
395 } else if (number_spatial_layers == 2) {
396 rc_cfg_.scaling_factor_num[0] = 1;
397 rc_cfg_.scaling_factor_den[0] = 2;
398 rc_cfg_.scaling_factor_num[1] = 2;
399 rc_cfg_.scaling_factor_den[1] = 2;
400 svc_params_.scaling_factor_num[0] = 1;
401 svc_params_.scaling_factor_den[0] = 2;
402 svc_params_.scaling_factor_num[1] = 2;
403 svc_params_.scaling_factor_den[1] = 2;
404 } else if (number_spatial_layers == 1) {
405 rc_cfg_.scaling_factor_num[0] = 1;
406 rc_cfg_.scaling_factor_den[0] = 1;
407 svc_params_.scaling_factor_num[0] = 1;
408 svc_params_.scaling_factor_den[0] = 1;
409 }
410
411 // TS rate decimator.
412 if (number_temporal_layers == 3) {
413 rc_cfg_.ts_rate_decimator[0] = 4;
414 rc_cfg_.ts_rate_decimator[1] = 2;
415 rc_cfg_.ts_rate_decimator[2] = 1;
416 svc_params_.framerate_factor[0] = 4;
417 svc_params_.framerate_factor[1] = 2;
418 svc_params_.framerate_factor[2] = 1;
419 } else if (number_temporal_layers == 2) {
420 rc_cfg_.ts_rate_decimator[0] = 2;
421 rc_cfg_.ts_rate_decimator[1] = 1;
422 svc_params_.framerate_factor[0] = 2;
423 svc_params_.framerate_factor[1] = 1;
424 } else if (number_temporal_layers == 1) {
425 rc_cfg_.ts_rate_decimator[0] = 1;
426 svc_params_.framerate_factor[0] = 1;
427 }
428
429 // Bitate.
430 rc_cfg_.target_bandwidth = 0;
431 cfg_.rc_target_bitrate = 0;
432 for (int sl = 0; sl < number_spatial_layers; sl++) {
433 int spatial_bitrate = 0;
434 if (number_spatial_layers <= 3)
435 spatial_bitrate = kSpatialLayerBitrate[sl];
436 for (int tl = 0; tl < number_temporal_layers; tl++) {
437 int layer = sl * number_temporal_layers + tl;
438 if (number_temporal_layers == 3) {
439 rc_cfg_.layer_target_bitrate[layer] =
440 kTemporalRateAllocation3Layer[tl] * spatial_bitrate / 100;
441 svc_params_.layer_target_bitrate[layer] =
442 kTemporalRateAllocation3Layer[tl] * spatial_bitrate / 100;
443 } else if (number_temporal_layers == 2) {
444 rc_cfg_.layer_target_bitrate[layer] =
445 kTemporalRateAllocation2Layer[tl] * spatial_bitrate / 100;
446 svc_params_.layer_target_bitrate[layer] =
447 kTemporalRateAllocation2Layer[tl] * spatial_bitrate / 100;
448 } else if (number_temporal_layers == 1) {
449 rc_cfg_.layer_target_bitrate[layer] = spatial_bitrate;
450 svc_params_.layer_target_bitrate[layer] = spatial_bitrate;
451 }
452 }
453 rc_cfg_.target_bandwidth += spatial_bitrate;
454 cfg_.rc_target_bitrate += spatial_bitrate;
455 }
456
457 // Layer min/max quantizer.
458 for (int sl = 0; sl < number_spatial_layers; ++sl) {
459 for (int tl = 0; tl < number_temporal_layers; ++tl) {
460 const int i = sl * number_temporal_layers + tl;
461 rc_cfg_.max_quantizers[i] = rc_cfg_.max_quantizer;
462 rc_cfg_.min_quantizers[i] = rc_cfg_.min_quantizer;
463 svc_params_.max_quantizers[i] = cfg_.rc_max_quantizer;
464 svc_params_.min_quantizers[i] = cfg_.rc_min_quantizer;
465 }
466 }
467 }
468
469 std::unique_ptr<aom::AV1RateControlRTC> rc_api_;
470 aom::AV1RateControlRtcConfig rc_cfg_;
471 int aq_mode_;
472 int key_interval_;
473 aom::AV1FrameParamsRTC frame_params_;
474 bool encoder_exit_;
475 aom_svc_params_t svc_params_;
476 aom_svc_layer_id_t layer_id_;
477 int layer_frame_cnt_;
478 int superframe_cnt_;
479 int frame_cnt_;
480 bool dynamic_temporal_layers_;
481 bool dynamic_spatial_layers_;
482 int num_drops_;
483 int max_consec_drop_;
484 int frame_drop_thresh_;
485 };
486
TEST_P(RcInterfaceTest,OneLayer)487 TEST_P(RcInterfaceTest, OneLayer) { RunOneLayer(); }
488
TEST_P(RcInterfaceTest,OneLayerDropFramesCBR)489 TEST_P(RcInterfaceTest, OneLayerDropFramesCBR) { RunOneLayerDropFramesCBR(); }
490
TEST_P(RcInterfaceTest,OneLayerPeriodicKey)491 TEST_P(RcInterfaceTest, OneLayerPeriodicKey) { RunOneLayerPeriodicKey(); }
492
TEST_P(RcInterfaceTest,OneLayerScreen)493 TEST_P(RcInterfaceTest, OneLayerScreen) { RunOneLayerScreen(); }
494
TEST_P(RcInterfaceTest,Svc)495 TEST_P(RcInterfaceTest, Svc) { RunSvc(); }
496
TEST_P(RcInterfaceTest,SvcPeriodicKey)497 TEST_P(RcInterfaceTest, SvcPeriodicKey) { RunSvcPeriodicKey(); }
498
TEST_P(RcInterfaceTest,SvcDynamicTemporal)499 TEST_P(RcInterfaceTest, SvcDynamicTemporal) { RunSvcDynamicTemporal(); }
500
TEST_P(RcInterfaceTest,SvcDynamicSpatial)501 TEST_P(RcInterfaceTest, SvcDynamicSpatial) { RunSvcDynamicSpatial(); }
502
503 AV1_INSTANTIATE_TEST_SUITE(RcInterfaceTest, ::testing::Values(0, 3));
504
505 } // namespace
506