1 /*
2  *  Copyright (c) 2018 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/vp9/svc_config.h"
12 
13 #include <algorithm>
14 #include <cmath>
15 #include <vector>
16 
17 #include "modules/video_coding/codecs/vp9/include/vp9_globals.h"
18 #include "rtc_base/checks.h"
19 #include "rtc_base/logging.h"
20 
21 namespace webrtc {
22 
23 namespace {
24 const size_t kMinVp9SvcBitrateKbps = 30;
25 
26 const size_t kMaxNumLayersForScreenSharing = 3;
27 const float kMaxScreenSharingLayerFramerateFps[] = {5.0, 10.0, 30.0};
28 const size_t kMinScreenSharingLayerBitrateKbps[] = {30, 200, 500};
29 const size_t kTargetScreenSharingLayerBitrateKbps[] = {150, 350, 950};
30 const size_t kMaxScreenSharingLayerBitrateKbps[] = {250, 500, 950};
31 
32 }  // namespace
33 
ConfigureSvcScreenSharing(size_t input_width,size_t input_height,float max_framerate_fps,size_t num_spatial_layers)34 std::vector<SpatialLayer> ConfigureSvcScreenSharing(size_t input_width,
35                                                     size_t input_height,
36                                                     float max_framerate_fps,
37                                                     size_t num_spatial_layers) {
38   num_spatial_layers =
39       std::min(num_spatial_layers, kMaxNumLayersForScreenSharing);
40   std::vector<SpatialLayer> spatial_layers;
41 
42   for (size_t sl_idx = 0; sl_idx < num_spatial_layers; ++sl_idx) {
43     SpatialLayer spatial_layer = {0};
44     spatial_layer.width = input_width;
45     spatial_layer.height = input_height;
46     spatial_layer.maxFramerate =
47         std::min(kMaxScreenSharingLayerFramerateFps[sl_idx], max_framerate_fps);
48     spatial_layer.numberOfTemporalLayers = 1;
49     spatial_layer.minBitrate =
50         static_cast<int>(kMinScreenSharingLayerBitrateKbps[sl_idx]);
51     spatial_layer.maxBitrate =
52         static_cast<int>(kMaxScreenSharingLayerBitrateKbps[sl_idx]);
53     spatial_layer.targetBitrate =
54         static_cast<int>(kTargetScreenSharingLayerBitrateKbps[sl_idx]);
55     spatial_layer.active = true;
56     spatial_layers.push_back(spatial_layer);
57   }
58 
59   return spatial_layers;
60 }
61 
ConfigureSvcNormalVideo(size_t input_width,size_t input_height,float max_framerate_fps,size_t first_active_layer,size_t num_spatial_layers,size_t num_temporal_layers)62 std::vector<SpatialLayer> ConfigureSvcNormalVideo(size_t input_width,
63                                                   size_t input_height,
64                                                   float max_framerate_fps,
65                                                   size_t first_active_layer,
66                                                   size_t num_spatial_layers,
67                                                   size_t num_temporal_layers) {
68   RTC_DCHECK_LT(first_active_layer, num_spatial_layers);
69   std::vector<SpatialLayer> spatial_layers;
70 
71   // Limit number of layers for given resolution.
72   const size_t num_layers_fit_horz = static_cast<size_t>(std::floor(
73       1 + std::max(0.0f,
74                    std::log2(1.0f * input_width / kMinVp9SpatialLayerWidth))));
75   const size_t num_layers_fit_vert = static_cast<size_t>(
76       std::floor(1 + std::max(0.0f, std::log2(1.0f * input_height /
77                                               kMinVp9SpatialLayerHeight))));
78   const size_t limited_num_spatial_layers =
79       std::min(num_layers_fit_horz, num_layers_fit_vert);
80   if (limited_num_spatial_layers < num_spatial_layers) {
81     RTC_LOG(LS_WARNING) << "Reducing number of spatial layers from "
82                         << num_spatial_layers << " to "
83                         << limited_num_spatial_layers
84                         << " due to low input resolution.";
85     num_spatial_layers = limited_num_spatial_layers;
86   }
87   // First active layer must be configured.
88   num_spatial_layers = std::max(num_spatial_layers, first_active_layer + 1);
89 
90   // Ensure top layer is even enough.
91   int required_divisiblity = 1 << (num_spatial_layers - first_active_layer - 1);
92   input_width = input_width - input_width % required_divisiblity;
93   input_height = input_height - input_height % required_divisiblity;
94 
95   for (size_t sl_idx = first_active_layer; sl_idx < num_spatial_layers;
96        ++sl_idx) {
97     SpatialLayer spatial_layer = {0};
98     spatial_layer.width = input_width >> (num_spatial_layers - sl_idx - 1);
99     spatial_layer.height = input_height >> (num_spatial_layers - sl_idx - 1);
100     spatial_layer.maxFramerate = max_framerate_fps;
101     spatial_layer.numberOfTemporalLayers = num_temporal_layers;
102     spatial_layer.active = true;
103 
104     // minBitrate and maxBitrate formulas were derived from
105     // subjective-quality data to determing bit rates below which video
106     // quality is unacceptable and above which additional bits do not provide
107     // benefit. The formulas express rate in units of kbps.
108 
109     // TODO(ssilkin): Add to the comment PSNR/SSIM we get at encoding certain
110     // video to min/max bitrate specified by those formulas.
111     const size_t num_pixels = spatial_layer.width * spatial_layer.height;
112     int min_bitrate =
113         static_cast<int>((600. * std::sqrt(num_pixels) - 95000.) / 1000.);
114     min_bitrate = std::max(min_bitrate, 0);
115     spatial_layer.minBitrate =
116         std::max(static_cast<size_t>(min_bitrate), kMinVp9SvcBitrateKbps);
117     spatial_layer.maxBitrate =
118         static_cast<int>((1.6 * num_pixels + 50 * 1000) / 1000);
119     spatial_layer.targetBitrate =
120         (spatial_layer.minBitrate + spatial_layer.maxBitrate) / 2;
121     spatial_layers.push_back(spatial_layer);
122   }
123 
124   // A workaround for sitiation when single HD layer is left with minBitrate
125   // about 500kbps. This would mean that there will always be at least 500kbps
126   // allocated to video regardless of how low is the actual BWE.
127   // Also, boost maxBitrate for the first layer to account for lost ability to
128   // predict from previous layers.
129   if (first_active_layer > 0) {
130     spatial_layers[0].minBitrate = kMinVp9SvcBitrateKbps;
131     // TODO(ilnik): tune this value or come up with a different formula to
132     // ensure that all singlecast configurations look good and not too much
133     // bitrate is added.
134     spatial_layers[0].maxBitrate *= 1.1;
135   }
136 
137   return spatial_layers;
138 }
139 
GetSvcConfig(size_t input_width,size_t input_height,float max_framerate_fps,size_t first_active_layer,size_t num_spatial_layers,size_t num_temporal_layers,bool is_screen_sharing)140 std::vector<SpatialLayer> GetSvcConfig(size_t input_width,
141                                        size_t input_height,
142                                        float max_framerate_fps,
143                                        size_t first_active_layer,
144                                        size_t num_spatial_layers,
145                                        size_t num_temporal_layers,
146                                        bool is_screen_sharing) {
147   RTC_DCHECK_GT(input_width, 0);
148   RTC_DCHECK_GT(input_height, 0);
149   RTC_DCHECK_GT(num_spatial_layers, 0);
150   RTC_DCHECK_GT(num_temporal_layers, 0);
151 
152   if (is_screen_sharing) {
153     return ConfigureSvcScreenSharing(input_width, input_height,
154                                      max_framerate_fps, num_spatial_layers);
155   } else {
156     return ConfigureSvcNormalVideo(input_width, input_height, max_framerate_fps,
157                                    first_active_layer, num_spatial_layers,
158                                    num_temporal_layers);
159   }
160 }
161 
162 }  // namespace webrtc
163