video_codec_initializer_unittest.cc (30468B)
1 /* 2 * Copyright (c) 2017 The WebRTC 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 11 #include "modules/video_coding/include/video_codec_initializer.h" 12 13 #include <cstddef> 14 #include <cstdint> 15 #include <memory> 16 #include <optional> 17 #include <vector> 18 19 #include "api/environment/environment.h" 20 #include "api/environment/environment_factory.h" 21 #include "api/make_ref_counted.h" 22 #include "api/scoped_refptr.h" 23 #include "api/test/mock_fec_controller_override.h" 24 #include "api/video/builtin_video_bitrate_allocator_factory.h" 25 #include "api/video/video_bitrate_allocation.h" 26 #include "api/video/video_bitrate_allocator.h" 27 #include "api/video/video_bitrate_allocator_factory.h" 28 #include "api/video/video_codec_type.h" 29 #include "api/video_codecs/scalability_mode.h" 30 #include "api/video_codecs/video_codec.h" 31 #include "api/video_codecs/video_encoder.h" 32 #include "api/video_codecs/vp8_frame_buffer_controller.h" 33 #include "api/video_codecs/vp8_temporal_layers_factory.h" 34 #include "modules/video_coding/codecs/vp9/include/vp9_globals.h" 35 #include "rtc_base/checks.h" 36 #include "test/gtest.h" 37 #include "video/config/video_encoder_config.h" 38 39 namespace webrtc { 40 41 namespace { 42 constexpr int kDefaultWidth = 1280; 43 constexpr int kDefaultHeight = 720; 44 constexpr int kDefaultFrameRate = 30; 45 constexpr uint32_t kDefaultMinBitrateBps = 60000; 46 constexpr uint32_t kDefaultTargetBitrateBps = 2000000; 47 constexpr uint32_t kDefaultMaxBitrateBps = 2000000; 48 constexpr uint32_t kDefaultMinTransmitBitrateBps = 400000; 49 constexpr int kDefaultMaxQp = 48; 50 constexpr uint32_t kScreenshareTl0BitrateBps = 120000; 51 constexpr uint32_t kScreenshareConferenceTl0BitrateBps = 200000; 52 constexpr uint32_t kScreenshareCodecTargetBitrateBps = 200000; 53 constexpr uint32_t kScreenshareDefaultFramerate = 5; 54 // Bitrates for the temporal layers of the higher screenshare simulcast stream. 55 constexpr uint32_t kHighScreenshareTl0Bps = 800000; 56 constexpr uint32_t kHighScreenshareTl1Bps = 1200000; 57 } // namespace 58 59 // TODO(sprang): Extend coverage to handle the rest of the codec initializer. 60 class VideoCodecInitializerTest : public ::testing::Test { 61 public: 62 VideoCodecInitializerTest() {} 63 ~VideoCodecInitializerTest() override {} 64 65 protected: 66 void SetUpFor(VideoCodecType type, 67 std::optional<int> num_simulcast_streams, 68 std::optional<int> num_spatial_streams, 69 int num_temporal_streams, 70 bool screenshare) { 71 config_ = VideoEncoderConfig(); 72 config_.codec_type = type; 73 74 if (screenshare) { 75 config_.min_transmit_bitrate_bps = kDefaultMinTransmitBitrateBps; 76 config_.content_type = VideoEncoderConfig::ContentType::kScreen; 77 } 78 79 if (num_simulcast_streams.has_value()) { 80 config_.number_of_streams = num_simulcast_streams.value(); 81 } 82 if (type == VideoCodecType::kVideoCodecVP8) { 83 ASSERT_FALSE(num_spatial_streams.has_value()); 84 VideoCodecVP8 vp8_settings = VideoEncoder::GetDefaultVp8Settings(); 85 vp8_settings.numberOfTemporalLayers = num_temporal_streams; 86 config_.encoder_specific_settings = 87 make_ref_counted<VideoEncoderConfig::Vp8EncoderSpecificSettings>( 88 vp8_settings); 89 } else if (type == VideoCodecType::kVideoCodecVP9) { 90 ASSERT_TRUE(num_spatial_streams.has_value()); 91 VideoCodecVP9 vp9_settings = VideoEncoder::GetDefaultVp9Settings(); 92 vp9_settings.numberOfSpatialLayers = num_spatial_streams.value(); 93 vp9_settings.numberOfTemporalLayers = num_temporal_streams; 94 config_.encoder_specific_settings = 95 make_ref_counted<VideoEncoderConfig::Vp9EncoderSpecificSettings>( 96 vp9_settings); 97 } 98 } 99 100 void InitializeCodec() { 101 frame_buffer_controller_.reset(); 102 codec_out_ = VideoCodecInitializer::SetupCodec(env_.field_trials(), config_, 103 streams_); 104 bitrate_allocator_ = 105 CreateBuiltinVideoBitrateAllocatorFactory()->Create(env_, codec_out_); 106 RTC_CHECK(bitrate_allocator_); 107 108 // Make sure temporal layers instances have been created. 109 if (codec_out_.codecType == VideoCodecType::kVideoCodecVP8) { 110 Vp8TemporalLayersFactory factory; 111 const VideoEncoder::Settings settings(VideoEncoder::Capabilities(false), 112 1, 1000); 113 frame_buffer_controller_ = 114 factory.Create(env_, codec_out_, settings, &fec_controller_override_); 115 } 116 } 117 118 VideoStream DefaultStream( 119 int width = kDefaultWidth, 120 int height = kDefaultHeight, 121 std::optional<ScalabilityMode> scalability_mode = std::nullopt) { 122 VideoStream stream; 123 stream.width = width; 124 stream.height = height; 125 stream.max_framerate = kDefaultFrameRate; 126 stream.min_bitrate_bps = kDefaultMinBitrateBps; 127 stream.target_bitrate_bps = kDefaultTargetBitrateBps; 128 stream.max_bitrate_bps = kDefaultMaxBitrateBps; 129 stream.max_qp = kDefaultMaxQp; 130 stream.num_temporal_layers = 1; 131 stream.active = true; 132 stream.scalability_mode = scalability_mode; 133 return stream; 134 } 135 136 VideoStream DefaultScreenshareStream() { 137 VideoStream stream = DefaultStream(); 138 stream.min_bitrate_bps = 30000; 139 stream.target_bitrate_bps = kScreenshareCodecTargetBitrateBps; 140 stream.max_bitrate_bps = 1000000; 141 stream.max_framerate = kScreenshareDefaultFramerate; 142 stream.num_temporal_layers = 2; 143 stream.active = true; 144 return stream; 145 } 146 147 const Environment env_ = CreateEnvironment(); 148 MockFecControllerOverride fec_controller_override_; 149 150 // Input settings. 151 VideoEncoderConfig config_; 152 std::vector<VideoStream> streams_; 153 154 // Output. 155 VideoCodec codec_out_; 156 std::unique_ptr<VideoBitrateAllocator> bitrate_allocator_; 157 std::unique_ptr<Vp8FrameBufferController> frame_buffer_controller_; 158 }; 159 160 TEST_F(VideoCodecInitializerTest, SingleStreamVp8Screenshare) { 161 SetUpFor(VideoCodecType::kVideoCodecVP8, 1, std::nullopt, 1, true); 162 streams_.push_back(DefaultStream()); 163 InitializeCodec(); 164 165 VideoBitrateAllocation bitrate_allocation = 166 bitrate_allocator_->Allocate(VideoBitrateAllocationParameters( 167 kDefaultTargetBitrateBps, kDefaultFrameRate)); 168 EXPECT_EQ(1u, codec_out_.numberOfSimulcastStreams); 169 EXPECT_EQ(1u, codec_out_.VP8()->numberOfTemporalLayers); 170 EXPECT_EQ(kDefaultTargetBitrateBps, bitrate_allocation.get_sum_bps()); 171 } 172 173 TEST_F(VideoCodecInitializerTest, SingleStreamVp8ScreenshareInactive) { 174 SetUpFor(VideoCodecType::kVideoCodecVP8, 1, std::nullopt, 1, true); 175 VideoStream inactive_stream = DefaultStream(); 176 inactive_stream.active = false; 177 streams_.push_back(inactive_stream); 178 InitializeCodec(); 179 180 VideoBitrateAllocation bitrate_allocation = 181 bitrate_allocator_->Allocate(VideoBitrateAllocationParameters( 182 kDefaultTargetBitrateBps, kDefaultFrameRate)); 183 EXPECT_EQ(1u, codec_out_.numberOfSimulcastStreams); 184 EXPECT_EQ(1u, codec_out_.VP8()->numberOfTemporalLayers); 185 EXPECT_EQ(0U, bitrate_allocation.get_sum_bps()); 186 } 187 188 TEST_F(VideoCodecInitializerTest, TemporalLayeredVp8ScreenshareConference) { 189 SetUpFor(VideoCodecType::kVideoCodecVP8, 1, std::nullopt, 2, true); 190 streams_.push_back(DefaultScreenshareStream()); 191 InitializeCodec(); 192 bitrate_allocator_->SetLegacyConferenceMode(true); 193 194 EXPECT_EQ(1u, codec_out_.numberOfSimulcastStreams); 195 EXPECT_EQ(2u, codec_out_.VP8()->numberOfTemporalLayers); 196 VideoBitrateAllocation bitrate_allocation = 197 bitrate_allocator_->Allocate(VideoBitrateAllocationParameters( 198 kScreenshareCodecTargetBitrateBps, kScreenshareDefaultFramerate)); 199 EXPECT_EQ(kScreenshareCodecTargetBitrateBps, 200 bitrate_allocation.get_sum_bps()); 201 EXPECT_EQ(kScreenshareConferenceTl0BitrateBps, 202 bitrate_allocation.GetBitrate(0, 0)); 203 } 204 205 TEST_F(VideoCodecInitializerTest, TemporalLayeredVp8Screenshare) { 206 SetUpFor(VideoCodecType::kVideoCodecVP8, 1, std::nullopt, 2, true); 207 streams_.push_back(DefaultScreenshareStream()); 208 InitializeCodec(); 209 210 EXPECT_EQ(1u, codec_out_.numberOfSimulcastStreams); 211 EXPECT_EQ(2u, codec_out_.VP8()->numberOfTemporalLayers); 212 VideoBitrateAllocation bitrate_allocation = 213 bitrate_allocator_->Allocate(VideoBitrateAllocationParameters( 214 kScreenshareCodecTargetBitrateBps, kScreenshareDefaultFramerate)); 215 EXPECT_EQ(kScreenshareCodecTargetBitrateBps, 216 bitrate_allocation.get_sum_bps()); 217 EXPECT_EQ(kScreenshareTl0BitrateBps, bitrate_allocation.GetBitrate(0, 0)); 218 } 219 220 TEST_F(VideoCodecInitializerTest, SimulcastVp8Screenshare) { 221 SetUpFor(VideoCodecType::kVideoCodecVP8, 2, std::nullopt, 1, true); 222 streams_.push_back(DefaultScreenshareStream()); 223 VideoStream video_stream = DefaultStream(); 224 video_stream.max_framerate = kScreenshareDefaultFramerate; 225 streams_.push_back(video_stream); 226 InitializeCodec(); 227 228 EXPECT_EQ(2u, codec_out_.numberOfSimulcastStreams); 229 EXPECT_EQ(1u, codec_out_.VP8()->numberOfTemporalLayers); 230 const uint32_t max_bitrate_bps = 231 streams_[0].target_bitrate_bps + streams_[1].max_bitrate_bps; 232 VideoBitrateAllocation bitrate_allocation = 233 bitrate_allocator_->Allocate(VideoBitrateAllocationParameters( 234 max_bitrate_bps, kScreenshareDefaultFramerate)); 235 EXPECT_EQ(max_bitrate_bps, bitrate_allocation.get_sum_bps()); 236 EXPECT_EQ(static_cast<uint32_t>(streams_[0].target_bitrate_bps), 237 bitrate_allocation.GetSpatialLayerSum(0)); 238 EXPECT_EQ(static_cast<uint32_t>(streams_[1].max_bitrate_bps), 239 bitrate_allocation.GetSpatialLayerSum(1)); 240 } 241 242 // Tests that when a video stream is inactive, then the bitrate allocation will 243 // be 0 for that stream. 244 TEST_F(VideoCodecInitializerTest, SimulcastVp8ScreenshareInactive) { 245 SetUpFor(VideoCodecType::kVideoCodecVP8, 2, std::nullopt, 1, true); 246 streams_.push_back(DefaultScreenshareStream()); 247 VideoStream inactive_video_stream = DefaultStream(); 248 inactive_video_stream.active = false; 249 inactive_video_stream.max_framerate = kScreenshareDefaultFramerate; 250 streams_.push_back(inactive_video_stream); 251 InitializeCodec(); 252 253 EXPECT_EQ(2u, codec_out_.numberOfSimulcastStreams); 254 EXPECT_EQ(1u, codec_out_.VP8()->numberOfTemporalLayers); 255 const uint32_t target_bitrate = 256 streams_[0].target_bitrate_bps + streams_[1].target_bitrate_bps; 257 VideoBitrateAllocation bitrate_allocation = 258 bitrate_allocator_->Allocate(VideoBitrateAllocationParameters( 259 target_bitrate, kScreenshareDefaultFramerate)); 260 EXPECT_EQ(static_cast<uint32_t>(streams_[0].max_bitrate_bps), 261 bitrate_allocation.get_sum_bps()); 262 EXPECT_EQ(static_cast<uint32_t>(streams_[0].max_bitrate_bps), 263 bitrate_allocation.GetSpatialLayerSum(0)); 264 EXPECT_EQ(0U, bitrate_allocation.GetSpatialLayerSum(1)); 265 } 266 267 TEST_F(VideoCodecInitializerTest, HighFpsSimulcastVp8Screenshare) { 268 // Two simulcast streams, the lower one using legacy settings (two temporal 269 // streams, 5fps), the higher one using 3 temporal streams and 30fps. 270 SetUpFor(VideoCodecType::kVideoCodecVP8, 2, std::nullopt, 3, true); 271 streams_.push_back(DefaultScreenshareStream()); 272 VideoStream video_stream = DefaultStream(); 273 video_stream.num_temporal_layers = 3; 274 streams_.push_back(video_stream); 275 InitializeCodec(); 276 277 EXPECT_EQ(2u, codec_out_.numberOfSimulcastStreams); 278 EXPECT_EQ(3u, codec_out_.VP8()->numberOfTemporalLayers); 279 const uint32_t max_bitrate_bps = 280 streams_[0].target_bitrate_bps + streams_[1].max_bitrate_bps; 281 VideoBitrateAllocation bitrate_allocation = bitrate_allocator_->Allocate( 282 VideoBitrateAllocationParameters(max_bitrate_bps, kDefaultFrameRate)); 283 EXPECT_EQ(max_bitrate_bps, bitrate_allocation.get_sum_bps()); 284 EXPECT_EQ(static_cast<uint32_t>(streams_[0].target_bitrate_bps), 285 bitrate_allocation.GetSpatialLayerSum(0)); 286 EXPECT_EQ(static_cast<uint32_t>(streams_[1].max_bitrate_bps), 287 bitrate_allocation.GetSpatialLayerSum(1)); 288 EXPECT_EQ(kHighScreenshareTl0Bps, bitrate_allocation.GetBitrate(1, 0)); 289 EXPECT_EQ(kHighScreenshareTl1Bps - kHighScreenshareTl0Bps, 290 bitrate_allocation.GetBitrate(1, 1)); 291 } 292 293 TEST_F(VideoCodecInitializerTest, Vp9SvcDefaultLayering) { 294 SetUpFor(VideoCodecType::kVideoCodecVP9, std::nullopt, 3, 3, false); 295 VideoStream stream = DefaultStream(); 296 stream.num_temporal_layers = 3; 297 streams_.push_back(stream); 298 299 InitializeCodec(); 300 EXPECT_EQ(codec_out_.VP9()->numberOfSpatialLayers, 3u); 301 EXPECT_EQ(codec_out_.VP9()->numberOfTemporalLayers, 3u); 302 } 303 304 TEST_F(VideoCodecInitializerTest, Vp9SvcAdjustedLayering) { 305 SetUpFor(VideoCodecType::kVideoCodecVP9, std::nullopt, 3, 3, false); 306 VideoStream stream = DefaultStream(); 307 stream.num_temporal_layers = 3; 308 // Set resolution which is only enough to produce 2 spatial layers. 309 stream.width = kMinVp9SpatialLayerLongSideLength * 2; 310 stream.height = kMinVp9SpatialLayerShortSideLength * 2; 311 312 streams_.push_back(stream); 313 314 InitializeCodec(); 315 EXPECT_EQ(codec_out_.VP9()->numberOfSpatialLayers, 2u); 316 } 317 318 TEST_F(VideoCodecInitializerTest, 319 Vp9SingleSpatialLayerMaxBitrateIsEqualToCodecMaxBitrate) { 320 SetUpFor(VideoCodecType::kVideoCodecVP9, std::nullopt, 1, 3, false); 321 VideoStream stream = DefaultStream(); 322 stream.num_temporal_layers = 3; 323 streams_.push_back(stream); 324 325 InitializeCodec(); 326 EXPECT_EQ(codec_out_.spatialLayers[0].maxBitrate, 327 kDefaultMaxBitrateBps / 1000); 328 } 329 330 TEST_F(VideoCodecInitializerTest, 331 Vp9SingleSpatialLayerMaxBitrateIsEqualToCodecMaxBitrateWithL1T1) { 332 SetUpFor(VideoCodecType::kVideoCodecVP9, 1, 1, 1, false); 333 VideoStream stream = DefaultStream(); 334 stream.num_temporal_layers = 1; 335 stream.scalability_mode = ScalabilityMode::kL1T1; 336 streams_.push_back(stream); 337 338 InitializeCodec(); 339 EXPECT_EQ(1u, codec_out_.VP9()->numberOfSpatialLayers); 340 EXPECT_EQ(codec_out_.spatialLayers[0].minBitrate, 341 kDefaultMinBitrateBps / 1000); 342 EXPECT_EQ(codec_out_.spatialLayers[0].maxBitrate, 343 kDefaultMaxBitrateBps / 1000); 344 } 345 346 TEST_F(VideoCodecInitializerTest, 347 Vp9SingleSpatialLayerTargetBitrateIsEqualToCodecMaxBitrate) { 348 SetUpFor(VideoCodecType::kVideoCodecVP9, std::nullopt, 1, 1, true); 349 VideoStream stream = DefaultStream(); 350 stream.num_temporal_layers = 1; 351 streams_.push_back(stream); 352 353 InitializeCodec(); 354 EXPECT_EQ(codec_out_.spatialLayers[0].targetBitrate, 355 kDefaultMaxBitrateBps / 1000); 356 } 357 358 TEST_F(VideoCodecInitializerTest, 359 Vp9KeepBitrateLimitsIfNumberOfSpatialLayersIsReducedToOne) { 360 // Request 3 spatial layers for 320x180 input. Actual number of layers will be 361 // reduced to 1 due to low input resolution but SVC bitrate limits should be 362 // applied. 363 SetUpFor(VideoCodecType::kVideoCodecVP9, std::nullopt, 3, 3, false); 364 VideoStream stream = DefaultStream(); 365 stream.width = 320; 366 stream.height = 180; 367 stream.num_temporal_layers = 3; 368 streams_.push_back(stream); 369 370 InitializeCodec(); 371 EXPECT_LT(codec_out_.spatialLayers[0].maxBitrate, 372 kDefaultMaxBitrateBps / 1000); 373 } 374 375 TEST_F(VideoCodecInitializerTest, 376 Vp9KeepBitrateLimitsIfNumberOfSpatialLayersIsReducedToOneWithL3T1) { 377 // Request 3 spatial layers for 320x180 input. Actual number of layers will be 378 // reduced to 1 due to low input resolution but SVC bitrate limits should be 379 // applied. 380 SetUpFor(VideoCodecType::kVideoCodecVP9, 1, 3, 1, false); 381 VideoStream stream = DefaultStream(); 382 stream.width = 320; 383 stream.height = 180; 384 stream.num_temporal_layers = 1; 385 stream.scalability_mode = ScalabilityMode::kL3T1; 386 streams_.push_back(stream); 387 388 InitializeCodec(); 389 EXPECT_EQ(1u, codec_out_.VP9()->numberOfSpatialLayers); 390 EXPECT_LT(codec_out_.spatialLayers[0].minBitrate, 391 kDefaultMinBitrateBps / 1000); 392 EXPECT_LT(codec_out_.spatialLayers[0].maxBitrate, 393 kDefaultMaxBitrateBps / 1000); 394 } 395 396 TEST_F(VideoCodecInitializerTest, Vp9DeactivateLayers) { 397 SetUpFor(VideoCodecType::kVideoCodecVP9, std::nullopt, 3, 1, false); 398 VideoStream stream = DefaultStream(); 399 streams_.push_back(stream); 400 401 config_.simulcast_layers.resize(3); 402 403 // Activate all layers. 404 config_.simulcast_layers[0].active = true; 405 config_.simulcast_layers[1].active = true; 406 config_.simulcast_layers[2].active = true; 407 InitializeCodec(); 408 EXPECT_EQ(codec_out_.VP9()->numberOfSpatialLayers, 3); 409 EXPECT_TRUE(codec_out_.spatialLayers[0].active); 410 EXPECT_TRUE(codec_out_.spatialLayers[1].active); 411 EXPECT_TRUE(codec_out_.spatialLayers[2].active); 412 413 // Deactivate top layer. 414 config_.simulcast_layers[0].active = true; 415 config_.simulcast_layers[1].active = true; 416 config_.simulcast_layers[2].active = false; 417 InitializeCodec(); 418 EXPECT_EQ(codec_out_.VP9()->numberOfSpatialLayers, 3); 419 EXPECT_TRUE(codec_out_.spatialLayers[0].active); 420 EXPECT_TRUE(codec_out_.spatialLayers[1].active); 421 EXPECT_FALSE(codec_out_.spatialLayers[2].active); 422 423 // Deactivate middle layer. 424 config_.simulcast_layers[0].active = true; 425 config_.simulcast_layers[1].active = false; 426 config_.simulcast_layers[2].active = true; 427 InitializeCodec(); 428 EXPECT_EQ(codec_out_.VP9()->numberOfSpatialLayers, 3); 429 EXPECT_TRUE(codec_out_.spatialLayers[0].active); 430 EXPECT_FALSE(codec_out_.spatialLayers[1].active); 431 EXPECT_TRUE(codec_out_.spatialLayers[2].active); 432 433 // Deactivate first layer. 434 config_.simulcast_layers[0].active = false; 435 config_.simulcast_layers[1].active = true; 436 config_.simulcast_layers[2].active = true; 437 InitializeCodec(); 438 EXPECT_EQ(codec_out_.VP9()->numberOfSpatialLayers, 2); 439 EXPECT_TRUE(codec_out_.spatialLayers[0].active); 440 EXPECT_TRUE(codec_out_.spatialLayers[1].active); 441 442 // HD singlecast. 443 config_.simulcast_layers[0].active = false; 444 config_.simulcast_layers[1].active = false; 445 config_.simulcast_layers[2].active = true; 446 InitializeCodec(); 447 EXPECT_EQ(codec_out_.VP9()->numberOfSpatialLayers, 1); 448 EXPECT_TRUE(codec_out_.spatialLayers[0].active); 449 450 // VGA singlecast. 451 config_.simulcast_layers[0].active = false; 452 config_.simulcast_layers[1].active = true; 453 config_.simulcast_layers[2].active = false; 454 InitializeCodec(); 455 EXPECT_EQ(codec_out_.VP9()->numberOfSpatialLayers, 2); 456 EXPECT_TRUE(codec_out_.spatialLayers[0].active); 457 EXPECT_FALSE(codec_out_.spatialLayers[1].active); 458 459 // QVGA singlecast. 460 config_.simulcast_layers[0].active = true; 461 config_.simulcast_layers[1].active = false; 462 config_.simulcast_layers[2].active = false; 463 InitializeCodec(); 464 EXPECT_EQ(codec_out_.VP9()->numberOfSpatialLayers, 3); 465 EXPECT_TRUE(codec_out_.spatialLayers[0].active); 466 EXPECT_FALSE(codec_out_.spatialLayers[1].active); 467 EXPECT_FALSE(codec_out_.spatialLayers[2].active); 468 } 469 470 TEST_F(VideoCodecInitializerTest, Vp9SvcResolutionAlignment) { 471 SetUpFor(VideoCodecType::kVideoCodecVP9, std::nullopt, 3, 3, false); 472 VideoStream stream = DefaultStream(); 473 stream.width = 1281; 474 stream.height = 721; 475 stream.num_temporal_layers = 3; 476 streams_.push_back(stream); 477 478 InitializeCodec(); 479 EXPECT_EQ(codec_out_.width, 1280); 480 EXPECT_EQ(codec_out_.height, 720); 481 EXPECT_EQ(codec_out_.numberOfSimulcastStreams, 1); 482 EXPECT_EQ(codec_out_.simulcastStream[0].width, 1280); 483 EXPECT_EQ(codec_out_.simulcastStream[0].height, 720); 484 } 485 486 TEST_F(VideoCodecInitializerTest, Vp9SimulcastResolutions) { 487 // 3 x L1T3 488 SetUpFor(VideoCodecType::kVideoCodecVP9, 3, 1, 3, false); 489 // Scalability mode has to be set on all layers to avoid legacy SVC paths. 490 streams_ = {DefaultStream(320, 180, ScalabilityMode::kL1T3), 491 DefaultStream(640, 360, ScalabilityMode::kL1T3), 492 DefaultStream(1280, 720, ScalabilityMode::kL1T3)}; 493 494 InitializeCodec(); 495 // This is expected to be the largest layer. 496 EXPECT_EQ(codec_out_.width, 1280); 497 EXPECT_EQ(codec_out_.height, 720); 498 // `simulcastStream` is expected to be the same as the input (same order). 499 EXPECT_EQ(codec_out_.numberOfSimulcastStreams, 3); 500 EXPECT_EQ(codec_out_.simulcastStream[0].width, 320); 501 EXPECT_EQ(codec_out_.simulcastStream[0].height, 180); 502 EXPECT_EQ(codec_out_.simulcastStream[1].width, 640); 503 EXPECT_EQ(codec_out_.simulcastStream[1].height, 360); 504 EXPECT_EQ(codec_out_.simulcastStream[2].width, 1280); 505 EXPECT_EQ(codec_out_.simulcastStream[2].height, 720); 506 } 507 508 TEST_F(VideoCodecInitializerTest, Av1SingleSpatialLayerBitratesAreConsistent) { 509 VideoEncoderConfig config; 510 config.codec_type = VideoCodecType::kVideoCodecAV1; 511 std::vector<VideoStream> streams = {DefaultStream()}; 512 streams[0].scalability_mode = ScalabilityMode::kL1T2; 513 514 VideoCodec codec = 515 VideoCodecInitializer::SetupCodec(env_.field_trials(), config, streams); 516 517 EXPECT_GE(codec.spatialLayers[0].targetBitrate, 518 codec.spatialLayers[0].minBitrate); 519 EXPECT_LE(codec.spatialLayers[0].targetBitrate, 520 codec.spatialLayers[0].maxBitrate); 521 } 522 523 TEST_F(VideoCodecInitializerTest, Av1TwoSpatialLayersBitratesAreConsistent) { 524 VideoEncoderConfig config; 525 config.codec_type = VideoCodecType::kVideoCodecAV1; 526 std::vector<VideoStream> streams = {DefaultStream()}; 527 streams[0].scalability_mode = ScalabilityMode::kL2T2; 528 529 VideoCodec codec = 530 VideoCodecInitializer::SetupCodec(env_.field_trials(), config, streams); 531 532 EXPECT_GE(codec.spatialLayers[0].targetBitrate, 533 codec.spatialLayers[0].minBitrate); 534 EXPECT_LE(codec.spatialLayers[0].targetBitrate, 535 codec.spatialLayers[0].maxBitrate); 536 537 EXPECT_GE(codec.spatialLayers[1].targetBitrate, 538 codec.spatialLayers[1].minBitrate); 539 EXPECT_LE(codec.spatialLayers[1].targetBitrate, 540 codec.spatialLayers[1].maxBitrate); 541 } 542 543 TEST_F(VideoCodecInitializerTest, Av1ConfiguredMinBitrateApplied) { 544 VideoEncoderConfig config; 545 config.simulcast_layers.resize(1); 546 config.simulcast_layers[0].min_bitrate_bps = 28000; 547 config.codec_type = VideoCodecType::kVideoCodecAV1; 548 std::vector<VideoStream> streams = {DefaultStream()}; 549 streams[0].scalability_mode = ScalabilityMode::kL3T2; 550 551 VideoCodec codec = 552 VideoCodecInitializer::SetupCodec(env_.field_trials(), config, streams); 553 554 EXPECT_EQ(codec.spatialLayers[0].minBitrate, 28u); 555 EXPECT_GE(codec.spatialLayers[0].targetBitrate, 556 codec.spatialLayers[0].minBitrate); 557 } 558 559 TEST_F(VideoCodecInitializerTest, 560 Av1ConfiguredMinBitrateLimitedByDefaultTargetBitrate) { 561 VideoEncoderConfig config; 562 config.simulcast_layers.resize(1); 563 config.simulcast_layers[0].min_bitrate_bps = 2228000; 564 config.codec_type = VideoCodecType::kVideoCodecAV1; 565 std::vector<VideoStream> streams = {DefaultStream()}; 566 streams[0].scalability_mode = ScalabilityMode::kL3T2; 567 568 VideoCodec codec = 569 VideoCodecInitializer::SetupCodec(env_.field_trials(), config, streams); 570 571 EXPECT_GE(codec.spatialLayers[0].targetBitrate, 572 codec.spatialLayers[0].minBitrate); 573 } 574 575 TEST_F(VideoCodecInitializerTest, Av1ConfiguredMinBitrateNotAppliedIfUnset) { 576 VideoEncoderConfig config; 577 config.simulcast_layers.resize(1); 578 config.codec_type = VideoCodecType::kVideoCodecAV1; 579 std::vector<VideoStream> streams = {DefaultStream()}; 580 streams[0].scalability_mode = ScalabilityMode::kL3T2; 581 582 VideoCodec codec = 583 VideoCodecInitializer::SetupCodec(env_.field_trials(), config, streams); 584 585 EXPECT_GT(codec.spatialLayers[0].minBitrate, 0u); 586 } 587 588 TEST_F(VideoCodecInitializerTest, Av1TwoSpatialLayersActiveByDefault) { 589 VideoEncoderConfig config; 590 config.codec_type = VideoCodecType::kVideoCodecAV1; 591 std::vector<VideoStream> streams = {DefaultStream()}; 592 streams[0].scalability_mode = ScalabilityMode::kL2T2; 593 config.spatial_layers = {}; 594 595 VideoCodec codec = 596 VideoCodecInitializer::SetupCodec(env_.field_trials(), config, streams); 597 598 EXPECT_TRUE(codec.spatialLayers[0].active); 599 EXPECT_TRUE(codec.spatialLayers[1].active); 600 } 601 602 TEST_F(VideoCodecInitializerTest, Av1TwoSpatialLayersOneDeactivated) { 603 VideoEncoderConfig config; 604 config.codec_type = VideoCodecType::kVideoCodecAV1; 605 std::vector<VideoStream> streams = {DefaultStream()}; 606 streams[0].scalability_mode = ScalabilityMode::kL2T2; 607 config.spatial_layers.resize(2); 608 config.spatial_layers[0].active = true; 609 config.spatial_layers[1].active = false; 610 611 VideoCodec codec = 612 VideoCodecInitializer::SetupCodec(env_.field_trials(), config, streams); 613 614 EXPECT_TRUE(codec.spatialLayers[0].active); 615 EXPECT_FALSE(codec.spatialLayers[1].active); 616 } 617 618 TEST_F(VideoCodecInitializerTest, Vp9SingleSpatialLayerBitratesAreConsistent) { 619 VideoEncoderConfig config; 620 config.simulcast_layers.resize(3); 621 config.simulcast_layers[0].active = true; 622 config.simulcast_layers[1].active = false; 623 config.simulcast_layers[2].active = false; 624 625 config.codec_type = VideoCodecType::kVideoCodecVP9; 626 std::vector<VideoStream> streams = {DefaultStream()}; 627 streams[0].scalability_mode = ScalabilityMode::kL1T2; 628 629 VideoCodec codec = 630 VideoCodecInitializer::SetupCodec(env_.field_trials(), config, streams); 631 632 EXPECT_EQ(1u, codec.VP9()->numberOfSpatialLayers); 633 // Target is consistent with min and max (min <= target <= max). 634 EXPECT_GE(codec.spatialLayers[0].targetBitrate, 635 codec.spatialLayers[0].minBitrate); 636 EXPECT_LE(codec.spatialLayers[0].targetBitrate, 637 codec.spatialLayers[0].maxBitrate); 638 // In the single spatial layer case, the spatial layer bitrates are copied 639 // from the codec's bitrate which is the sum if VideoStream bitrates. In this 640 // case we only have a single VideoStream using default values. 641 EXPECT_EQ(codec.spatialLayers[0].minBitrate, kDefaultMinBitrateBps / 1000); 642 EXPECT_EQ(codec.spatialLayers[0].targetBitrate, kDefaultMaxBitrateBps / 1000); 643 EXPECT_EQ(codec.spatialLayers[0].maxBitrate, kDefaultMaxBitrateBps / 1000); 644 } 645 646 TEST_F(VideoCodecInitializerTest, Vp9TwoSpatialLayersBitratesAreConsistent) { 647 VideoEncoderConfig config; 648 config.simulcast_layers.resize(3); 649 config.simulcast_layers[0].active = true; 650 config.simulcast_layers[1].active = false; 651 config.simulcast_layers[2].active = false; 652 653 config.codec_type = VideoCodecType::kVideoCodecVP9; 654 std::vector<VideoStream> streams = {DefaultStream()}; 655 streams[0].scalability_mode = ScalabilityMode::kL2T2; 656 657 VideoCodec codec = 658 VideoCodecInitializer::SetupCodec(env_.field_trials(), config, streams); 659 660 EXPECT_EQ(2u, codec.VP9()->numberOfSpatialLayers); 661 EXPECT_GE(codec.spatialLayers[0].targetBitrate, 662 codec.spatialLayers[0].minBitrate); 663 EXPECT_LE(codec.spatialLayers[0].targetBitrate, 664 codec.spatialLayers[0].maxBitrate); 665 EXPECT_LT(codec.spatialLayers[0].minBitrate, kDefaultMinBitrateBps / 1000); 666 667 EXPECT_GE(codec.spatialLayers[1].targetBitrate, 668 codec.spatialLayers[1].minBitrate); 669 EXPECT_LE(codec.spatialLayers[1].targetBitrate, 670 codec.spatialLayers[1].maxBitrate); 671 EXPECT_GT(codec.spatialLayers[1].minBitrate, 672 codec.spatialLayers[0].maxBitrate); 673 } 674 675 TEST_F(VideoCodecInitializerTest, UpdatesVp9SpecificFieldsWithScalabilityMode) { 676 VideoEncoderConfig config; 677 config.codec_type = VideoCodecType::kVideoCodecVP9; 678 std::vector<VideoStream> streams = {DefaultStream()}; 679 streams[0].scalability_mode = ScalabilityMode::kL2T3_KEY; 680 681 VideoCodec codec = 682 VideoCodecInitializer::SetupCodec(env_.field_trials(), config, streams); 683 684 EXPECT_EQ(codec.VP9()->numberOfSpatialLayers, 2u); 685 EXPECT_EQ(codec.VP9()->numberOfTemporalLayers, 3u); 686 EXPECT_EQ(codec.VP9()->interLayerPred, InterLayerPredMode::kOnKeyPic); 687 688 streams[0].scalability_mode = ScalabilityMode::kS3T1; 689 codec = 690 VideoCodecInitializer::SetupCodec(env_.field_trials(), config, streams); 691 692 EXPECT_EQ(codec.VP9()->numberOfSpatialLayers, 3u); 693 EXPECT_EQ(codec.VP9()->numberOfTemporalLayers, 1u); 694 EXPECT_EQ(codec.VP9()->interLayerPred, InterLayerPredMode::kOff); 695 } 696 697 #ifdef RTC_ENABLE_H265 698 TEST_F(VideoCodecInitializerTest, H265SingleSpatialLayerBitratesAreConsistent) { 699 VideoEncoderConfig config; 700 config.codec_type = VideoCodecType::kVideoCodecH265; 701 std::vector<VideoStream> streams = {DefaultStream()}; 702 streams[0].scalability_mode = ScalabilityMode::kL1T2; 703 704 VideoCodec codec = 705 VideoCodecInitializer::SetupCodec(env_.field_trials(), config, streams); 706 707 EXPECT_GE(codec.spatialLayers[0].targetBitrate, 708 codec.spatialLayers[0].minBitrate); 709 EXPECT_LE(codec.spatialLayers[0].targetBitrate, 710 codec.spatialLayers[0].maxBitrate); 711 } 712 713 // Test that the H.265 codec initializer carries over invalid simulcast layer 714 // scalability mode to top level scalability mode setting. 715 TEST_F(VideoCodecInitializerTest, 716 H265ScalabilityModeConfiguredToTopLevelWhenNotAllowed) { 717 VideoEncoderConfig config; 718 config.codec_type = VideoCodecType::kVideoCodecH265; 719 720 std::vector<VideoStream> streams = {DefaultStream()}; 721 streams[0].scalability_mode = ScalabilityMode::kL3T3; 722 723 VideoCodec codec = 724 VideoCodecInitializer::SetupCodec(env_.field_trials(), config, streams); 725 726 // Check that an unsupported scalability mode will cause top-level scalability 727 // to be set to the same unsupported mode. 728 EXPECT_EQ(codec.GetScalabilityMode(), ScalabilityMode::kL3T3); 729 EXPECT_EQ(codec.spatialLayers[0].numberOfTemporalLayers, 3); 730 EXPECT_EQ(codec.simulcastStream[0].numberOfTemporalLayers, 3); 731 } 732 733 // Test that inconistent scalability mode settings in simulcast streams will 734 // clear top level scalability mode setting. 735 TEST_F(VideoCodecInitializerTest, 736 H265InconsistentScalabilityModesWillClearTopLevelScalability) { 737 VideoEncoderConfig config; 738 config.simulcast_layers.resize(2); 739 config.simulcast_layers[0].active = true; 740 config.simulcast_layers[1].active = true; 741 config.codec_type = VideoCodecType::kVideoCodecH265; 742 743 std::vector<VideoStream> streams = {DefaultStream(), DefaultStream()}; 744 streams[0].scalability_mode = ScalabilityMode::kL1T3; 745 streams[1].scalability_mode = ScalabilityMode::kL1T1; 746 747 VideoCodec codec = 748 VideoCodecInitializer::SetupCodec(env_.field_trials(), config, streams); 749 750 // Top level scalability mode should be cleared if the simulcast streams have 751 // different per-stream temporal layer settings. 752 EXPECT_EQ(codec.GetScalabilityMode(), std::nullopt); 753 EXPECT_EQ(codec.spatialLayers[0].numberOfTemporalLayers, 3); 754 EXPECT_EQ(codec.simulcastStream[0].numberOfTemporalLayers, 3); 755 EXPECT_EQ(codec.simulcastStream[1].numberOfTemporalLayers, 1); 756 } 757 #endif 758 759 } // namespace webrtc