blob: 40096e7535563288a629a9896188ffe3a1faa328 [file] [log] [blame]
Erik Språng08127a92016-11-16 16:41:30 +01001/*
2 * Copyright (c) 2016 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
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020011#include "modules/video_coding/include/video_codec_initializer.h"
Erik Språng08127a92016-11-16 16:41:30 +010012
Yves Gerey3e707812018-11-28 16:47:49 +010013#include <stdint.h>
14#include <string.h>
15#include <algorithm>
16
17#include "absl/types/optional.h"
Mirko Bonadeid9708072019-01-25 20:26:48 +010018#include "api/scoped_refptr.h"
Yves Gerey3e707812018-11-28 16:47:49 +010019#include "api/video/video_bitrate_allocation.h"
Anders Carlssondd8c1652018-01-30 10:32:13 +010020#include "api/video_codecs/video_encoder.h"
Mirko Bonadei71207422017-09-15 13:58:09 +020021#include "common_types.h" // NOLINT(build/include)
Sergey Silkin86684962018-03-28 19:32:37 +020022#include "modules/video_coding/codecs/vp9/svc_config.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020023#include "modules/video_coding/include/video_coding_defines.h"
Yves Gerey3e707812018-11-28 16:47:49 +010024#include "rtc_base/checks.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020025#include "rtc_base/logging.h"
Erik Språng08127a92016-11-16 16:41:30 +010026
27namespace webrtc {
28
Jiawei Ouc2ebe212018-11-08 10:02:56 -080029bool VideoCodecInitializer::SetupCodec(const VideoEncoderConfig& config,
30 const std::vector<VideoStream>& streams,
31 VideoCodec* codec) {
Niels Möller259a4972018-04-05 15:36:51 +020032 if (config.codec_type == kVideoCodecMultiplex) {
Niels Möller24a842a2018-03-22 08:52:50 +010033 VideoEncoderConfig associated_config = config.Copy();
34 associated_config.codec_type = kVideoCodecVP9;
Jiawei Ouc2ebe212018-11-08 10:02:56 -080035 if (!SetupCodec(associated_config, streams, codec)) {
Emircan Uysaler0a375472017-12-11 12:21:02 +053036 RTC_LOG(LS_ERROR) << "Failed to create stereo encoder configuration.";
37 return false;
38 }
Emircan Uysalerd7ae3c32018-01-25 13:01:09 -080039 codec->codecType = kVideoCodecMultiplex;
Emircan Uysaler0a375472017-12-11 12:21:02 +053040 return true;
41 }
42
Yves Gerey665174f2018-06-19 15:03:05 +020043 *codec = VideoEncoderConfigToVideoCodec(config, streams);
Erik Språng08127a92016-11-16 16:41:30 +010044 return true;
45}
46
Erik Språng08127a92016-11-16 16:41:30 +010047// TODO(sprang): Split this up and separate the codec specific parts.
48VideoCodec VideoCodecInitializer::VideoEncoderConfigToVideoCodec(
49 const VideoEncoderConfig& config,
Niels Möllerf1338562018-04-26 09:51:47 +020050 const std::vector<VideoStream>& streams) {
Erik Språng08127a92016-11-16 16:41:30 +010051 static const int kEncoderMinBitrateKbps = 30;
52 RTC_DCHECK(!streams.empty());
53 RTC_DCHECK_GE(config.min_transmit_bitrate_bps, 0);
54
55 VideoCodec video_codec;
56 memset(&video_codec, 0, sizeof(video_codec));
Niels Möller259a4972018-04-05 15:36:51 +020057 video_codec.codecType = config.codec_type;
Erik Språng08127a92016-11-16 16:41:30 +010058
59 switch (config.content_type) {
60 case VideoEncoderConfig::ContentType::kRealtimeVideo:
Niels Möllere3cf3d02018-06-13 11:52:16 +020061 video_codec.mode = VideoCodecMode::kRealtimeVideo;
Erik Språng08127a92016-11-16 16:41:30 +010062 break;
63 case VideoEncoderConfig::ContentType::kScreen:
Niels Möllere3cf3d02018-06-13 11:52:16 +020064 video_codec.mode = VideoCodecMode::kScreensharing;
Erik Språng08127a92016-11-16 16:41:30 +010065 break;
66 }
67
Niels Möller24a842a2018-03-22 08:52:50 +010068 // TODO(nisse): The plType field should be deleted. Luckily, our
69 // callers don't need it.
70 video_codec.plType = 0;
Erik Språng08127a92016-11-16 16:41:30 +010071 video_codec.numberOfSimulcastStreams =
72 static_cast<unsigned char>(streams.size());
73 video_codec.minBitrate = streams[0].min_bitrate_bps / 1000;
Seth Hampson46e31ba2018-01-18 10:39:54 -080074 bool codec_active = false;
75 for (const VideoStream& stream : streams) {
76 if (stream.active) {
77 codec_active = true;
78 break;
79 }
80 }
81 // Set active for the entire video codec for the non simulcast case.
82 video_codec.active = codec_active;
Erik Språng08127a92016-11-16 16:41:30 +010083 if (video_codec.minBitrate < kEncoderMinBitrateKbps)
84 video_codec.minBitrate = kEncoderMinBitrateKbps;
ilnik04f4d122017-06-19 07:18:55 -070085 video_codec.timing_frame_thresholds = {kDefaultTimingFramesDelayMs,
86 kDefaultOutlierFrameSizePercent};
kwiberg352444f2016-11-28 15:58:53 -080087 RTC_DCHECK_LE(streams.size(), kMaxSimulcastStreams);
Sergey Silkin86684962018-03-28 19:32:37 +020088
Ilya Nikolaevskiy7b412252019-03-06 16:40:42 +010089 int max_framerate = 0;
Erik Språng08127a92016-11-16 16:41:30 +010090 for (size_t i = 0; i < streams.size(); ++i) {
91 SimulcastStream* sim_stream = &video_codec.simulcastStream[i];
kwibergaf476c72016-11-28 15:21:39 -080092 RTC_DCHECK_GT(streams[i].width, 0);
93 RTC_DCHECK_GT(streams[i].height, 0);
Erik Språng08127a92016-11-16 16:41:30 +010094 RTC_DCHECK_GT(streams[i].max_framerate, 0);
sprang429600d2017-01-26 06:12:26 -080095 // Different framerates not supported per stream at the moment, unless it's
96 // screenshare where there is an exception and a simulcast encoder adapter,
97 // which supports different framerates, is used instead.
98 if (config.content_type != VideoEncoderConfig::ContentType::kScreen) {
99 RTC_DCHECK_EQ(streams[i].max_framerate, streams[0].max_framerate);
100 }
Erik Språng08127a92016-11-16 16:41:30 +0100101 RTC_DCHECK_GE(streams[i].min_bitrate_bps, 0);
102 RTC_DCHECK_GE(streams[i].target_bitrate_bps, streams[i].min_bitrate_bps);
103 RTC_DCHECK_GE(streams[i].max_bitrate_bps, streams[i].target_bitrate_bps);
104 RTC_DCHECK_GE(streams[i].max_qp, 0);
105
106 sim_stream->width = static_cast<uint16_t>(streams[i].width);
107 sim_stream->height = static_cast<uint16_t>(streams[i].height);
Sergey Silkin1946a3f2018-08-22 11:42:16 +0200108 sim_stream->maxFramerate = streams[i].max_framerate;
Ilya Nikolaevskiy7b412252019-03-06 16:40:42 +0100109 max_framerate = std::max(max_framerate, streams[i].max_framerate);
Erik Språng08127a92016-11-16 16:41:30 +0100110 sim_stream->minBitrate = streams[i].min_bitrate_bps / 1000;
111 sim_stream->targetBitrate = streams[i].target_bitrate_bps / 1000;
112 sim_stream->maxBitrate = streams[i].max_bitrate_bps / 1000;
113 sim_stream->qpMax = streams[i].max_qp;
Sergey Silkina796a7e2018-03-01 15:11:29 +0100114 sim_stream->numberOfTemporalLayers =
115 static_cast<unsigned char>(streams[i].num_temporal_layers.value_or(1));
Seth Hampson46e31ba2018-01-18 10:39:54 -0800116 sim_stream->active = streams[i].active;
Erik Språng08127a92016-11-16 16:41:30 +0100117
118 video_codec.width =
Danil Chapovalov350531e2018-06-08 11:04:04 +0000119 std::max(video_codec.width, static_cast<uint16_t>(streams[i].width));
Erik Språng08127a92016-11-16 16:41:30 +0100120 video_codec.height =
Danil Chapovalov350531e2018-06-08 11:04:04 +0000121 std::max(video_codec.height, static_cast<uint16_t>(streams[i].height));
Erik Språng08127a92016-11-16 16:41:30 +0100122 video_codec.minBitrate =
123 std::min(static_cast<uint16_t>(video_codec.minBitrate),
124 static_cast<uint16_t>(streams[i].min_bitrate_bps / 1000));
125 video_codec.maxBitrate += streams[i].max_bitrate_bps / 1000;
126 video_codec.qpMax = std::max(video_codec.qpMax,
127 static_cast<unsigned int>(streams[i].max_qp));
128 }
129
130 if (video_codec.maxBitrate == 0) {
131 // Unset max bitrate -> cap to one bit per pixel.
132 video_codec.maxBitrate =
133 (video_codec.width * video_codec.height * video_codec.maxFramerate) /
134 1000;
135 }
136 if (video_codec.maxBitrate < kEncoderMinBitrateKbps)
137 video_codec.maxBitrate = kEncoderMinBitrateKbps;
138
Ilya Nikolaevskiy7b412252019-03-06 16:40:42 +0100139 RTC_DCHECK_GT(max_framerate, 0);
140 video_codec.maxFramerate = max_framerate;
Sergey Silkin86684962018-03-28 19:32:37 +0200141
142 // Set codec specific options
143 if (config.encoder_specific_settings)
144 config.encoder_specific_settings->FillEncoderSpecificSettings(&video_codec);
145
146 switch (video_codec.codecType) {
147 case kVideoCodecVP8: {
148 if (!config.encoder_specific_settings) {
149 *video_codec.VP8() = VideoEncoder::GetDefaultVp8Settings();
150 }
151
152 video_codec.VP8()->numberOfTemporalLayers = static_cast<unsigned char>(
153 streams.back().num_temporal_layers.value_or(
154 video_codec.VP8()->numberOfTemporalLayers));
155 RTC_DCHECK_GE(video_codec.VP8()->numberOfTemporalLayers, 1);
156 RTC_DCHECK_LE(video_codec.VP8()->numberOfTemporalLayers,
157 kMaxTemporalStreams);
158
Sergey Silkin86684962018-03-28 19:32:37 +0200159 break;
160 }
161 case kVideoCodecVP9: {
162 if (!config.encoder_specific_settings) {
163 *video_codec.VP9() = VideoEncoder::GetDefaultVp9Settings();
164 }
165
166 video_codec.VP9()->numberOfTemporalLayers = static_cast<unsigned char>(
167 streams.back().num_temporal_layers.value_or(
168 video_codec.VP9()->numberOfTemporalLayers));
169 RTC_DCHECK_GE(video_codec.VP9()->numberOfTemporalLayers, 1);
170 RTC_DCHECK_LE(video_codec.VP9()->numberOfTemporalLayers,
171 kMaxTemporalStreams);
172
Sergey Silkinbe71a1e2018-05-17 16:46:43 +0200173 RTC_DCHECK(config.spatial_layers.empty() ||
174 config.spatial_layers.size() ==
175 video_codec.VP9()->numberOfSpatialLayers);
176
177 std::vector<SpatialLayer> spatial_layers;
178 if (!config.spatial_layers.empty()) {
179 // Layering is set explicitly.
180 spatial_layers = config.spatial_layers;
Sergey Silkin86684962018-03-28 19:32:37 +0200181 } else {
Sergey Silkin1946a3f2018-08-22 11:42:16 +0200182 spatial_layers = GetSvcConfig(
183 video_codec.width, video_codec.height, video_codec.maxFramerate,
184 video_codec.VP9()->numberOfSpatialLayers,
185 video_codec.VP9()->numberOfTemporalLayers,
186 video_codec.mode == VideoCodecMode::kScreensharing);
Sergey Silkin86684962018-03-28 19:32:37 +0200187
Sergey Silkin33120922018-11-28 13:32:13 +0100188 // If there was no request for spatial layering, don't limit bitrate
189 // of single spatial layer.
190 const bool no_spatial_layering =
191 video_codec.VP9()->numberOfSpatialLayers <= 1;
Sergey Silkinbe71a1e2018-05-17 16:46:43 +0200192 if (no_spatial_layering) {
193 // Use codec's bitrate limits.
194 spatial_layers.back().minBitrate = video_codec.minBitrate;
Ilya Nikolaevskiy9ef5e052019-03-05 10:08:35 +0100195 spatial_layers.back().targetBitrate = video_codec.maxBitrate;
Sergey Silkinbe71a1e2018-05-17 16:46:43 +0200196 spatial_layers.back().maxBitrate = video_codec.maxBitrate;
Sergey Silkin86684962018-03-28 19:32:37 +0200197 }
Sergey Silkin8b9b5f92018-12-10 09:28:53 +0100198
199 for (size_t spatial_idx = 0;
200 spatial_idx < config.simulcast_layers.size() &&
201 spatial_idx < spatial_layers.size();
202 ++spatial_idx) {
203 spatial_layers[spatial_layers.size() - spatial_idx - 1].active =
204 config.simulcast_layers[spatial_idx].active;
205 }
Sergey Silkin86684962018-03-28 19:32:37 +0200206 }
207
Sergey Silkinbe71a1e2018-05-17 16:46:43 +0200208 RTC_DCHECK(!spatial_layers.empty());
209 for (size_t i = 0; i < spatial_layers.size(); ++i) {
210 video_codec.spatialLayers[i] = spatial_layers[i];
211 }
212
213 // Update layering settings.
214 video_codec.VP9()->numberOfSpatialLayers =
215 static_cast<unsigned char>(spatial_layers.size());
216 RTC_DCHECK_GE(video_codec.VP9()->numberOfSpatialLayers, 1);
217 RTC_DCHECK_LE(video_codec.VP9()->numberOfSpatialLayers,
218 kMaxSpatialLayers);
219
220 video_codec.VP9()->numberOfTemporalLayers = static_cast<unsigned char>(
221 spatial_layers.back().numberOfTemporalLayers);
222 RTC_DCHECK_GE(video_codec.VP9()->numberOfTemporalLayers, 1);
223 RTC_DCHECK_LE(video_codec.VP9()->numberOfTemporalLayers,
224 kMaxTemporalStreams);
225
Sergey Silkin86684962018-03-28 19:32:37 +0200226 break;
227 }
228 case kVideoCodecH264: {
229 if (!config.encoder_specific_settings)
230 *video_codec.H264() = VideoEncoder::GetDefaultH264Settings();
Johnny Lee1a1c52b2019-02-08 14:25:40 -0500231 video_codec.H264()->numberOfTemporalLayers = static_cast<unsigned char>(
232 streams.back().num_temporal_layers.value_or(
233 video_codec.H264()->numberOfTemporalLayers));
234 RTC_DCHECK_GE(video_codec.H264()->numberOfTemporalLayers, 1);
235 RTC_DCHECK_LE(video_codec.H264()->numberOfTemporalLayers,
236 kMaxTemporalStreams);
Sergey Silkin86684962018-03-28 19:32:37 +0200237 break;
238 }
239 default:
240 // TODO(pbos): Support encoder_settings codec-agnostically.
241 RTC_DCHECK(!config.encoder_specific_settings)
242 << "Encoder-specific settings for codec type not wired up.";
243 break;
244 }
245
Erik Språng08127a92016-11-16 16:41:30 +0100246 return video_codec;
247}
248
249} // namespace webrtc