1 /*
2 * Copyright (c) 2020 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/codecs/av1/av1_svc_config.h"
12
13 #include <algorithm>
14 #include <cmath>
15 #include <memory>
16
17 #include "modules/video_coding/svc/create_scalability_structure.h"
18 #include "modules/video_coding/svc/scalability_mode_util.h"
19 #include "modules/video_coding/svc/scalable_video_controller.h"
20 #include "rtc_base/checks.h"
21 #include "rtc_base/logging.h"
22 #include "rtc_base/strings/string_builder.h"
23
24 namespace webrtc {
25 namespace {
BuildScalabilityMode(int num_temporal_layers,int num_spatial_layers)26 absl::optional<ScalabilityMode> BuildScalabilityMode(int num_temporal_layers,
27 int num_spatial_layers) {
28 char name[20];
29 rtc::SimpleStringBuilder ss(name);
30 ss << "L" << num_spatial_layers << "T" << num_temporal_layers;
31 if (num_spatial_layers > 1) {
32 ss << "_KEY";
33 }
34
35 return ScalabilityModeFromString(name);
36 }
37 } // namespace
38
39 absl::InlinedVector<ScalabilityMode, kScalabilityModeCount>
LibaomAv1EncoderSupportedScalabilityModes()40 LibaomAv1EncoderSupportedScalabilityModes() {
41 absl::InlinedVector<ScalabilityMode, kScalabilityModeCount> scalability_modes;
42 for (ScalabilityMode scalability_mode : kAllScalabilityModes) {
43 if (ScalabilityStructureConfig(scalability_mode) != absl::nullopt) {
44 scalability_modes.push_back(scalability_mode);
45 }
46 }
47 return scalability_modes;
48 }
49
LibaomAv1EncoderSupportsScalabilityMode(ScalabilityMode scalability_mode)50 bool LibaomAv1EncoderSupportsScalabilityMode(ScalabilityMode scalability_mode) {
51 // For libaom AV1, the scalability mode is supported if we can create the
52 // scalability structure.
53 return ScalabilityStructureConfig(scalability_mode) != absl::nullopt;
54 }
55
SetAv1SvcConfig(VideoCodec & video_codec,int num_temporal_layers,int num_spatial_layers)56 bool SetAv1SvcConfig(VideoCodec& video_codec,
57 int num_temporal_layers,
58 int num_spatial_layers) {
59 RTC_DCHECK_EQ(video_codec.codecType, kVideoCodecAV1);
60
61 absl::optional<ScalabilityMode> scalability_mode =
62 video_codec.GetScalabilityMode();
63 if (!scalability_mode.has_value()) {
64 scalability_mode =
65 BuildScalabilityMode(num_temporal_layers, num_spatial_layers);
66 if (!scalability_mode) {
67 RTC_LOG(LS_WARNING) << "Scalability mode is not set, using 'L1T1'.";
68 scalability_mode = ScalabilityMode::kL1T1;
69 }
70 }
71
72 std::unique_ptr<ScalableVideoController> structure =
73 CreateScalabilityStructure(*scalability_mode);
74 if (structure == nullptr) {
75 RTC_LOG(LS_WARNING) << "Failed to create structure "
76 << static_cast<int>(*scalability_mode);
77 return false;
78 }
79
80 video_codec.SetScalabilityMode(*scalability_mode);
81
82 ScalableVideoController::StreamLayersConfig info = structure->StreamConfig();
83 for (int sl_idx = 0; sl_idx < info.num_spatial_layers; ++sl_idx) {
84 SpatialLayer& spatial_layer = video_codec.spatialLayers[sl_idx];
85 spatial_layer.width = video_codec.width * info.scaling_factor_num[sl_idx] /
86 info.scaling_factor_den[sl_idx];
87 spatial_layer.height = video_codec.height *
88 info.scaling_factor_num[sl_idx] /
89 info.scaling_factor_den[sl_idx];
90 spatial_layer.maxFramerate = video_codec.maxFramerate;
91 spatial_layer.numberOfTemporalLayers = info.num_temporal_layers;
92 spatial_layer.active = true;
93 }
94
95 if (info.num_spatial_layers == 1) {
96 SpatialLayer& spatial_layer = video_codec.spatialLayers[0];
97 spatial_layer.minBitrate = video_codec.minBitrate;
98 spatial_layer.maxBitrate = video_codec.maxBitrate;
99 spatial_layer.targetBitrate =
100 (video_codec.minBitrate + video_codec.maxBitrate) / 2;
101 return true;
102 }
103
104 for (int sl_idx = 0; sl_idx < info.num_spatial_layers; ++sl_idx) {
105 SpatialLayer& spatial_layer = video_codec.spatialLayers[sl_idx];
106 // minBitrate and maxBitrate formulas are copied from vp9 settings and
107 // are not yet tuned for av1.
108 const int num_pixels = spatial_layer.width * spatial_layer.height;
109 int min_bitrate_kbps = (600.0 * std::sqrt(num_pixels) - 95'000.0) / 1000.0;
110 spatial_layer.minBitrate = std::max(min_bitrate_kbps, 20);
111 spatial_layer.maxBitrate = 50 + static_cast<int>(1.6 * num_pixels / 1000.0);
112 spatial_layer.targetBitrate =
113 (spatial_layer.minBitrate + spatial_layer.maxBitrate) / 2;
114 }
115 return true;
116 }
117
118 } // namespace webrtc
119