blob: 245c86b06b2d5fb93ea8f6ce0d5fad49d48d91b9 [file] [log] [blame]
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001/*
kjellander1afca732016-02-07 20:46:45 -08002 * Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00003 *
kjellander1afca732016-02-07 20:46:45 -08004 * 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.
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00009 */
10
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020011#include "media/engine/webrtcvideoengine.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000012
asaperssonc5dabdd2016-03-21 04:15:50 -070013#include <stdio.h>
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +000014#include <algorithm>
pbos@webrtc.org3c107582014-07-20 15:27:35 +000015#include <set>
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000016#include <string>
perkjfa10b552016-10-02 23:45:26 -070017#include <utility>
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000018
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020019#include "api/video/i420_buffer.h"
20#include "api/video_codecs/sdp_video_format.h"
21#include "api/video_codecs/video_decoder.h"
22#include "api/video_codecs/video_decoder_factory.h"
23#include "api/video_codecs/video_encoder.h"
24#include "api/video_codecs/video_encoder_factory.h"
25#include "call/call.h"
26#include "common_video/h264/profile_level_id.h"
27#include "media/engine/constants.h"
Anders Carlssondd8c1652018-01-30 10:32:13 +010028#if defined(USE_BUILTIN_SW_CODECS)
29#include "media/engine/convert_legacy_video_factory.h" // nogncheck
30#endif
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020031#include "media/engine/simulcast.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020032#include "media/engine/webrtcmediaengine.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020033#include "media/engine/webrtcvoiceengine.h"
Magnus Jedvert7501b1c2017-11-09 13:43:42 +010034#include "modules/video_coding/include/video_error_codes.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020035#include "rtc_base/copyonwritebuffer.h"
36#include "rtc_base/logging.h"
37#include "rtc_base/stringutils.h"
38#include "rtc_base/timeutils.h"
39#include "rtc_base/trace_event.h"
40#include "system_wrappers/include/field_trial.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000041
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000042namespace cricket {
Magnus Jedvert07e0d012017-10-31 11:24:54 +010043
44// Hack in order to pass in |receive_stream_id| to legacy clients.
45// TODO(magjed): Remove once WebRtcVideoDecoderFactory is deprecated and
magjeda35df422017-08-30 04:21:30 -070046// webrtc:7925 is fixed.
Taylor Brandstettera7678662017-10-30 22:52:53 +000047class DecoderFactoryAdapter {
48 public:
Anders Carlssondd8c1652018-01-30 10:32:13 +010049#if defined(USE_BUILTIN_SW_CODECS)
Magnus Jedvert07e0d012017-10-31 11:24:54 +010050 explicit DecoderFactoryAdapter(
51 std::unique_ptr<WebRtcVideoDecoderFactory> external_video_decoder_factory)
52 : cricket_decoder_with_params_(new CricketDecoderWithParams(
53 std::move(external_video_decoder_factory))),
54 decoder_factory_(ConvertVideoDecoderFactory(
55 std::unique_ptr<WebRtcVideoDecoderFactory>(
56 cricket_decoder_with_params_))) {}
Anders Carlssondd8c1652018-01-30 10:32:13 +010057#endif
Taylor Brandstettera7678662017-10-30 22:52:53 +000058
Magnus Jedvert07e0d012017-10-31 11:24:54 +010059 explicit DecoderFactoryAdapter(
60 std::unique_ptr<webrtc::VideoDecoderFactory> video_decoder_factory)
61 : cricket_decoder_with_params_(nullptr),
62 decoder_factory_(std::move(video_decoder_factory)) {}
63
64 void SetReceiveStreamId(const std::string& receive_stream_id) {
65 if (cricket_decoder_with_params_)
66 cricket_decoder_with_params_->SetReceiveStreamId(receive_stream_id);
67 }
68
69 std::vector<webrtc::SdpVideoFormat> GetSupportedFormats() const {
70 return decoder_factory_->GetSupportedFormats();
71 }
72
73 std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
74 const webrtc::SdpVideoFormat& format) {
75 return decoder_factory_->CreateVideoDecoder(format);
76 }
77
78 private:
79 // WebRtcVideoDecoderFactory implementation that allows to override
80 // |receive_stream_id|.
81 class CricketDecoderWithParams : public WebRtcVideoDecoderFactory {
82 public:
83 explicit CricketDecoderWithParams(
84 std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory)
85 : external_decoder_factory_(std::move(external_decoder_factory)) {}
86
87 void SetReceiveStreamId(const std::string& receive_stream_id) {
88 receive_stream_id_ = receive_stream_id;
89 }
90
91 private:
92 webrtc::VideoDecoder* CreateVideoDecoderWithParams(
93 const VideoCodec& codec,
94 VideoDecoderParams params) override {
95 if (!external_decoder_factory_)
96 return nullptr;
97 params.receive_stream_id = receive_stream_id_;
98 return external_decoder_factory_->CreateVideoDecoderWithParams(codec,
99 params);
100 }
101
102 webrtc::VideoDecoder* CreateVideoDecoderWithParams(
103 webrtc::VideoCodecType type,
104 VideoDecoderParams params) override {
105 RTC_NOTREACHED();
106 return nullptr;
107 }
108
109 void DestroyVideoDecoder(webrtc::VideoDecoder* decoder) override {
110 if (external_decoder_factory_) {
111 external_decoder_factory_->DestroyVideoDecoder(decoder);
112 } else {
113 delete decoder;
114 }
115 }
116
117 const std::unique_ptr<WebRtcVideoDecoderFactory> external_decoder_factory_;
118 std::string receive_stream_id_;
119 };
120
121 // If |cricket_decoder_with_params_| is non-null, it's owned by
122 // |decoder_factory_|.
123 CricketDecoderWithParams* const cricket_decoder_with_params_;
124 std::unique_ptr<webrtc::VideoDecoderFactory> decoder_factory_;
andersc063f0c02017-09-11 11:50:51 -0700125};
126
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000127namespace {
magjeda35df422017-08-30 04:21:30 -0700128
Magnus Jedvert7501b1c2017-11-09 13:43:42 +0100129// Video decoder class to be used for unknown codecs. Doesn't support decoding
130// but logs messages to LS_ERROR.
131class NullVideoDecoder : public webrtc::VideoDecoder {
132 public:
133 int32_t InitDecode(const webrtc::VideoCodec* codec_settings,
134 int32_t number_of_cores) override {
Mirko Bonadeid4fcfb82017-11-10 10:30:48 +0100135 RTC_LOG(LS_ERROR) << "Can't initialize NullVideoDecoder.";
Magnus Jedvert7501b1c2017-11-09 13:43:42 +0100136 return WEBRTC_VIDEO_CODEC_OK;
137 }
138
139 int32_t Decode(const webrtc::EncodedImage& input_image,
140 bool missing_frames,
Magnus Jedvert7501b1c2017-11-09 13:43:42 +0100141 const webrtc::CodecSpecificInfo* codec_specific_info,
142 int64_t render_time_ms) override {
Mirko Bonadeid4fcfb82017-11-10 10:30:48 +0100143 RTC_LOG(LS_ERROR) << "The NullVideoDecoder doesn't support decoding.";
Magnus Jedvert7501b1c2017-11-09 13:43:42 +0100144 return WEBRTC_VIDEO_CODEC_OK;
145 }
146
147 int32_t RegisterDecodeCompleteCallback(
148 webrtc::DecodedImageCallback* callback) override {
Mirko Bonadeid4fcfb82017-11-10 10:30:48 +0100149 RTC_LOG(LS_ERROR)
Magnus Jedvert7501b1c2017-11-09 13:43:42 +0100150 << "Can't register decode complete callback on NullVideoDecoder.";
151 return WEBRTC_VIDEO_CODEC_OK;
152 }
153
154 int32_t Release() override { return WEBRTC_VIDEO_CODEC_OK; }
155
156 const char* ImplementationName() const override { return "NullVideoDecoder"; }
157};
158
brandtr340e3fd2017-02-28 15:43:10 -0800159// If this field trial is enabled, we will enable sending FlexFEC and disable
brandtr31bd2242017-05-19 05:47:46 -0700160// sending ULPFEC whenever the former has been negotiated in the SDPs.
brandtr468da7c2016-11-22 02:16:47 -0800161bool IsFlexfecFieldTrialEnabled() {
brandtrdbb1be52017-04-26 00:02:34 -0700162 return webrtc::field_trial::IsEnabled("WebRTC-FlexFEC-03");
brandtr468da7c2016-11-22 02:16:47 -0800163}
164
Magnus Jedvert9b16e2d2017-11-18 12:08:55 +0100165// If this field trial is enabled, the "flexfec-03" codec will be advertised
166// as being supported. This means that "flexfec-03" will appear in the default
167// SDP offer, and we therefore need to be ready to receive FlexFEC packets from
168// the remote. It also means that FlexFEC SSRCs will be generated by
169// MediaSession and added as "a=ssrc:" and "a=ssrc-group:" lines in the local
170// SDP.
brandtr31bd2242017-05-19 05:47:46 -0700171bool IsFlexfecAdvertisedFieldTrialEnabled() {
172 return webrtc::field_trial::IsEnabled("WebRTC-FlexFEC-03-Advertised");
173}
174
Peter Boström81ea54e2015-05-07 11:41:09 +0200175void AddDefaultFeedbackParams(VideoCodec* codec) {
Magnus Jedvertef207952017-10-25 17:08:04 +0200176 // Don't add any feedback params for RED and ULPFEC.
177 if (codec->name == kRedCodecName || codec->name == kUlpfecCodecName)
178 return;
Peter Boström81ea54e2015-05-07 11:41:09 +0200179 codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamRemb, kParamValueEmpty));
stefan43edf0f2015-11-20 18:05:48 -0800180 codec->AddFeedbackParam(
181 FeedbackParam(kRtcpFbParamTransportCc, kParamValueEmpty));
Magnus Jedvertef207952017-10-25 17:08:04 +0200182 // Don't add any more feedback params for FLEXFEC.
183 if (codec->name == kFlexfecCodecName)
184 return;
185 codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamCcm, kRtcpFbCcmParamFir));
186 codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamNack, kParamValueEmpty));
187 codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamNack, kRtcpFbNackParamPli));
Peter Boström81ea54e2015-05-07 11:41:09 +0200188}
189
Magnus Jedvert9b16e2d2017-11-18 12:08:55 +0100190// This function will assign dynamic payload types (in the range [96, 127]) to
191// the input codecs, and also add ULPFEC, RED, FlexFEC, and associated RTX
192// codecs for recognized codecs (VP8, VP9, H264, and RED). It will also add
193// default feedback params to the codecs.
194std::vector<VideoCodec> AssignPayloadTypesAndDefaultCodecs(
195 std::vector<webrtc::SdpVideoFormat> input_formats) {
196 if (input_formats.empty())
197 return std::vector<VideoCodec>();
198 static const int kFirstDynamicPayloadType = 96;
199 static const int kLastDynamicPayloadType = 127;
200 int payload_type = kFirstDynamicPayloadType;
201
202 input_formats.push_back(webrtc::SdpVideoFormat(kRedCodecName));
203 input_formats.push_back(webrtc::SdpVideoFormat(kUlpfecCodecName));
204
205 if (IsFlexfecAdvertisedFieldTrialEnabled()) {
206 webrtc::SdpVideoFormat flexfec_format(kFlexfecCodecName);
207 // This value is currently arbitrarily set to 10 seconds. (The unit
208 // is microseconds.) This parameter MUST be present in the SDP, but
209 // we never use the actual value anywhere in our code however.
210 // TODO(brandtr): Consider honouring this value in the sender and receiver.
211 flexfec_format.parameters = {{kFlexfecFmtpRepairWindow, "10000000"}};
212 input_formats.push_back(flexfec_format);
213 }
214
215 std::vector<VideoCodec> output_codecs;
216 for (const webrtc::SdpVideoFormat& format : input_formats) {
217 VideoCodec codec(format);
218 codec.id = payload_type;
219 AddDefaultFeedbackParams(&codec);
220 output_codecs.push_back(codec);
221
222 // Increment payload type.
223 ++payload_type;
Sami Kalliomäkie9a18b22018-07-13 10:28:21 +0200224 if (payload_type > kLastDynamicPayloadType) {
225 RTC_LOG(LS_ERROR) << "Out of dynamic payload types, skipping the rest.";
Magnus Jedvert9b16e2d2017-11-18 12:08:55 +0100226 break;
Sami Kalliomäkie9a18b22018-07-13 10:28:21 +0200227 }
Magnus Jedvert9b16e2d2017-11-18 12:08:55 +0100228
Sami Kalliomäkie9a18b22018-07-13 10:28:21 +0200229 // Add associated RTX codec for non-FEC codecs.
230 if (!CodecNamesEq(codec.name, kUlpfecCodecName) &&
231 !CodecNamesEq(codec.name, kFlexfecCodecName)) {
Magnus Jedvert9b16e2d2017-11-18 12:08:55 +0100232 output_codecs.push_back(
233 VideoCodec::CreateRtxCodec(payload_type, codec.id));
234
235 // Increment payload type.
236 ++payload_type;
Sami Kalliomäkie9a18b22018-07-13 10:28:21 +0200237 if (payload_type > kLastDynamicPayloadType) {
238 RTC_LOG(LS_ERROR) << "Out of dynamic payload types, skipping the rest.";
Magnus Jedvert9b16e2d2017-11-18 12:08:55 +0100239 break;
Sami Kalliomäkie9a18b22018-07-13 10:28:21 +0200240 }
Magnus Jedvert9b16e2d2017-11-18 12:08:55 +0100241 }
242 }
243 return output_codecs;
244}
245
246std::vector<VideoCodec> AssignPayloadTypesAndDefaultCodecs(
247 const webrtc::VideoEncoderFactory* encoder_factory) {
248 return encoder_factory ? AssignPayloadTypesAndDefaultCodecs(
249 encoder_factory->GetSupportedFormats())
250 : std::vector<VideoCodec>();
251}
252
Åsa Perssonced5cfd2018-08-10 16:16:43 +0200253int GetMaxFramerate(const webrtc::VideoEncoderConfig& encoder_config,
254 size_t num_layers) {
255 int max_fps = -1;
256 for (size_t i = 0; i < num_layers; ++i) {
257 int fps = (encoder_config.simulcast_layers[i].max_framerate > 0)
258 ? encoder_config.simulcast_layers[i].max_framerate
259 : kDefaultVideoMaxFramerate;
260 max_fps = std::max(fps, max_fps);
261 }
262 return max_fps;
263}
264
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000265static std::string CodecVectorToString(const std::vector<VideoCodec>& codecs) {
266 std::stringstream out;
267 out << '{';
268 for (size_t i = 0; i < codecs.size(); ++i) {
269 out << codecs[i].ToString();
270 if (i != codecs.size() - 1) {
271 out << ", ";
272 }
273 }
274 out << '}';
275 return out.str();
276}
277
278static bool ValidateCodecFormats(const std::vector<VideoCodec>& codecs) {
279 bool has_video = false;
280 for (size_t i = 0; i < codecs.size(); ++i) {
281 if (!codecs[i].ValidateCodecFormat()) {
282 return false;
283 }
284 if (codecs[i].GetCodecType() == VideoCodec::CODEC_VIDEO) {
285 has_video = true;
286 }
287 }
288 if (!has_video) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100289 RTC_LOG(LS_ERROR) << "Setting codecs without a video codec is invalid: "
290 << CodecVectorToString(codecs);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000291 return false;
292 }
293 return true;
294}
295
Peter Boströmd4362cd2015-03-25 14:17:23 +0100296static bool ValidateStreamParams(const StreamParams& sp) {
297 if (sp.ssrcs.empty()) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100298 RTC_LOG(LS_ERROR) << "No SSRCs in stream parameters: " << sp.ToString();
Peter Boströmd4362cd2015-03-25 14:17:23 +0100299 return false;
300 }
301
Peter Boström0c4e06b2015-10-07 12:23:21 +0200302 std::vector<uint32_t> primary_ssrcs;
Peter Boströmd4362cd2015-03-25 14:17:23 +0100303 sp.GetPrimarySsrcs(&primary_ssrcs);
Peter Boström0c4e06b2015-10-07 12:23:21 +0200304 std::vector<uint32_t> rtx_ssrcs;
Peter Boströmd4362cd2015-03-25 14:17:23 +0100305 sp.GetFidSsrcs(primary_ssrcs, &rtx_ssrcs);
306 for (uint32_t rtx_ssrc : rtx_ssrcs) {
307 bool rtx_ssrc_present = false;
308 for (uint32_t sp_ssrc : sp.ssrcs) {
309 if (sp_ssrc == rtx_ssrc) {
310 rtx_ssrc_present = true;
311 break;
312 }
313 }
314 if (!rtx_ssrc_present) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100315 RTC_LOG(LS_ERROR) << "RTX SSRC '" << rtx_ssrc
316 << "' missing from StreamParams ssrcs: "
317 << sp.ToString();
Peter Boströmd4362cd2015-03-25 14:17:23 +0100318 return false;
319 }
320 }
321 if (!rtx_ssrcs.empty() && primary_ssrcs.size() != rtx_ssrcs.size()) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100322 RTC_LOG(LS_ERROR)
Peter Boströmd4362cd2015-03-25 14:17:23 +0100323 << "RTX SSRCs exist, but don't cover all SSRCs (unsupported): "
324 << sp.ToString();
325 return false;
326 }
327
328 return true;
329}
330
noahricfdac5162015-08-27 01:59:29 -0700331// Returns true if the given codec is disallowed from doing simulcast.
332bool IsCodecBlacklistedForSimulcast(const std::string& codec_name) {
Sergio Garcia Murillo43800f92018-06-21 16:16:38 +0200333 return webrtc::field_trial::IsEnabled("WebRTC-H264Simulcast")
334 ? CodecNamesEq(codec_name, kVp9CodecName)
335 : CodecNamesEq(codec_name, kH264CodecName) ||
336 CodecNamesEq(codec_name, kVp9CodecName);
noahricfdac5162015-08-27 01:59:29 -0700337}
338
Åsa Persson1c7d48d2015-09-08 09:21:43 +0200339// The selected thresholds for QVGA and VGA corresponded to a QP around 10.
340// The change in QP declined above the selected bitrates.
341static int GetMaxDefaultVideoBitrateKbps(int width, int height) {
342 if (width * height <= 320 * 240) {
343 return 600;
344 } else if (width * height <= 640 * 480) {
345 return 1700;
346 } else if (width * height <= 960 * 540) {
347 return 2000;
348 } else {
349 return 2500;
350 }
351}
perkj2d5f0912016-02-29 00:04:41 -0800352
Sergey Silkinf18072e2018-03-14 10:35:35 +0100353bool GetVp9LayersFromFieldTrialGroup(size_t* num_spatial_layers,
354 size_t* num_temporal_layers) {
asaperssonc5dabdd2016-03-21 04:15:50 -0700355 std::string group = webrtc::field_trial::FindFullName("WebRTC-SupportVP9SVC");
356 if (group.empty())
357 return false;
358
Sergey Silkinf18072e2018-03-14 10:35:35 +0100359 if (sscanf(group.c_str(), "EnabledByFlag_%zuSL%zuTL", num_spatial_layers,
asaperssonc5dabdd2016-03-21 04:15:50 -0700360 num_temporal_layers) != 2) {
361 return false;
362 }
Sergey Silkinf18072e2018-03-14 10:35:35 +0100363 const size_t kMaxSpatialLayers = 3;
asaperssonc5dabdd2016-03-21 04:15:50 -0700364 if (*num_spatial_layers > kMaxSpatialLayers || *num_spatial_layers < 1)
365 return false;
366
Sergey Silkinf18072e2018-03-14 10:35:35 +0100367 const size_t kMaxTemporalLayers = 3;
asaperssonc5dabdd2016-03-21 04:15:50 -0700368 if (*num_temporal_layers > kMaxTemporalLayers || *num_temporal_layers < 1)
369 return false;
370
371 return true;
372}
373
Danil Chapovalov00c71832018-06-15 15:58:38 +0200374absl::optional<size_t> GetVp9SpatialLayersFromFieldTrial() {
Sergey Silkinf18072e2018-03-14 10:35:35 +0100375 size_t num_sl;
376 size_t num_tl;
asaperssonc5dabdd2016-03-21 04:15:50 -0700377 if (GetVp9LayersFromFieldTrialGroup(&num_sl, &num_tl)) {
378 return num_sl;
379 }
Danil Chapovalov00c71832018-06-15 15:58:38 +0200380 return absl::nullopt;
asaperssonc5dabdd2016-03-21 04:15:50 -0700381}
382
Danil Chapovalov00c71832018-06-15 15:58:38 +0200383absl::optional<size_t> GetVp9TemporalLayersFromFieldTrial() {
Sergey Silkinf18072e2018-03-14 10:35:35 +0100384 size_t num_sl;
385 size_t num_tl;
asaperssonc5dabdd2016-03-21 04:15:50 -0700386 if (GetVp9LayersFromFieldTrialGroup(&num_sl, &num_tl)) {
387 return num_tl;
388 }
Danil Chapovalov00c71832018-06-15 15:58:38 +0200389 return absl::nullopt;
asaperssonc5dabdd2016-03-21 04:15:50 -0700390}
Åsa Persson45bbc8a2017-11-13 10:16:47 +0100391
392const char kForcedFallbackFieldTrial[] =
393 "WebRTC-VP8-Forced-Fallback-Encoder-v2";
394
Danil Chapovalov00c71832018-06-15 15:58:38 +0200395absl::optional<int> GetFallbackMinBpsFromFieldTrial() {
Åsa Persson45bbc8a2017-11-13 10:16:47 +0100396 if (!webrtc::field_trial::IsEnabled(kForcedFallbackFieldTrial))
Danil Chapovalov00c71832018-06-15 15:58:38 +0200397 return absl::nullopt;
Åsa Persson45bbc8a2017-11-13 10:16:47 +0100398
399 std::string group =
400 webrtc::field_trial::FindFullName(kForcedFallbackFieldTrial);
401 if (group.empty())
Danil Chapovalov00c71832018-06-15 15:58:38 +0200402 return absl::nullopt;
Åsa Persson45bbc8a2017-11-13 10:16:47 +0100403
404 int min_pixels;
405 int max_pixels;
406 int min_bps;
407 if (sscanf(group.c_str(), "Enabled-%d,%d,%d", &min_pixels, &max_pixels,
408 &min_bps) != 3) {
Danil Chapovalov00c71832018-06-15 15:58:38 +0200409 return absl::nullopt;
Åsa Persson45bbc8a2017-11-13 10:16:47 +0100410 }
411
412 if (min_bps <= 0)
Danil Chapovalov00c71832018-06-15 15:58:38 +0200413 return absl::nullopt;
Åsa Persson45bbc8a2017-11-13 10:16:47 +0100414
Oskar Sundbom78807582017-11-16 11:09:55 +0100415 return min_bps;
Åsa Persson45bbc8a2017-11-13 10:16:47 +0100416}
417
418int GetMinVideoBitrateBps() {
419 return GetFallbackMinBpsFromFieldTrial().value_or(kMinVideoBitrateBps);
420}
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000421} // namespace
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000422
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000423// This constant is really an on/off, lower-level configurable NACK history
424// duration hasn't been implemented.
425static const int kNackHistoryMs = 1000;
426
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000427static const int kDefaultRtcpReceiverReportSsrc = 1;
428
asapersson2e5cfcd2016-08-11 08:41:18 -0700429// Minimum time interval for logging stats.
430static const int64_t kStatsLogIntervalMs = 10000;
431
kthelgason29a44e32016-09-27 03:52:02 -0700432rtc::scoped_refptr<webrtc::VideoEncoderConfig::EncoderSpecificSettings>
eladalonf1841382017-06-12 01:16:46 -0700433WebRtcVideoChannel::WebRtcVideoSendStream::ConfigureVideoEncoderSettings(
Niels Möller60653ba2016-03-02 11:41:36 +0100434 const VideoCodec& codec) {
perkjfa10b552016-10-02 23:45:26 -0700435 RTC_DCHECK_RUN_ON(&thread_checker_);
Niels Möller60653ba2016-03-02 11:41:36 +0100436 bool is_screencast = parameters_.options.is_screencast.value_or(false);
Peter Boström2feafdb2015-09-09 14:32:14 +0200437 // No automatic resizing when using simulcast or screencast.
438 bool automatic_resize =
439 !is_screencast && parameters_.config.rtp.ssrcs.size() == 1;
Erik Språng143cec12015-04-28 10:01:41 +0200440 bool frame_dropping = !is_screencast;
441 bool denoising;
pbos4cba4eb2015-10-26 11:18:18 -0700442 bool codec_default_denoising = false;
Erik Språng143cec12015-04-28 10:01:41 +0200443 if (is_screencast) {
444 denoising = false;
445 } else {
pbos4cba4eb2015-10-26 11:18:18 -0700446 // Use codec default if video_noise_reduction is unset.
Niels Möller60653ba2016-03-02 11:41:36 +0100447 codec_default_denoising = !parameters_.options.video_noise_reduction;
448 denoising = parameters_.options.video_noise_reduction.value_or(false);
Erik Språng143cec12015-04-28 10:01:41 +0200449 }
450
hbosbab934b2016-01-27 01:36:03 -0800451 if (CodecNamesEq(codec.name, kH264CodecName)) {
kthelgason29a44e32016-09-27 03:52:02 -0700452 webrtc::VideoCodecH264 h264_settings =
453 webrtc::VideoEncoder::GetDefaultH264Settings();
454 h264_settings.frameDroppingOn = frame_dropping;
455 return new rtc::RefCountedObject<
456 webrtc::VideoEncoderConfig::H264EncoderSpecificSettings>(h264_settings);
hbosbab934b2016-01-27 01:36:03 -0800457 }
Shao Changbine62202f2015-04-21 20:24:50 +0800458 if (CodecNamesEq(codec.name, kVp8CodecName)) {
kthelgason29a44e32016-09-27 03:52:02 -0700459 webrtc::VideoCodecVP8 vp8_settings =
460 webrtc::VideoEncoder::GetDefaultVp8Settings();
461 vp8_settings.automaticResizeOn = automatic_resize;
pbos4cba4eb2015-10-26 11:18:18 -0700462 // VP8 denoising is enabled by default.
kthelgason29a44e32016-09-27 03:52:02 -0700463 vp8_settings.denoisingOn = codec_default_denoising ? true : denoising;
464 vp8_settings.frameDroppingOn = frame_dropping;
465 return new rtc::RefCountedObject<
466 webrtc::VideoEncoderConfig::Vp8EncoderSpecificSettings>(vp8_settings);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000467 }
Shao Changbine62202f2015-04-21 20:24:50 +0800468 if (CodecNamesEq(codec.name, kVp9CodecName)) {
kthelgason29a44e32016-09-27 03:52:02 -0700469 webrtc::VideoCodecVP9 vp9_settings =
470 webrtc::VideoEncoder::GetDefaultVp9Settings();
Sergey Silkinbe71a1e2018-05-17 16:46:43 +0200471 const size_t default_num_spatial_layers =
472 parameters_.config.rtp.ssrcs.size();
473 const size_t num_spatial_layers =
474 GetVp9SpatialLayersFromFieldTrial().value_or(
475 default_num_spatial_layers);
Sergey Silkinf18072e2018-03-14 10:35:35 +0100476
Sergey Silkinbe71a1e2018-05-17 16:46:43 +0200477 const size_t default_num_temporal_layers =
478 num_spatial_layers > 1 ? kConferenceDefaultNumTemporalLayers : 1;
479 const size_t num_temporal_layers =
480 GetVp9TemporalLayersFromFieldTrial().value_or(
481 default_num_temporal_layers);
Sergey Silkinf18072e2018-03-14 10:35:35 +0100482
Sergey Silkinbe71a1e2018-05-17 16:46:43 +0200483 vp9_settings.numberOfSpatialLayers = std::min<unsigned char>(
484 num_spatial_layers, kConferenceMaxNumSpatialLayers);
485 vp9_settings.numberOfTemporalLayers = std::min<unsigned char>(
486 num_temporal_layers, kConferenceMaxNumTemporalLayers);
Sergey Silkina796a7e2018-03-01 15:11:29 +0100487
pbos4cba4eb2015-10-26 11:18:18 -0700488 // VP9 denoising is disabled by default.
jianja5e8aa62017-03-27 10:09:00 -0700489 vp9_settings.denoisingOn = codec_default_denoising ? true : denoising;
asapersson1e15a992017-06-07 04:09:45 -0700490 vp9_settings.automaticResizeOn = automatic_resize;
Sergey Silkinbe71a1e2018-05-17 16:46:43 +0200491 // Ensure frame dropping is always enabled.
492 RTC_DCHECK(vp9_settings.frameDroppingOn);
493 if (!is_screencast) {
494 // Limit inter-layer prediction to key pictures.
495 vp9_settings.interLayerPred = webrtc::InterLayerPredMode::kOnKeyPic;
496 }
kthelgason29a44e32016-09-27 03:52:02 -0700497 return new rtc::RefCountedObject<
498 webrtc::VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings);
andresp@webrtc.org188d3b22014-11-07 13:21:04 +0000499 }
kthelgason29a44e32016-09-27 03:52:02 -0700500 return nullptr;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000501}
502
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000503DefaultUnsignalledSsrcHandler::DefaultUnsignalledSsrcHandler()
brandtr0dc57ea2017-05-29 23:33:31 -0700504 : default_sink_(nullptr) {}
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000505
506UnsignalledSsrcHandler::Action DefaultUnsignalledSsrcHandler::OnUnsignalledSsrc(
eladalonf1841382017-06-12 01:16:46 -0700507 WebRtcVideoChannel* channel,
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000508 uint32_t ssrc) {
Danil Chapovalov00c71832018-06-15 15:58:38 +0200509 absl::optional<uint32_t> default_recv_ssrc =
brandtr0dc57ea2017-05-29 23:33:31 -0700510 channel->GetDefaultReceiveStreamSsrc();
511
512 if (default_recv_ssrc) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100513 RTC_LOG(LS_INFO) << "Destroying old default receive stream for SSRC="
514 << ssrc << ".";
brandtr0dc57ea2017-05-29 23:33:31 -0700515 channel->RemoveRecvStream(*default_recv_ssrc);
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000516 }
517
Seth Hampson5897a6e2018-04-03 11:16:33 -0700518 StreamParams sp = channel->unsignaled_stream_params();
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000519 sp.ssrcs.push_back(ssrc);
Seth Hampson5897a6e2018-04-03 11:16:33 -0700520
Mirko Bonadei675513b2017-11-09 11:09:25 +0100521 RTC_LOG(LS_INFO) << "Creating default receive stream for SSRC=" << ssrc
522 << ".";
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +0000523 if (!channel->AddRecvStream(sp, true)) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100524 RTC_LOG(LS_WARNING) << "Could not create default receive stream.";
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000525 }
526
nisse08582ff2016-02-04 01:24:52 -0800527 channel->SetSink(ssrc, default_sink_);
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000528 return kDeliverPacket;
529}
530
nisseacd935b2016-11-11 03:55:13 -0800531rtc::VideoSinkInterface<webrtc::VideoFrame>*
nisse08582ff2016-02-04 01:24:52 -0800532DefaultUnsignalledSsrcHandler::GetDefaultSink() const {
533 return default_sink_;
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000534}
535
nisse08582ff2016-02-04 01:24:52 -0800536void DefaultUnsignalledSsrcHandler::SetDefaultSink(
eladalonf1841382017-06-12 01:16:46 -0700537 WebRtcVideoChannel* channel,
nisseacd935b2016-11-11 03:55:13 -0800538 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
nisse08582ff2016-02-04 01:24:52 -0800539 default_sink_ = sink;
Danil Chapovalov00c71832018-06-15 15:58:38 +0200540 absl::optional<uint32_t> default_recv_ssrc =
brandtr0dc57ea2017-05-29 23:33:31 -0700541 channel->GetDefaultReceiveStreamSsrc();
542 if (default_recv_ssrc) {
543 channel->SetSink(*default_recv_ssrc, default_sink_);
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000544 }
545}
546
Anders Carlssondd8c1652018-01-30 10:32:13 +0100547#if defined(USE_BUILTIN_SW_CODECS)
magjed2475ae22017-09-12 04:42:15 -0700548WebRtcVideoEngine::WebRtcVideoEngine(
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200549 std::unique_ptr<WebRtcVideoEncoderFactory> external_video_encoder_factory,
550 std::unique_ptr<WebRtcVideoDecoderFactory> external_video_decoder_factory)
Magnus Jedvert07e0d012017-10-31 11:24:54 +0100551 : decoder_factory_(
552 new DecoderFactoryAdapter(std::move(external_video_decoder_factory))),
553 encoder_factory_(ConvertVideoEncoderFactory(
Magnus Jedvert02e7a192017-09-23 17:21:32 +0200554 std::move(external_video_encoder_factory))) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100555 RTC_LOG(LS_INFO) << "WebRtcVideoEngine::WebRtcVideoEngine()";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000556}
Anders Carlssondd8c1652018-01-30 10:32:13 +0100557#endif
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000558
Magnus Jedvertd4b0c052017-09-14 10:24:54 +0200559WebRtcVideoEngine::WebRtcVideoEngine(
560 std::unique_ptr<webrtc::VideoEncoderFactory> video_encoder_factory,
561 std::unique_ptr<webrtc::VideoDecoderFactory> video_decoder_factory)
562 : decoder_factory_(
Magnus Jedvert07e0d012017-10-31 11:24:54 +0100563 new DecoderFactoryAdapter(std::move(video_decoder_factory))),
564 encoder_factory_(std::move(video_encoder_factory)) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100565 RTC_LOG(LS_INFO) << "WebRtcVideoEngine::WebRtcVideoEngine()";
Magnus Jedvertd4b0c052017-09-14 10:24:54 +0200566}
567
eladalonf1841382017-06-12 01:16:46 -0700568WebRtcVideoEngine::~WebRtcVideoEngine() {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100569 RTC_LOG(LS_INFO) << "WebRtcVideoEngine::~WebRtcVideoEngine";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000570}
571
eladalonf1841382017-06-12 01:16:46 -0700572WebRtcVideoChannel* WebRtcVideoEngine::CreateChannel(
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200573 webrtc::Call* call,
nisse51542be2016-02-12 02:27:06 -0800574 const MediaConfig& config,
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200575 const VideoOptions& options) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100576 RTC_LOG(LS_INFO) << "CreateChannel. Options: " << options.ToString();
magjed2475ae22017-09-12 04:42:15 -0700577 return new WebRtcVideoChannel(call, config, options, encoder_factory_.get(),
578 decoder_factory_.get());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000579}
580
eladalonf1841382017-06-12 01:16:46 -0700581std::vector<VideoCodec> WebRtcVideoEngine::codecs() const {
Magnus Jedvert9b16e2d2017-11-18 12:08:55 +0100582 return AssignPayloadTypesAndDefaultCodecs(encoder_factory_.get());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000583}
584
eladalonf1841382017-06-12 01:16:46 -0700585RtpCapabilities WebRtcVideoEngine::GetCapabilities() const {
Stefan Holmer9d69c3f2015-12-07 10:45:43 +0100586 RtpCapabilities capabilities;
587 capabilities.header_extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -0700588 webrtc::RtpExtension(webrtc::RtpExtension::kTimestampOffsetUri,
589 webrtc::RtpExtension::kTimestampOffsetDefaultId));
Stefan Holmer9d69c3f2015-12-07 10:45:43 +0100590 capabilities.header_extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -0700591 webrtc::RtpExtension(webrtc::RtpExtension::kAbsSendTimeUri,
592 webrtc::RtpExtension::kAbsSendTimeDefaultId));
Stefan Holmer9d69c3f2015-12-07 10:45:43 +0100593 capabilities.header_extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -0700594 webrtc::RtpExtension(webrtc::RtpExtension::kVideoRotationUri,
595 webrtc::RtpExtension::kVideoRotationDefaultId));
Stefan Holmer06a5e1a2016-09-02 12:36:49 +0200596 capabilities.header_extensions.push_back(webrtc::RtpExtension(
597 webrtc::RtpExtension::kTransportSequenceNumberUri,
598 webrtc::RtpExtension::kTransportSequenceNumberDefaultId));
isheriff6b4b5f32016-06-08 00:24:21 -0700599 capabilities.header_extensions.push_back(
600 webrtc::RtpExtension(webrtc::RtpExtension::kPlayoutDelayUri,
601 webrtc::RtpExtension::kPlayoutDelayDefaultId));
sprangee21f372017-08-15 01:32:51 -0700602 capabilities.header_extensions.push_back(
603 webrtc::RtpExtension(webrtc::RtpExtension::kVideoContentTypeUri,
604 webrtc::RtpExtension::kVideoContentTypeDefaultId));
sprangeb13f5e2017-08-22 07:05:47 -0700605 capabilities.header_extensions.push_back(
Yves Gerey665174f2018-06-19 15:03:05 +0200606 webrtc::RtpExtension(webrtc::RtpExtension::kVideoTimingUri,
607 webrtc::RtpExtension::kVideoTimingDefaultId));
Steve Antonbb50ce52018-03-26 10:24:32 -0700608 // TODO(bugs.webrtc.org/4050): Add MID header extension as capability once MID
609 // demuxing is completed.
610 // capabilities.header_extensions.push_back(webrtc::RtpExtension(
611 // webrtc::RtpExtension::kMidUri, webrtc::RtpExtension::kMidDefaultId));
Stefan Holmer9d69c3f2015-12-07 10:45:43 +0100612 return capabilities;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000613}
614
eladalonf1841382017-06-12 01:16:46 -0700615WebRtcVideoChannel::WebRtcVideoChannel(
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200616 webrtc::Call* call,
nisse51542be2016-02-12 02:27:06 -0800617 const MediaConfig& config,
pbos@webrtc.orgfa553ef2014-10-20 11:07:07 +0000618 const VideoOptions& options,
Magnus Jedvert07e0d012017-10-31 11:24:54 +0100619 webrtc::VideoEncoderFactory* encoder_factory,
620 DecoderFactoryAdapter* decoder_factory)
nisse51542be2016-02-12 02:27:06 -0800621 : VideoMediaChannel(config),
622 call_(call),
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200623 unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
nisse0db023a2016-03-01 04:29:59 -0800624 video_config_(config.video),
magjed2475ae22017-09-12 04:42:15 -0700625 encoder_factory_(encoder_factory),
626 decoder_factory_(decoder_factory),
Stefan Holmer2b1f6512016-05-17 16:33:30 +0200627 default_send_options_(options),
asapersson2e5cfcd2016-08-11 08:41:18 -0700628 last_stats_log_ms_(-1) {
henrikg91d6ede2015-09-17 00:24:34 -0700629 RTC_DCHECK(thread_checker_.CalledOnValidThread());
nissea293ef02016-02-17 07:24:50 -0800630
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000631 rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc;
632 sending_ = false;
Magnus Jedvert07e0d012017-10-31 11:24:54 +0100633 recv_codecs_ =
Magnus Jedvert9b16e2d2017-11-18 12:08:55 +0100634 MapCodecs(AssignPayloadTypesAndDefaultCodecs(encoder_factory_));
brandtr11fb4722017-05-30 01:31:37 -0700635 recv_flexfec_payload_type_ = recv_codecs_.front().flexfec_payload_type;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000636}
637
eladalonf1841382017-06-12 01:16:46 -0700638WebRtcVideoChannel::~WebRtcVideoChannel() {
Peter Boströmdfd53fe2015-03-27 15:58:11 +0100639 for (auto& kv : send_streams_)
640 delete kv.second;
641 for (auto& kv : receive_streams_)
642 delete kv.second;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000643}
644
Danil Chapovalov00c71832018-06-15 15:58:38 +0200645absl::optional<WebRtcVideoChannel::VideoCodecSettings>
eladalonf1841382017-06-12 01:16:46 -0700646WebRtcVideoChannel::SelectSendVideoCodec(
magjed23b7a4a2016-11-08 01:12:54 -0800647 const std::vector<VideoCodecSettings>& remote_mapped_codecs) const {
648 const std::vector<VideoCodec> local_supported_codecs =
Magnus Jedvert9b16e2d2017-11-18 12:08:55 +0100649 AssignPayloadTypesAndDefaultCodecs(encoder_factory_);
magjed23b7a4a2016-11-08 01:12:54 -0800650 // Select the first remote codec that is supported locally.
651 for (const VideoCodecSettings& remote_mapped_codec : remote_mapped_codecs) {
magjedf823ede2016-11-12 09:53:04 -0800652 // For H264, we will limit the encode level to the remote offered level
653 // regardless if level asymmetry is allowed or not. This is strictly not
654 // following the spec in https://tools.ietf.org/html/rfc6184#section-8.2.2
655 // since we should limit the encode level to the lower of local and remote
656 // level when level asymmetry is not allowed.
657 if (FindMatchingCodec(local_supported_codecs, remote_mapped_codec.codec))
Oskar Sundbom78807582017-11-16 11:09:55 +0100658 return remote_mapped_codec;
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000659 }
magjed23b7a4a2016-11-08 01:12:54 -0800660 // No remote codec was supported.
Danil Chapovalov00c71832018-06-15 15:58:38 +0200661 return absl::nullopt;
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000662}
663
eladalonf1841382017-06-12 01:16:46 -0700664bool WebRtcVideoChannel::NonFlexfecReceiveCodecsHaveChanged(
deadbeef874ca3a2015-08-20 17:19:20 -0700665 std::vector<VideoCodecSettings> before,
666 std::vector<VideoCodecSettings> after) {
667 if (before.size() != after.size()) {
668 return true;
669 }
brandtr11fb4722017-05-30 01:31:37 -0700670
deadbeef874ca3a2015-08-20 17:19:20 -0700671 // The receive codec order doesn't matter, so we sort the codecs before
672 // comparing. This is necessary because currently the
673 // only way to change the send codec is to munge SDP, which causes
674 // the receive codec list to change order, which causes the streams
675 // to be recreates which causes a "blink" of black video. In order
676 // to support munging the SDP in this way without recreating receive
677 // streams, we ignore the order of the received codecs so that
678 // changing the order doesn't cause this "blink".
Yves Gerey665174f2018-06-19 15:03:05 +0200679 auto comparison = [](const VideoCodecSettings& codec1,
680 const VideoCodecSettings& codec2) {
681 return codec1.codec.id > codec2.codec.id;
682 };
deadbeef874ca3a2015-08-20 17:19:20 -0700683 std::sort(before.begin(), before.end(), comparison);
684 std::sort(after.begin(), after.end(), comparison);
brandtr11fb4722017-05-30 01:31:37 -0700685
686 // Changes in FlexFEC payload type are handled separately in
eladalonf1841382017-06-12 01:16:46 -0700687 // WebRtcVideoChannel::GetChangedRecvParameters, so disregard FlexFEC in the
brandtr11fb4722017-05-30 01:31:37 -0700688 // comparison here.
689 return !std::equal(before.begin(), before.end(), after.begin(),
690 VideoCodecSettings::EqualsDisregardingFlexfec);
deadbeef874ca3a2015-08-20 17:19:20 -0700691}
692
eladalonf1841382017-06-12 01:16:46 -0700693bool WebRtcVideoChannel::GetChangedSendParameters(
Peter Boström3afc8c42016-01-27 16:45:21 +0100694 const VideoSendParameters& params,
695 ChangedSendParameters* changed_params) const {
696 if (!ValidateCodecFormats(params.codecs) ||
697 !ValidateRtpExtensions(params.extensions)) {
698 return false;
699 }
700
magjed23b7a4a2016-11-08 01:12:54 -0800701 // Select one of the remote codecs that will be used as send codec.
Danil Chapovalov00c71832018-06-15 15:58:38 +0200702 absl::optional<VideoCodecSettings> selected_send_codec =
magjed23b7a4a2016-11-08 01:12:54 -0800703 SelectSendVideoCodec(MapCodecs(params.codecs));
Peter Boström3afc8c42016-01-27 16:45:21 +0100704
magjed23b7a4a2016-11-08 01:12:54 -0800705 if (!selected_send_codec) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100706 RTC_LOG(LS_ERROR) << "No video codecs supported.";
Peter Boström3afc8c42016-01-27 16:45:21 +0100707 return false;
708 }
709
brandtr31bd2242017-05-19 05:47:46 -0700710 // Never enable sending FlexFEC, unless we are in the experiment.
711 if (!IsFlexfecFieldTrialEnabled()) {
712 if (selected_send_codec->flexfec_payload_type != -1) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100713 RTC_LOG(LS_INFO)
714 << "Remote supports flexfec-03, but we will not send since "
715 << "WebRTC-FlexFEC-03 field trial is not enabled.";
brandtr31bd2242017-05-19 05:47:46 -0700716 }
717 selected_send_codec->flexfec_payload_type = -1;
718 }
719
magjed23b7a4a2016-11-08 01:12:54 -0800720 if (!send_codec_ || *selected_send_codec != *send_codec_)
721 changed_params->codec = selected_send_codec;
Peter Boström3afc8c42016-01-27 16:45:21 +0100722
pbos378dc772016-01-28 15:58:41 -0800723 // Handle RTP header extensions.
Peter Boström3afc8c42016-01-27 16:45:21 +0100724 std::vector<webrtc::RtpExtension> filtered_extensions = FilterRtpExtensions(
725 params.extensions, webrtc::RtpExtension::IsSupportedForVideo, true);
skvlad3abb7642016-06-16 12:08:03 -0700726 if (!send_rtp_extensions_ || (*send_rtp_extensions_ != filtered_extensions)) {
Peter Boström3afc8c42016-01-27 16:45:21 +0100727 changed_params->rtp_header_extensions =
Danil Chapovalov00c71832018-06-15 15:58:38 +0200728 absl::optional<std::vector<webrtc::RtpExtension>>(filtered_extensions);
Peter Boström3afc8c42016-01-27 16:45:21 +0100729 }
730
Steve Antonbb50ce52018-03-26 10:24:32 -0700731 if (params.mid != send_params_.mid) {
732 changed_params->mid = params.mid;
733 }
734
pbos378dc772016-01-28 15:58:41 -0800735 // Handle max bitrate.
Taylor Brandstetter58f2bd92016-04-26 17:15:23 -0700736 if (params.max_bandwidth_bps != send_params_.max_bandwidth_bps &&
pbos5c7760a2017-03-10 11:23:12 -0800737 params.max_bandwidth_bps >= -1) {
738 // 0 or -1 uncaps max bitrate.
739 // TODO(pbos): Reconsider how 0 should be treated. It is not mentioned as a
740 // special value and might very well be used for stopping sending.
Oskar Sundbom78807582017-11-16 11:09:55 +0100741 changed_params->max_bandwidth_bps =
742 params.max_bandwidth_bps == 0 ? -1 : params.max_bandwidth_bps;
Peter Boström3afc8c42016-01-27 16:45:21 +0100743 }
744
nisse4b4dc862016-02-17 05:25:36 -0800745 // Handle conference mode.
746 if (params.conference_mode != send_params_.conference_mode) {
Oskar Sundbom78807582017-11-16 11:09:55 +0100747 changed_params->conference_mode = params.conference_mode;
nisse4b4dc862016-02-17 05:25:36 -0800748 }
749
pbos378dc772016-01-28 15:58:41 -0800750 // Handle RTCP mode.
Peter Boström3afc8c42016-01-27 16:45:21 +0100751 if (params.rtcp.reduced_size != send_params_.rtcp.reduced_size) {
Oskar Sundbom78807582017-11-16 11:09:55 +0100752 changed_params->rtcp_mode = params.rtcp.reduced_size
753 ? webrtc::RtcpMode::kReducedSize
754 : webrtc::RtcpMode::kCompound;
Peter Boström3afc8c42016-01-27 16:45:21 +0100755 }
756
757 return true;
758}
759
eladalonf1841382017-06-12 01:16:46 -0700760rtc::DiffServCodePoint WebRtcVideoChannel::PreferredDscp() const {
nisse51542be2016-02-12 02:27:06 -0800761 return rtc::DSCP_AF41;
762}
763
eladalonf1841382017-06-12 01:16:46 -0700764bool WebRtcVideoChannel::SetSendParameters(const VideoSendParameters& params) {
765 TRACE_EVENT0("webrtc", "WebRtcVideoChannel::SetSendParameters");
Mirko Bonadei675513b2017-11-09 11:09:25 +0100766 RTC_LOG(LS_INFO) << "SetSendParameters: " << params.ToString();
Peter Boström3afc8c42016-01-27 16:45:21 +0100767 ChangedSendParameters changed_params;
768 if (!GetChangedSendParameters(params, &changed_params)) {
deadbeef13871492015-12-09 12:37:51 -0800769 return false;
770 }
Peter Boström3afc8c42016-01-27 16:45:21 +0100771
Peter Boström3afc8c42016-01-27 16:45:21 +0100772 if (changed_params.codec) {
773 const VideoCodecSettings& codec_settings = *changed_params.codec;
Oskar Sundbom78807582017-11-16 11:09:55 +0100774 send_codec_ = codec_settings;
Mirko Bonadei675513b2017-11-09 11:09:25 +0100775 RTC_LOG(LS_INFO) << "Using codec: " << codec_settings.codec.ToString();
Peter Boström3afc8c42016-01-27 16:45:21 +0100776 }
777
778 if (changed_params.rtp_header_extensions) {
skvlad3abb7642016-06-16 12:08:03 -0700779 send_rtp_extensions_ = changed_params.rtp_header_extensions;
Peter Boström3afc8c42016-01-27 16:45:21 +0100780 }
781
Taylor Brandstetter58f2bd92016-04-26 17:15:23 -0700782 if (changed_params.codec || changed_params.max_bandwidth_bps) {
pbos5c7760a2017-03-10 11:23:12 -0800783 if (params.max_bandwidth_bps == -1) {
784 // Unset the global max bitrate (max_bitrate_bps) if max_bandwidth_bps is
785 // -1, which corresponds to no "b=AS" attribute in SDP. Note that the
786 // global max bitrate may be set below in GetBitrateConfigForCodec, from
787 // the codec max bitrate.
788 // TODO(pbos): This should be reconsidered (codec max bitrate should
789 // probably not affect global call max bitrate).
790 bitrate_config_.max_bitrate_bps = -1;
791 }
Taylor Brandstetter58f2bd92016-04-26 17:15:23 -0700792 if (send_codec_) {
793 // TODO(holmer): Changing the codec parameters shouldn't necessarily mean
794 // that we change the min/max of bandwidth estimation. Reevaluate this.
795 bitrate_config_ = GetBitrateConfigForCodec(send_codec_->codec);
796 if (!changed_params.codec) {
797 // If the codec isn't changing, set the start bitrate to -1 which means
798 // "unchanged" so that BWE isn't affected.
799 bitrate_config_.start_bitrate_bps = -1;
800 }
Peter Boström3afc8c42016-01-27 16:45:21 +0100801 }
Taylor Brandstetter58f2bd92016-04-26 17:15:23 -0700802 if (params.max_bandwidth_bps >= 0) {
803 // Note that max_bandwidth_bps intentionally takes priority over the
804 // bitrate config for the codec. This allows FEC to be applied above the
805 // codec target bitrate.
806 // TODO(pbos): Figure out whether b=AS means max bitrate for this
eladalonf1841382017-06-12 01:16:46 -0700807 // WebRtcVideoChannel (in which case we're good), or per sender (SSRC),
Sebastian Janssonfc8d26b2018-02-21 09:52:06 +0100808 // in which case this should not set a BitrateConstraints but rather
Taylor Brandstetter58f2bd92016-04-26 17:15:23 -0700809 // reconfigure all senders.
810 bitrate_config_.max_bitrate_bps =
811 params.max_bandwidth_bps == 0 ? -1 : params.max_bandwidth_bps;
812 }
Sebastian Jansson8f83b422018-02-21 13:07:13 +0100813 call_->GetTransportControllerSend()->SetSdpBitrateParameters(
814 bitrate_config_);
Peter Boström3afc8c42016-01-27 16:45:21 +0100815 }
816
Peter Boström3afc8c42016-01-27 16:45:21 +0100817 {
deadbeef13871492015-12-09 12:37:51 -0800818 rtc::CritScope stream_lock(&stream_crit_);
819 for (auto& kv : send_streams_) {
Peter Boström3afc8c42016-01-27 16:45:21 +0100820 kv.second->SetSendParameters(changed_params);
821 }
Taylor Brandstetter5f0b83b2016-03-18 15:02:07 -0700822 if (changed_params.codec || changed_params.rtcp_mode) {
823 // Update receive feedback parameters from new codec or RTCP mode.
Mirko Bonadei675513b2017-11-09 11:09:25 +0100824 RTC_LOG(LS_INFO)
Peter Boström3afc8c42016-01-27 16:45:21 +0100825 << "SetFeedbackOptions on all the receive streams because the send "
Taylor Brandstetter5f0b83b2016-03-18 15:02:07 -0700826 "codec or RTCP mode has changed.";
Peter Boström3afc8c42016-01-27 16:45:21 +0100827 for (auto& kv : receive_streams_) {
828 RTC_DCHECK(kv.second != nullptr);
Taylor Brandstetter5f0b83b2016-03-18 15:02:07 -0700829 kv.second->SetFeedbackParameters(
830 HasNack(send_codec_->codec), HasRemb(send_codec_->codec),
831 HasTransportCc(send_codec_->codec),
832 params.rtcp.reduced_size ? webrtc::RtcpMode::kReducedSize
833 : webrtc::RtcpMode::kCompound);
Peter Boström3afc8c42016-01-27 16:45:21 +0100834 }
deadbeef13871492015-12-09 12:37:51 -0800835 }
836 }
837 send_params_ = params;
838 return true;
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700839}
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700840
eladalonf1841382017-06-12 01:16:46 -0700841webrtc::RtpParameters WebRtcVideoChannel::GetRtpSendParameters(
skvladdc1c62c2016-03-16 19:07:43 -0700842 uint32_t ssrc) const {
843 rtc::CritScope stream_lock(&stream_crit_);
844 auto it = send_streams_.find(ssrc);
845 if (it == send_streams_.end()) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100846 RTC_LOG(LS_WARNING) << "Attempting to get RTP send parameters for stream "
847 << "with ssrc " << ssrc << " which doesn't exist.";
skvladdc1c62c2016-03-16 19:07:43 -0700848 return webrtc::RtpParameters();
849 }
850
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700851 webrtc::RtpParameters rtp_params = it->second->GetRtpParameters();
852 // Need to add the common list of codecs to the send stream-specific
853 // RTP parameters.
854 for (const VideoCodec& codec : send_params_.codecs) {
855 rtp_params.codecs.push_back(codec.ToCodecParameters());
856 }
857 return rtp_params;
skvladdc1c62c2016-03-16 19:07:43 -0700858}
859
Zach Steinba37b4b2018-01-23 15:02:36 -0800860webrtc::RTCError WebRtcVideoChannel::SetRtpSendParameters(
skvladdc1c62c2016-03-16 19:07:43 -0700861 uint32_t ssrc,
862 const webrtc::RtpParameters& parameters) {
eladalonf1841382017-06-12 01:16:46 -0700863 TRACE_EVENT0("webrtc", "WebRtcVideoChannel::SetRtpSendParameters");
skvladdc1c62c2016-03-16 19:07:43 -0700864 rtc::CritScope stream_lock(&stream_crit_);
865 auto it = send_streams_.find(ssrc);
866 if (it == send_streams_.end()) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100867 RTC_LOG(LS_ERROR) << "Attempting to set RTP send parameters for stream "
868 << "with ssrc " << ssrc << " which doesn't exist.";
Zach Steinba37b4b2018-01-23 15:02:36 -0800869 return webrtc::RTCError(webrtc::RTCErrorType::INTERNAL_ERROR);
skvladdc1c62c2016-03-16 19:07:43 -0700870 }
871
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700872 // TODO(deadbeef): Handle setting parameters with a list of codecs in a
873 // different order (which should change the send codec).
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700874 webrtc::RtpParameters current_parameters = GetRtpSendParameters(ssrc);
875 if (current_parameters.codecs != parameters.codecs) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100876 RTC_LOG(LS_ERROR) << "Using SetParameters to change the set of codecs "
877 << "is not currently supported.";
Zach Steinba37b4b2018-01-23 15:02:36 -0800878 return webrtc::RTCError(webrtc::RTCErrorType::INTERNAL_ERROR);
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700879 }
880
skvladdc1c62c2016-03-16 19:07:43 -0700881 return it->second->SetRtpParameters(parameters);
882}
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700883
eladalonf1841382017-06-12 01:16:46 -0700884webrtc::RtpParameters WebRtcVideoChannel::GetRtpReceiveParameters(
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700885 uint32_t ssrc) const {
deadbeef3bc15102017-04-20 19:25:07 -0700886 webrtc::RtpParameters rtp_params;
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700887 rtc::CritScope stream_lock(&stream_crit_);
deadbeef3bc15102017-04-20 19:25:07 -0700888 // SSRC of 0 represents an unsignaled receive stream.
889 if (ssrc == 0) {
890 if (!default_unsignalled_ssrc_handler_.GetDefaultSink()) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100891 RTC_LOG(LS_WARNING)
892 << "Attempting to get RTP parameters for the default, "
893 "unsignaled video receive stream, but not yet "
894 "configured to receive such a stream.";
deadbeef3bc15102017-04-20 19:25:07 -0700895 return rtp_params;
896 }
897 rtp_params.encodings.emplace_back();
898 } else {
899 auto it = receive_streams_.find(ssrc);
900 if (it == receive_streams_.end()) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100901 RTC_LOG(LS_WARNING)
902 << "Attempting to get RTP receive parameters for stream "
903 << "with SSRC " << ssrc << " which doesn't exist.";
deadbeef3bc15102017-04-20 19:25:07 -0700904 return webrtc::RtpParameters();
905 }
Florent Castelliabe301f2018-06-12 18:33:49 +0200906 rtp_params = it->second->GetRtpParameters();
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700907 }
908
deadbeef3bc15102017-04-20 19:25:07 -0700909 // Add codecs, which any stream is prepared to receive.
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700910 for (const VideoCodec& codec : recv_params_.codecs) {
911 rtp_params.codecs.push_back(codec.ToCodecParameters());
912 }
Florent Castelliabe301f2018-06-12 18:33:49 +0200913
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700914 return rtp_params;
915}
916
eladalonf1841382017-06-12 01:16:46 -0700917bool WebRtcVideoChannel::SetRtpReceiveParameters(
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700918 uint32_t ssrc,
919 const webrtc::RtpParameters& parameters) {
eladalonf1841382017-06-12 01:16:46 -0700920 TRACE_EVENT0("webrtc", "WebRtcVideoChannel::SetRtpReceiveParameters");
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700921 rtc::CritScope stream_lock(&stream_crit_);
deadbeef3bc15102017-04-20 19:25:07 -0700922
923 // SSRC of 0 represents an unsignaled receive stream.
924 if (ssrc == 0) {
925 if (!default_unsignalled_ssrc_handler_.GetDefaultSink()) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100926 RTC_LOG(LS_WARNING)
927 << "Attempting to set RTP parameters for the default, "
928 "unsignaled video receive stream, but not yet "
929 "configured to receive such a stream.";
deadbeef3bc15102017-04-20 19:25:07 -0700930 return false;
931 }
932 } else {
933 auto it = receive_streams_.find(ssrc);
934 if (it == receive_streams_.end()) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100935 RTC_LOG(LS_WARNING)
936 << "Attempting to set RTP receive parameters for stream "
937 << "with SSRC " << ssrc << " which doesn't exist.";
deadbeef3bc15102017-04-20 19:25:07 -0700938 return false;
939 }
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700940 }
941
942 webrtc::RtpParameters current_parameters = GetRtpReceiveParameters(ssrc);
943 if (current_parameters != parameters) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100944 RTC_LOG(LS_ERROR) << "Changing the RTP receive parameters is currently "
945 << "unsupported.";
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700946 return false;
947 }
948 return true;
949}
950
eladalonf1841382017-06-12 01:16:46 -0700951bool WebRtcVideoChannel::GetChangedRecvParameters(
pbos378dc772016-01-28 15:58:41 -0800952 const VideoRecvParameters& params,
953 ChangedRecvParameters* changed_params) const {
954 if (!ValidateCodecFormats(params.codecs) ||
955 !ValidateRtpExtensions(params.extensions)) {
956 return false;
957 }
958
959 // Handle receive codecs.
960 const std::vector<VideoCodecSettings> mapped_codecs =
961 MapCodecs(params.codecs);
962 if (mapped_codecs.empty()) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100963 RTC_LOG(LS_ERROR) << "SetRecvParameters called without any video codecs.";
pbos378dc772016-01-28 15:58:41 -0800964 return false;
965 }
966
magjed23b7a4a2016-11-08 01:12:54 -0800967 // Verify that every mapped codec is supported locally.
968 const std::vector<VideoCodec> local_supported_codecs =
Magnus Jedvert9b16e2d2017-11-18 12:08:55 +0100969 AssignPayloadTypesAndDefaultCodecs(encoder_factory_);
magjed23b7a4a2016-11-08 01:12:54 -0800970 for (const VideoCodecSettings& mapped_codec : mapped_codecs) {
magjedf823ede2016-11-12 09:53:04 -0800971 if (!FindMatchingCodec(local_supported_codecs, mapped_codec.codec)) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100972 RTC_LOG(LS_ERROR)
973 << "SetRecvParameters called with unsupported video codec: "
974 << mapped_codec.codec.ToString();
magjed23b7a4a2016-11-08 01:12:54 -0800975 return false;
976 }
pbos378dc772016-01-28 15:58:41 -0800977 }
978
brandtr11fb4722017-05-30 01:31:37 -0700979 if (NonFlexfecReceiveCodecsHaveChanged(recv_codecs_, mapped_codecs)) {
pbos378dc772016-01-28 15:58:41 -0800980 changed_params->codec_settings =
Danil Chapovalov00c71832018-06-15 15:58:38 +0200981 absl::optional<std::vector<VideoCodecSettings>>(mapped_codecs);
pbos378dc772016-01-28 15:58:41 -0800982 }
983
984 // Handle RTP header extensions.
985 std::vector<webrtc::RtpExtension> filtered_extensions = FilterRtpExtensions(
986 params.extensions, webrtc::RtpExtension::IsSupportedForVideo, false);
987 if (filtered_extensions != recv_rtp_extensions_) {
988 changed_params->rtp_header_extensions =
Danil Chapovalov00c71832018-06-15 15:58:38 +0200989 absl::optional<std::vector<webrtc::RtpExtension>>(filtered_extensions);
pbos378dc772016-01-28 15:58:41 -0800990 }
991
brandtr11fb4722017-05-30 01:31:37 -0700992 int flexfec_payload_type = mapped_codecs.front().flexfec_payload_type;
993 if (flexfec_payload_type != recv_flexfec_payload_type_) {
Oskar Sundbom78807582017-11-16 11:09:55 +0100994 changed_params->flexfec_payload_type = flexfec_payload_type;
brandtr11fb4722017-05-30 01:31:37 -0700995 }
996
pbos378dc772016-01-28 15:58:41 -0800997 return true;
998}
999
eladalonf1841382017-06-12 01:16:46 -07001000bool WebRtcVideoChannel::SetRecvParameters(const VideoRecvParameters& params) {
1001 TRACE_EVENT0("webrtc", "WebRtcVideoChannel::SetRecvParameters");
Mirko Bonadei675513b2017-11-09 11:09:25 +01001002 RTC_LOG(LS_INFO) << "SetRecvParameters: " << params.ToString();
pbos378dc772016-01-28 15:58:41 -08001003 ChangedRecvParameters changed_params;
1004 if (!GetChangedRecvParameters(params, &changed_params)) {
deadbeef13871492015-12-09 12:37:51 -08001005 return false;
1006 }
brandtr11fb4722017-05-30 01:31:37 -07001007 if (changed_params.flexfec_payload_type) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01001008 RTC_LOG(LS_INFO) << "Changing FlexFEC payload type (recv) from "
1009 << recv_flexfec_payload_type_ << " to "
1010 << *changed_params.flexfec_payload_type;
brandtr11fb4722017-05-30 01:31:37 -07001011 recv_flexfec_payload_type_ = *changed_params.flexfec_payload_type;
1012 }
pbos378dc772016-01-28 15:58:41 -08001013 if (changed_params.rtp_header_extensions) {
1014 recv_rtp_extensions_ = *changed_params.rtp_header_extensions;
1015 }
1016 if (changed_params.codec_settings) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01001017 RTC_LOG(LS_INFO) << "Changing recv codecs from "
1018 << CodecSettingsVectorToString(recv_codecs_) << " to "
1019 << CodecSettingsVectorToString(
1020 *changed_params.codec_settings);
pbos378dc772016-01-28 15:58:41 -08001021 recv_codecs_ = *changed_params.codec_settings;
1022 }
1023
1024 {
deadbeef13871492015-12-09 12:37:51 -08001025 rtc::CritScope stream_lock(&stream_crit_);
1026 for (auto& kv : receive_streams_) {
pbos378dc772016-01-28 15:58:41 -08001027 kv.second->SetRecvParameters(changed_params);
deadbeef13871492015-12-09 12:37:51 -08001028 }
1029 }
1030 recv_params_ = params;
1031 return true;
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001032}
1033
eladalonf1841382017-06-12 01:16:46 -07001034std::string WebRtcVideoChannel::CodecSettingsVectorToString(
deadbeef874ca3a2015-08-20 17:19:20 -07001035 const std::vector<VideoCodecSettings>& codecs) {
1036 std::stringstream out;
1037 out << '{';
1038 for (size_t i = 0; i < codecs.size(); ++i) {
1039 out << codecs[i].codec.ToString();
1040 if (i != codecs.size() - 1) {
1041 out << ", ";
1042 }
1043 }
1044 out << '}';
1045 return out.str();
1046}
1047
eladalonf1841382017-06-12 01:16:46 -07001048bool WebRtcVideoChannel::GetSendCodec(VideoCodec* codec) {
kwiberg102c6a62015-10-30 02:47:38 -07001049 if (!send_codec_) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01001050 RTC_LOG(LS_VERBOSE) << "GetSendCodec: No send codec set.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001051 return false;
1052 }
kwiberg102c6a62015-10-30 02:47:38 -07001053 *codec = send_codec_->codec;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001054 return true;
1055}
1056
eladalonf1841382017-06-12 01:16:46 -07001057bool WebRtcVideoChannel::SetSend(bool send) {
1058 TRACE_EVENT0("webrtc", "WebRtcVideoChannel::SetSend");
Mirko Bonadei675513b2017-11-09 11:09:25 +01001059 RTC_LOG(LS_VERBOSE) << "SetSend: " << (send ? "true" : "false");
kwiberg102c6a62015-10-30 02:47:38 -07001060 if (send && !send_codec_) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01001061 RTC_LOG(LS_ERROR) << "SetSend(true) called before setting codec.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001062 return false;
1063 }
deadbeefdbe2b872016-03-22 15:42:00 -07001064 {
1065 rtc::CritScope stream_lock(&stream_crit_);
1066 for (const auto& kv : send_streams_) {
1067 kv.second->SetSend(send);
1068 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001069 }
1070 sending_ = send;
1071 return true;
1072}
1073
eladalonf1841382017-06-12 01:16:46 -07001074bool WebRtcVideoChannel::SetVideoSend(
deadbeef5a4a75a2016-06-02 16:23:38 -07001075 uint32_t ssrc,
deadbeef5a4a75a2016-06-02 16:23:38 -07001076 const VideoOptions* options,
nisseacd935b2016-11-11 03:55:13 -08001077 rtc::VideoSourceInterface<webrtc::VideoFrame>* source) {
Peter Boström3afc8c42016-01-27 16:45:21 +01001078 TRACE_EVENT0("webrtc", "SetVideoSend");
deadbeef5a4a75a2016-06-02 16:23:38 -07001079 RTC_DCHECK(ssrc != 0);
Yves Gerey665174f2018-06-19 15:03:05 +02001080 RTC_LOG(LS_INFO) << "SetVideoSend (ssrc= " << ssrc << ", options: "
Mirko Bonadei675513b2017-11-09 11:09:25 +01001081 << (options ? options->ToString() : "nullptr")
1082 << ", source = " << (source ? "(source)" : "nullptr") << ")";
Peter Boström3afc8c42016-01-27 16:45:21 +01001083
deadbeef5a4a75a2016-06-02 16:23:38 -07001084 rtc::CritScope stream_lock(&stream_crit_);
1085 const auto& kv = send_streams_.find(ssrc);
1086 if (kv == send_streams_.end()) {
1087 // Allow unknown ssrc only if source is null.
1088 RTC_CHECK(source == nullptr);
Mirko Bonadei675513b2017-11-09 11:09:25 +01001089 RTC_LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc;
deadbeef5a4a75a2016-06-02 16:23:38 -07001090 return false;
solenberg1dd98f32015-09-10 01:57:14 -07001091 }
deadbeef5a4a75a2016-06-02 16:23:38 -07001092
Niels Möllerff40b142018-04-09 08:49:14 +02001093 return kv->second->SetVideoSend(options, source);
solenberg1dd98f32015-09-10 01:57:14 -07001094}
1095
eladalonf1841382017-06-12 01:16:46 -07001096bool WebRtcVideoChannel::ValidateSendSsrcAvailability(
Peter Boströmd6f4c252015-03-26 16:23:04 +01001097 const StreamParams& sp) const {
Pera5092412016-02-12 13:30:57 +01001098 for (uint32_t ssrc : sp.ssrcs) {
Peter Boströmd6f4c252015-03-26 16:23:04 +01001099 if (send_ssrcs_.find(ssrc) != send_ssrcs_.end()) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01001100 RTC_LOG(LS_ERROR) << "Send stream with SSRC '" << ssrc
1101 << "' already exists.";
Peter Boströmd6f4c252015-03-26 16:23:04 +01001102 return false;
1103 }
1104 }
1105 return true;
1106}
1107
eladalonf1841382017-06-12 01:16:46 -07001108bool WebRtcVideoChannel::ValidateReceiveSsrcAvailability(
Peter Boströmd6f4c252015-03-26 16:23:04 +01001109 const StreamParams& sp) const {
Pera5092412016-02-12 13:30:57 +01001110 for (uint32_t ssrc : sp.ssrcs) {
Peter Boströmd6f4c252015-03-26 16:23:04 +01001111 if (receive_ssrcs_.find(ssrc) != receive_ssrcs_.end()) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01001112 RTC_LOG(LS_ERROR) << "Receive stream with SSRC '" << ssrc
1113 << "' already exists.";
Peter Boströmd6f4c252015-03-26 16:23:04 +01001114 return false;
1115 }
1116 }
1117 return true;
1118}
1119
eladalonf1841382017-06-12 01:16:46 -07001120bool WebRtcVideoChannel::AddSendStream(const StreamParams& sp) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01001121 RTC_LOG(LS_INFO) << "AddSendStream: " << sp.ToString();
Peter Boströmd4362cd2015-03-25 14:17:23 +01001122 if (!ValidateStreamParams(sp))
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001123 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001124
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001125 rtc::CritScope stream_lock(&stream_crit_);
Peter Boströmd6f4c252015-03-26 16:23:04 +01001126
1127 if (!ValidateSendSsrcAvailability(sp))
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001128 return false;
Peter Boströmd6f4c252015-03-26 16:23:04 +01001129
Peter Boström0c4e06b2015-10-07 12:23:21 +02001130 for (uint32_t used_ssrc : sp.ssrcs)
Peter Boströmd6f4c252015-03-26 16:23:04 +01001131 send_ssrcs_.insert(used_ssrc);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001132
solenberge5269742015-09-08 05:13:22 -07001133 webrtc::VideoSendStream::Config config(this);
nisse0db023a2016-03-01 04:29:59 -08001134 config.suspend_below_min_bitrate = video_config_.suspend_below_min_bitrate;
sergeyu80ed35e2016-11-28 13:11:13 -08001135 config.periodic_alr_bandwidth_probing =
1136 video_config_.periodic_alr_bandwidth_probing;
Niels Möller6539f692018-01-18 08:58:50 +01001137 config.encoder_settings.experiment_cpu_load_estimator =
1138 video_config_.experiment_cpu_load_estimator;
Niels Möller88614b02018-03-27 16:39:01 +02001139 config.encoder_settings.encoder_factory = encoder_factory_;
Niels Möller6539f692018-01-18 08:58:50 +01001140
nisse05103312016-03-16 02:22:50 -07001141 WebRtcVideoSendStream* stream = new WebRtcVideoSendStream(
Niels Möller88614b02018-03-27 16:39:01 +02001142 call_, sp, std::move(config), default_send_options_,
Yves Gerey665174f2018-06-19 15:03:05 +02001143 video_config_.enable_cpu_adaptation, bitrate_config_.max_bitrate_bps,
1144 send_codec_, send_rtp_extensions_, send_params_);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001145
Peter Boström0c4e06b2015-10-07 12:23:21 +02001146 uint32_t ssrc = sp.first_ssrc();
henrikg91d6ede2015-09-17 00:24:34 -07001147 RTC_DCHECK(ssrc != 0);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001148 send_streams_[ssrc] = stream;
1149
1150 if (rtcp_receiver_report_ssrc_ == kDefaultRtcpReceiverReportSsrc) {
1151 rtcp_receiver_report_ssrc_ = ssrc;
Mirko Bonadei675513b2017-11-09 11:09:25 +01001152 RTC_LOG(LS_INFO)
1153 << "SetLocalSsrc on all the receive streams because we added "
1154 "a send stream.";
Peter Boström3548dd22015-05-22 18:48:36 +02001155 for (auto& kv : receive_streams_)
1156 kv.second->SetLocalSsrc(ssrc);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001157 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001158 if (sending_) {
deadbeefdbe2b872016-03-22 15:42:00 -07001159 stream->SetSend(true);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001160 }
1161
1162 return true;
1163}
1164
eladalonf1841382017-06-12 01:16:46 -07001165bool WebRtcVideoChannel::RemoveSendStream(uint32_t ssrc) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01001166 RTC_LOG(LS_INFO) << "RemoveSendStream: " << ssrc;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001167
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001168 WebRtcVideoSendStream* removed_stream;
1169 {
1170 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001171 std::map<uint32_t, WebRtcVideoSendStream*>::iterator it =
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001172 send_streams_.find(ssrc);
1173 if (it == send_streams_.end()) {
1174 return false;
1175 }
1176
Peter Boström0c4e06b2015-10-07 12:23:21 +02001177 for (uint32_t old_ssrc : it->second->GetSsrcs())
Peter Boströmd6f4c252015-03-26 16:23:04 +01001178 send_ssrcs_.erase(old_ssrc);
1179
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001180 removed_stream = it->second;
1181 send_streams_.erase(it);
Peter Boströmdfa28152015-10-21 17:21:10 +02001182
1183 // Switch receiver report SSRCs, the one in use is no longer valid.
1184 if (rtcp_receiver_report_ssrc_ == ssrc) {
1185 rtcp_receiver_report_ssrc_ = send_streams_.empty()
1186 ? kDefaultRtcpReceiverReportSsrc
1187 : send_streams_.begin()->first;
Mirko Bonadei675513b2017-11-09 11:09:25 +01001188 RTC_LOG(LS_INFO) << "SetLocalSsrc on all the receive streams because the "
1189 "previous local SSRC was removed.";
Peter Boströmdfa28152015-10-21 17:21:10 +02001190
1191 for (auto& kv : receive_streams_) {
1192 kv.second->SetLocalSsrc(rtcp_receiver_report_ssrc_);
1193 }
1194 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001195 }
1196
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001197 delete removed_stream;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001198
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001199 return true;
1200}
1201
eladalonf1841382017-06-12 01:16:46 -07001202void WebRtcVideoChannel::DeleteReceiveStream(
1203 WebRtcVideoChannel::WebRtcVideoReceiveStream* stream) {
Peter Boström0c4e06b2015-10-07 12:23:21 +02001204 for (uint32_t old_ssrc : stream->GetSsrcs())
Peter Boströmd6f4c252015-03-26 16:23:04 +01001205 receive_ssrcs_.erase(old_ssrc);
1206 delete stream;
1207}
1208
eladalonf1841382017-06-12 01:16:46 -07001209bool WebRtcVideoChannel::AddRecvStream(const StreamParams& sp) {
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00001210 return AddRecvStream(sp, false);
1211}
1212
eladalonf1841382017-06-12 01:16:46 -07001213bool WebRtcVideoChannel::AddRecvStream(const StreamParams& sp,
1214 bool default_stream) {
henrikg91d6ede2015-09-17 00:24:34 -07001215 RTC_DCHECK(thread_checker_.CalledOnValidThread());
Fredrik Solenberg4b60c732015-05-07 14:07:48 +02001216
Mirko Bonadei675513b2017-11-09 11:09:25 +01001217 RTC_LOG(LS_INFO) << "AddRecvStream"
1218 << (default_stream ? " (default stream)" : "") << ": "
1219 << sp.ToString();
Seth Hampson5897a6e2018-04-03 11:16:33 -07001220 if (!sp.has_ssrcs()) {
1221 // This is a StreamParam with unsignaled SSRCs. Store it, so it can be used
1222 // later when we know the SSRC on the first packet arrival.
1223 unsignaled_stream_params_ = sp;
1224 return true;
1225 }
1226
Peter Boströmd4362cd2015-03-25 14:17:23 +01001227 if (!ValidateStreamParams(sp))
1228 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001229
Peter Boström0c4e06b2015-10-07 12:23:21 +02001230 uint32_t ssrc = sp.first_ssrc();
henrikg91d6ede2015-09-17 00:24:34 -07001231 RTC_DCHECK(ssrc != 0); // TODO(pbos): Is this ever valid?
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001232
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001233 rtc::CritScope stream_lock(&stream_crit_);
Peter Boströmd6f4c252015-03-26 16:23:04 +01001234 // Remove running stream if this was a default stream.
nissea293ef02016-02-17 07:24:50 -08001235 const auto& prev_stream = receive_streams_.find(ssrc);
Peter Boströmd6f4c252015-03-26 16:23:04 +01001236 if (prev_stream != receive_streams_.end()) {
1237 if (default_stream || !prev_stream->second->IsDefaultStream()) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01001238 RTC_LOG(LS_ERROR) << "Receive stream for SSRC '" << ssrc
1239 << "' already exists.";
Peter Boströmd6f4c252015-03-26 16:23:04 +01001240 return false;
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00001241 }
Peter Boströmd6f4c252015-03-26 16:23:04 +01001242 DeleteReceiveStream(prev_stream->second);
1243 receive_streams_.erase(prev_stream);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001244 }
1245
Peter Boströmd6f4c252015-03-26 16:23:04 +01001246 if (!ValidateReceiveSsrcAvailability(sp))
1247 return false;
1248
Peter Boström0c4e06b2015-10-07 12:23:21 +02001249 for (uint32_t used_ssrc : sp.ssrcs)
Peter Boströmd6f4c252015-03-26 16:23:04 +01001250 receive_ssrcs_.insert(used_ssrc);
1251
solenberg4fbae2b2015-08-28 04:07:10 -07001252 webrtc::VideoReceiveStream::Config config(this);
brandtr8313a6f2017-01-13 07:41:19 -08001253 webrtc::FlexfecReceiveStream::Config flexfec_config(this);
brandtr468da7c2016-11-22 02:16:47 -08001254 ConfigureReceiverRtp(&config, &flexfec_config, sp);
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +00001255
Niels Möller1d7ecd22018-01-18 15:25:12 +01001256 // TODO(nisse): Rename config variable to avoid negation.
nisse7ade7b32016-03-23 04:48:10 -07001257 config.disable_prerenderer_smoothing =
Niels Möller1d7ecd22018-01-18 15:25:12 +01001258 !video_config_.enable_prerenderer_smoothing;
Seth Hampson845e8782018-03-02 11:34:10 -08001259 if (!sp.stream_ids().empty()) {
1260 config.sync_group = sp.stream_ids()[0];
Steve Anton5a26a3a2018-02-28 11:38:47 -08001261 }
Peter Boström126c03e2015-05-11 12:48:12 +02001262
Peter Boströmd6f4c252015-03-26 16:23:04 +01001263 receive_streams_[ssrc] = new WebRtcVideoReceiveStream(
magjed2475ae22017-09-12 04:42:15 -07001264 call_, sp, std::move(config), decoder_factory_, default_stream,
brandtr468da7c2016-11-22 02:16:47 -08001265 recv_codecs_, flexfec_config);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001266
1267 return true;
1268}
1269
eladalonf1841382017-06-12 01:16:46 -07001270void WebRtcVideoChannel::ConfigureReceiverRtp(
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001271 webrtc::VideoReceiveStream::Config* config,
brandtr8313a6f2017-01-13 07:41:19 -08001272 webrtc::FlexfecReceiveStream::Config* flexfec_config,
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001273 const StreamParams& sp) const {
Peter Boström0c4e06b2015-10-07 12:23:21 +02001274 uint32_t ssrc = sp.first_ssrc();
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001275
1276 config->rtp.remote_ssrc = ssrc;
1277 config->rtp.local_ssrc = rtcp_receiver_report_ssrc_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001278
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001279 // TODO(pbos): This protection is against setting the same local ssrc as
1280 // remote which is not permitted by the lower-level API. RTCP requires a
1281 // corresponding sender SSRC. Figure out what to do when we don't have
1282 // (receive-only) or know a good local SSRC.
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001283 if (config->rtp.remote_ssrc == config->rtp.local_ssrc) {
1284 if (config->rtp.local_ssrc != kDefaultRtcpReceiverReportSsrc) {
1285 config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001286 } else {
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001287 config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc + 1;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001288 }
1289 }
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001290
brandtr11273f12017-01-10 05:18:15 -08001291 // Whether or not the receive stream sends reduced size RTCP is determined
1292 // by the send params.
1293 // TODO(deadbeef): Once we change "send_params" to "sender_params" and
1294 // "recv_params" to "receiver_params", we should get this out of
1295 // receiver_params_.
1296 config->rtp.rtcp_mode = send_params_.rtcp.reduced_size
1297 ? webrtc::RtcpMode::kReducedSize
1298 : webrtc::RtcpMode::kCompound;
1299
1300 config->rtp.remb = send_codec_ ? HasRemb(send_codec_->codec) : false;
1301 config->rtp.transport_cc =
1302 send_codec_ ? HasTransportCc(send_codec_->codec) : false;
1303
brandtr9d58d942017-02-03 04:43:41 -08001304 sp.GetFidSsrc(ssrc, &config->rtp.rtx_ssrc);
1305
1306 config->rtp.extensions = recv_rtp_extensions_;
1307
brandtr11273f12017-01-10 05:18:15 -08001308 // TODO(brandtr): Generalize when we add support for multistream protection.
brandtr11fb4722017-05-30 01:31:37 -07001309 flexfec_config->payload_type = recv_flexfec_payload_type_;
brandtr31bd2242017-05-19 05:47:46 -07001310 if (IsFlexfecAdvertisedFieldTrialEnabled() &&
1311 sp.GetFecFrSsrc(ssrc, &flexfec_config->remote_ssrc)) {
brandtr11273f12017-01-10 05:18:15 -08001312 flexfec_config->protected_media_ssrcs = {ssrc};
brandtr8313a6f2017-01-13 07:41:19 -08001313 flexfec_config->local_ssrc = config->rtp.local_ssrc;
1314 flexfec_config->rtcp_mode = config->rtp.rtcp_mode;
brandtr9d58d942017-02-03 04:43:41 -08001315 // TODO(brandtr): We should be spec-compliant and set |transport_cc| here
1316 // based on the rtcp-fb for the FlexFEC codec, not the media codec.
brandtr8313a6f2017-01-13 07:41:19 -08001317 flexfec_config->transport_cc = config->rtp.transport_cc;
1318 flexfec_config->rtp_header_extensions = config->rtp.extensions;
brandtr11273f12017-01-10 05:18:15 -08001319 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001320}
1321
eladalonf1841382017-06-12 01:16:46 -07001322bool WebRtcVideoChannel::RemoveRecvStream(uint32_t ssrc) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01001323 RTC_LOG(LS_INFO) << "RemoveRecvStream: " << ssrc;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001324 if (ssrc == 0) {
Seth Hampson5897a6e2018-04-03 11:16:33 -07001325 // This indicates that we need to remove the unsignaled stream parameters
1326 // that are cached.
1327 unsignaled_stream_params_ = StreamParams();
1328 return true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001329 }
1330
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001331 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001332 std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator stream =
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001333 receive_streams_.find(ssrc);
1334 if (stream == receive_streams_.end()) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01001335 RTC_LOG(LS_ERROR) << "Stream not found for ssrc: " << ssrc;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001336 return false;
1337 }
Peter Boströmd6f4c252015-03-26 16:23:04 +01001338 DeleteReceiveStream(stream->second);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001339 receive_streams_.erase(stream);
1340
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001341 return true;
1342}
1343
eladalonf1841382017-06-12 01:16:46 -07001344bool WebRtcVideoChannel::SetSink(
nisseacd935b2016-11-11 03:55:13 -08001345 uint32_t ssrc,
1346 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01001347 RTC_LOG(LS_INFO) << "SetSink: ssrc:" << ssrc << " "
1348 << (sink ? "(ptr)" : "nullptr");
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001349 if (ssrc == 0) {
brandtr0dc57ea2017-05-29 23:33:31 -07001350 // Do not hold |stream_crit_| here, since SetDefaultSink will call
eladalonf1841382017-06-12 01:16:46 -07001351 // WebRtcVideoChannel::GetDefaultReceiveStreamSsrc().
nisse08582ff2016-02-04 01:24:52 -08001352 default_unsignalled_ssrc_handler_.SetDefaultSink(this, sink);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001353 return true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001354 }
1355
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001356 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001357 std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it =
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001358 receive_streams_.find(ssrc);
1359 if (it == receive_streams_.end()) {
1360 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001361 }
1362
nisse08582ff2016-02-04 01:24:52 -08001363 it->second->SetSink(sink);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001364 return true;
1365}
1366
eladalonf1841382017-06-12 01:16:46 -07001367bool WebRtcVideoChannel::GetStats(VideoMediaInfo* info) {
1368 TRACE_EVENT0("webrtc", "WebRtcVideoChannel::GetStats");
asapersson2e5cfcd2016-08-11 08:41:18 -07001369
1370 // Log stats periodically.
1371 bool log_stats = false;
1372 int64_t now_ms = rtc::TimeMillis();
1373 if (last_stats_log_ms_ == -1 ||
1374 now_ms - last_stats_log_ms_ > kStatsLogIntervalMs) {
1375 last_stats_log_ms_ = now_ms;
1376 log_stats = true;
1377 }
1378
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001379 info->Clear();
asapersson2e5cfcd2016-08-11 08:41:18 -07001380 FillSenderStats(info, log_stats);
1381 FillReceiverStats(info, log_stats);
hbosa65704b2016-11-14 02:28:16 -08001382 FillSendAndReceiveCodecStats(info);
stefanf79ade12017-06-02 06:44:03 -07001383 // TODO(holmer): We should either have rtt available as a metric on
1384 // VideoSend/ReceiveStreams, or we should remove rtt from VideoSenderInfo.
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00001385 webrtc::Call::Stats stats = call_->GetStats();
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00001386 if (stats.rtt_ms != -1) {
1387 for (size_t i = 0; i < info->senders.size(); ++i) {
1388 info->senders[i].rtt_ms = stats.rtt_ms;
1389 }
1390 }
asapersson2e5cfcd2016-08-11 08:41:18 -07001391
1392 if (log_stats)
Mirko Bonadei675513b2017-11-09 11:09:25 +01001393 RTC_LOG(LS_INFO) << stats.ToString(now_ms);
asapersson2e5cfcd2016-08-11 08:41:18 -07001394
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001395 return true;
1396}
1397
eladalonf1841382017-06-12 01:16:46 -07001398void WebRtcVideoChannel::FillSenderStats(VideoMediaInfo* video_media_info,
Yves Gerey665174f2018-06-19 15:03:05 +02001399 bool log_stats) {
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001400 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001401 for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator it =
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001402 send_streams_.begin();
Peter Boström0c4e06b2015-10-07 12:23:21 +02001403 it != send_streams_.end(); ++it) {
asapersson2e5cfcd2016-08-11 08:41:18 -07001404 video_media_info->senders.push_back(
1405 it->second->GetVideoSenderInfo(log_stats));
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001406 }
1407}
1408
eladalonf1841382017-06-12 01:16:46 -07001409void WebRtcVideoChannel::FillReceiverStats(VideoMediaInfo* video_media_info,
Yves Gerey665174f2018-06-19 15:03:05 +02001410 bool log_stats) {
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001411 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001412 for (std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it =
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001413 receive_streams_.begin();
Peter Boström0c4e06b2015-10-07 12:23:21 +02001414 it != receive_streams_.end(); ++it) {
asapersson2e5cfcd2016-08-11 08:41:18 -07001415 video_media_info->receivers.push_back(
1416 it->second->GetVideoReceiverInfo(log_stats));
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001417 }
1418}
1419
eladalonf1841382017-06-12 01:16:46 -07001420void WebRtcVideoChannel::FillBitrateInfo(BandwidthEstimationInfo* bwe_info) {
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001421 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001422 for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator stream =
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001423 send_streams_.begin();
Peter Boström0c4e06b2015-10-07 12:23:21 +02001424 stream != send_streams_.end(); ++stream) {
stefanf79ade12017-06-02 06:44:03 -07001425 stream->second->FillBitrateInfo(bwe_info);
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001426 }
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001427}
1428
eladalonf1841382017-06-12 01:16:46 -07001429void WebRtcVideoChannel::FillSendAndReceiveCodecStats(
hbosa65704b2016-11-14 02:28:16 -08001430 VideoMediaInfo* video_media_info) {
1431 for (const VideoCodec& codec : send_params_.codecs) {
1432 webrtc::RtpCodecParameters codec_params = codec.ToCodecParameters();
1433 video_media_info->send_codecs.insert(
1434 std::make_pair(codec_params.payload_type, std::move(codec_params)));
1435 }
1436 for (const VideoCodec& codec : recv_params_.codecs) {
1437 webrtc::RtpCodecParameters codec_params = codec.ToCodecParameters();
1438 video_media_info->receive_codecs.insert(
1439 std::make_pair(codec_params.payload_type, std::move(codec_params)));
1440 }
1441}
1442
Yves Gerey665174f2018-06-19 15:03:05 +02001443void WebRtcVideoChannel::OnPacketReceived(rtc::CopyOnWriteBuffer* packet,
1444 const rtc::PacketTime& packet_time) {
pbos@webrtc.org4e545cc2014-05-14 13:58:13 +00001445 const webrtc::PacketReceiver::DeliveryStatus delivery_result =
Danil Chapovalov292a73e2017-12-07 17:00:40 +01001446 call_->Receiver()->DeliverPacket(webrtc::MediaType::VIDEO, *packet,
Niels Möller70082872018-08-07 11:03:12 +02001447 packet_time.timestamp);
pbos@webrtc.org4e545cc2014-05-14 13:58:13 +00001448 switch (delivery_result) {
1449 case webrtc::PacketReceiver::DELIVERY_OK:
1450 return;
1451 case webrtc::PacketReceiver::DELIVERY_PACKET_ERROR:
1452 return;
1453 case webrtc::PacketReceiver::DELIVERY_UNKNOWN_SSRC:
1454 break;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001455 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001456
Peter Boström0c4e06b2015-10-07 12:23:21 +02001457 uint32_t ssrc = 0;
jbaucheec21bd2016-03-20 06:15:43 -07001458 if (!GetRtpSsrc(packet->cdata(), packet->size(), &ssrc)) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001459 return;
1460 }
1461
noahricd10a68e2015-07-10 11:27:55 -07001462 int payload_type = 0;
jbaucheec21bd2016-03-20 06:15:43 -07001463 if (!GetRtpPayloadType(packet->cdata(), packet->size(), &payload_type)) {
noahricd10a68e2015-07-10 11:27:55 -07001464 return;
1465 }
1466
1467 // See if this payload_type is registered as one that usually gets its own
brandtr468da7c2016-11-22 02:16:47 -08001468 // SSRC (RTX) or at least is safe to drop either way (FEC). If it is, and
noahricd10a68e2015-07-10 11:27:55 -07001469 // it wasn't handled above by DeliverPacket, that means we don't know what
1470 // stream it associates with, and we shouldn't ever create an implicit channel
1471 // for these.
1472 for (auto& codec : recv_codecs_) {
1473 if (payload_type == codec.rtx_payload_type ||
brandtrb5f2c3f2016-10-04 23:28:39 -07001474 payload_type == codec.ulpfec.red_rtx_payload_type ||
brandtr11fb4722017-05-30 01:31:37 -07001475 payload_type == codec.ulpfec.ulpfec_payload_type) {
noahricd10a68e2015-07-10 11:27:55 -07001476 return;
1477 }
1478 }
brandtr11fb4722017-05-30 01:31:37 -07001479 if (payload_type == recv_flexfec_payload_type_) {
1480 return;
1481 }
noahricd10a68e2015-07-10 11:27:55 -07001482
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001483 switch (unsignalled_ssrc_handler_->OnUnsignalledSsrc(this, ssrc)) {
1484 case UnsignalledSsrcHandler::kDropPacket:
1485 return;
1486 case UnsignalledSsrcHandler::kDeliverPacket:
1487 break;
1488 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001489
Danil Chapovalov292a73e2017-12-07 17:00:40 +01001490 if (call_->Receiver()->DeliverPacket(webrtc::MediaType::VIDEO, *packet,
Niels Möller70082872018-08-07 11:03:12 +02001491 packet_time.timestamp) !=
Danil Chapovalov292a73e2017-12-07 17:00:40 +01001492 webrtc::PacketReceiver::DELIVERY_OK) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01001493 RTC_LOG(LS_WARNING) << "Failed to deliver RTP packet on re-delivery.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001494 return;
1495 }
1496}
1497
Yves Gerey665174f2018-06-19 15:03:05 +02001498void WebRtcVideoChannel::OnRtcpReceived(rtc::CopyOnWriteBuffer* packet,
1499 const rtc::PacketTime& packet_time) {
Peter Boström2aff6152015-11-18 13:47:16 +01001500 // TODO(pbos): Check webrtc::PacketReceiver::DELIVERY_OK once we deliver
1501 // for both audio and video on the same path. Since BundleFilter doesn't
1502 // filter RTCP anymore incoming RTCP packets could've been going to audio (so
1503 // logging failures spam the log).
Danil Chapovalov292a73e2017-12-07 17:00:40 +01001504 call_->Receiver()->DeliverPacket(webrtc::MediaType::VIDEO, *packet,
Niels Möller70082872018-08-07 11:03:12 +02001505 packet_time.timestamp);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001506}
1507
eladalonf1841382017-06-12 01:16:46 -07001508void WebRtcVideoChannel::OnReadyToSend(bool ready) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01001509 RTC_LOG(LS_VERBOSE) << "OnReadyToSend: " << (ready ? "Ready." : "Not ready.");
skvlad7a43d252016-03-22 15:32:27 -07001510 call_->SignalChannelNetworkState(
1511 webrtc::MediaType::VIDEO,
1512 ready ? webrtc::kNetworkUp : webrtc::kNetworkDown);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001513}
1514
eladalonf1841382017-06-12 01:16:46 -07001515void WebRtcVideoChannel::OnNetworkRouteChanged(
Honghai Zhangcc411c02016-03-29 17:27:21 -07001516 const std::string& transport_name,
Honghai Zhang0e533ef2016-04-19 15:41:36 -07001517 const rtc::NetworkRoute& network_route) {
Sebastian Jansson8f83b422018-02-21 13:07:13 +01001518 call_->GetTransportControllerSend()->OnNetworkRouteChanged(transport_name,
1519 network_route);
michaelt79e05882016-11-08 02:50:09 -08001520 call_->OnTransportOverheadChanged(webrtc::MediaType::VIDEO,
Zhi Huang5f5918f2017-11-12 17:26:23 -08001521 network_route.packet_overhead);
michaelt79e05882016-11-08 02:50:09 -08001522}
1523
eladalonf1841382017-06-12 01:16:46 -07001524void WebRtcVideoChannel::SetInterface(NetworkInterface* iface) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001525 MediaChannel::SetInterface(iface);
1526 // Set the RTP recv/send buffer to a bigger size
Yves Gerey665174f2018-06-19 15:03:05 +02001527 MediaChannel::SetOption(NetworkInterface::ST_RTP, rtc::Socket::OPT_RCVBUF,
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001528 kVideoRtpBufferSize);
1529
buildbot@webrtc.orgae694ef2014-10-28 17:37:17 +00001530 // Speculative change to increase the outbound socket buffer size.
1531 // In b/15152257, we are seeing a significant number of packets discarded
1532 // due to lack of socket buffer space, although it's not yet clear what the
1533 // ideal value should be.
Yves Gerey665174f2018-06-19 15:03:05 +02001534 MediaChannel::SetOption(NetworkInterface::ST_RTP, rtc::Socket::OPT_SNDBUF,
buildbot@webrtc.orgae694ef2014-10-28 17:37:17 +00001535 kVideoRtpBufferSize);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001536}
1537
Danil Chapovalov00c71832018-06-15 15:58:38 +02001538absl::optional<uint32_t> WebRtcVideoChannel::GetDefaultReceiveStreamSsrc() {
brandtr0dc57ea2017-05-29 23:33:31 -07001539 rtc::CritScope stream_lock(&stream_crit_);
Danil Chapovalov00c71832018-06-15 15:58:38 +02001540 absl::optional<uint32_t> ssrc;
brandtr0dc57ea2017-05-29 23:33:31 -07001541 for (auto it = receive_streams_.begin(); it != receive_streams_.end(); ++it) {
1542 if (it->second->IsDefaultStream()) {
1543 ssrc.emplace(it->first);
1544 break;
1545 }
1546 }
1547 return ssrc;
1548}
1549
eladalonf1841382017-06-12 01:16:46 -07001550bool WebRtcVideoChannel::SendRtp(const uint8_t* data,
1551 size_t len,
1552 const webrtc::PacketOptions& options) {
jbaucheec21bd2016-03-20 06:15:43 -07001553 rtc::CopyOnWriteBuffer packet(data, len, kMaxRtpPacketLen);
stefanc1aeaf02015-10-15 07:26:07 -07001554 rtc::PacketOptions rtc_options;
1555 rtc_options.packet_id = options.packet_id;
1556 return MediaChannel::SendPacket(&packet, rtc_options);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001557}
1558
eladalonf1841382017-06-12 01:16:46 -07001559bool WebRtcVideoChannel::SendRtcp(const uint8_t* data, size_t len) {
jbaucheec21bd2016-03-20 06:15:43 -07001560 rtc::CopyOnWriteBuffer packet(data, len, kMaxRtpPacketLen);
stefanc1aeaf02015-10-15 07:26:07 -07001561 return MediaChannel::SendRtcp(&packet, rtc::PacketOptions());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001562}
1563
eladalonf1841382017-06-12 01:16:46 -07001564WebRtcVideoChannel::WebRtcVideoSendStream::VideoSendStreamParameters::
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001565 VideoSendStreamParameters(
perkj26091b12016-09-01 01:17:40 -07001566 webrtc::VideoSendStream::Config config,
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001567 const VideoOptions& options,
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001568 int max_bitrate_bps,
Danil Chapovalov00c71832018-06-15 15:58:38 +02001569 const absl::optional<VideoCodecSettings>& codec_settings)
perkj26091b12016-09-01 01:17:40 -07001570 : config(std::move(config)),
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001571 options(options),
1572 max_bitrate_bps(max_bitrate_bps),
perkjfa10b552016-10-02 23:45:26 -07001573 conference_mode(false),
kwiberg102c6a62015-10-30 02:47:38 -07001574 codec_settings(codec_settings) {}
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001575
eladalonf1841382017-06-12 01:16:46 -07001576WebRtcVideoChannel::WebRtcVideoSendStream::WebRtcVideoSendStream(
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001577 webrtc::Call* call,
solenberg4fbae2b2015-08-28 04:07:10 -07001578 const StreamParams& sp,
perkj26091b12016-09-01 01:17:40 -07001579 webrtc::VideoSendStream::Config config,
nisse05103312016-03-16 02:22:50 -07001580 const VideoOptions& options,
perkj2d5f0912016-02-29 00:04:41 -08001581 bool enable_cpu_overuse_detection,
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001582 int max_bitrate_bps,
Danil Chapovalov00c71832018-06-15 15:58:38 +02001583 const absl::optional<VideoCodecSettings>& codec_settings,
1584 const absl::optional<std::vector<webrtc::RtpExtension>>& rtp_extensions,
deadbeef13871492015-12-09 12:37:51 -08001585 // TODO(deadbeef): Don't duplicate information between send_params,
1586 // rtp_extensions, options, etc.
1587 const VideoSendParameters& send_params)
perkj2d5f0912016-02-29 00:04:41 -08001588 : worker_thread_(rtc::Thread::Current()),
1589 ssrcs_(sp.ssrcs),
Peter Boström259bd202015-05-28 13:39:50 +02001590 ssrc_groups_(sp.ssrc_groups),
Henrik Kjellander7c027b62015-04-22 13:21:30 +02001591 call_(call),
perkj803d97f2016-11-01 11:45:46 -07001592 enable_cpu_overuse_detection_(enable_cpu_overuse_detection),
nisse2ded9b12016-04-08 02:23:55 -07001593 source_(nullptr),
perkj2d5f0912016-02-29 00:04:41 -08001594 stream_(nullptr),
perkja49cbd32016-09-16 07:53:41 -07001595 encoder_sink_(nullptr),
perkj26091b12016-09-01 01:17:40 -07001596 parameters_(std::move(config), options, max_bitrate_bps, codec_settings),
Zach Stein3ca452b2018-01-18 10:01:24 -08001597 rtp_parameters_(CreateRtpParametersWithEncodings(sp)),
perkjd533aec2017-01-13 05:57:25 -08001598 sending_(false) {
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001599 parameters_.config.rtp.max_packet_size = kVideoMtu;
nisse4b4dc862016-02-17 05:25:36 -08001600 parameters_.conference_mode = send_params.conference_mode;
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001601
1602 sp.GetPrimarySsrcs(&parameters_.config.rtp.ssrcs);
brandtr468da7c2016-11-22 02:16:47 -08001603
deadbeeffb2aced2017-01-06 23:05:37 -08001604 // ValidateStreamParams should prevent this from happening.
1605 RTC_CHECK(!parameters_.config.rtp.ssrcs.empty());
Oskar Sundbom78807582017-11-16 11:09:55 +01001606 rtp_parameters_.encodings[0].ssrc = parameters_.config.rtp.ssrcs[0];
deadbeeffb2aced2017-01-06 23:05:37 -08001607
brandtr468da7c2016-11-22 02:16:47 -08001608 // RTX.
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001609 sp.GetFidSsrcs(parameters_.config.rtp.ssrcs,
1610 &parameters_.config.rtp.rtx.ssrcs);
brandtr468da7c2016-11-22 02:16:47 -08001611
brandtr340e3fd2017-02-28 15:43:10 -08001612 // FlexFEC SSRCs.
brandtr468da7c2016-11-22 02:16:47 -08001613 // TODO(brandtr): This code needs to be generalized when we add support for
1614 // multistream protection.
1615 if (IsFlexfecFieldTrialEnabled()) {
1616 uint32_t flexfec_ssrc;
1617 bool flexfec_enabled = false;
1618 for (uint32_t primary_ssrc : parameters_.config.rtp.ssrcs) {
1619 if (sp.GetFecFrSsrc(primary_ssrc, &flexfec_ssrc)) {
1620 if (flexfec_enabled) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01001621 RTC_LOG(LS_INFO)
1622 << "Multiple FlexFEC streams in local SDP, but "
1623 "our implementation only supports a single FlexFEC "
1624 "stream. Will not enable FlexFEC for proposed "
1625 "stream with SSRC: "
1626 << flexfec_ssrc << ".";
brandtr468da7c2016-11-22 02:16:47 -08001627 continue;
1628 }
1629
1630 flexfec_enabled = true;
brandtr3d200bd2017-01-16 06:59:19 -08001631 parameters_.config.rtp.flexfec.ssrc = flexfec_ssrc;
brandtr468da7c2016-11-22 02:16:47 -08001632 parameters_.config.rtp.flexfec.protected_media_ssrcs = {primary_ssrc};
1633 }
1634 }
1635 }
1636
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001637 parameters_.config.rtp.c_name = sp.cname;
Alex Narestb3944f02017-10-13 14:56:18 +02001638 parameters_.config.track_id = sp.id;
skvlad3abb7642016-06-16 12:08:03 -07001639 if (rtp_extensions) {
1640 parameters_.config.rtp.extensions = *rtp_extensions;
Florent Castelliabe301f2018-06-12 18:33:49 +02001641 rtp_parameters_.header_extensions = *rtp_extensions;
skvlad3abb7642016-06-16 12:08:03 -07001642 }
deadbeef13871492015-12-09 12:37:51 -08001643 parameters_.config.rtp.rtcp_mode = send_params.rtcp.reduced_size
1644 ? webrtc::RtcpMode::kReducedSize
1645 : webrtc::RtcpMode::kCompound;
Steve Antonbb50ce52018-03-26 10:24:32 -07001646 parameters_.config.rtp.mid = send_params.mid;
1647
Florent Castellidacec712018-05-24 16:24:21 +02001648 rtp_parameters_.rtcp.reduced_size = send_params.rtcp.reduced_size;
1649
kwiberg102c6a62015-10-30 02:47:38 -07001650 if (codec_settings) {
Niels Möller5bf8ccd2018-03-15 14:16:11 +01001651 SetCodec(*codec_settings);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001652 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001653}
1654
eladalonf1841382017-06-12 01:16:46 -07001655WebRtcVideoChannel::WebRtcVideoSendStream::~WebRtcVideoSendStream() {
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001656 if (stream_ != NULL) {
1657 call_->DestroyVideoSendStream(stream_);
1658 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001659}
1660
eladalonf1841382017-06-12 01:16:46 -07001661bool WebRtcVideoChannel::WebRtcVideoSendStream::SetVideoSend(
deadbeef5a4a75a2016-06-02 16:23:38 -07001662 const VideoOptions* options,
nisseacd935b2016-11-11 03:55:13 -08001663 rtc::VideoSourceInterface<webrtc::VideoFrame>* source) {
deadbeef5a4a75a2016-06-02 16:23:38 -07001664 TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::SetVideoSend");
perkjfa10b552016-10-02 23:45:26 -07001665 RTC_DCHECK_RUN_ON(&thread_checker_);
nisse2ded9b12016-04-08 02:23:55 -07001666
Niels Möllerff40b142018-04-09 08:49:14 +02001667 if (options) {
perkjfa10b552016-10-02 23:45:26 -07001668 VideoOptions old_options = parameters_.options;
1669 parameters_.options.SetAll(*options);
sprangf24a0642017-02-28 13:23:26 -08001670 if (parameters_.options.is_screencast.value_or(false) !=
1671 old_options.is_screencast.value_or(false) &&
1672 parameters_.codec_settings) {
1673 // If screen content settings change, we may need to recreate the codec
1674 // instance so that the correct type is used.
1675
Niels Möller5bf8ccd2018-03-15 14:16:11 +01001676 SetCodec(*parameters_.codec_settings);
sprangf24a0642017-02-28 13:23:26 -08001677 // Mark screenshare parameter as being updated, then test for any other
1678 // changes that may require codec reconfiguration.
1679 old_options.is_screencast = options->is_screencast;
1680 }
perkjfa10b552016-10-02 23:45:26 -07001681 if (parameters_.options != old_options) {
1682 ReconfigureEncoder();
perkj3b703ed2016-09-29 23:25:40 -07001683 }
perkj26105b42016-09-29 22:39:10 -07001684 }
1685
perkj803d97f2016-11-01 11:45:46 -07001686 if (source_ && stream_) {
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07001687 stream_->SetSource(nullptr, webrtc::DegradationPreference::DISABLED);
perkj803d97f2016-11-01 11:45:46 -07001688 }
1689 // Switch to the new source.
1690 source_ = source;
1691 if (source && stream_) {
sprangc5d62e22017-04-02 23:53:04 -07001692 stream_->SetSource(this, GetDegradationPreference());
nisse2ded9b12016-04-08 02:23:55 -07001693 }
deadbeef5a4a75a2016-06-02 16:23:38 -07001694 return true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001695}
1696
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07001697webrtc::DegradationPreference
eladalonf1841382017-06-12 01:16:46 -07001698WebRtcVideoChannel::WebRtcVideoSendStream::GetDegradationPreference() const {
sprangc5d62e22017-04-02 23:53:04 -07001699 // Do not adapt resolution for screen content as this will likely
1700 // result in blurry and unreadable text.
1701 // |this| acts like a VideoSource to make sure SinkWants are handled on the
1702 // correct thread.
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07001703 webrtc::DegradationPreference degradation_preference;
Florent Castelli87b3c512018-07-18 16:00:28 +02001704 if (rtp_parameters_.degradation_preference !=
1705 webrtc::DegradationPreference::BALANCED) {
1706 // If the degradationPreference is different from the default value, assume
1707 // it is what we want, regardless of trials or other internal settings.
1708 degradation_preference = rtp_parameters_.degradation_preference;
1709 } else if (!enable_cpu_overuse_detection_) {
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07001710 degradation_preference = webrtc::DegradationPreference::DISABLED;
Florent Castelli87b3c512018-07-18 16:00:28 +02001711 } else if (parameters_.options.is_screencast.value_or(false)) {
1712 degradation_preference = webrtc::DegradationPreference::MAINTAIN_RESOLUTION;
1713 } else if (webrtc::field_trial::IsEnabled(
1714 "WebRTC-Video-BalancedDegradation")) {
1715 degradation_preference = webrtc::DegradationPreference::BALANCED;
sprangc5d62e22017-04-02 23:53:04 -07001716 } else {
Florent Castelli87b3c512018-07-18 16:00:28 +02001717 // TODO(orphis): The default should be BALANCED as the standard mandates.
1718 // Right now, there is no way to set it to BALANCED as it would change
1719 // the behavior for any project expecting MAINTAIN_FRAMERATE by default.
1720 degradation_preference = webrtc::DegradationPreference::MAINTAIN_FRAMERATE;
sprangc5d62e22017-04-02 23:53:04 -07001721 }
1722 return degradation_preference;
1723}
1724
Peter Boström0c4e06b2015-10-07 12:23:21 +02001725const std::vector<uint32_t>&
eladalonf1841382017-06-12 01:16:46 -07001726WebRtcVideoChannel::WebRtcVideoSendStream::GetSsrcs() const {
Peter Boströmd6f4c252015-03-26 16:23:04 +01001727 return ssrcs_;
1728}
1729
eladalonf1841382017-06-12 01:16:46 -07001730void WebRtcVideoChannel::WebRtcVideoSendStream::SetCodec(
Niels Möller5bf8ccd2018-03-15 14:16:11 +01001731 const VideoCodecSettings& codec_settings) {
perkjfa10b552016-10-02 23:45:26 -07001732 RTC_DCHECK_RUN_ON(&thread_checker_);
skvlad3abb7642016-06-16 12:08:03 -07001733 parameters_.encoder_config = CreateVideoEncoderConfig(codec_settings.codec);
kwibergaf476c72016-11-28 15:21:39 -08001734 RTC_DCHECK_GT(parameters_.encoder_config.number_of_streams, 0);
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001735
Niels Möller259a4972018-04-05 15:36:51 +02001736 parameters_.config.rtp.payload_name = codec_settings.codec.name;
1737 parameters_.config.rtp.payload_type = codec_settings.codec.id;
brandtrb5f2c3f2016-10-04 23:28:39 -07001738 parameters_.config.rtp.ulpfec = codec_settings.ulpfec;
brandtr31bd2242017-05-19 05:47:46 -07001739 parameters_.config.rtp.flexfec.payload_type =
1740 codec_settings.flexfec_payload_type;
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001741
1742 // Set RTX payload type if RTX is enabled.
1743 if (!parameters_.config.rtp.rtx.ssrcs.empty()) {
pbos@webrtc.orgb9557a92015-03-20 19:52:56 +00001744 if (codec_settings.rtx_payload_type == -1) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01001745 RTC_LOG(LS_WARNING)
1746 << "RTX SSRCs configured but there's no configured RTX "
1747 "payload type. Ignoring.";
pbos@webrtc.orgb9557a92015-03-20 19:52:56 +00001748 parameters_.config.rtp.rtx.ssrcs.clear();
1749 } else {
1750 parameters_.config.rtp.rtx.payload_type = codec_settings.rtx_payload_type;
1751 }
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001752 }
1753
Peter Boström67c9df72015-05-11 14:34:58 +02001754 parameters_.config.rtp.nack.rtp_history_ms =
1755 HasNack(codec_settings.codec) ? kNackHistoryMs : 0;
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001756
Oskar Sundbom78807582017-11-16 11:09:55 +01001757 parameters_.codec_settings = codec_settings;
Niels Möller60653ba2016-03-02 11:41:36 +01001758
Niels Möller4db138e2018-04-19 09:04:13 +02001759 // TODO(nisse): Avoid recreation, it should be enough to call
1760 // ReconfigureEncoder.
Mirko Bonadei675513b2017-11-09 11:09:25 +01001761 RTC_LOG(LS_INFO) << "RecreateWebRtcStream (send) because of SetCodec.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001762 RecreateWebRtcStream();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001763}
1764
eladalonf1841382017-06-12 01:16:46 -07001765void WebRtcVideoChannel::WebRtcVideoSendStream::SetSendParameters(
Peter Boström3afc8c42016-01-27 16:45:21 +01001766 const ChangedSendParameters& params) {
perkjfa10b552016-10-02 23:45:26 -07001767 RTC_DCHECK_RUN_ON(&thread_checker_);
1768 // |recreate_stream| means construction-time parameters have changed and the
1769 // sending stream needs to be reset with the new config.
1770 bool recreate_stream = false;
1771 if (params.rtcp_mode) {
1772 parameters_.config.rtp.rtcp_mode = *params.rtcp_mode;
Florent Castellidacec712018-05-24 16:24:21 +02001773 rtp_parameters_.rtcp.reduced_size =
1774 parameters_.config.rtp.rtcp_mode == webrtc::RtcpMode::kReducedSize;
perkjfa10b552016-10-02 23:45:26 -07001775 recreate_stream = true;
1776 }
1777 if (params.rtp_header_extensions) {
1778 parameters_.config.rtp.extensions = *params.rtp_header_extensions;
Florent Castelliabe301f2018-06-12 18:33:49 +02001779 rtp_parameters_.header_extensions = *params.rtp_header_extensions;
perkjfa10b552016-10-02 23:45:26 -07001780 recreate_stream = true;
1781 }
Steve Antonbb50ce52018-03-26 10:24:32 -07001782 if (params.mid) {
1783 parameters_.config.rtp.mid = *params.mid;
1784 recreate_stream = true;
1785 }
perkjfa10b552016-10-02 23:45:26 -07001786 if (params.max_bandwidth_bps) {
1787 parameters_.max_bitrate_bps = *params.max_bandwidth_bps;
1788 ReconfigureEncoder();
1789 }
1790 if (params.conference_mode) {
1791 parameters_.conference_mode = *params.conference_mode;
1792 }
perkjf0dcfe22016-03-10 18:32:00 +01001793
perkjfa10b552016-10-02 23:45:26 -07001794 // Set codecs and options.
1795 if (params.codec) {
Niels Möller5bf8ccd2018-03-15 14:16:11 +01001796 SetCodec(*params.codec);
perkjfa10b552016-10-02 23:45:26 -07001797 recreate_stream = false; // SetCodec has already recreated the stream.
1798 } else if (params.conference_mode && parameters_.codec_settings) {
Niels Möller5bf8ccd2018-03-15 14:16:11 +01001799 SetCodec(*parameters_.codec_settings);
perkjfa10b552016-10-02 23:45:26 -07001800 recreate_stream = false; // SetCodec has already recreated the stream.
1801 }
1802 if (recreate_stream) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01001803 RTC_LOG(LS_INFO)
1804 << "RecreateWebRtcStream (send) because of SetSendParameters";
perkjfa10b552016-10-02 23:45:26 -07001805 RecreateWebRtcStream();
1806 }
deadbeef13871492015-12-09 12:37:51 -08001807}
1808
Zach Steinba37b4b2018-01-23 15:02:36 -08001809webrtc::RTCError WebRtcVideoChannel::WebRtcVideoSendStream::SetRtpParameters(
skvladdc1c62c2016-03-16 19:07:43 -07001810 const webrtc::RtpParameters& new_parameters) {
perkjfa10b552016-10-02 23:45:26 -07001811 RTC_DCHECK_RUN_ON(&thread_checker_);
Zach Steinba37b4b2018-01-23 15:02:36 -08001812 webrtc::RTCError error = ValidateRtpParameters(new_parameters);
1813 if (!error.ok()) {
1814 return error;
skvladdc1c62c2016-03-16 19:07:43 -07001815 }
1816
Åsa Perssonced5cfd2018-08-10 16:16:43 +02001817 bool new_param = false;
Åsa Persson55659812018-06-18 17:51:32 +02001818 for (size_t i = 0; i < rtp_parameters_.encodings.size(); ++i) {
1819 if ((new_parameters.encodings[i].min_bitrate_bps !=
1820 rtp_parameters_.encodings[i].min_bitrate_bps) ||
1821 (new_parameters.encodings[i].max_bitrate_bps !=
Åsa Perssonced5cfd2018-08-10 16:16:43 +02001822 rtp_parameters_.encodings[i].max_bitrate_bps) ||
1823 (new_parameters.encodings[i].max_framerate !=
1824 rtp_parameters_.encodings[i].max_framerate)) {
1825 new_param = true;
1826 break;
Åsa Persson55659812018-06-18 17:51:32 +02001827 }
1828 }
1829
Florent Castelli87b3c512018-07-18 16:00:28 +02001830 bool new_degradation_preference = false;
1831 if (new_parameters.degradation_preference !=
1832 rtp_parameters_.degradation_preference) {
1833 new_degradation_preference = true;
1834 }
1835
Seth Hampsoncc7125f2018-02-02 08:46:16 -08001836 // TODO(bugs.webrtc.org/8807): The bitrate priority really doesn't require an
1837 // entire encoder reconfiguration, it just needs to update the bitrate
1838 // allocator.
Åsa Persson55659812018-06-18 17:51:32 +02001839 bool reconfigure_encoder =
Åsa Perssonced5cfd2018-08-10 16:16:43 +02001840 new_param || (new_parameters.encodings[0].bitrate_priority !=
1841 rtp_parameters_.encodings[0].bitrate_priority);
Åsa Persson55659812018-06-18 17:51:32 +02001842
Seth Hampson8234ead2018-02-02 15:16:24 -08001843 // TODO(bugs.webrtc.org/8807): The active field as well should not require
1844 // a full encoder reconfiguration, but it needs to update both the bitrate
1845 // allocator and the video bitrate allocator.
1846 bool new_send_state = false;
1847 for (size_t i = 0; i < rtp_parameters_.encodings.size(); ++i) {
1848 if (new_parameters.encodings[i].active !=
1849 rtp_parameters_.encodings[i].active) {
1850 new_send_state = true;
1851 }
1852 }
skvladdc1c62c2016-03-16 19:07:43 -07001853 rtp_parameters_ = new_parameters;
eladalonf1841382017-06-12 01:16:46 -07001854 // Codecs are currently handled at the WebRtcVideoChannel level.
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07001855 rtp_parameters_.codecs.clear();
Seth Hampson8234ead2018-02-02 15:16:24 -08001856 if (reconfigure_encoder || new_send_state) {
perkjfa10b552016-10-02 23:45:26 -07001857 ReconfigureEncoder();
1858 }
Seth Hampson8234ead2018-02-02 15:16:24 -08001859 if (new_send_state) {
1860 UpdateSendState();
1861 }
Florent Castelli87b3c512018-07-18 16:00:28 +02001862 if (new_degradation_preference) {
1863 stream_->SetSource(this, GetDegradationPreference());
1864 }
Zach Steinba37b4b2018-01-23 15:02:36 -08001865 return webrtc::RTCError::OK();
skvladdc1c62c2016-03-16 19:07:43 -07001866}
1867
deadbeefdbe2b872016-03-22 15:42:00 -07001868webrtc::RtpParameters
eladalonf1841382017-06-12 01:16:46 -07001869WebRtcVideoChannel::WebRtcVideoSendStream::GetRtpParameters() const {
perkjfa10b552016-10-02 23:45:26 -07001870 RTC_DCHECK_RUN_ON(&thread_checker_);
deadbeefdbe2b872016-03-22 15:42:00 -07001871 return rtp_parameters_;
1872}
1873
Zach Steinba37b4b2018-01-23 15:02:36 -08001874webrtc::RTCError
1875WebRtcVideoChannel::WebRtcVideoSendStream::ValidateRtpParameters(
skvladdc1c62c2016-03-16 19:07:43 -07001876 const webrtc::RtpParameters& rtp_parameters) {
Zach Steinba37b4b2018-01-23 15:02:36 -08001877 using webrtc::RTCErrorType;
deadbeeffb2aced2017-01-06 23:05:37 -08001878 RTC_DCHECK_RUN_ON(&thread_checker_);
Zach Stein3ca452b2018-01-18 10:01:24 -08001879 if (rtp_parameters.encodings.size() != rtp_parameters_.encodings.size()) {
Zach Steinba37b4b2018-01-23 15:02:36 -08001880 LOG_AND_RETURN_ERROR(
1881 RTCErrorType::INVALID_MODIFICATION,
1882 "Attempted to set RtpParameters with different encoding count");
skvladdc1c62c2016-03-16 19:07:43 -07001883 }
Florent Castellidacec712018-05-24 16:24:21 +02001884 if (rtp_parameters.rtcp != rtp_parameters_.rtcp) {
1885 LOG_AND_RETURN_ERROR(
1886 RTCErrorType::INVALID_MODIFICATION,
1887 "Attempted to set RtpParameters with modified RTCP parameters");
1888 }
Florent Castelliabe301f2018-06-12 18:33:49 +02001889 if (rtp_parameters.header_extensions != rtp_parameters_.header_extensions) {
1890 LOG_AND_RETURN_ERROR(
1891 RTCErrorType::INVALID_MODIFICATION,
1892 "Attempted to set RtpParameters with modified header extensions");
1893 }
deadbeeffb2aced2017-01-06 23:05:37 -08001894 if (rtp_parameters.encodings[0].ssrc != rtp_parameters_.encodings[0].ssrc) {
Zach Steinba37b4b2018-01-23 15:02:36 -08001895 LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_MODIFICATION,
1896 "Attempted to set RtpParameters with modified SSRC");
deadbeeffb2aced2017-01-06 23:05:37 -08001897 }
Seth Hampson24722b32017-12-22 09:36:42 -08001898 if (rtp_parameters.encodings[0].bitrate_priority <= 0) {
Zach Steinba37b4b2018-01-23 15:02:36 -08001899 LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_RANGE,
1900 "Attempted to set RtpParameters bitrate_priority to "
1901 "an invalid number. bitrate_priority must be > 0.");
Seth Hampson24722b32017-12-22 09:36:42 -08001902 }
Åsa Persson55659812018-06-18 17:51:32 +02001903 for (size_t i = 0; i < rtp_parameters.encodings.size(); ++i) {
1904 if (rtp_parameters.encodings[i].min_bitrate_bps &&
1905 rtp_parameters.encodings[i].max_bitrate_bps) {
1906 if (*rtp_parameters.encodings[i].max_bitrate_bps <
1907 *rtp_parameters.encodings[i].min_bitrate_bps) {
1908 LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_RANGE,
1909 "Attempted to set RtpParameters min bitrate "
1910 "larger than max bitrate.");
1911 }
1912 }
1913 }
Zach Steinba37b4b2018-01-23 15:02:36 -08001914 return webrtc::RTCError::OK();
skvladdc1c62c2016-03-16 19:07:43 -07001915}
1916
eladalonf1841382017-06-12 01:16:46 -07001917void WebRtcVideoChannel::WebRtcVideoSendStream::UpdateSendState() {
perkjfa10b552016-10-02 23:45:26 -07001918 RTC_DCHECK_RUN_ON(&thread_checker_);
Seth Hampson8234ead2018-02-02 15:16:24 -08001919 if (sending_) {
deadbeefdbe2b872016-03-22 15:42:00 -07001920 RTC_DCHECK(stream_ != nullptr);
Seth Hampson8234ead2018-02-02 15:16:24 -08001921 std::vector<bool> active_layers(rtp_parameters_.encodings.size());
1922 for (size_t i = 0; i < active_layers.size(); ++i) {
1923 active_layers[i] = rtp_parameters_.encodings[i].active;
1924 }
1925 // This updates what simulcast layers are sending, and possibly starts
1926 // or stops the VideoSendStream.
1927 stream_->UpdateActiveSimulcastLayers(active_layers);
deadbeefdbe2b872016-03-22 15:42:00 -07001928 } else {
1929 if (stream_ != nullptr) {
1930 stream_->Stop();
1931 }
1932 }
1933}
1934
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001935webrtc::VideoEncoderConfig
eladalonf1841382017-06-12 01:16:46 -07001936WebRtcVideoChannel::WebRtcVideoSendStream::CreateVideoEncoderConfig(
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001937 const VideoCodec& codec) const {
perkjfa10b552016-10-02 23:45:26 -07001938 RTC_DCHECK_RUN_ON(&thread_checker_);
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001939 webrtc::VideoEncoderConfig encoder_config;
Niels Möller259a4972018-04-05 15:36:51 +02001940 encoder_config.codec_type = webrtc::PayloadStringToCodecType(codec.name);
Niels Möller4db138e2018-04-19 09:04:13 +02001941 encoder_config.video_format =
1942 webrtc::SdpVideoFormat(codec.name, codec.params);
Niels Möller259a4972018-04-05 15:36:51 +02001943
Niels Möller60653ba2016-03-02 11:41:36 +01001944 bool is_screencast = parameters_.options.is_screencast.value_or(false);
1945 if (is_screencast) {
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001946 encoder_config.min_transmit_bitrate_bps =
nisse51542be2016-02-12 02:27:06 -08001947 1000 * parameters_.options.screencast_min_bitrate_kbps.value_or(0);
Erik Språng143cec12015-04-28 10:01:41 +02001948 encoder_config.content_type =
1949 webrtc::VideoEncoderConfig::ContentType::kScreen;
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001950 } else {
1951 encoder_config.min_transmit_bitrate_bps = 0;
Erik Språng143cec12015-04-28 10:01:41 +02001952 encoder_config.content_type =
1953 webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo;
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001954 }
1955
noahricfdac5162015-08-27 01:59:29 -07001956 // By default, the stream count for the codec configuration should match the
1957 // number of negotiated ssrcs. But if the codec is blacklisted for simulcast
sprang429600d2017-01-26 06:12:26 -08001958 // or a screencast (and not in simulcast screenshare experiment), only
1959 // configure a single stream.
perkjfa10b552016-10-02 23:45:26 -07001960 encoder_config.number_of_streams = parameters_.config.rtp.ssrcs.size();
sprang429600d2017-01-26 06:12:26 -08001961 if (IsCodecBlacklistedForSimulcast(codec.name) ||
Ilya Nikolaevskiya3df0f22018-07-24 17:02:07 +02001962 (is_screencast && !parameters_.conference_mode)) {
perkjfa10b552016-10-02 23:45:26 -07001963 encoder_config.number_of_streams = 1;
noahricfdac5162015-08-27 01:59:29 -07001964 }
1965
Seth Hampsonfeec91e2018-07-13 10:41:10 -07001966 // parameters_.max_bitrate comes from the max bitrate set at the SDP
1967 // (m-section) level with the attribute "b=AS." Note that we override this
1968 // value below if the RtpParameters max bitrate set with
1969 // RtpSender::SetParameters has a lower value.
deadbeefe702b302017-02-04 12:09:01 -08001970 int stream_max_bitrate = parameters_.max_bitrate_bps;
Åsa Persson55659812018-06-18 17:51:32 +02001971 // When simulcast is enabled (when there are multiple encodings),
1972 // encodings[i].max_bitrate_bps will be enforced by
1973 // encoder_config.simulcast_layers[i].max_bitrate_bps. Otherwise, it's
1974 // enforced by stream_max_bitrate, taking the minimum of the two maximums
1975 // (one coming from SDP, the other coming from RtpParameters).
1976 if (rtp_parameters_.encodings[0].max_bitrate_bps &&
1977 rtp_parameters_.encodings.size() == 1) {
deadbeefe702b302017-02-04 12:09:01 -08001978 stream_max_bitrate =
zsteina5e0df62017-06-14 11:41:48 -07001979 webrtc::MinPositive(*(rtp_parameters_.encodings[0].max_bitrate_bps),
1980 parameters_.max_bitrate_bps);
deadbeefe702b302017-02-04 12:09:01 -08001981 }
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001982
Seth Hampsonfeec91e2018-07-13 10:41:10 -07001983 // The codec max bitrate comes from the "x-google-max-bitrate" parameter
1984 // attribute set in the SDP for a specific codec. As done in
1985 // WebRtcVideoChannel::SetSendParameters, this value does not override the
1986 // stream max_bitrate set above.
perkjfa10b552016-10-02 23:45:26 -07001987 int codec_max_bitrate_kbps;
Seth Hampsonfeec91e2018-07-13 10:41:10 -07001988 if (codec.GetParam(kCodecParamMaxBitrate, &codec_max_bitrate_kbps) &&
1989 stream_max_bitrate == -1) {
perkjfa10b552016-10-02 23:45:26 -07001990 stream_max_bitrate = codec_max_bitrate_kbps * 1000;
1991 }
1992 encoder_config.max_bitrate_bps = stream_max_bitrate;
perkj3b703ed2016-09-29 23:25:40 -07001993
Seth Hampson24722b32017-12-22 09:36:42 -08001994 // The encoder config's default bitrate priority is set to 1.0,
1995 // unless it is set through the sender's encoding parameters.
1996 // The bitrate priority, which is used in the bitrate allocation, is done
1997 // on a per sender basis, so we use the first encoding's value.
1998 encoder_config.bitrate_priority =
1999 rtp_parameters_.encodings[0].bitrate_priority;
2000
Seth Hampson8234ead2018-02-02 15:16:24 -08002001 // Application-controlled state is held in the encoder_config's
2002 // simulcast_layers. Currently this is used to control which simulcast layers
Åsa Perssonced5cfd2018-08-10 16:16:43 +02002003 // are active and for configuring the min/max bitrate and max framerate.
Åsa Perssonbdee46d2018-06-25 11:28:06 +02002004 // The encoder_config's simulcast_layers is also used for non-simulcast (when
2005 // there is a single layer).
Seth Hampson8234ead2018-02-02 15:16:24 -08002006 RTC_DCHECK_GE(rtp_parameters_.encodings.size(),
2007 encoder_config.number_of_streams);
2008 RTC_DCHECK_GT(encoder_config.number_of_streams, 0);
2009 encoder_config.simulcast_layers.resize(encoder_config.number_of_streams);
2010 for (size_t i = 0; i < encoder_config.simulcast_layers.size(); ++i) {
2011 encoder_config.simulcast_layers[i].active =
2012 rtp_parameters_.encodings[i].active;
Åsa Persson55659812018-06-18 17:51:32 +02002013 if (rtp_parameters_.encodings[i].min_bitrate_bps) {
2014 encoder_config.simulcast_layers[i].min_bitrate_bps =
2015 *rtp_parameters_.encodings[i].min_bitrate_bps;
2016 }
2017 if (rtp_parameters_.encodings[i].max_bitrate_bps) {
2018 encoder_config.simulcast_layers[i].max_bitrate_bps =
2019 *rtp_parameters_.encodings[i].max_bitrate_bps;
2020 }
Åsa Perssonced5cfd2018-08-10 16:16:43 +02002021 if (rtp_parameters_.encodings[i].max_framerate) {
2022 encoder_config.simulcast_layers[i].max_framerate =
2023 *rtp_parameters_.encodings[i].max_framerate;
2024 }
Seth Hampson8234ead2018-02-02 15:16:24 -08002025 }
2026
perkjfa10b552016-10-02 23:45:26 -07002027 int max_qp = kDefaultQpMax;
2028 codec.GetParam(kCodecParamMaxQuantization, &max_qp);
perkjfa10b552016-10-02 23:45:26 -07002029 encoder_config.video_stream_factory =
2030 new rtc::RefCountedObject<EncoderStreamFactory>(
Åsa Perssonced5cfd2018-08-10 16:16:43 +02002031 codec.name, max_qp, is_screencast, parameters_.conference_mode);
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002032 return encoder_config;
2033}
2034
eladalonf1841382017-06-12 01:16:46 -07002035void WebRtcVideoChannel::WebRtcVideoSendStream::ReconfigureEncoder() {
perkjfa10b552016-10-02 23:45:26 -07002036 RTC_DCHECK_RUN_ON(&thread_checker_);
2037 if (!stream_) {
sprangfe627f32017-03-29 08:24:59 -07002038 // The webrtc::VideoSendStream |stream_| has not yet been created but other
perkjfa10b552016-10-02 23:45:26 -07002039 // parameters has changed.
2040 return;
2041 }
2042
kwibergaf476c72016-11-28 15:21:39 -08002043 RTC_DCHECK_GT(parameters_.encoder_config.number_of_streams, 0);
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002044
kwiberg102c6a62015-10-30 02:47:38 -07002045 RTC_CHECK(parameters_.codec_settings);
2046 VideoCodecSettings codec_settings = *parameters_.codec_settings;
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002047
2048 webrtc::VideoEncoderConfig encoder_config =
skvlad3abb7642016-06-16 12:08:03 -07002049 CreateVideoEncoderConfig(codec_settings.codec);
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002050
Yves Gerey665174f2018-06-19 15:03:05 +02002051 encoder_config.encoder_specific_settings =
2052 ConfigureVideoEncoderSettings(codec_settings.codec);
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00002053
perkj26091b12016-09-01 01:17:40 -07002054 stream_->ReconfigureVideoEncoder(encoder_config.Copy());
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00002055
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00002056 encoder_config.encoder_specific_settings = NULL;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002057
perkj26091b12016-09-01 01:17:40 -07002058 parameters_.encoder_config = std::move(encoder_config);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002059}
2060
eladalonf1841382017-06-12 01:16:46 -07002061void WebRtcVideoChannel::WebRtcVideoSendStream::SetSend(bool send) {
perkjfa10b552016-10-02 23:45:26 -07002062 RTC_DCHECK_RUN_ON(&thread_checker_);
deadbeefdbe2b872016-03-22 15:42:00 -07002063 sending_ = send;
2064 UpdateSendState();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002065}
2066
eladalonf1841382017-06-12 01:16:46 -07002067void WebRtcVideoChannel::WebRtcVideoSendStream::RemoveSink(
perkjd533aec2017-01-13 05:57:25 -08002068 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
perkj803d97f2016-11-01 11:45:46 -07002069 RTC_DCHECK_RUN_ON(&thread_checker_);
perkjd533aec2017-01-13 05:57:25 -08002070 RTC_DCHECK(encoder_sink_ == sink);
2071 encoder_sink_ = nullptr;
2072 source_->RemoveSink(sink);
perkj803d97f2016-11-01 11:45:46 -07002073}
2074
eladalonf1841382017-06-12 01:16:46 -07002075void WebRtcVideoChannel::WebRtcVideoSendStream::AddOrUpdateSink(
perkjd533aec2017-01-13 05:57:25 -08002076 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink,
perkja49cbd32016-09-16 07:53:41 -07002077 const rtc::VideoSinkWants& wants) {
perkj803d97f2016-11-01 11:45:46 -07002078 if (worker_thread_ == rtc::Thread::Current()) {
2079 // AddOrUpdateSink is called on |worker_thread_| if this is the first
2080 // registration of |sink|.
2081 RTC_DCHECK_RUN_ON(&thread_checker_);
perkjd533aec2017-01-13 05:57:25 -08002082 encoder_sink_ = sink;
2083 source_->AddOrUpdateSink(encoder_sink_, wants);
perkjfa10b552016-10-02 23:45:26 -07002084 } else {
perkj803d97f2016-11-01 11:45:46 -07002085 // Subsequent calls to AddOrUpdateSink will happen on the encoder task
2086 // queue.
perkjd533aec2017-01-13 05:57:25 -08002087 invoker_.AsyncInvoke<void>(
2088 RTC_FROM_HERE, worker_thread_, [this, sink, wants] {
2089 RTC_DCHECK_RUN_ON(&thread_checker_);
2090 // |sink| may be invalidated after this task was posted since
2091 // RemoveSink is called on the worker thread.
2092 bool encoder_sink_valid = (sink == encoder_sink_);
2093 if (source_ && encoder_sink_valid) {
2094 source_->AddOrUpdateSink(encoder_sink_, wants);
2095 }
2096 });
perkj2d5f0912016-02-29 00:04:41 -08002097 }
perkj2d5f0912016-02-29 00:04:41 -08002098}
2099
eladalonf1841382017-06-12 01:16:46 -07002100VideoSenderInfo WebRtcVideoChannel::WebRtcVideoSendStream::GetVideoSenderInfo(
asapersson2e5cfcd2016-08-11 08:41:18 -07002101 bool log_stats) {
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002102 VideoSenderInfo info;
perkjfa10b552016-10-02 23:45:26 -07002103 RTC_DCHECK_RUN_ON(&thread_checker_);
2104 for (uint32_t ssrc : parameters_.config.rtp.ssrcs)
2105 info.add_ssrc(ssrc);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002106
hbosa65704b2016-11-14 02:28:16 -08002107 if (parameters_.codec_settings) {
perkjfa10b552016-10-02 23:45:26 -07002108 info.codec_name = parameters_.codec_settings->codec.name;
Oskar Sundbom78807582017-11-16 11:09:55 +01002109 info.codec_payload_type = parameters_.codec_settings->codec.id;
hbosa65704b2016-11-14 02:28:16 -08002110 }
pbos@webrtc.orgc3d2bd22014-08-12 20:55:10 +00002111
perkjfa10b552016-10-02 23:45:26 -07002112 if (stream_ == NULL)
2113 return info;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002114
perkjfa10b552016-10-02 23:45:26 -07002115 webrtc::VideoSendStream::Stats stats = stream_->GetStats();
asapersson2e5cfcd2016-08-11 08:41:18 -07002116
2117 if (log_stats)
Mirko Bonadei675513b2017-11-09 11:09:25 +01002118 RTC_LOG(LS_INFO) << stats.ToString(rtc::TimeMillis());
asapersson2e5cfcd2016-08-11 08:41:18 -07002119
perkj803d97f2016-11-01 11:45:46 -07002120 info.adapt_changes = stats.number_of_cpu_adapt_changes;
Per766ad3b2016-04-05 15:23:49 +02002121 info.adapt_reason =
perkj803d97f2016-11-01 11:45:46 -07002122 stats.cpu_limited_resolution ? ADAPTREASON_CPU : ADAPTREASON_NONE;
Åsa Perssonc3ed6302017-11-16 14:04:52 +01002123 info.has_entered_low_resolution = stats.has_entered_low_resolution;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002124
asapersson17821db2015-12-14 02:08:12 -08002125 // Get bandwidth limitation info from stream_->GetStats().
2126 // Input resolution (output from video_adapter) can be further scaled down or
2127 // higher video layer(s) can be dropped due to bitrate constraints.
2128 // Note, adapt_changes only include changes from the video_adapter.
2129 if (stats.bw_limited_resolution)
Per766ad3b2016-04-05 15:23:49 +02002130 info.adapt_reason |= ADAPTREASON_BANDWIDTH;
asapersson17821db2015-12-14 02:08:12 -08002131
Peter Boströmb7d9a972015-12-18 16:01:11 +01002132 info.encoder_implementation_name = stats.encoder_implementation_name;
Peter Boström259bd202015-05-28 13:39:50 +02002133 info.ssrc_groups = ssrc_groups_;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002134 info.framerate_input = stats.input_frame_rate;
2135 info.framerate_sent = stats.encode_frame_rate;
pbos@webrtc.org3e6e2712015-02-26 12:19:31 +00002136 info.avg_encode_ms = stats.avg_encode_time_ms;
2137 info.encode_usage_percent = stats.encode_usage_percent;
sakal43536c32016-10-24 01:46:43 -07002138 info.frames_encoded = stats.frames_encoded;
sakal87da4042016-10-31 06:53:47 -07002139 info.qp_sum = stats.qp_sum;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002140
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002141 info.nominal_bitrate = stats.media_bitrate_bps;
2142
ilnik50864a82017-09-06 12:32:35 -07002143 info.content_type = stats.content_type;
Ilya Nikolaevskiy70473fc2018-02-28 16:35:03 +01002144 info.huge_frames_sent = stats.huge_frames_sent;
ilnik50864a82017-09-06 12:32:35 -07002145
pbos@webrtc.org273a4142014-12-01 15:23:21 +00002146 info.send_frame_width = 0;
2147 info.send_frame_height = 0;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002148 for (std::map<uint32_t, webrtc::VideoSendStream::StreamStats>::iterator it =
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002149 stats.substreams.begin();
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002150 it != stats.substreams.end(); ++it) {
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002151 // TODO(pbos): Wire up additional stats, such as padding bytes.
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002152 webrtc::VideoSendStream::StreamStats stream_stats = it->second;
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59 +00002153 info.bytes_sent += stream_stats.rtp_stats.transmitted.payload_bytes +
2154 stream_stats.rtp_stats.transmitted.header_bytes +
2155 stream_stats.rtp_stats.transmitted.padding_bytes;
2156 info.packets_sent += stream_stats.rtp_stats.transmitted.packets;
srte186d9c32017-08-04 05:03:53 -07002157 info.packets_lost += stream_stats.rtcp_stats.packets_lost;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002158 if (stream_stats.width > info.send_frame_width)
2159 info.send_frame_width = stream_stats.width;
2160 if (stream_stats.height > info.send_frame_height)
2161 info.send_frame_height = stream_stats.height;
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002162 info.firs_rcvd += stream_stats.rtcp_packet_type_counts.fir_packets;
2163 info.nacks_rcvd += stream_stats.rtcp_packet_type_counts.nack_packets;
2164 info.plis_rcvd += stream_stats.rtcp_packet_type_counts.pli_packets;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002165 }
2166
2167 if (!stats.substreams.empty()) {
2168 // TODO(pbos): Report fraction lost per SSRC.
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002169 webrtc::VideoSendStream::StreamStats first_stream_stats =
2170 stats.substreams.begin()->second;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002171 info.fraction_lost =
2172 static_cast<float>(first_stream_stats.rtcp_stats.fraction_lost) /
2173 (1 << 8);
2174 }
2175
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002176 return info;
2177}
2178
eladalonf1841382017-06-12 01:16:46 -07002179void WebRtcVideoChannel::WebRtcVideoSendStream::FillBitrateInfo(
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00002180 BandwidthEstimationInfo* bwe_info) {
perkjfa10b552016-10-02 23:45:26 -07002181 RTC_DCHECK_RUN_ON(&thread_checker_);
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00002182 if (stream_ == NULL) {
2183 return;
2184 }
2185 webrtc::VideoSendStream::Stats stats = stream_->GetStats();
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002186 for (std::map<uint32_t, webrtc::VideoSendStream::StreamStats>::iterator it =
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00002187 stats.substreams.begin();
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002188 it != stats.substreams.end(); ++it) {
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00002189 bwe_info->transmit_bitrate += it->second.total_bitrate_bps;
2190 bwe_info->retransmit_bitrate += it->second.retransmit_bitrate_bps;
2191 }
pbos@webrtc.org891d4832015-02-26 13:15:22 +00002192 bwe_info->target_enc_bitrate += stats.target_media_bitrate_bps;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002193 bwe_info->actual_enc_bitrate += stats.media_bitrate_bps;
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00002194}
2195
eladalonf1841382017-06-12 01:16:46 -07002196void WebRtcVideoChannel::WebRtcVideoSendStream::RecreateWebRtcStream() {
perkjfa10b552016-10-02 23:45:26 -07002197 RTC_DCHECK_RUN_ON(&thread_checker_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002198 if (stream_ != NULL) {
2199 call_->DestroyVideoSendStream(stream_);
2200 }
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00002201
kwiberg102c6a62015-10-30 02:47:38 -07002202 RTC_CHECK(parameters_.codec_settings);
Niels Möller60653ba2016-03-02 11:41:36 +01002203 RTC_DCHECK_EQ((parameters_.encoder_config.content_type ==
2204 webrtc::VideoEncoderConfig::ContentType::kScreen),
2205 parameters_.options.is_screencast.value_or(false))
2206 << "encoder content type inconsistent with screencast option";
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00002207 parameters_.encoder_config.encoder_specific_settings =
Niels Möller60653ba2016-03-02 11:41:36 +01002208 ConfigureVideoEncoderSettings(parameters_.codec_settings->codec);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002209
perkj26091b12016-09-01 01:17:40 -07002210 webrtc::VideoSendStream::Config config = parameters_.config.Copy();
pbos@webrtc.orgb9557a92015-03-20 19:52:56 +00002211 if (!config.rtp.rtx.ssrcs.empty() && config.rtp.rtx.payload_type == -1) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01002212 RTC_LOG(LS_WARNING) << "RTX SSRCs configured but there's no configured RTX "
2213 "payload type the set codec. Ignoring RTX.";
pbos@webrtc.orgb9557a92015-03-20 19:52:56 +00002214 config.rtp.rtx.ssrcs.clear();
2215 }
perkj26091b12016-09-01 01:17:40 -07002216 stream_ = call_->CreateVideoSendStream(std::move(config),
2217 parameters_.encoder_config.Copy());
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002218
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00002219 parameters_.encoder_config.encoder_specific_settings = NULL;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002220
perkj803d97f2016-11-01 11:45:46 -07002221 if (source_) {
sprangc5d62e22017-04-02 23:53:04 -07002222 stream_->SetSource(this, GetDegradationPreference());
perkj803d97f2016-11-01 11:45:46 -07002223 }
2224
Taylor Brandstetter14b9d792016-09-07 17:16:54 -07002225 // Call stream_->Start() if necessary conditions are met.
2226 UpdateSendState();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002227}
2228
eladalonf1841382017-06-12 01:16:46 -07002229WebRtcVideoChannel::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002230 webrtc::Call* call,
Peter Boström259bd202015-05-28 13:39:50 +02002231 const StreamParams& sp,
Tommi733b5472016-06-10 17:58:01 +02002232 webrtc::VideoReceiveStream::Config config,
Magnus Jedvert07e0d012017-10-31 11:24:54 +01002233 DecoderFactoryAdapter* decoder_factory,
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00002234 bool default_stream,
brandtr468da7c2016-11-22 02:16:47 -08002235 const std::vector<VideoCodecSettings>& recv_codecs,
brandtr8313a6f2017-01-13 07:41:19 -08002236 const webrtc::FlexfecReceiveStream::Config& flexfec_config)
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002237 : call_(call),
sakal1fd95952016-06-22 00:46:15 -07002238 stream_params_(sp),
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002239 stream_(NULL),
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00002240 default_stream_(default_stream),
Tommi733b5472016-06-10 17:58:01 +02002241 config_(std::move(config)),
brandtr468da7c2016-11-22 02:16:47 -08002242 flexfec_config_(flexfec_config),
2243 flexfec_stream_(nullptr),
magjed2475ae22017-09-12 04:42:15 -07002244 decoder_factory_(decoder_factory),
nissee73afba2016-01-28 04:47:08 -08002245 sink_(NULL),
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002246 first_frame_timestamp_(-1),
2247 estimated_remote_start_ntp_time_ms_(0) {
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002248 config_.renderer = this;
andersc063f0c02017-09-11 11:50:51 -07002249 DecoderMap old_decoders;
pbos378dc772016-01-28 15:58:41 -08002250 ConfigureCodecs(recv_codecs, &old_decoders);
brandtr11fb4722017-05-30 01:31:37 -07002251 ConfigureFlexfecCodec(flexfec_config.payload_type);
2252 MaybeRecreateWebRtcFlexfecStream();
2253 RecreateWebRtcVideoStream();
pbos378dc772016-01-28 15:58:41 -08002254 RTC_DCHECK(old_decoders.empty());
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002255}
2256
eladalonf1841382017-06-12 01:16:46 -07002257WebRtcVideoChannel::WebRtcVideoReceiveStream::~WebRtcVideoReceiveStream() {
brandtr9c3d4c42017-01-23 06:59:13 -08002258 if (flexfec_stream_) {
eladalonc0d481a2017-08-02 07:39:07 -07002259 MaybeDissociateFlexfecFromVideo();
brandtr9c3d4c42017-01-23 06:59:13 -08002260 call_->DestroyFlexfecReceiveStream(flexfec_stream_);
2261 }
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002262 call_->DestroyVideoReceiveStream(stream_);
andersc063f0c02017-09-11 11:50:51 -07002263 allocated_decoders_.clear();
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002264}
2265
Peter Boström0c4e06b2015-10-07 12:23:21 +02002266const std::vector<uint32_t>&
eladalonf1841382017-06-12 01:16:46 -07002267WebRtcVideoChannel::WebRtcVideoReceiveStream::GetSsrcs() const {
sakal1fd95952016-06-22 00:46:15 -07002268 return stream_params_.ssrcs;
2269}
2270
Danil Chapovalov00c71832018-06-15 15:58:38 +02002271absl::optional<uint32_t>
eladalonf1841382017-06-12 01:16:46 -07002272WebRtcVideoChannel::WebRtcVideoReceiveStream::GetFirstPrimarySsrc() const {
sakal1fd95952016-06-22 00:46:15 -07002273 std::vector<uint32_t> primary_ssrcs;
2274 stream_params_.GetPrimarySsrcs(&primary_ssrcs);
2275
2276 if (primary_ssrcs.empty()) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01002277 RTC_LOG(LS_WARNING)
2278 << "Empty primary ssrcs vector, returning empty optional";
Danil Chapovalov00c71832018-06-15 15:58:38 +02002279 return absl::nullopt;
sakal1fd95952016-06-22 00:46:15 -07002280 } else {
Oskar Sundbom78807582017-11-16 11:09:55 +01002281 return primary_ssrcs[0];
sakal1fd95952016-06-22 00:46:15 -07002282 }
Peter Boströmd6f4c252015-03-26 16:23:04 +01002283}
2284
Florent Castelliabe301f2018-06-12 18:33:49 +02002285webrtc::RtpParameters
2286WebRtcVideoChannel::WebRtcVideoReceiveStream::GetRtpParameters() const {
2287 webrtc::RtpParameters rtp_parameters;
2288 rtp_parameters.encodings.emplace_back();
2289 rtp_parameters.encodings[0].ssrc = GetFirstPrimarySsrc();
2290 rtp_parameters.header_extensions = config_.rtp.extensions;
2291
2292 return rtp_parameters;
2293}
2294
eladalonf1841382017-06-12 01:16:46 -07002295void WebRtcVideoChannel::WebRtcVideoReceiveStream::ConfigureCodecs(
pbos378dc772016-01-28 15:58:41 -08002296 const std::vector<VideoCodecSettings>& recv_codecs,
andersc063f0c02017-09-11 11:50:51 -07002297 DecoderMap* old_decoders) {
nisse3b3622f2017-09-26 02:49:21 -07002298 RTC_DCHECK(!recv_codecs.empty());
andersc063f0c02017-09-11 11:50:51 -07002299 *old_decoders = std::move(allocated_decoders_);
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002300 config_.decoders.clear();
kthelgason0c88a502017-09-04 06:29:23 -07002301 config_.rtp.rtx_associated_payload_types.clear();
2302 for (const auto& recv_codec : recv_codecs) {
andersc063f0c02017-09-11 11:50:51 -07002303 webrtc::SdpVideoFormat video_format(recv_codec.codec.name,
2304 recv_codec.codec.params);
2305 std::unique_ptr<webrtc::VideoDecoder> new_decoder;
2306
Anders Carlsson7dbb7012018-03-05 10:26:03 +01002307 if (allocated_decoders_.count(video_format) > 0) {
2308 RTC_LOG(LS_WARNING)
2309 << "VideoReceiveStream configured with duplicate codecs: "
2310 << video_format.name;
2311 continue;
2312 }
2313
andersc063f0c02017-09-11 11:50:51 -07002314 auto it = old_decoders->find(video_format);
2315 if (it != old_decoders->end()) {
2316 new_decoder = std::move(it->second);
2317 old_decoders->erase(it);
2318 }
2319
Magnus Jedvert07e0d012017-10-31 11:24:54 +01002320 if (!new_decoder && decoder_factory_) {
2321 decoder_factory_->SetReceiveStreamId(stream_params_.id);
2322 new_decoder = decoder_factory_->CreateVideoDecoder(webrtc::SdpVideoFormat(
2323 recv_codec.codec.name, recv_codec.codec.params));
andersc063f0c02017-09-11 11:50:51 -07002324 }
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002325
Magnus Jedvert7501b1c2017-11-09 13:43:42 +01002326 // If we still have no valid decoder, we have to create a "Null" decoder
2327 // that ignores all calls. The reason we can get into this state is that
2328 // the old decoder factory interface doesn't have a way to query supported
2329 // codecs.
2330 if (!new_decoder)
2331 new_decoder.reset(new NullVideoDecoder());
2332
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002333 webrtc::VideoReceiveStream::Decoder decoder;
andersc063f0c02017-09-11 11:50:51 -07002334 decoder.decoder = new_decoder.get();
kthelgason0c88a502017-09-04 06:29:23 -07002335 decoder.payload_type = recv_codec.codec.id;
2336 decoder.payload_name = recv_codec.codec.name;
2337 decoder.codec_params = recv_codec.codec.params;
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002338 config_.decoders.push_back(decoder);
nisse26e3abb2017-08-25 04:44:25 -07002339 config_.rtp.rtx_associated_payload_types[recv_codec.rtx_payload_type] =
2340 recv_codec.codec.id;
andersc063f0c02017-09-11 11:50:51 -07002341
2342 const bool did_insert =
2343 allocated_decoders_
2344 .insert(std::make_pair(video_format, std::move(new_decoder)))
2345 .second;
2346 RTC_CHECK(did_insert);
brandtr14742122017-01-27 04:53:07 -08002347 }
2348
nisse3b3622f2017-09-26 02:49:21 -07002349 const auto& codec = recv_codecs.front();
2350 config_.rtp.ulpfec_payload_type = codec.ulpfec.ulpfec_payload_type;
2351 config_.rtp.red_payload_type = codec.ulpfec.red_payload_type;
brandtrbb7066f2016-12-19 09:41:04 -08002352
nisse3b3622f2017-09-26 02:49:21 -07002353 config_.rtp.nack.rtp_history_ms = HasNack(codec.codec) ? kNackHistoryMs : 0;
Ilya Nikolaevskiy634a7772018-04-04 16:33:49 +02002354 config_.rtp.rtcp_xr.receiver_reference_time_report = HasRrtr(codec.codec);
nisse3b3622f2017-09-26 02:49:21 -07002355 if (codec.ulpfec.red_rtx_payload_type != -1) {
nisseca5706d2017-09-11 02:32:16 -07002356 config_.rtp
nisse3b3622f2017-09-26 02:49:21 -07002357 .rtx_associated_payload_types[codec.ulpfec.red_rtx_payload_type] =
2358 codec.ulpfec.red_payload_type;
nisseca5706d2017-09-11 02:32:16 -07002359 }
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002360}
2361
eladalonf1841382017-06-12 01:16:46 -07002362void WebRtcVideoChannel::WebRtcVideoReceiveStream::ConfigureFlexfecCodec(
brandtr11fb4722017-05-30 01:31:37 -07002363 int flexfec_payload_type) {
2364 flexfec_config_.payload_type = flexfec_payload_type;
2365}
2366
eladalonf1841382017-06-12 01:16:46 -07002367void WebRtcVideoChannel::WebRtcVideoReceiveStream::SetLocalSsrc(
Peter Boström3548dd22015-05-22 18:48:36 +02002368 uint32_t local_ssrc) {
henrikg91d6ede2015-09-17 00:24:34 -07002369 // TODO(pbos): Consider turning this sanity check into a RTC_DCHECK. You
2370 // should not be able to create a sender with the same SSRC as a receiver, but
2371 // right now this can't be done due to unittests depending on receiving what
2372 // they are sending from the same MediaChannel.
Jonas Olssona564afe2018-02-14 10:51:15 +01002373 if (local_ssrc == config_.rtp.local_ssrc) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01002374 RTC_LOG(LS_INFO) << "Ignoring call to SetLocalSsrc because parameters are "
2375 "unchanged; local_ssrc="
2376 << local_ssrc;
Peter Boström3548dd22015-05-22 18:48:36 +02002377 return;
deadbeef874ca3a2015-08-20 17:19:20 -07002378 }
Peter Boström3548dd22015-05-22 18:48:36 +02002379
2380 config_.rtp.local_ssrc = local_ssrc;
brandtrfa5a3682017-01-17 01:33:54 -08002381 flexfec_config_.local_ssrc = local_ssrc;
Mirko Bonadei675513b2017-11-09 11:09:25 +01002382 RTC_LOG(LS_INFO)
deadbeef874ca3a2015-08-20 17:19:20 -07002383 << "RecreateWebRtcStream (recv) because of SetLocalSsrc; local_ssrc="
2384 << local_ssrc;
brandtr11fb4722017-05-30 01:31:37 -07002385 MaybeRecreateWebRtcFlexfecStream();
2386 RecreateWebRtcVideoStream();
Peter Boström3548dd22015-05-22 18:48:36 +02002387}
2388
eladalonf1841382017-06-12 01:16:46 -07002389void WebRtcVideoChannel::WebRtcVideoReceiveStream::SetFeedbackParameters(
stefan43edf0f2015-11-20 18:05:48 -08002390 bool nack_enabled,
2391 bool remb_enabled,
Taylor Brandstetter5f0b83b2016-03-18 15:02:07 -07002392 bool transport_cc_enabled,
2393 webrtc::RtcpMode rtcp_mode) {
Peter Boström67c9df72015-05-11 14:34:58 +02002394 int nack_history_ms = nack_enabled ? kNackHistoryMs : 0;
2395 if (config_.rtp.nack.rtp_history_ms == nack_history_ms &&
stefan43edf0f2015-11-20 18:05:48 -08002396 config_.rtp.remb == remb_enabled &&
Taylor Brandstetter5f0b83b2016-03-18 15:02:07 -07002397 config_.rtp.transport_cc == transport_cc_enabled &&
2398 config_.rtp.rtcp_mode == rtcp_mode) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01002399 RTC_LOG(LS_INFO)
stefan43edf0f2015-11-20 18:05:48 -08002400 << "Ignoring call to SetFeedbackParameters because parameters are "
2401 "unchanged; nack="
2402 << nack_enabled << ", remb=" << remb_enabled
2403 << ", transport_cc=" << transport_cc_enabled;
Peter Boström126c03e2015-05-11 12:48:12 +02002404 return;
Peter Boström67c9df72015-05-11 14:34:58 +02002405 }
2406 config_.rtp.remb = remb_enabled;
2407 config_.rtp.nack.rtp_history_ms = nack_history_ms;
stefan43edf0f2015-11-20 18:05:48 -08002408 config_.rtp.transport_cc = transport_cc_enabled;
Taylor Brandstetter5f0b83b2016-03-18 15:02:07 -07002409 config_.rtp.rtcp_mode = rtcp_mode;
brandtr9d58d942017-02-03 04:43:41 -08002410 // TODO(brandtr): We should be spec-compliant and set |transport_cc| here
2411 // based on the rtcp-fb for the FlexFEC codec, not the media codec.
2412 flexfec_config_.transport_cc = config_.rtp.transport_cc;
2413 flexfec_config_.rtcp_mode = config_.rtp.rtcp_mode;
Mirko Bonadei675513b2017-11-09 11:09:25 +01002414 RTC_LOG(LS_INFO)
stefan43edf0f2015-11-20 18:05:48 -08002415 << "RecreateWebRtcStream (recv) because of SetFeedbackParameters; nack="
2416 << nack_enabled << ", remb=" << remb_enabled
2417 << ", transport_cc=" << transport_cc_enabled;
brandtr11fb4722017-05-30 01:31:37 -07002418 MaybeRecreateWebRtcFlexfecStream();
2419 RecreateWebRtcVideoStream();
Peter Boström126c03e2015-05-11 12:48:12 +02002420}
2421
eladalonf1841382017-06-12 01:16:46 -07002422void WebRtcVideoChannel::WebRtcVideoReceiveStream::SetRecvParameters(
pbos378dc772016-01-28 15:58:41 -08002423 const ChangedRecvParameters& params) {
brandtr11fb4722017-05-30 01:31:37 -07002424 bool video_needs_recreation = false;
2425 bool flexfec_needs_recreation = false;
andersc063f0c02017-09-11 11:50:51 -07002426 DecoderMap old_decoders;
pbos378dc772016-01-28 15:58:41 -08002427 if (params.codec_settings) {
2428 ConfigureCodecs(*params.codec_settings, &old_decoders);
brandtr11fb4722017-05-30 01:31:37 -07002429 video_needs_recreation = true;
pbos378dc772016-01-28 15:58:41 -08002430 }
2431 if (params.rtp_header_extensions) {
2432 config_.rtp.extensions = *params.rtp_header_extensions;
brandtr9d58d942017-02-03 04:43:41 -08002433 flexfec_config_.rtp_header_extensions = *params.rtp_header_extensions;
brandtr11fb4722017-05-30 01:31:37 -07002434 video_needs_recreation = true;
2435 flexfec_needs_recreation = true;
pbos378dc772016-01-28 15:58:41 -08002436 }
brandtr11fb4722017-05-30 01:31:37 -07002437 if (params.flexfec_payload_type) {
2438 ConfigureFlexfecCodec(*params.flexfec_payload_type);
2439 flexfec_needs_recreation = true;
2440 }
2441 if (flexfec_needs_recreation) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01002442 RTC_LOG(LS_INFO) << "MaybeRecreateWebRtcFlexfecStream (recv) because of "
2443 "SetRecvParameters";
brandtr11fb4722017-05-30 01:31:37 -07002444 MaybeRecreateWebRtcFlexfecStream();
2445 }
2446 if (video_needs_recreation) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01002447 RTC_LOG(LS_INFO)
brandtr11fb4722017-05-30 01:31:37 -07002448 << "RecreateWebRtcVideoStream (recv) because of SetRecvParameters";
2449 RecreateWebRtcVideoStream();
pbos378dc772016-01-28 15:58:41 -08002450 }
deadbeef13871492015-12-09 12:37:51 -08002451}
2452
Yves Gerey665174f2018-06-19 15:03:05 +02002453void WebRtcVideoChannel::WebRtcVideoReceiveStream::RecreateWebRtcVideoStream() {
brandtrfb45c6c2017-01-27 06:47:55 -08002454 if (stream_) {
eladalonc0d481a2017-08-02 07:39:07 -07002455 MaybeDissociateFlexfecFromVideo();
brandtrfb45c6c2017-01-27 06:47:55 -08002456 call_->DestroyVideoReceiveStream(stream_);
2457 stream_ = nullptr;
2458 }
brandtr11fb4722017-05-30 01:31:37 -07002459 webrtc::VideoReceiveStream::Config config = config_.Copy();
2460 config.rtp.protected_by_flexfec = (flexfec_stream_ != nullptr);
2461 stream_ = call_->CreateVideoReceiveStream(std::move(config));
eladalonc0d481a2017-08-02 07:39:07 -07002462 MaybeAssociateFlexfecWithVideo();
brandtr11fb4722017-05-30 01:31:37 -07002463 stream_->Start();
2464}
2465
eladalonf1841382017-06-12 01:16:46 -07002466void WebRtcVideoChannel::WebRtcVideoReceiveStream::
brandtr11fb4722017-05-30 01:31:37 -07002467 MaybeRecreateWebRtcFlexfecStream() {
brandtr468da7c2016-11-22 02:16:47 -08002468 if (flexfec_stream_) {
eladalonc0d481a2017-08-02 07:39:07 -07002469 MaybeDissociateFlexfecFromVideo();
brandtr468da7c2016-11-22 02:16:47 -08002470 call_->DestroyFlexfecReceiveStream(flexfec_stream_);
2471 flexfec_stream_ = nullptr;
2472 }
brandtr11fb4722017-05-30 01:31:37 -07002473 if (flexfec_config_.IsCompleteAndEnabled()) {
brandtr8313a6f2017-01-13 07:41:19 -08002474 flexfec_stream_ = call_->CreateFlexfecReceiveStream(flexfec_config_);
eladalonc0d481a2017-08-02 07:39:07 -07002475 MaybeAssociateFlexfecWithVideo();
2476 }
2477}
2478
2479void WebRtcVideoChannel::WebRtcVideoReceiveStream::
2480 MaybeAssociateFlexfecWithVideo() {
2481 if (stream_ && flexfec_stream_) {
2482 stream_->AddSecondarySink(flexfec_stream_);
2483 }
2484}
2485
2486void WebRtcVideoChannel::WebRtcVideoReceiveStream::
2487 MaybeDissociateFlexfecFromVideo() {
2488 if (stream_ && flexfec_stream_) {
2489 stream_->RemoveSecondarySink(flexfec_stream_);
brandtr468da7c2016-11-22 02:16:47 -08002490 }
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002491}
2492
eladalonf1841382017-06-12 01:16:46 -07002493void WebRtcVideoChannel::WebRtcVideoReceiveStream::OnFrame(
nisseeb83a1a2016-03-21 01:27:56 -07002494 const webrtc::VideoFrame& frame) {
nissee73afba2016-01-28 04:47:08 -08002495 rtc::CritScope crit(&sink_lock_);
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002496
2497 if (first_frame_timestamp_ < 0)
2498 first_frame_timestamp_ = frame.timestamp();
2499 int64_t rtp_time_elapsed_since_first_frame =
2500 (timestamp_wraparound_handler_.Unwrap(frame.timestamp()) -
2501 first_frame_timestamp_);
2502 int64_t elapsed_time_ms = rtp_time_elapsed_since_first_frame /
2503 (cricket::kVideoCodecClockrate / 1000);
2504 if (frame.ntp_time_ms() > 0)
2505 estimated_remote_start_ntp_time_ms_ = frame.ntp_time_ms() - elapsed_time_ms;
2506
nissee73afba2016-01-28 04:47:08 -08002507 if (sink_ == NULL) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01002508 RTC_LOG(LS_WARNING) << "VideoReceiveStream not connected to a VideoSink.";
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002509 return;
2510 }
2511
nisse09347852016-10-19 00:30:30 -07002512 sink_->OnFrame(frame);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002513}
2514
eladalonf1841382017-06-12 01:16:46 -07002515bool WebRtcVideoChannel::WebRtcVideoReceiveStream::IsDefaultStream() const {
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00002516 return default_stream_;
2517}
2518
eladalonf1841382017-06-12 01:16:46 -07002519void WebRtcVideoChannel::WebRtcVideoReceiveStream::SetSink(
nisseacd935b2016-11-11 03:55:13 -08002520 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
nissee73afba2016-01-28 04:47:08 -08002521 rtc::CritScope crit(&sink_lock_);
2522 sink_ = sink;
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002523}
2524
pbosf42376c2015-08-28 07:35:32 -07002525std::string
eladalonf1841382017-06-12 01:16:46 -07002526WebRtcVideoChannel::WebRtcVideoReceiveStream::GetCodecNameFromPayloadType(
pbosf42376c2015-08-28 07:35:32 -07002527 int payload_type) {
2528 for (const webrtc::VideoReceiveStream::Decoder& decoder : config_.decoders) {
2529 if (decoder.payload_type == payload_type) {
2530 return decoder.payload_name;
2531 }
2532 }
2533 return "";
2534}
2535
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002536VideoReceiverInfo
eladalonf1841382017-06-12 01:16:46 -07002537WebRtcVideoChannel::WebRtcVideoReceiveStream::GetVideoReceiverInfo(
asapersson2e5cfcd2016-08-11 08:41:18 -07002538 bool log_stats) {
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002539 VideoReceiverInfo info;
sakal1fd95952016-06-22 00:46:15 -07002540 info.ssrc_groups = stream_params_.ssrc_groups;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002541 info.add_ssrc(config_.rtp.remote_ssrc);
2542 webrtc::VideoReceiveStream::Stats stats = stream_->GetStats();
Peter Boströmb7d9a972015-12-18 16:01:11 +01002543 info.decoder_implementation_name = stats.decoder_implementation_name;
hbosa65704b2016-11-14 02:28:16 -08002544 if (stats.current_payload_type != -1) {
Oskar Sundbom78807582017-11-16 11:09:55 +01002545 info.codec_payload_type = stats.current_payload_type;
hbosa65704b2016-11-14 02:28:16 -08002546 }
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59 +00002547 info.bytes_rcvd = stats.rtp_stats.transmitted.payload_bytes +
2548 stats.rtp_stats.transmitted.header_bytes +
2549 stats.rtp_stats.transmitted.padding_bytes;
2550 info.packets_rcvd = stats.rtp_stats.transmitted.packets;
srte186d9c32017-08-04 05:03:53 -07002551 info.packets_lost = stats.rtcp_stats.packets_lost;
Peter Boström393347f2015-04-22 14:52:45 +02002552 info.fraction_lost =
2553 static_cast<float>(stats.rtcp_stats.fraction_lost) / (1 << 8);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002554
2555 info.framerate_rcvd = stats.network_frame_rate;
2556 info.framerate_decoded = stats.decode_frame_rate;
2557 info.framerate_output = stats.render_frame_rate;
asapersson26dd92b2016-08-30 00:45:45 -07002558 info.frame_width = stats.width;
2559 info.frame_height = stats.height;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002560
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002561 {
nissee73afba2016-01-28 04:47:08 -08002562 rtc::CritScope frame_cs(&sink_lock_);
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002563 info.capture_start_ntp_time_ms = estimated_remote_start_ntp_time_ms_;
2564 }
2565
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002566 info.decode_ms = stats.decode_ms;
2567 info.max_decode_ms = stats.max_decode_ms;
2568 info.current_delay_ms = stats.current_delay_ms;
2569 info.target_delay_ms = stats.target_delay_ms;
2570 info.jitter_buffer_ms = stats.jitter_buffer_ms;
2571 info.min_playout_delay_ms = stats.min_playout_delay_ms;
2572 info.render_delay_ms = stats.render_delay_ms;
Yves Gerey665174f2018-06-19 15:03:05 +02002573 info.frames_received =
2574 stats.frame_counts.key_frames + stats.frame_counts.delta_frames;
sakale5ba44e2016-10-26 07:09:24 -07002575 info.frames_decoded = stats.frames_decoded;
hbos50cfe1f2017-01-23 07:21:55 -08002576 info.frames_rendered = stats.frames_rendered;
sakalcc452e12017-02-09 04:53:45 -08002577 info.qp_sum = stats.qp_sum;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002578
ilnika79cc282017-08-23 05:24:10 -07002579 info.interframe_delay_max_ms = stats.interframe_delay_max_ms;
ilnikf04afde2017-07-07 01:26:24 -07002580
ilnik2e1b40b2017-09-04 07:57:17 -07002581 info.content_type = stats.content_type;
2582
pbosf42376c2015-08-28 07:35:32 -07002583 info.codec_name = GetCodecNameFromPayloadType(stats.current_payload_type);
2584
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002585 info.firs_sent = stats.rtcp_packet_type_counts.fir_packets;
2586 info.plis_sent = stats.rtcp_packet_type_counts.pli_packets;
2587 info.nacks_sent = stats.rtcp_packet_type_counts.nack_packets;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002588
ilnik75204c52017-09-04 03:35:40 -07002589 info.timing_frame_info = stats.timing_frame_info;
ilnik2edc6842017-07-06 03:06:50 -07002590
asapersson2e5cfcd2016-08-11 08:41:18 -07002591 if (log_stats)
Mirko Bonadei675513b2017-11-09 11:09:25 +01002592 RTC_LOG(LS_INFO) << stats.ToString(rtc::TimeMillis());
asapersson2e5cfcd2016-08-11 08:41:18 -07002593
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002594 return info;
2595}
2596
eladalonf1841382017-06-12 01:16:46 -07002597WebRtcVideoChannel::VideoCodecSettings::VideoCodecSettings()
brandtrbb7066f2016-12-19 09:41:04 -08002598 : flexfec_payload_type(-1), rtx_payload_type(-1) {}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002599
eladalonf1841382017-06-12 01:16:46 -07002600bool WebRtcVideoChannel::VideoCodecSettings::operator==(
2601 const WebRtcVideoChannel::VideoCodecSettings& other) const {
brandtr468da7c2016-11-22 02:16:47 -08002602 return codec == other.codec && ulpfec == other.ulpfec &&
brandtrbb7066f2016-12-19 09:41:04 -08002603 flexfec_payload_type == other.flexfec_payload_type &&
2604 rtx_payload_type == other.rtx_payload_type;
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002605}
2606
eladalonf1841382017-06-12 01:16:46 -07002607bool WebRtcVideoChannel::VideoCodecSettings::EqualsDisregardingFlexfec(
2608 const WebRtcVideoChannel::VideoCodecSettings& a,
2609 const WebRtcVideoChannel::VideoCodecSettings& b) {
brandtr11fb4722017-05-30 01:31:37 -07002610 return a.codec == b.codec && a.ulpfec == b.ulpfec &&
2611 a.rtx_payload_type == b.rtx_payload_type;
2612}
2613
eladalonf1841382017-06-12 01:16:46 -07002614bool WebRtcVideoChannel::VideoCodecSettings::operator!=(
2615 const WebRtcVideoChannel::VideoCodecSettings& other) const {
Peter Boströmee0b00e2015-04-22 18:41:14 +02002616 return !(*this == other);
2617}
2618
eladalonf1841382017-06-12 01:16:46 -07002619std::vector<WebRtcVideoChannel::VideoCodecSettings>
2620WebRtcVideoChannel::MapCodecs(const std::vector<VideoCodec>& codecs) {
henrikg91d6ede2015-09-17 00:24:34 -07002621 RTC_DCHECK(!codecs.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002622
2623 std::vector<VideoCodecSettings> video_codecs;
2624 std::map<int, bool> payload_used;
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002625 std::map<int, VideoCodec::CodecType> payload_codec_type;
pkasting@chromium.orgd3245462015-02-23 21:28:22 +00002626 // |rtx_mapping| maps video payload type to rtx payload type.
2627 std::map<int, int> rtx_mapping;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002628
brandtrb5f2c3f2016-10-04 23:28:39 -07002629 webrtc::UlpfecConfig ulpfec_config;
brandtr468da7c2016-11-22 02:16:47 -08002630 int flexfec_payload_type = -1;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002631
2632 for (size_t i = 0; i < codecs.size(); ++i) {
2633 const VideoCodec& in_codec = codecs[i];
2634 int payload_type = in_codec.id;
2635
2636 if (payload_used[payload_type]) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01002637 RTC_LOG(LS_ERROR) << "Payload type already registered: "
2638 << in_codec.ToString();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002639 return std::vector<VideoCodecSettings>();
2640 }
2641 payload_used[payload_type] = true;
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002642 payload_codec_type[payload_type] = in_codec.GetCodecType();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002643
2644 switch (in_codec.GetCodecType()) {
2645 case VideoCodec::CODEC_RED: {
2646 // RED payload type, should not have duplicates.
brandtr468da7c2016-11-22 02:16:47 -08002647 RTC_DCHECK_EQ(-1, ulpfec_config.red_payload_type);
brandtrb5f2c3f2016-10-04 23:28:39 -07002648 ulpfec_config.red_payload_type = in_codec.id;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002649 continue;
2650 }
2651
2652 case VideoCodec::CODEC_ULPFEC: {
2653 // ULPFEC payload type, should not have duplicates.
brandtr468da7c2016-11-22 02:16:47 -08002654 RTC_DCHECK_EQ(-1, ulpfec_config.ulpfec_payload_type);
brandtrb5f2c3f2016-10-04 23:28:39 -07002655 ulpfec_config.ulpfec_payload_type = in_codec.id;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002656 continue;
2657 }
2658
brandtr87d7d772016-11-07 03:03:41 -08002659 case VideoCodec::CODEC_FLEXFEC: {
brandtr468da7c2016-11-22 02:16:47 -08002660 // FlexFEC payload type, should not have duplicates.
2661 RTC_DCHECK_EQ(-1, flexfec_payload_type);
2662 flexfec_payload_type = in_codec.id;
brandtr87d7d772016-11-07 03:03:41 -08002663 continue;
2664 }
2665
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002666 case VideoCodec::CODEC_RTX: {
2667 int associated_payload_type;
2668 if (!in_codec.GetParam(kCodecParamAssociatedPayloadType,
pkasting@chromium.orge9facf82015-02-17 20:36:28 +00002669 &associated_payload_type) ||
2670 !IsValidRtpPayloadType(associated_payload_type)) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01002671 RTC_LOG(LS_ERROR)
pkasting@chromium.orge9facf82015-02-17 20:36:28 +00002672 << "RTX codec with invalid or no associated payload type: "
2673 << in_codec.ToString();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002674 return std::vector<VideoCodecSettings>();
2675 }
2676 rtx_mapping[associated_payload_type] = in_codec.id;
2677 continue;
2678 }
2679
2680 case VideoCodec::CODEC_VIDEO:
2681 break;
2682 }
2683
2684 video_codecs.push_back(VideoCodecSettings());
2685 video_codecs.back().codec = in_codec;
2686 }
2687
2688 // One of these codecs should have been a video codec. Only having FEC
2689 // parameters into this code is a logic error.
henrikg91d6ede2015-09-17 00:24:34 -07002690 RTC_DCHECK(!video_codecs.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002691
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002692 for (std::map<int, int>::const_iterator it = rtx_mapping.begin();
Yves Gerey665174f2018-06-19 15:03:05 +02002693 it != rtx_mapping.end(); ++it) {
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002694 if (!payload_used[it->first]) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01002695 RTC_LOG(LS_ERROR) << "RTX mapped to payload not in codec list.";
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002696 return std::vector<VideoCodecSettings>();
2697 }
Shao Changbine62202f2015-04-21 20:24:50 +08002698 if (payload_codec_type[it->first] != VideoCodec::CODEC_VIDEO &&
2699 payload_codec_type[it->first] != VideoCodec::CODEC_RED) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01002700 RTC_LOG(LS_ERROR)
2701 << "RTX not mapped to regular video codec or RED codec.";
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002702 return std::vector<VideoCodecSettings>();
2703 }
Shao Changbine62202f2015-04-21 20:24:50 +08002704
brandtrb5f2c3f2016-10-04 23:28:39 -07002705 if (it->first == ulpfec_config.red_payload_type) {
2706 ulpfec_config.red_rtx_payload_type = it->second;
Shao Changbine62202f2015-04-21 20:24:50 +08002707 }
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002708 }
2709
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002710 for (size_t i = 0; i < video_codecs.size(); ++i) {
brandtrb5f2c3f2016-10-04 23:28:39 -07002711 video_codecs[i].ulpfec = ulpfec_config;
brandtrbb7066f2016-12-19 09:41:04 -08002712 video_codecs[i].flexfec_payload_type = flexfec_payload_type;
Shao Changbine62202f2015-04-21 20:24:50 +08002713 if (rtx_mapping[video_codecs[i].codec.id] != 0 &&
2714 rtx_mapping[video_codecs[i].codec.id] !=
brandtrb5f2c3f2016-10-04 23:28:39 -07002715 ulpfec_config.red_payload_type) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002716 video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
2717 }
2718 }
2719
2720 return video_codecs;
2721}
2722
Åsa Perssonced5cfd2018-08-10 16:16:43 +02002723// TODO(bugs.webrtc.org/8785): Consider removing max_qp as member of
2724// EncoderStreamFactory and instead set this value individually for each stream
2725// in the VideoEncoderConfig.simulcast_layers.
Seth Hampson1370e302018-02-07 08:50:36 -08002726EncoderStreamFactory::EncoderStreamFactory(
2727 std::string codec_name,
2728 int max_qp,
Seth Hampson1370e302018-02-07 08:50:36 -08002729 bool is_screenshare,
2730 bool screenshare_config_explicitly_enabled)
2731
ilnik6b826ef2017-06-16 06:53:48 -07002732 : codec_name_(codec_name),
2733 max_qp_(max_qp),
Seth Hampson1370e302018-02-07 08:50:36 -08002734 is_screenshare_(is_screenshare),
2735 screenshare_config_explicitly_enabled_(
2736 screenshare_config_explicitly_enabled) {}
ilnik6b826ef2017-06-16 06:53:48 -07002737
2738std::vector<webrtc::VideoStream> EncoderStreamFactory::CreateEncoderStreams(
2739 int width,
2740 int height,
2741 const webrtc::VideoEncoderConfig& encoder_config) {
Ilya Nikolaevskiya3df0f22018-07-24 17:02:07 +02002742 if (is_screenshare_ && !screenshare_config_explicitly_enabled_) {
ilnik6b826ef2017-06-16 06:53:48 -07002743 RTC_DCHECK_EQ(1, encoder_config.number_of_streams);
2744 }
Åsa Perssonbdee46d2018-06-25 11:28:06 +02002745 RTC_DCHECK_GT(encoder_config.number_of_streams, 0);
Seth Hampson8234ead2018-02-02 15:16:24 -08002746 RTC_DCHECK_EQ(encoder_config.simulcast_layers.size(),
2747 encoder_config.number_of_streams);
2748 std::vector<webrtc::VideoStream> layers;
2749
ilnik6b826ef2017-06-16 06:53:48 -07002750 if (encoder_config.number_of_streams > 1 ||
Sergio Garcia Murillo43800f92018-06-21 16:16:38 +02002751 ((CodecNamesEq(codec_name_, kVp8CodecName) ||
2752 CodecNamesEq(codec_name_, kH264CodecName)) &&
2753 is_screenshare_ && screenshare_config_explicitly_enabled_)) {
2754 bool temporal_layers_supported = CodecNamesEq(codec_name_, kVp8CodecName);
Seth Hampson8234ead2018-02-02 15:16:24 -08002755 layers = GetSimulcastConfig(encoder_config.number_of_streams, width, height,
Åsa Persson55659812018-06-18 17:51:32 +02002756 0 /*not used*/, encoder_config.bitrate_priority,
Åsa Perssonced5cfd2018-08-10 16:16:43 +02002757 max_qp_, 0 /*not_used*/, is_screenshare_,
Sergio Garcia Murillo43800f92018-06-21 16:16:38 +02002758 temporal_layers_supported);
Åsa Perssonced5cfd2018-08-10 16:16:43 +02002759 // The maximum |max_framerate| is currently used for video.
2760 int max_framerate = GetMaxFramerate(encoder_config, layers.size());
Åsa Persson55659812018-06-18 17:51:32 +02002761 // Update the active simulcast layers and configured bitrates.
2762 bool is_highest_layer_max_bitrate_configured = false;
Seth Hampson8234ead2018-02-02 15:16:24 -08002763 for (size_t i = 0; i < layers.size(); ++i) {
2764 layers[i].active = encoder_config.simulcast_layers[i].active;
Åsa Perssonced5cfd2018-08-10 16:16:43 +02002765 if (!is_screenshare_) {
2766 // Update simulcast framerates with max configured max framerate.
2767 layers[i].max_framerate = max_framerate;
2768 }
Åsa Persson55659812018-06-18 17:51:32 +02002769 // Update simulcast bitrates with configured min and max bitrate.
2770 if (encoder_config.simulcast_layers[i].min_bitrate_bps > 0) {
2771 layers[i].min_bitrate_bps =
2772 encoder_config.simulcast_layers[i].min_bitrate_bps;
2773 }
2774 if (encoder_config.simulcast_layers[i].max_bitrate_bps > 0) {
2775 layers[i].max_bitrate_bps =
2776 encoder_config.simulcast_layers[i].max_bitrate_bps;
2777 }
2778 if (encoder_config.simulcast_layers[i].min_bitrate_bps > 0 &&
2779 encoder_config.simulcast_layers[i].max_bitrate_bps > 0) {
2780 // Min and max bitrate are configured.
2781 // Set target to 3/4 of the max bitrate (or to max if below min).
2782 layers[i].target_bitrate_bps = layers[i].max_bitrate_bps * 3 / 4;
2783 if (layers[i].target_bitrate_bps < layers[i].min_bitrate_bps)
2784 layers[i].target_bitrate_bps = layers[i].max_bitrate_bps;
2785 } else if (encoder_config.simulcast_layers[i].min_bitrate_bps > 0) {
2786 // Only min bitrate is configured, make sure target/max are above min.
2787 layers[i].target_bitrate_bps =
2788 std::max(layers[i].target_bitrate_bps, layers[i].min_bitrate_bps);
2789 layers[i].max_bitrate_bps =
2790 std::max(layers[i].max_bitrate_bps, layers[i].min_bitrate_bps);
2791 } else if (encoder_config.simulcast_layers[i].max_bitrate_bps > 0) {
2792 // Only max bitrate is configured, make sure min/target are below max.
2793 layers[i].min_bitrate_bps =
2794 std::min(layers[i].min_bitrate_bps, layers[i].max_bitrate_bps);
2795 layers[i].target_bitrate_bps =
2796 std::min(layers[i].target_bitrate_bps, layers[i].max_bitrate_bps);
2797 }
2798 if (i == layers.size() - 1) {
2799 is_highest_layer_max_bitrate_configured =
2800 encoder_config.simulcast_layers[i].max_bitrate_bps > 0;
2801 }
2802 }
2803 if (!is_screenshare_ && !is_highest_layer_max_bitrate_configured) {
2804 // No application-configured maximum for the largest layer.
2805 // If there is bitrate leftover, give it to the largest layer.
2806 BoostMaxSimulcastLayer(encoder_config.max_bitrate_bps, &layers);
Seth Hampson8234ead2018-02-02 15:16:24 -08002807 }
2808 return layers;
ilnik6b826ef2017-06-16 06:53:48 -07002809 }
2810
2811 // For unset max bitrates set default bitrate for non-simulcast.
2812 int max_bitrate_bps =
2813 (encoder_config.max_bitrate_bps > 0)
2814 ? encoder_config.max_bitrate_bps
2815 : GetMaxDefaultVideoBitrateKbps(width, height) * 1000;
2816
Åsa Perssonbdee46d2018-06-25 11:28:06 +02002817 int min_bitrate_bps = GetMinVideoBitrateBps();
2818 if (encoder_config.simulcast_layers[0].min_bitrate_bps > 0) {
2819 // Use set min bitrate.
2820 min_bitrate_bps = encoder_config.simulcast_layers[0].min_bitrate_bps;
2821 // If only min bitrate is configured, make sure max is above min.
2822 if (encoder_config.max_bitrate_bps <= 0)
2823 max_bitrate_bps = std::max(min_bitrate_bps, max_bitrate_bps);
2824 }
Åsa Perssonced5cfd2018-08-10 16:16:43 +02002825 int max_framerate = (encoder_config.simulcast_layers[0].max_framerate > 0)
2826 ? encoder_config.simulcast_layers[0].max_framerate
2827 : kDefaultVideoMaxFramerate;
Åsa Perssonbdee46d2018-06-25 11:28:06 +02002828
Seth Hampson8234ead2018-02-02 15:16:24 -08002829 webrtc::VideoStream layer;
2830 layer.width = width;
2831 layer.height = height;
Åsa Perssonced5cfd2018-08-10 16:16:43 +02002832 layer.max_framerate = max_framerate;
Åsa Perssonbdee46d2018-06-25 11:28:06 +02002833
2834 // In the case that the application sets a max bitrate that's lower than the
2835 // min bitrate, we adjust it down (see bugs.webrtc.org/9141).
2836 layer.min_bitrate_bps = std::min(min_bitrate_bps, max_bitrate_bps);
Seth Hampson8234ead2018-02-02 15:16:24 -08002837 layer.target_bitrate_bps = layer.max_bitrate_bps = max_bitrate_bps;
2838 layer.max_qp = max_qp_;
2839 layer.bitrate_priority = encoder_config.bitrate_priority;
ilnik6b826ef2017-06-16 06:53:48 -07002840
Sergey Silkina796a7e2018-03-01 15:11:29 +01002841 if (CodecNamesEq(codec_name_, kVp9CodecName)) {
2842 RTC_DCHECK(encoder_config.encoder_specific_settings);
2843 // Use VP9 SVC layering from codec settings which might be initialized
2844 // though field trial in ConfigureVideoEncoderSettings.
2845 webrtc::VideoCodecVP9 vp9_settings;
2846 encoder_config.encoder_specific_settings->FillVideoCodecVp9(&vp9_settings);
2847 layer.num_temporal_layers = vp9_settings.numberOfTemporalLayers;
ilnik6b826ef2017-06-16 06:53:48 -07002848 }
2849
Seth Hampson8234ead2018-02-02 15:16:24 -08002850 layers.push_back(layer);
2851 return layers;
ilnik6b826ef2017-06-16 06:53:48 -07002852}
2853
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002854} // namespace cricket