blob: 03e97f776bfe7f42a063fd8a5b53410403915f50 [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
kjellander@webrtc.org5ad12972016-02-12 06:39:40 +010011#include "webrtc/media/engine/webrtcvideoengine2.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
nisseaf916892017-01-10 07:44:26 -080019#include "webrtc/api/video/i420_buffer.h"
ilnikd60d06a2017-04-05 03:02:20 -070020#include "webrtc/api/video_codecs/video_decoder.h"
21#include "webrtc/api/video_codecs/video_encoder.h"
jbaucheec21bd2016-03-20 06:15:43 -070022#include "webrtc/base/copyonwritebuffer.h"
buildbot@webrtc.orga09a9992014-08-13 17:26:08 +000023#include "webrtc/base/logging.h"
24#include "webrtc/base/stringutils.h"
qiangchenc27d89f2015-07-16 10:27:16 -070025#include "webrtc/base/timeutils.h"
tommie4f96502015-10-20 23:00:48 -070026#include "webrtc/base/trace_event.h"
ossuf515ab82016-12-07 04:52:58 -080027#include "webrtc/call/call.h"
magjed725e4842016-11-16 00:48:13 -080028#include "webrtc/common_video/h264/profile_level_id.h"
kjellander@webrtc.org5ad12972016-02-12 06:39:40 +010029#include "webrtc/media/engine/constants.h"
magjed509e4fe2016-11-18 01:34:11 -080030#include "webrtc/media/engine/internalencoderfactory.h"
magjeddd407022016-12-01 00:27:27 -080031#include "webrtc/media/engine/internaldecoderfactory.h"
kjellander@webrtc.org5ad12972016-02-12 06:39:40 +010032#include "webrtc/media/engine/simulcast.h"
magjed614d5b72016-11-15 06:30:54 -080033#include "webrtc/media/engine/videoencodersoftwarefallbackwrapper.h"
magjedf6acc2a2016-11-22 01:43:03 -080034#include "webrtc/media/engine/videodecodersoftwarefallbackwrapper.h"
kjellander@webrtc.org5ad12972016-02-12 06:39:40 +010035#include "webrtc/media/engine/webrtcmediaengine.h"
36#include "webrtc/media/engine/webrtcvideoencoderfactory.h"
kjellander@webrtc.org5ad12972016-02-12 06:39:40 +010037#include "webrtc/media/engine/webrtcvoiceengine.h"
Peter Boström81ea54e2015-05-07 11:41:09 +020038#include "webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h"
Henrik Kjellander98f53512015-10-28 18:17:40 +010039#include "webrtc/system_wrappers/include/field_trial.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000040
sprangc5d62e22017-04-02 23:53:04 -070041using DegradationPreference = webrtc::VideoSendStream::DegradationPreference;
42
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000043namespace cricket {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +000044namespace {
brandtr340e3fd2017-02-28 15:43:10 -080045// If this field trial is enabled, we will enable sending FlexFEC and disable
brandtr31bd2242017-05-19 05:47:46 -070046// sending ULPFEC whenever the former has been negotiated in the SDPs.
brandtr468da7c2016-11-22 02:16:47 -080047bool IsFlexfecFieldTrialEnabled() {
brandtrdbb1be52017-04-26 00:02:34 -070048 return webrtc::field_trial::IsEnabled("WebRTC-FlexFEC-03");
brandtr468da7c2016-11-22 02:16:47 -080049}
50
brandtr31bd2242017-05-19 05:47:46 -070051// If this field trial is enabled, the "flexfec-03" codec may have been
52// advertised as being supported in the local SDP. That means that we must be
53// ready to receive FlexFEC packets. See internalencoderfactory.cc.
54bool IsFlexfecAdvertisedFieldTrialEnabled() {
55 return webrtc::field_trial::IsEnabled("WebRTC-FlexFEC-03-Advertised");
56}
57
ilnika244ec62017-04-24 05:12:35 -070058// If this field trial is enabled, we will report VideoContentType RTP extension
59// in capabilities (thus, it will end up in the default SDP and extension will
60// be sent for all key-frames).
61bool IsVideoContentTypeExtensionFieldTrialEnabled() {
62 return webrtc::field_trial::IsEnabled("WebRTC-VideoContentTypeExtension");
63}
64
Peter Boström81ea54e2015-05-07 11:41:09 +020065// Wrap cricket::WebRtcVideoEncoderFactory as a webrtc::VideoEncoderFactory.
66class EncoderFactoryAdapter : public webrtc::VideoEncoderFactory {
67 public:
68 // EncoderFactoryAdapter doesn't take ownership of |factory|, which is owned
69 // by e.g. PeerConnectionFactory.
70 explicit EncoderFactoryAdapter(cricket::WebRtcVideoEncoderFactory* factory)
71 : factory_(factory) {}
72 virtual ~EncoderFactoryAdapter() {}
73
74 // Implement webrtc::VideoEncoderFactory.
75 webrtc::VideoEncoder* Create() override {
magjed1e45cc62016-10-28 07:43:45 -070076 return factory_->CreateVideoEncoder(VideoCodec(kVp8CodecName));
Peter Boström81ea54e2015-05-07 11:41:09 +020077 }
78
79 void Destroy(webrtc::VideoEncoder* encoder) override {
80 return factory_->DestroyVideoEncoder(encoder);
81 }
82
83 private:
84 cricket::WebRtcVideoEncoderFactory* const factory_;
85};
86
87// An encoder factory that wraps Create requests for simulcastable codec types
88// with a webrtc::SimulcastEncoderAdapter. Non simulcastable codec type
89// requests are just passed through to the contained encoder factory.
90class WebRtcSimulcastEncoderFactory
91 : public cricket::WebRtcVideoEncoderFactory {
92 public:
93 // WebRtcSimulcastEncoderFactory doesn't take ownership of |factory|, which is
94 // owned by e.g. PeerConnectionFactory.
95 explicit WebRtcSimulcastEncoderFactory(
96 cricket::WebRtcVideoEncoderFactory* factory)
97 : factory_(factory) {}
98
99 static bool UseSimulcastEncoderFactory(
magjed1e45cc62016-10-28 07:43:45 -0700100 const std::vector<cricket::VideoCodec>& codecs) {
Peter Boström81ea54e2015-05-07 11:41:09 +0200101 // If any codec is VP8, use the simulcast factory. If asked to create a
102 // non-VP8 codec, we'll just return a contained factory encoder directly.
103 for (const auto& codec : codecs) {
magjed1e45cc62016-10-28 07:43:45 -0700104 if (CodecNamesEq(codec.name.c_str(), kVp8CodecName)) {
Peter Boström81ea54e2015-05-07 11:41:09 +0200105 return true;
106 }
107 }
108 return false;
109 }
110
111 webrtc::VideoEncoder* CreateVideoEncoder(
magjed1e45cc62016-10-28 07:43:45 -0700112 const cricket::VideoCodec& codec) override {
henrikg91d6ede2015-09-17 00:24:34 -0700113 RTC_DCHECK(factory_ != NULL);
Peter Boström81ea54e2015-05-07 11:41:09 +0200114 // If it's a codec type we can simulcast, create a wrapped encoder.
magjed1e45cc62016-10-28 07:43:45 -0700115 if (CodecNamesEq(codec.name.c_str(), kVp8CodecName)) {
Peter Boström81ea54e2015-05-07 11:41:09 +0200116 return new webrtc::SimulcastEncoderAdapter(
117 new EncoderFactoryAdapter(factory_));
118 }
magjed1e45cc62016-10-28 07:43:45 -0700119 webrtc::VideoEncoder* encoder = factory_->CreateVideoEncoder(codec);
Peter Boström81ea54e2015-05-07 11:41:09 +0200120 if (encoder) {
121 non_simulcast_encoders_.push_back(encoder);
122 }
123 return encoder;
124 }
125
magjed1e45cc62016-10-28 07:43:45 -0700126 const std::vector<cricket::VideoCodec>& supported_codecs() const override {
127 return factory_->supported_codecs();
Peter Boström81ea54e2015-05-07 11:41:09 +0200128 }
129
130 bool EncoderTypeHasInternalSource(
131 webrtc::VideoCodecType type) const override {
132 return factory_->EncoderTypeHasInternalSource(type);
133 }
134
135 void DestroyVideoEncoder(webrtc::VideoEncoder* encoder) override {
136 // Check first to see if the encoder wasn't wrapped in a
137 // SimulcastEncoderAdapter. In that case, ask the factory to destroy it.
138 if (std::remove(non_simulcast_encoders_.begin(),
139 non_simulcast_encoders_.end(),
140 encoder) != non_simulcast_encoders_.end()) {
141 factory_->DestroyVideoEncoder(encoder);
142 return;
143 }
144
145 // Otherwise, SimulcastEncoderAdapter can be deleted directly, and will call
146 // DestroyVideoEncoder on the factory for individual encoder instances.
147 delete encoder;
148 }
149
150 private:
151 cricket::WebRtcVideoEncoderFactory* factory_;
152 // A list of encoders that were created without being wrapped in a
153 // SimulcastEncoderAdapter.
154 std::vector<webrtc::VideoEncoder*> non_simulcast_encoders_;
155};
156
Peter Boström81ea54e2015-05-07 11:41:09 +0200157void AddDefaultFeedbackParams(VideoCodec* codec) {
158 codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamCcm, kRtcpFbCcmParamFir));
159 codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamNack, kParamValueEmpty));
160 codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamNack, kRtcpFbNackParamPli));
161 codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamRemb, kParamValueEmpty));
stefan43edf0f2015-11-20 18:05:48 -0800162 codec->AddFeedbackParam(
163 FeedbackParam(kRtcpFbParamTransportCc, kParamValueEmpty));
Peter Boström81ea54e2015-05-07 11:41:09 +0200164}
165
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000166static std::string CodecVectorToString(const std::vector<VideoCodec>& codecs) {
167 std::stringstream out;
168 out << '{';
169 for (size_t i = 0; i < codecs.size(); ++i) {
170 out << codecs[i].ToString();
171 if (i != codecs.size() - 1) {
172 out << ", ";
173 }
174 }
175 out << '}';
176 return out.str();
177}
178
179static bool ValidateCodecFormats(const std::vector<VideoCodec>& codecs) {
180 bool has_video = false;
181 for (size_t i = 0; i < codecs.size(); ++i) {
182 if (!codecs[i].ValidateCodecFormat()) {
183 return false;
184 }
185 if (codecs[i].GetCodecType() == VideoCodec::CODEC_VIDEO) {
186 has_video = true;
187 }
188 }
189 if (!has_video) {
190 LOG(LS_ERROR) << "Setting codecs without a video codec is invalid: "
191 << CodecVectorToString(codecs);
192 return false;
193 }
194 return true;
195}
196
Peter Boströmd4362cd2015-03-25 14:17:23 +0100197static bool ValidateStreamParams(const StreamParams& sp) {
198 if (sp.ssrcs.empty()) {
199 LOG(LS_ERROR) << "No SSRCs in stream parameters: " << sp.ToString();
200 return false;
201 }
202
Peter Boström0c4e06b2015-10-07 12:23:21 +0200203 std::vector<uint32_t> primary_ssrcs;
Peter Boströmd4362cd2015-03-25 14:17:23 +0100204 sp.GetPrimarySsrcs(&primary_ssrcs);
Peter Boström0c4e06b2015-10-07 12:23:21 +0200205 std::vector<uint32_t> rtx_ssrcs;
Peter Boströmd4362cd2015-03-25 14:17:23 +0100206 sp.GetFidSsrcs(primary_ssrcs, &rtx_ssrcs);
207 for (uint32_t rtx_ssrc : rtx_ssrcs) {
208 bool rtx_ssrc_present = false;
209 for (uint32_t sp_ssrc : sp.ssrcs) {
210 if (sp_ssrc == rtx_ssrc) {
211 rtx_ssrc_present = true;
212 break;
213 }
214 }
215 if (!rtx_ssrc_present) {
216 LOG(LS_ERROR) << "RTX SSRC '" << rtx_ssrc
217 << "' missing from StreamParams ssrcs: " << sp.ToString();
218 return false;
219 }
220 }
221 if (!rtx_ssrcs.empty() && primary_ssrcs.size() != rtx_ssrcs.size()) {
222 LOG(LS_ERROR)
223 << "RTX SSRCs exist, but don't cover all SSRCs (unsupported): "
224 << sp.ToString();
225 return false;
226 }
227
228 return true;
229}
230
noahricfdac5162015-08-27 01:59:29 -0700231// Returns true if the given codec is disallowed from doing simulcast.
232bool IsCodecBlacklistedForSimulcast(const std::string& codec_name) {
asapersson3ed34872015-11-10 05:16:26 -0800233 return CodecNamesEq(codec_name, kH264CodecName) ||
234 CodecNamesEq(codec_name, kVp9CodecName);
noahricfdac5162015-08-27 01:59:29 -0700235}
236
Åsa Persson1c7d48d2015-09-08 09:21:43 +0200237// The selected thresholds for QVGA and VGA corresponded to a QP around 10.
238// The change in QP declined above the selected bitrates.
239static int GetMaxDefaultVideoBitrateKbps(int width, int height) {
240 if (width * height <= 320 * 240) {
241 return 600;
242 } else if (width * height <= 640 * 480) {
243 return 1700;
244 } else if (width * height <= 960 * 540) {
245 return 2000;
246 } else {
247 return 2500;
248 }
249}
perkj2d5f0912016-02-29 00:04:41 -0800250
asaperssonc5dabdd2016-03-21 04:15:50 -0700251bool GetVp9LayersFromFieldTrialGroup(int* num_spatial_layers,
252 int* num_temporal_layers) {
253 std::string group = webrtc::field_trial::FindFullName("WebRTC-SupportVP9SVC");
254 if (group.empty())
255 return false;
256
257 if (sscanf(group.c_str(), "EnabledByFlag_%dSL%dTL", num_spatial_layers,
258 num_temporal_layers) != 2) {
259 return false;
260 }
asaperssonaf9e4ac2016-03-31 00:36:49 -0700261 const int kMaxSpatialLayers = 2;
asaperssonc5dabdd2016-03-21 04:15:50 -0700262 if (*num_spatial_layers > kMaxSpatialLayers || *num_spatial_layers < 1)
263 return false;
264
265 const int kMaxTemporalLayers = 3;
266 if (*num_temporal_layers > kMaxTemporalLayers || *num_temporal_layers < 1)
267 return false;
268
269 return true;
270}
271
272int GetDefaultVp9SpatialLayers() {
273 int num_sl;
274 int num_tl;
275 if (GetVp9LayersFromFieldTrialGroup(&num_sl, &num_tl)) {
276 return num_sl;
277 }
278 return 1;
279}
280
281int GetDefaultVp9TemporalLayers() {
282 int num_sl;
283 int num_tl;
284 if (GetVp9LayersFromFieldTrialGroup(&num_sl, &num_tl)) {
285 return num_tl;
286 }
287 return 1;
288}
perkjfa10b552016-10-02 23:45:26 -0700289
290class EncoderStreamFactory
291 : public webrtc::VideoEncoderConfig::VideoStreamFactoryInterface {
292 public:
293 EncoderStreamFactory(std::string codec_name,
294 int max_qp,
295 int max_framerate,
296 bool is_screencast,
297 bool conference_mode)
298 : codec_name_(codec_name),
299 max_qp_(max_qp),
300 max_framerate_(max_framerate),
301 is_screencast_(is_screencast),
302 conference_mode_(conference_mode) {}
303
304 private:
305 std::vector<webrtc::VideoStream> CreateEncoderStreams(
306 int width,
307 int height,
308 const webrtc::VideoEncoderConfig& encoder_config) override {
sprang429600d2017-01-26 06:12:26 -0800309 if (is_screencast_ &&
310 (!conference_mode_ || !cricket::UseSimulcastScreenshare())) {
311 RTC_DCHECK_EQ(1, encoder_config.number_of_streams);
312 }
313 if (encoder_config.number_of_streams > 1 ||
314 (CodecNamesEq(codec_name_, kVp8CodecName) && is_screencast_ &&
315 conference_mode_)) {
perkjfa10b552016-10-02 23:45:26 -0700316 return GetSimulcastConfig(encoder_config.number_of_streams, width, height,
317 encoder_config.max_bitrate_bps, max_qp_,
sprang429600d2017-01-26 06:12:26 -0800318 max_framerate_, is_screencast_);
perkjfa10b552016-10-02 23:45:26 -0700319 }
320
321 // For unset max bitrates set default bitrate for non-simulcast.
322 int max_bitrate_bps =
323 (encoder_config.max_bitrate_bps > 0)
324 ? encoder_config.max_bitrate_bps
325 : GetMaxDefaultVideoBitrateKbps(width, height) * 1000;
326
327 webrtc::VideoStream stream;
328 stream.width = width;
329 stream.height = height;
330 stream.max_framerate = max_framerate_;
331 stream.min_bitrate_bps = kMinVideoBitrateKbps * 1000;
332 stream.target_bitrate_bps = stream.max_bitrate_bps = max_bitrate_bps;
333 stream.max_qp = max_qp_;
334
perkjfa10b552016-10-02 23:45:26 -0700335 if (CodecNamesEq(codec_name_, kVp9CodecName) && !is_screencast_) {
336 stream.temporal_layer_thresholds_bps.resize(
337 GetDefaultVp9TemporalLayers() - 1);
338 }
339
340 std::vector<webrtc::VideoStream> streams;
341 streams.push_back(stream);
342 return streams;
343 }
344
345 const std::string codec_name_;
346 const int max_qp_;
347 const int max_framerate_;
348 const bool is_screencast_;
349 const bool conference_mode_;
350};
351
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000352} // namespace
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000353
kjellander@webrtc.org5ad12972016-02-12 06:39:40 +0100354// Constants defined in webrtc/media/engine/constants.h
Peter Boström81ea54e2015-05-07 11:41:09 +0200355// TODO(pbos): Move these to a separate constants.cc file.
perkjfa10b552016-10-02 23:45:26 -0700356const int kMinVideoBitrateKbps = 30;
Peter Boström81ea54e2015-05-07 11:41:09 +0200357
358const int kVideoMtu = 1200;
359const int kVideoRtpBufferSize = 65536;
360
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000361// This constant is really an on/off, lower-level configurable NACK history
362// duration hasn't been implemented.
363static const int kNackHistoryMs = 1000;
364
buildbot@webrtc.org933d88a2014-09-18 20:23:05 +0000365static const int kDefaultQpMax = 56;
366
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000367static const int kDefaultRtcpReceiverReportSsrc = 1;
368
asapersson2e5cfcd2016-08-11 08:41:18 -0700369// Minimum time interval for logging stats.
370static const int64_t kStatsLogIntervalMs = 10000;
371
magjed1e45cc62016-10-28 07:43:45 -0700372static std::vector<VideoCodec> GetSupportedCodecs(
373 const WebRtcVideoEncoderFactory* external_encoder_factory);
374
kthelgason29a44e32016-09-27 03:52:02 -0700375rtc::scoped_refptr<webrtc::VideoEncoderConfig::EncoderSpecificSettings>
376WebRtcVideoChannel2::WebRtcVideoSendStream::ConfigureVideoEncoderSettings(
Niels Möller60653ba2016-03-02 11:41:36 +0100377 const VideoCodec& codec) {
perkjfa10b552016-10-02 23:45:26 -0700378 RTC_DCHECK_RUN_ON(&thread_checker_);
Niels Möller60653ba2016-03-02 11:41:36 +0100379 bool is_screencast = parameters_.options.is_screencast.value_or(false);
Peter Boström2feafdb2015-09-09 14:32:14 +0200380 // No automatic resizing when using simulcast or screencast.
381 bool automatic_resize =
382 !is_screencast && parameters_.config.rtp.ssrcs.size() == 1;
Erik Språng143cec12015-04-28 10:01:41 +0200383 bool frame_dropping = !is_screencast;
384 bool denoising;
pbos4cba4eb2015-10-26 11:18:18 -0700385 bool codec_default_denoising = false;
Erik Språng143cec12015-04-28 10:01:41 +0200386 if (is_screencast) {
387 denoising = false;
388 } else {
pbos4cba4eb2015-10-26 11:18:18 -0700389 // Use codec default if video_noise_reduction is unset.
Niels Möller60653ba2016-03-02 11:41:36 +0100390 codec_default_denoising = !parameters_.options.video_noise_reduction;
391 denoising = parameters_.options.video_noise_reduction.value_or(false);
Erik Språng143cec12015-04-28 10:01:41 +0200392 }
393
hbosbab934b2016-01-27 01:36:03 -0800394 if (CodecNamesEq(codec.name, kH264CodecName)) {
kthelgason29a44e32016-09-27 03:52:02 -0700395 webrtc::VideoCodecH264 h264_settings =
396 webrtc::VideoEncoder::GetDefaultH264Settings();
397 h264_settings.frameDroppingOn = frame_dropping;
398 return new rtc::RefCountedObject<
399 webrtc::VideoEncoderConfig::H264EncoderSpecificSettings>(h264_settings);
hbosbab934b2016-01-27 01:36:03 -0800400 }
Shao Changbine62202f2015-04-21 20:24:50 +0800401 if (CodecNamesEq(codec.name, kVp8CodecName)) {
kthelgason29a44e32016-09-27 03:52:02 -0700402 webrtc::VideoCodecVP8 vp8_settings =
403 webrtc::VideoEncoder::GetDefaultVp8Settings();
404 vp8_settings.automaticResizeOn = automatic_resize;
pbos4cba4eb2015-10-26 11:18:18 -0700405 // VP8 denoising is enabled by default.
kthelgason29a44e32016-09-27 03:52:02 -0700406 vp8_settings.denoisingOn = codec_default_denoising ? true : denoising;
407 vp8_settings.frameDroppingOn = frame_dropping;
408 return new rtc::RefCountedObject<
409 webrtc::VideoEncoderConfig::Vp8EncoderSpecificSettings>(vp8_settings);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000410 }
Shao Changbine62202f2015-04-21 20:24:50 +0800411 if (CodecNamesEq(codec.name, kVp9CodecName)) {
kthelgason29a44e32016-09-27 03:52:02 -0700412 webrtc::VideoCodecVP9 vp9_settings =
413 webrtc::VideoEncoder::GetDefaultVp9Settings();
asaperssonc5dabdd2016-03-21 04:15:50 -0700414 if (is_screencast) {
415 // TODO(asapersson): Set to 2 for now since there is a DCHECK in
416 // VideoSendStream::ReconfigureVideoEncoder.
kthelgason29a44e32016-09-27 03:52:02 -0700417 vp9_settings.numberOfSpatialLayers = 2;
asaperssonc5dabdd2016-03-21 04:15:50 -0700418 } else {
kthelgason29a44e32016-09-27 03:52:02 -0700419 vp9_settings.numberOfSpatialLayers = GetDefaultVp9SpatialLayers();
asaperssonc5dabdd2016-03-21 04:15:50 -0700420 }
pbos4cba4eb2015-10-26 11:18:18 -0700421 // VP9 denoising is disabled by default.
jianja5e8aa62017-03-27 10:09:00 -0700422 vp9_settings.denoisingOn = codec_default_denoising ? true : denoising;
kthelgason29a44e32016-09-27 03:52:02 -0700423 vp9_settings.frameDroppingOn = frame_dropping;
424 return new rtc::RefCountedObject<
425 webrtc::VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings);
andresp@webrtc.org188d3b22014-11-07 13:21:04 +0000426 }
kthelgason29a44e32016-09-27 03:52:02 -0700427 return nullptr;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000428}
429
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000430DefaultUnsignalledSsrcHandler::DefaultUnsignalledSsrcHandler()
brandtr0dc57ea2017-05-29 23:33:31 -0700431 : default_sink_(nullptr) {}
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000432
433UnsignalledSsrcHandler::Action DefaultUnsignalledSsrcHandler::OnUnsignalledSsrc(
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +0000434 WebRtcVideoChannel2* channel,
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000435 uint32_t ssrc) {
brandtr0dc57ea2017-05-29 23:33:31 -0700436 rtc::Optional<uint32_t> default_recv_ssrc =
437 channel->GetDefaultReceiveStreamSsrc();
438
439 if (default_recv_ssrc) {
440 LOG(LS_INFO) << "Destroying old default receive stream for SSRC=" << ssrc
441 << ".";
442 channel->RemoveRecvStream(*default_recv_ssrc);
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000443 }
444
445 StreamParams sp;
446 sp.ssrcs.push_back(ssrc);
447 LOG(LS_INFO) << "Creating default receive stream for SSRC=" << ssrc << ".";
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +0000448 if (!channel->AddRecvStream(sp, true)) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000449 LOG(LS_WARNING) << "Could not create default receive stream.";
450 }
451
nisse08582ff2016-02-04 01:24:52 -0800452 channel->SetSink(ssrc, default_sink_);
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000453 return kDeliverPacket;
454}
455
nisseacd935b2016-11-11 03:55:13 -0800456rtc::VideoSinkInterface<webrtc::VideoFrame>*
nisse08582ff2016-02-04 01:24:52 -0800457DefaultUnsignalledSsrcHandler::GetDefaultSink() const {
458 return default_sink_;
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000459}
460
nisse08582ff2016-02-04 01:24:52 -0800461void DefaultUnsignalledSsrcHandler::SetDefaultSink(
brandtr0dc57ea2017-05-29 23:33:31 -0700462 WebRtcVideoChannel2* channel,
nisseacd935b2016-11-11 03:55:13 -0800463 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
nisse08582ff2016-02-04 01:24:52 -0800464 default_sink_ = sink;
brandtr0dc57ea2017-05-29 23:33:31 -0700465 rtc::Optional<uint32_t> default_recv_ssrc =
466 channel->GetDefaultReceiveStreamSsrc();
467 if (default_recv_ssrc) {
468 channel->SetSink(*default_recv_ssrc, default_sink_);
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000469 }
470}
471
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200472WebRtcVideoEngine2::WebRtcVideoEngine2()
473 : initialized_(false),
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000474 external_decoder_factory_(NULL),
475 external_encoder_factory_(NULL) {
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +0000476 LOG(LS_INFO) << "WebRtcVideoEngine2::WebRtcVideoEngine2()";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000477}
478
479WebRtcVideoEngine2::~WebRtcVideoEngine2() {
480 LOG(LS_INFO) << "WebRtcVideoEngine2::~WebRtcVideoEngine2";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000481}
482
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200483void WebRtcVideoEngine2::Init() {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000484 LOG(LS_INFO) << "WebRtcVideoEngine2::Init";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000485 initialized_ = true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000486}
487
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000488WebRtcVideoChannel2* WebRtcVideoEngine2::CreateChannel(
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200489 webrtc::Call* call,
nisse51542be2016-02-12 02:27:06 -0800490 const MediaConfig& config,
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200491 const VideoOptions& options) {
henrikg91d6ede2015-09-17 00:24:34 -0700492 RTC_DCHECK(initialized_);
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200493 LOG(LS_INFO) << "CreateChannel. Options: " << options.ToString();
magjed23b7a4a2016-11-08 01:12:54 -0800494 return new WebRtcVideoChannel2(call, config, options,
nisse51542be2016-02-12 02:27:06 -0800495 external_encoder_factory_,
496 external_decoder_factory_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000497}
498
brandtrffc61182016-11-28 06:02:22 -0800499std::vector<VideoCodec> WebRtcVideoEngine2::codecs() const {
500 return GetSupportedCodecs(external_encoder_factory_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000501}
502
Stefan Holmer9d69c3f2015-12-07 10:45:43 +0100503RtpCapabilities WebRtcVideoEngine2::GetCapabilities() const {
504 RtpCapabilities capabilities;
505 capabilities.header_extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -0700506 webrtc::RtpExtension(webrtc::RtpExtension::kTimestampOffsetUri,
507 webrtc::RtpExtension::kTimestampOffsetDefaultId));
Stefan Holmer9d69c3f2015-12-07 10:45:43 +0100508 capabilities.header_extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -0700509 webrtc::RtpExtension(webrtc::RtpExtension::kAbsSendTimeUri,
510 webrtc::RtpExtension::kAbsSendTimeDefaultId));
Stefan Holmer9d69c3f2015-12-07 10:45:43 +0100511 capabilities.header_extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -0700512 webrtc::RtpExtension(webrtc::RtpExtension::kVideoRotationUri,
513 webrtc::RtpExtension::kVideoRotationDefaultId));
Stefan Holmer06a5e1a2016-09-02 12:36:49 +0200514 capabilities.header_extensions.push_back(webrtc::RtpExtension(
515 webrtc::RtpExtension::kTransportSequenceNumberUri,
516 webrtc::RtpExtension::kTransportSequenceNumberDefaultId));
isheriff6b4b5f32016-06-08 00:24:21 -0700517 capabilities.header_extensions.push_back(
518 webrtc::RtpExtension(webrtc::RtpExtension::kPlayoutDelayUri,
519 webrtc::RtpExtension::kPlayoutDelayDefaultId));
ilnika244ec62017-04-24 05:12:35 -0700520 if (IsVideoContentTypeExtensionFieldTrialEnabled()) {
521 capabilities.header_extensions.push_back(
522 webrtc::RtpExtension(webrtc::RtpExtension::kVideoContentTypeUri,
523 webrtc::RtpExtension::kVideoContentTypeDefaultId));
524 }
Stefan Holmer9d69c3f2015-12-07 10:45:43 +0100525 return capabilities;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000526}
527
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000528void WebRtcVideoEngine2::SetExternalDecoderFactory(
529 WebRtcVideoDecoderFactory* decoder_factory) {
henrikg91d6ede2015-09-17 00:24:34 -0700530 RTC_DCHECK(!initialized_);
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000531 external_decoder_factory_ = decoder_factory;
532}
533
534void WebRtcVideoEngine2::SetExternalEncoderFactory(
535 WebRtcVideoEncoderFactory* encoder_factory) {
henrikg91d6ede2015-09-17 00:24:34 -0700536 RTC_DCHECK(!initialized_);
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000537 if (external_encoder_factory_ == encoder_factory)
538 return;
539
540 // No matter what happens we shouldn't hold on to a stale
541 // WebRtcSimulcastEncoderFactory.
542 simulcast_encoder_factory_.reset();
543
544 if (encoder_factory &&
545 WebRtcSimulcastEncoderFactory::UseSimulcastEncoderFactory(
magjed1e45cc62016-10-28 07:43:45 -0700546 encoder_factory->supported_codecs())) {
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000547 simulcast_encoder_factory_.reset(
548 new WebRtcSimulcastEncoderFactory(encoder_factory));
549 encoder_factory = simulcast_encoder_factory_.get();
550 }
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000551 external_encoder_factory_ = encoder_factory;
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000552}
553
magjed509e4fe2016-11-18 01:34:11 -0800554// This is a helper function for AppendVideoCodecs below. It will return the
555// first unused dynamic payload type (in the range [96, 127]), or nothing if no
556// payload type is unused.
557static rtc::Optional<int> NextFreePayloadType(
558 const std::vector<VideoCodec>& codecs) {
559 static const int kFirstDynamicPayloadType = 96;
560 static const int kLastDynamicPayloadType = 127;
561 bool is_payload_used[1 + kLastDynamicPayloadType - kFirstDynamicPayloadType] =
562 {false};
563 for (const VideoCodec& codec : codecs) {
564 if (kFirstDynamicPayloadType <= codec.id &&
565 codec.id <= kLastDynamicPayloadType) {
566 is_payload_used[codec.id - kFirstDynamicPayloadType] = true;
magjedeacbaea2016-11-17 08:51:59 -0800567 }
magjed509e4fe2016-11-18 01:34:11 -0800568 }
569 for (int i = kFirstDynamicPayloadType; i <= kLastDynamicPayloadType; ++i) {
570 if (!is_payload_used[i - kFirstDynamicPayloadType])
571 return rtc::Optional<int>(i);
572 }
573 // No free payload type.
574 return rtc::Optional<int>();
575}
576
577// This is a helper function for GetSupportedCodecs below. It will append new
578// unique codecs from |input_codecs| to |unified_codecs|. It will add default
579// feedback params to the codecs and will also add an associated RTX codec for
brandtr36e7d702017-01-13 07:15:54 -0800580// recognized codecs (VP8, VP9, H264, and RED).
magjed509e4fe2016-11-18 01:34:11 -0800581static void AppendVideoCodecs(const std::vector<VideoCodec>& input_codecs,
582 std::vector<VideoCodec>* unified_codecs) {
583 for (VideoCodec codec : input_codecs) {
584 const rtc::Optional<int> payload_type =
585 NextFreePayloadType(*unified_codecs);
586 if (!payload_type)
587 return;
588 codec.id = *payload_type;
589 // TODO(magjed): Move the responsibility of setting these parameters to the
590 // encoder factories instead.
brandtr36e7d702017-01-13 07:15:54 -0800591 if (codec.name != kRedCodecName && codec.name != kUlpfecCodecName &&
592 codec.name != kFlexfecCodecName)
magjed509e4fe2016-11-18 01:34:11 -0800593 AddDefaultFeedbackParams(&codec);
594 // Don't add same codec twice.
595 if (FindMatchingCodec(*unified_codecs, codec))
magjedeacbaea2016-11-17 08:51:59 -0800596 continue;
597
magjed509e4fe2016-11-18 01:34:11 -0800598 unified_codecs->push_back(codec);
magjedeacbaea2016-11-17 08:51:59 -0800599
magjed509e4fe2016-11-18 01:34:11 -0800600 // Add associated RTX codec for recognized codecs.
601 // TODO(deadbeef): Should we add RTX codecs for external codecs whose names
602 // we don't recognize?
603 if (CodecNamesEq(codec.name, kVp8CodecName) ||
604 CodecNamesEq(codec.name, kVp9CodecName) ||
605 CodecNamesEq(codec.name, kH264CodecName) ||
606 CodecNamesEq(codec.name, kRedCodecName)) {
607 const rtc::Optional<int> rtx_payload_type =
608 NextFreePayloadType(*unified_codecs);
609 if (!rtx_payload_type)
610 return;
611 unified_codecs->push_back(
612 VideoCodec::CreateRtxCodec(*rtx_payload_type, codec.id));
613 }
magjedeacbaea2016-11-17 08:51:59 -0800614 }
magjed509e4fe2016-11-18 01:34:11 -0800615}
616
617static std::vector<VideoCodec> GetSupportedCodecs(
618 const WebRtcVideoEncoderFactory* external_encoder_factory) {
619 const std::vector<VideoCodec> internal_codecs =
620 InternalEncoderFactory().supported_codecs();
621 LOG(LS_INFO) << "Internally supported codecs: "
622 << CodecVectorToString(internal_codecs);
623
624 std::vector<VideoCodec> unified_codecs;
625 AppendVideoCodecs(internal_codecs, &unified_codecs);
626
627 if (external_encoder_factory != nullptr) {
628 const std::vector<VideoCodec>& external_codecs =
629 external_encoder_factory->supported_codecs();
630 AppendVideoCodecs(external_codecs, &unified_codecs);
631 LOG(LS_INFO) << "Codecs supported by the external encoder factory: "
632 << CodecVectorToString(external_codecs);
633 }
634
635 return unified_codecs;
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000636}
637
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000638WebRtcVideoChannel2::WebRtcVideoChannel2(
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200639 webrtc::Call* call,
nisse51542be2016-02-12 02:27:06 -0800640 const MediaConfig& config,
pbos@webrtc.orgfa553ef2014-10-20 11:07:07 +0000641 const VideoOptions& options,
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000642 WebRtcVideoEncoderFactory* external_encoder_factory,
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000643 WebRtcVideoDecoderFactory* external_decoder_factory)
nisse51542be2016-02-12 02:27:06 -0800644 : VideoMediaChannel(config),
645 call_(call),
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200646 unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
nisse0db023a2016-03-01 04:29:59 -0800647 video_config_(config.video),
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000648 external_encoder_factory_(external_encoder_factory),
nisse05103312016-03-16 02:22:50 -0700649 external_decoder_factory_(external_decoder_factory),
Stefan Holmer2b1f6512016-05-17 16:33:30 +0200650 default_send_options_(options),
asapersson2e5cfcd2016-08-11 08:41:18 -0700651 last_stats_log_ms_(-1) {
henrikg91d6ede2015-09-17 00:24:34 -0700652 RTC_DCHECK(thread_checker_.CalledOnValidThread());
nissea293ef02016-02-17 07:24:50 -0800653
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000654 rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc;
655 sending_ = false;
magjed23b7a4a2016-11-08 01:12:54 -0800656 recv_codecs_ = MapCodecs(GetSupportedCodecs(external_encoder_factory));
brandtr11fb4722017-05-30 01:31:37 -0700657 recv_flexfec_payload_type_ = recv_codecs_.front().flexfec_payload_type;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000658}
659
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000660WebRtcVideoChannel2::~WebRtcVideoChannel2() {
Peter Boströmdfd53fe2015-03-27 15:58:11 +0100661 for (auto& kv : send_streams_)
662 delete kv.second;
663 for (auto& kv : receive_streams_)
664 delete kv.second;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000665}
666
magjed23b7a4a2016-11-08 01:12:54 -0800667rtc::Optional<WebRtcVideoChannel2::VideoCodecSettings>
668WebRtcVideoChannel2::SelectSendVideoCodec(
669 const std::vector<VideoCodecSettings>& remote_mapped_codecs) const {
670 const std::vector<VideoCodec> local_supported_codecs =
magjed1e45cc62016-10-28 07:43:45 -0700671 GetSupportedCodecs(external_encoder_factory_);
magjed23b7a4a2016-11-08 01:12:54 -0800672 // Select the first remote codec that is supported locally.
673 for (const VideoCodecSettings& remote_mapped_codec : remote_mapped_codecs) {
magjedf823ede2016-11-12 09:53:04 -0800674 // For H264, we will limit the encode level to the remote offered level
675 // regardless if level asymmetry is allowed or not. This is strictly not
676 // following the spec in https://tools.ietf.org/html/rfc6184#section-8.2.2
677 // since we should limit the encode level to the lower of local and remote
678 // level when level asymmetry is not allowed.
679 if (FindMatchingCodec(local_supported_codecs, remote_mapped_codec.codec))
magjed23b7a4a2016-11-08 01:12:54 -0800680 return rtc::Optional<VideoCodecSettings>(remote_mapped_codec);
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000681 }
magjed23b7a4a2016-11-08 01:12:54 -0800682 // No remote codec was supported.
683 return rtc::Optional<VideoCodecSettings>();
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000684}
685
brandtr11fb4722017-05-30 01:31:37 -0700686bool WebRtcVideoChannel2::NonFlexfecReceiveCodecsHaveChanged(
deadbeef874ca3a2015-08-20 17:19:20 -0700687 std::vector<VideoCodecSettings> before,
688 std::vector<VideoCodecSettings> after) {
689 if (before.size() != after.size()) {
690 return true;
691 }
brandtr11fb4722017-05-30 01:31:37 -0700692
deadbeef874ca3a2015-08-20 17:19:20 -0700693 // The receive codec order doesn't matter, so we sort the codecs before
694 // comparing. This is necessary because currently the
695 // only way to change the send codec is to munge SDP, which causes
696 // the receive codec list to change order, which causes the streams
697 // to be recreates which causes a "blink" of black video. In order
698 // to support munging the SDP in this way without recreating receive
699 // streams, we ignore the order of the received codecs so that
700 // changing the order doesn't cause this "blink".
701 auto comparison =
702 [](const VideoCodecSettings& codec1, const VideoCodecSettings& codec2) {
703 return codec1.codec.id > codec2.codec.id;
704 };
705 std::sort(before.begin(), before.end(), comparison);
706 std::sort(after.begin(), after.end(), comparison);
brandtr11fb4722017-05-30 01:31:37 -0700707
708 // Changes in FlexFEC payload type are handled separately in
709 // WebRtcVideoChannel2::GetChangedRecvParameters, so disregard FlexFEC in the
710 // comparison here.
711 return !std::equal(before.begin(), before.end(), after.begin(),
712 VideoCodecSettings::EqualsDisregardingFlexfec);
deadbeef874ca3a2015-08-20 17:19:20 -0700713}
714
Peter Boström3afc8c42016-01-27 16:45:21 +0100715bool WebRtcVideoChannel2::GetChangedSendParameters(
716 const VideoSendParameters& params,
717 ChangedSendParameters* changed_params) const {
718 if (!ValidateCodecFormats(params.codecs) ||
719 !ValidateRtpExtensions(params.extensions)) {
720 return false;
721 }
722
magjed23b7a4a2016-11-08 01:12:54 -0800723 // Select one of the remote codecs that will be used as send codec.
brandtr31bd2242017-05-19 05:47:46 -0700724 rtc::Optional<VideoCodecSettings> selected_send_codec =
magjed23b7a4a2016-11-08 01:12:54 -0800725 SelectSendVideoCodec(MapCodecs(params.codecs));
Peter Boström3afc8c42016-01-27 16:45:21 +0100726
magjed23b7a4a2016-11-08 01:12:54 -0800727 if (!selected_send_codec) {
Peter Boström3afc8c42016-01-27 16:45:21 +0100728 LOG(LS_ERROR) << "No video codecs supported.";
729 return false;
730 }
731
brandtr31bd2242017-05-19 05:47:46 -0700732 // Never enable sending FlexFEC, unless we are in the experiment.
733 if (!IsFlexfecFieldTrialEnabled()) {
734 if (selected_send_codec->flexfec_payload_type != -1) {
735 LOG(LS_INFO) << "Remote supports flexfec-03, but we will not send since "
736 << "WebRTC-FlexFEC-03 field trial is not enabled.";
737 }
738 selected_send_codec->flexfec_payload_type = -1;
739 }
740
magjed23b7a4a2016-11-08 01:12:54 -0800741 if (!send_codec_ || *selected_send_codec != *send_codec_)
742 changed_params->codec = selected_send_codec;
Peter Boström3afc8c42016-01-27 16:45:21 +0100743
pbos378dc772016-01-28 15:58:41 -0800744 // Handle RTP header extensions.
Peter Boström3afc8c42016-01-27 16:45:21 +0100745 std::vector<webrtc::RtpExtension> filtered_extensions = FilterRtpExtensions(
746 params.extensions, webrtc::RtpExtension::IsSupportedForVideo, true);
skvlad3abb7642016-06-16 12:08:03 -0700747 if (!send_rtp_extensions_ || (*send_rtp_extensions_ != filtered_extensions)) {
Peter Boström3afc8c42016-01-27 16:45:21 +0100748 changed_params->rtp_header_extensions =
749 rtc::Optional<std::vector<webrtc::RtpExtension>>(filtered_extensions);
750 }
751
pbos378dc772016-01-28 15:58:41 -0800752 // Handle max bitrate.
Taylor Brandstetter58f2bd92016-04-26 17:15:23 -0700753 if (params.max_bandwidth_bps != send_params_.max_bandwidth_bps &&
pbos5c7760a2017-03-10 11:23:12 -0800754 params.max_bandwidth_bps >= -1) {
755 // 0 or -1 uncaps max bitrate.
756 // TODO(pbos): Reconsider how 0 should be treated. It is not mentioned as a
757 // special value and might very well be used for stopping sending.
Peter Boström3afc8c42016-01-27 16:45:21 +0100758 changed_params->max_bandwidth_bps = rtc::Optional<int>(
759 params.max_bandwidth_bps == 0 ? -1 : params.max_bandwidth_bps);
760 }
761
nisse4b4dc862016-02-17 05:25:36 -0800762 // Handle conference mode.
763 if (params.conference_mode != send_params_.conference_mode) {
764 changed_params->conference_mode =
765 rtc::Optional<bool>(params.conference_mode);
766 }
767
pbos378dc772016-01-28 15:58:41 -0800768 // Handle RTCP mode.
Peter Boström3afc8c42016-01-27 16:45:21 +0100769 if (params.rtcp.reduced_size != send_params_.rtcp.reduced_size) {
770 changed_params->rtcp_mode = rtc::Optional<webrtc::RtcpMode>(
771 params.rtcp.reduced_size ? webrtc::RtcpMode::kReducedSize
772 : webrtc::RtcpMode::kCompound);
773 }
774
775 return true;
776}
777
nisse51542be2016-02-12 02:27:06 -0800778rtc::DiffServCodePoint WebRtcVideoChannel2::PreferredDscp() const {
779 return rtc::DSCP_AF41;
780}
781
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700782bool WebRtcVideoChannel2::SetSendParameters(const VideoSendParameters& params) {
Peter Boström9f45a452015-12-08 13:25:57 +0100783 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetSendParameters");
solenberg7e4e01a2015-12-02 08:05:01 -0800784 LOG(LS_INFO) << "SetSendParameters: " << params.ToString();
Peter Boström3afc8c42016-01-27 16:45:21 +0100785 ChangedSendParameters changed_params;
786 if (!GetChangedSendParameters(params, &changed_params)) {
deadbeef13871492015-12-09 12:37:51 -0800787 return false;
788 }
Peter Boström3afc8c42016-01-27 16:45:21 +0100789
Peter Boström3afc8c42016-01-27 16:45:21 +0100790 if (changed_params.codec) {
791 const VideoCodecSettings& codec_settings = *changed_params.codec;
792 send_codec_ = rtc::Optional<VideoCodecSettings>(codec_settings);
Peter Boström3afc8c42016-01-27 16:45:21 +0100793 LOG(LS_INFO) << "Using codec: " << codec_settings.codec.ToString();
Peter Boström3afc8c42016-01-27 16:45:21 +0100794 }
795
796 if (changed_params.rtp_header_extensions) {
skvlad3abb7642016-06-16 12:08:03 -0700797 send_rtp_extensions_ = changed_params.rtp_header_extensions;
Peter Boström3afc8c42016-01-27 16:45:21 +0100798 }
799
Taylor Brandstetter58f2bd92016-04-26 17:15:23 -0700800 if (changed_params.codec || changed_params.max_bandwidth_bps) {
pbos5c7760a2017-03-10 11:23:12 -0800801 if (params.max_bandwidth_bps == -1) {
802 // Unset the global max bitrate (max_bitrate_bps) if max_bandwidth_bps is
803 // -1, which corresponds to no "b=AS" attribute in SDP. Note that the
804 // global max bitrate may be set below in GetBitrateConfigForCodec, from
805 // the codec max bitrate.
806 // TODO(pbos): This should be reconsidered (codec max bitrate should
807 // probably not affect global call max bitrate).
808 bitrate_config_.max_bitrate_bps = -1;
809 }
Taylor Brandstetter58f2bd92016-04-26 17:15:23 -0700810 if (send_codec_) {
811 // TODO(holmer): Changing the codec parameters shouldn't necessarily mean
812 // that we change the min/max of bandwidth estimation. Reevaluate this.
813 bitrate_config_ = GetBitrateConfigForCodec(send_codec_->codec);
814 if (!changed_params.codec) {
815 // If the codec isn't changing, set the start bitrate to -1 which means
816 // "unchanged" so that BWE isn't affected.
817 bitrate_config_.start_bitrate_bps = -1;
818 }
Peter Boström3afc8c42016-01-27 16:45:21 +0100819 }
Taylor Brandstetter58f2bd92016-04-26 17:15:23 -0700820 if (params.max_bandwidth_bps >= 0) {
821 // Note that max_bandwidth_bps intentionally takes priority over the
822 // bitrate config for the codec. This allows FEC to be applied above the
823 // codec target bitrate.
824 // TODO(pbos): Figure out whether b=AS means max bitrate for this
825 // WebRtcVideoChannel2 (in which case we're good), or per sender (SSRC),
826 // in which case this should not set a Call::BitrateConfig but rather
827 // reconfigure all senders.
828 bitrate_config_.max_bitrate_bps =
829 params.max_bandwidth_bps == 0 ? -1 : params.max_bandwidth_bps;
830 }
Peter Boström3afc8c42016-01-27 16:45:21 +0100831 call_->SetBitrateConfig(bitrate_config_);
832 }
833
Peter Boström3afc8c42016-01-27 16:45:21 +0100834 {
deadbeef13871492015-12-09 12:37:51 -0800835 rtc::CritScope stream_lock(&stream_crit_);
836 for (auto& kv : send_streams_) {
Peter Boström3afc8c42016-01-27 16:45:21 +0100837 kv.second->SetSendParameters(changed_params);
838 }
Taylor Brandstetter5f0b83b2016-03-18 15:02:07 -0700839 if (changed_params.codec || changed_params.rtcp_mode) {
840 // Update receive feedback parameters from new codec or RTCP mode.
Peter Boström3afc8c42016-01-27 16:45:21 +0100841 LOG(LS_INFO)
842 << "SetFeedbackOptions on all the receive streams because the send "
Taylor Brandstetter5f0b83b2016-03-18 15:02:07 -0700843 "codec or RTCP mode has changed.";
Peter Boström3afc8c42016-01-27 16:45:21 +0100844 for (auto& kv : receive_streams_) {
845 RTC_DCHECK(kv.second != nullptr);
Taylor Brandstetter5f0b83b2016-03-18 15:02:07 -0700846 kv.second->SetFeedbackParameters(
847 HasNack(send_codec_->codec), HasRemb(send_codec_->codec),
848 HasTransportCc(send_codec_->codec),
849 params.rtcp.reduced_size ? webrtc::RtcpMode::kReducedSize
850 : webrtc::RtcpMode::kCompound);
Peter Boström3afc8c42016-01-27 16:45:21 +0100851 }
deadbeef13871492015-12-09 12:37:51 -0800852 }
853 }
854 send_params_ = params;
855 return true;
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700856}
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700857
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700858webrtc::RtpParameters WebRtcVideoChannel2::GetRtpSendParameters(
skvladdc1c62c2016-03-16 19:07:43 -0700859 uint32_t ssrc) const {
860 rtc::CritScope stream_lock(&stream_crit_);
861 auto it = send_streams_.find(ssrc);
862 if (it == send_streams_.end()) {
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700863 LOG(LS_WARNING) << "Attempting to get RTP send parameters for stream "
864 << "with ssrc " << ssrc << " which doesn't exist.";
skvladdc1c62c2016-03-16 19:07:43 -0700865 return webrtc::RtpParameters();
866 }
867
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700868 webrtc::RtpParameters rtp_params = it->second->GetRtpParameters();
869 // Need to add the common list of codecs to the send stream-specific
870 // RTP parameters.
871 for (const VideoCodec& codec : send_params_.codecs) {
872 rtp_params.codecs.push_back(codec.ToCodecParameters());
873 }
874 return rtp_params;
skvladdc1c62c2016-03-16 19:07:43 -0700875}
876
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700877bool WebRtcVideoChannel2::SetRtpSendParameters(
skvladdc1c62c2016-03-16 19:07:43 -0700878 uint32_t ssrc,
879 const webrtc::RtpParameters& parameters) {
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700880 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRtpSendParameters");
skvladdc1c62c2016-03-16 19:07:43 -0700881 rtc::CritScope stream_lock(&stream_crit_);
882 auto it = send_streams_.find(ssrc);
883 if (it == send_streams_.end()) {
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700884 LOG(LS_ERROR) << "Attempting to set RTP send parameters for stream "
885 << "with ssrc " << ssrc << " which doesn't exist.";
skvladdc1c62c2016-03-16 19:07:43 -0700886 return false;
887 }
888
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700889 // TODO(deadbeef): Handle setting parameters with a list of codecs in a
890 // different order (which should change the send codec).
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700891 webrtc::RtpParameters current_parameters = GetRtpSendParameters(ssrc);
892 if (current_parameters.codecs != parameters.codecs) {
893 LOG(LS_ERROR) << "Using SetParameters to change the set of codecs "
894 << "is not currently supported.";
895 return false;
896 }
897
skvladdc1c62c2016-03-16 19:07:43 -0700898 return it->second->SetRtpParameters(parameters);
899}
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700900
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700901webrtc::RtpParameters WebRtcVideoChannel2::GetRtpReceiveParameters(
902 uint32_t ssrc) const {
deadbeef3bc15102017-04-20 19:25:07 -0700903 webrtc::RtpParameters rtp_params;
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700904 rtc::CritScope stream_lock(&stream_crit_);
deadbeef3bc15102017-04-20 19:25:07 -0700905 // SSRC of 0 represents an unsignaled receive stream.
906 if (ssrc == 0) {
907 if (!default_unsignalled_ssrc_handler_.GetDefaultSink()) {
908 LOG(LS_WARNING) << "Attempting to get RTP parameters for the default, "
909 "unsignaled video receive stream, but not yet "
910 "configured to receive such a stream.";
911 return rtp_params;
912 }
913 rtp_params.encodings.emplace_back();
914 } else {
915 auto it = receive_streams_.find(ssrc);
916 if (it == receive_streams_.end()) {
917 LOG(LS_WARNING) << "Attempting to get RTP receive parameters for stream "
918 << "with SSRC " << ssrc << " which doesn't exist.";
919 return webrtc::RtpParameters();
920 }
921 // TODO(deadbeef): Return stream-specific parameters, beyond just SSRC.
922 rtp_params.encodings.emplace_back();
923 rtp_params.encodings[0].ssrc = it->second->GetFirstPrimarySsrc();
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700924 }
925
deadbeef3bc15102017-04-20 19:25:07 -0700926 // Add codecs, which any stream is prepared to receive.
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700927 for (const VideoCodec& codec : recv_params_.codecs) {
928 rtp_params.codecs.push_back(codec.ToCodecParameters());
929 }
930 return rtp_params;
931}
932
933bool WebRtcVideoChannel2::SetRtpReceiveParameters(
934 uint32_t ssrc,
935 const webrtc::RtpParameters& parameters) {
936 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRtpReceiveParameters");
937 rtc::CritScope stream_lock(&stream_crit_);
deadbeef3bc15102017-04-20 19:25:07 -0700938
939 // SSRC of 0 represents an unsignaled receive stream.
940 if (ssrc == 0) {
941 if (!default_unsignalled_ssrc_handler_.GetDefaultSink()) {
942 LOG(LS_WARNING) << "Attempting to set RTP parameters for the default, "
943 "unsignaled video receive stream, but not yet "
944 "configured to receive such a stream.";
945 return false;
946 }
947 } else {
948 auto it = receive_streams_.find(ssrc);
949 if (it == receive_streams_.end()) {
950 LOG(LS_WARNING) << "Attempting to set RTP receive parameters for stream "
951 << "with SSRC " << ssrc << " which doesn't exist.";
952 return false;
953 }
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700954 }
955
956 webrtc::RtpParameters current_parameters = GetRtpReceiveParameters(ssrc);
957 if (current_parameters != parameters) {
958 LOG(LS_ERROR) << "Changing the RTP receive parameters is currently "
959 << "unsupported.";
960 return false;
961 }
962 return true;
963}
964
pbos378dc772016-01-28 15:58:41 -0800965bool WebRtcVideoChannel2::GetChangedRecvParameters(
966 const VideoRecvParameters& params,
967 ChangedRecvParameters* changed_params) const {
968 if (!ValidateCodecFormats(params.codecs) ||
969 !ValidateRtpExtensions(params.extensions)) {
970 return false;
971 }
972
973 // Handle receive codecs.
974 const std::vector<VideoCodecSettings> mapped_codecs =
975 MapCodecs(params.codecs);
976 if (mapped_codecs.empty()) {
977 LOG(LS_ERROR) << "SetRecvParameters called without any video codecs.";
978 return false;
979 }
980
magjed23b7a4a2016-11-08 01:12:54 -0800981 // Verify that every mapped codec is supported locally.
982 const std::vector<VideoCodec> local_supported_codecs =
983 GetSupportedCodecs(external_encoder_factory_);
984 for (const VideoCodecSettings& mapped_codec : mapped_codecs) {
magjedf823ede2016-11-12 09:53:04 -0800985 if (!FindMatchingCodec(local_supported_codecs, mapped_codec.codec)) {
magjed23b7a4a2016-11-08 01:12:54 -0800986 LOG(LS_ERROR) << "SetRecvParameters called with unsupported video codec: "
987 << mapped_codec.codec.ToString();
988 return false;
989 }
pbos378dc772016-01-28 15:58:41 -0800990 }
991
brandtr11fb4722017-05-30 01:31:37 -0700992 if (NonFlexfecReceiveCodecsHaveChanged(recv_codecs_, mapped_codecs)) {
pbos378dc772016-01-28 15:58:41 -0800993 changed_params->codec_settings =
magjed23b7a4a2016-11-08 01:12:54 -0800994 rtc::Optional<std::vector<VideoCodecSettings>>(mapped_codecs);
pbos378dc772016-01-28 15:58:41 -0800995 }
996
997 // Handle RTP header extensions.
998 std::vector<webrtc::RtpExtension> filtered_extensions = FilterRtpExtensions(
999 params.extensions, webrtc::RtpExtension::IsSupportedForVideo, false);
1000 if (filtered_extensions != recv_rtp_extensions_) {
1001 changed_params->rtp_header_extensions =
1002 rtc::Optional<std::vector<webrtc::RtpExtension>>(filtered_extensions);
1003 }
1004
brandtr11fb4722017-05-30 01:31:37 -07001005 int flexfec_payload_type = mapped_codecs.front().flexfec_payload_type;
1006 if (flexfec_payload_type != recv_flexfec_payload_type_) {
1007 changed_params->flexfec_payload_type =
1008 rtc::Optional<int>(flexfec_payload_type);
1009 }
1010
pbos378dc772016-01-28 15:58:41 -08001011 return true;
1012}
1013
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001014bool WebRtcVideoChannel2::SetRecvParameters(const VideoRecvParameters& params) {
Peter Boström9f45a452015-12-08 13:25:57 +01001015 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRecvParameters");
solenberg7e4e01a2015-12-02 08:05:01 -08001016 LOG(LS_INFO) << "SetRecvParameters: " << params.ToString();
pbos378dc772016-01-28 15:58:41 -08001017 ChangedRecvParameters changed_params;
1018 if (!GetChangedRecvParameters(params, &changed_params)) {
deadbeef13871492015-12-09 12:37:51 -08001019 return false;
1020 }
brandtr11fb4722017-05-30 01:31:37 -07001021 if (changed_params.flexfec_payload_type) {
1022 LOG(LS_INFO) << "Changing FlexFEC payload type (recv) from "
1023 << recv_flexfec_payload_type_ << " to "
1024 << *changed_params.flexfec_payload_type;
1025 recv_flexfec_payload_type_ = *changed_params.flexfec_payload_type;
1026 }
pbos378dc772016-01-28 15:58:41 -08001027 if (changed_params.rtp_header_extensions) {
1028 recv_rtp_extensions_ = *changed_params.rtp_header_extensions;
1029 }
1030 if (changed_params.codec_settings) {
1031 LOG(LS_INFO) << "Changing recv codecs from "
1032 << CodecSettingsVectorToString(recv_codecs_) << " to "
1033 << CodecSettingsVectorToString(*changed_params.codec_settings);
1034 recv_codecs_ = *changed_params.codec_settings;
1035 }
1036
1037 {
deadbeef13871492015-12-09 12:37:51 -08001038 rtc::CritScope stream_lock(&stream_crit_);
1039 for (auto& kv : receive_streams_) {
pbos378dc772016-01-28 15:58:41 -08001040 kv.second->SetRecvParameters(changed_params);
deadbeef13871492015-12-09 12:37:51 -08001041 }
1042 }
1043 recv_params_ = params;
1044 return true;
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001045}
1046
deadbeef874ca3a2015-08-20 17:19:20 -07001047std::string WebRtcVideoChannel2::CodecSettingsVectorToString(
1048 const std::vector<VideoCodecSettings>& codecs) {
1049 std::stringstream out;
1050 out << '{';
1051 for (size_t i = 0; i < codecs.size(); ++i) {
1052 out << codecs[i].codec.ToString();
1053 if (i != codecs.size() - 1) {
1054 out << ", ";
1055 }
1056 }
1057 out << '}';
1058 return out.str();
1059}
1060
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001061bool WebRtcVideoChannel2::GetSendCodec(VideoCodec* codec) {
kwiberg102c6a62015-10-30 02:47:38 -07001062 if (!send_codec_) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001063 LOG(LS_VERBOSE) << "GetSendCodec: No send codec set.";
1064 return false;
1065 }
kwiberg102c6a62015-10-30 02:47:38 -07001066 *codec = send_codec_->codec;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001067 return true;
1068}
1069
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001070bool WebRtcVideoChannel2::SetSend(bool send) {
Peter Boströmdabc9442016-04-11 11:45:14 +02001071 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetSend");
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001072 LOG(LS_VERBOSE) << "SetSend: " << (send ? "true" : "false");
kwiberg102c6a62015-10-30 02:47:38 -07001073 if (send && !send_codec_) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001074 LOG(LS_ERROR) << "SetSend(true) called before setting codec.";
1075 return false;
1076 }
deadbeefdbe2b872016-03-22 15:42:00 -07001077 {
1078 rtc::CritScope stream_lock(&stream_crit_);
1079 for (const auto& kv : send_streams_) {
1080 kv.second->SetSend(send);
1081 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001082 }
1083 sending_ = send;
1084 return true;
1085}
1086
nisse2ded9b12016-04-08 02:23:55 -07001087// TODO(nisse): The enable argument was used for mute logic which has
deadbeef5a4a75a2016-06-02 16:23:38 -07001088// been moved to VideoBroadcaster. So remove the argument from this
1089// method.
1090bool WebRtcVideoChannel2::SetVideoSend(
1091 uint32_t ssrc,
1092 bool enable,
1093 const VideoOptions* options,
nisseacd935b2016-11-11 03:55:13 -08001094 rtc::VideoSourceInterface<webrtc::VideoFrame>* source) {
Peter Boström3afc8c42016-01-27 16:45:21 +01001095 TRACE_EVENT0("webrtc", "SetVideoSend");
deadbeef5a4a75a2016-06-02 16:23:38 -07001096 RTC_DCHECK(ssrc != 0);
Peter Boström3afc8c42016-01-27 16:45:21 +01001097 LOG(LS_INFO) << "SetVideoSend (ssrc= " << ssrc << ", enable = " << enable
deadbeef5a4a75a2016-06-02 16:23:38 -07001098 << ", options: " << (options ? options->ToString() : "nullptr")
1099 << ", source = " << (source ? "(source)" : "nullptr") << ")";
Peter Boström3afc8c42016-01-27 16:45:21 +01001100
deadbeef5a4a75a2016-06-02 16:23:38 -07001101 rtc::CritScope stream_lock(&stream_crit_);
1102 const auto& kv = send_streams_.find(ssrc);
1103 if (kv == send_streams_.end()) {
1104 // Allow unknown ssrc only if source is null.
1105 RTC_CHECK(source == nullptr);
1106 LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc;
1107 return false;
solenberg1dd98f32015-09-10 01:57:14 -07001108 }
deadbeef5a4a75a2016-06-02 16:23:38 -07001109
1110 return kv->second->SetVideoSend(enable, options, source);
solenberg1dd98f32015-09-10 01:57:14 -07001111}
1112
Peter Boströmd6f4c252015-03-26 16:23:04 +01001113bool WebRtcVideoChannel2::ValidateSendSsrcAvailability(
1114 const StreamParams& sp) const {
Pera5092412016-02-12 13:30:57 +01001115 for (uint32_t ssrc : sp.ssrcs) {
Peter Boströmd6f4c252015-03-26 16:23:04 +01001116 if (send_ssrcs_.find(ssrc) != send_ssrcs_.end()) {
1117 LOG(LS_ERROR) << "Send stream with SSRC '" << ssrc << "' already exists.";
1118 return false;
1119 }
1120 }
1121 return true;
1122}
1123
1124bool WebRtcVideoChannel2::ValidateReceiveSsrcAvailability(
1125 const StreamParams& sp) const {
Pera5092412016-02-12 13:30:57 +01001126 for (uint32_t ssrc : sp.ssrcs) {
Peter Boströmd6f4c252015-03-26 16:23:04 +01001127 if (receive_ssrcs_.find(ssrc) != receive_ssrcs_.end()) {
1128 LOG(LS_ERROR) << "Receive stream with SSRC '" << ssrc
1129 << "' already exists.";
1130 return false;
1131 }
1132 }
1133 return true;
1134}
1135
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001136bool WebRtcVideoChannel2::AddSendStream(const StreamParams& sp) {
1137 LOG(LS_INFO) << "AddSendStream: " << sp.ToString();
Peter Boströmd4362cd2015-03-25 14:17:23 +01001138 if (!ValidateStreamParams(sp))
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001139 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001140
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001141 rtc::CritScope stream_lock(&stream_crit_);
Peter Boströmd6f4c252015-03-26 16:23:04 +01001142
1143 if (!ValidateSendSsrcAvailability(sp))
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001144 return false;
Peter Boströmd6f4c252015-03-26 16:23:04 +01001145
Peter Boström0c4e06b2015-10-07 12:23:21 +02001146 for (uint32_t used_ssrc : sp.ssrcs)
Peter Boströmd6f4c252015-03-26 16:23:04 +01001147 send_ssrcs_.insert(used_ssrc);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001148
solenberge5269742015-09-08 05:13:22 -07001149 webrtc::VideoSendStream::Config config(this);
nisse0db023a2016-03-01 04:29:59 -08001150 config.suspend_below_min_bitrate = video_config_.suspend_below_min_bitrate;
sergeyu80ed35e2016-11-28 13:11:13 -08001151 config.periodic_alr_bandwidth_probing =
1152 video_config_.periodic_alr_bandwidth_probing;
nisse05103312016-03-16 02:22:50 -07001153 WebRtcVideoSendStream* stream = new WebRtcVideoSendStream(
perkj26091b12016-09-01 01:17:40 -07001154 call_, sp, std::move(config), default_send_options_,
1155 external_encoder_factory_, video_config_.enable_cpu_overuse_detection,
nisse05103312016-03-16 02:22:50 -07001156 bitrate_config_.max_bitrate_bps, send_codec_, send_rtp_extensions_,
1157 send_params_);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001158
Peter Boström0c4e06b2015-10-07 12:23:21 +02001159 uint32_t ssrc = sp.first_ssrc();
henrikg91d6ede2015-09-17 00:24:34 -07001160 RTC_DCHECK(ssrc != 0);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001161 send_streams_[ssrc] = stream;
1162
1163 if (rtcp_receiver_report_ssrc_ == kDefaultRtcpReceiverReportSsrc) {
1164 rtcp_receiver_report_ssrc_ = ssrc;
deadbeef874ca3a2015-08-20 17:19:20 -07001165 LOG(LS_INFO) << "SetLocalSsrc on all the receive streams because we added "
1166 "a send stream.";
Peter Boström3548dd22015-05-22 18:48:36 +02001167 for (auto& kv : receive_streams_)
1168 kv.second->SetLocalSsrc(ssrc);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001169 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001170 if (sending_) {
deadbeefdbe2b872016-03-22 15:42:00 -07001171 stream->SetSend(true);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001172 }
1173
1174 return true;
1175}
1176
Peter Boström0c4e06b2015-10-07 12:23:21 +02001177bool WebRtcVideoChannel2::RemoveSendStream(uint32_t ssrc) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001178 LOG(LS_INFO) << "RemoveSendStream: " << ssrc;
1179
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001180 WebRtcVideoSendStream* removed_stream;
1181 {
1182 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001183 std::map<uint32_t, WebRtcVideoSendStream*>::iterator it =
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001184 send_streams_.find(ssrc);
1185 if (it == send_streams_.end()) {
1186 return false;
1187 }
1188
Peter Boström0c4e06b2015-10-07 12:23:21 +02001189 for (uint32_t old_ssrc : it->second->GetSsrcs())
Peter Boströmd6f4c252015-03-26 16:23:04 +01001190 send_ssrcs_.erase(old_ssrc);
1191
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001192 removed_stream = it->second;
1193 send_streams_.erase(it);
Peter Boströmdfa28152015-10-21 17:21:10 +02001194
1195 // Switch receiver report SSRCs, the one in use is no longer valid.
1196 if (rtcp_receiver_report_ssrc_ == ssrc) {
1197 rtcp_receiver_report_ssrc_ = send_streams_.empty()
1198 ? kDefaultRtcpReceiverReportSsrc
1199 : send_streams_.begin()->first;
1200 LOG(LS_INFO) << "SetLocalSsrc on all the receive streams because the "
1201 "previous local SSRC was removed.";
1202
1203 for (auto& kv : receive_streams_) {
1204 kv.second->SetLocalSsrc(rtcp_receiver_report_ssrc_);
1205 }
1206 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001207 }
1208
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001209 delete removed_stream;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001210
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001211 return true;
1212}
1213
Peter Boströmd6f4c252015-03-26 16:23:04 +01001214void WebRtcVideoChannel2::DeleteReceiveStream(
1215 WebRtcVideoChannel2::WebRtcVideoReceiveStream* stream) {
Peter Boström0c4e06b2015-10-07 12:23:21 +02001216 for (uint32_t old_ssrc : stream->GetSsrcs())
Peter Boströmd6f4c252015-03-26 16:23:04 +01001217 receive_ssrcs_.erase(old_ssrc);
1218 delete stream;
1219}
1220
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001221bool WebRtcVideoChannel2::AddRecvStream(const StreamParams& sp) {
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00001222 return AddRecvStream(sp, false);
1223}
1224
1225bool WebRtcVideoChannel2::AddRecvStream(const StreamParams& sp,
1226 bool default_stream) {
henrikg91d6ede2015-09-17 00:24:34 -07001227 RTC_DCHECK(thread_checker_.CalledOnValidThread());
Fredrik Solenberg4b60c732015-05-07 14:07:48 +02001228
Peter Boströmd4362cd2015-03-25 14:17:23 +01001229 LOG(LS_INFO) << "AddRecvStream" << (default_stream ? " (default stream)" : "")
1230 << ": " << sp.ToString();
1231 if (!ValidateStreamParams(sp))
1232 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001233
Peter Boström0c4e06b2015-10-07 12:23:21 +02001234 uint32_t ssrc = sp.first_ssrc();
henrikg91d6ede2015-09-17 00:24:34 -07001235 RTC_DCHECK(ssrc != 0); // TODO(pbos): Is this ever valid?
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001236
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001237 rtc::CritScope stream_lock(&stream_crit_);
Peter Boströmd6f4c252015-03-26 16:23:04 +01001238 // Remove running stream if this was a default stream.
nissea293ef02016-02-17 07:24:50 -08001239 const auto& prev_stream = receive_streams_.find(ssrc);
Peter Boströmd6f4c252015-03-26 16:23:04 +01001240 if (prev_stream != receive_streams_.end()) {
1241 if (default_stream || !prev_stream->second->IsDefaultStream()) {
1242 LOG(LS_ERROR) << "Receive stream for SSRC '" << ssrc
1243 << "' already exists.";
1244 return false;
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00001245 }
Peter Boströmd6f4c252015-03-26 16:23:04 +01001246 DeleteReceiveStream(prev_stream->second);
1247 receive_streams_.erase(prev_stream);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001248 }
1249
Peter Boströmd6f4c252015-03-26 16:23:04 +01001250 if (!ValidateReceiveSsrcAvailability(sp))
1251 return false;
1252
Peter Boström0c4e06b2015-10-07 12:23:21 +02001253 for (uint32_t used_ssrc : sp.ssrcs)
Peter Boströmd6f4c252015-03-26 16:23:04 +01001254 receive_ssrcs_.insert(used_ssrc);
1255
solenberg4fbae2b2015-08-28 04:07:10 -07001256 webrtc::VideoReceiveStream::Config config(this);
brandtr8313a6f2017-01-13 07:41:19 -08001257 webrtc::FlexfecReceiveStream::Config flexfec_config(this);
brandtr468da7c2016-11-22 02:16:47 -08001258 ConfigureReceiverRtp(&config, &flexfec_config, sp);
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +00001259
nisse7ade7b32016-03-23 04:48:10 -07001260 config.disable_prerenderer_smoothing =
1261 video_config_.disable_prerenderer_smoothing;
brandtr11273f12017-01-10 05:18:15 -08001262 config.sync_group = sp.sync_label;
Peter Boström126c03e2015-05-11 12:48:12 +02001263
Peter Boströmd6f4c252015-03-26 16:23:04 +01001264 receive_streams_[ssrc] = new WebRtcVideoReceiveStream(
Tommi733b5472016-06-10 17:58:01 +02001265 call_, sp, std::move(config), external_decoder_factory_, default_stream,
brandtr468da7c2016-11-22 02:16:47 -08001266 recv_codecs_, flexfec_config);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001267
1268 return true;
1269}
1270
1271void WebRtcVideoChannel2::ConfigureReceiverRtp(
1272 webrtc::VideoReceiveStream::Config* config,
brandtr8313a6f2017-01-13 07:41:19 -08001273 webrtc::FlexfecReceiveStream::Config* flexfec_config,
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001274 const StreamParams& sp) const {
Peter Boström0c4e06b2015-10-07 12:23:21 +02001275 uint32_t ssrc = sp.first_ssrc();
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001276
1277 config->rtp.remote_ssrc = ssrc;
1278 config->rtp.local_ssrc = rtcp_receiver_report_ssrc_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001279
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001280 // TODO(pbos): This protection is against setting the same local ssrc as
1281 // remote which is not permitted by the lower-level API. RTCP requires a
1282 // corresponding sender SSRC. Figure out what to do when we don't have
1283 // (receive-only) or know a good local SSRC.
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001284 if (config->rtp.remote_ssrc == config->rtp.local_ssrc) {
1285 if (config->rtp.local_ssrc != kDefaultRtcpReceiverReportSsrc) {
1286 config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001287 } else {
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001288 config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc + 1;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001289 }
1290 }
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001291
brandtr11273f12017-01-10 05:18:15 -08001292 // Whether or not the receive stream sends reduced size RTCP is determined
1293 // by the send params.
1294 // TODO(deadbeef): Once we change "send_params" to "sender_params" and
1295 // "recv_params" to "receiver_params", we should get this out of
1296 // receiver_params_.
1297 config->rtp.rtcp_mode = send_params_.rtcp.reduced_size
1298 ? webrtc::RtcpMode::kReducedSize
1299 : webrtc::RtcpMode::kCompound;
1300
1301 config->rtp.remb = send_codec_ ? HasRemb(send_codec_->codec) : false;
1302 config->rtp.transport_cc =
1303 send_codec_ ? HasTransportCc(send_codec_->codec) : false;
1304
brandtr9d58d942017-02-03 04:43:41 -08001305 sp.GetFidSsrc(ssrc, &config->rtp.rtx_ssrc);
1306
1307 config->rtp.extensions = recv_rtp_extensions_;
1308
brandtr11273f12017-01-10 05:18:15 -08001309 // TODO(brandtr): Generalize when we add support for multistream protection.
brandtr11fb4722017-05-30 01:31:37 -07001310 flexfec_config->payload_type = recv_flexfec_payload_type_;
brandtr31bd2242017-05-19 05:47:46 -07001311 if (IsFlexfecAdvertisedFieldTrialEnabled() &&
1312 sp.GetFecFrSsrc(ssrc, &flexfec_config->remote_ssrc)) {
brandtr11273f12017-01-10 05:18:15 -08001313 flexfec_config->protected_media_ssrcs = {ssrc};
brandtr8313a6f2017-01-13 07:41:19 -08001314 flexfec_config->local_ssrc = config->rtp.local_ssrc;
1315 flexfec_config->rtcp_mode = config->rtp.rtcp_mode;
brandtr9d58d942017-02-03 04:43:41 -08001316 // TODO(brandtr): We should be spec-compliant and set |transport_cc| here
1317 // based on the rtcp-fb for the FlexFEC codec, not the media codec.
brandtr8313a6f2017-01-13 07:41:19 -08001318 flexfec_config->transport_cc = config->rtp.transport_cc;
1319 flexfec_config->rtp_header_extensions = config->rtp.extensions;
brandtr11273f12017-01-10 05:18:15 -08001320 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001321}
1322
Peter Boström0c4e06b2015-10-07 12:23:21 +02001323bool WebRtcVideoChannel2::RemoveRecvStream(uint32_t ssrc) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001324 LOG(LS_INFO) << "RemoveRecvStream: " << ssrc;
1325 if (ssrc == 0) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001326 LOG(LS_ERROR) << "RemoveRecvStream with 0 ssrc is not supported.";
1327 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001328 }
1329
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001330 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001331 std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator stream =
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001332 receive_streams_.find(ssrc);
1333 if (stream == receive_streams_.end()) {
1334 LOG(LS_ERROR) << "Stream not found for ssrc: " << ssrc;
1335 return false;
1336 }
Peter Boströmd6f4c252015-03-26 16:23:04 +01001337 DeleteReceiveStream(stream->second);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001338 receive_streams_.erase(stream);
1339
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001340 return true;
1341}
1342
nisseacd935b2016-11-11 03:55:13 -08001343bool WebRtcVideoChannel2::SetSink(
1344 uint32_t ssrc,
1345 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
deadbeef5a4a75a2016-06-02 16:23:38 -07001346 LOG(LS_INFO) << "SetSink: ssrc:" << ssrc << " "
1347 << (sink ? "(ptr)" : "nullptr");
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001348 if (ssrc == 0) {
brandtr0dc57ea2017-05-29 23:33:31 -07001349 // Do not hold |stream_crit_| here, since SetDefaultSink will call
1350 // WebRtcVideoChannel2::GetDefaultReceiveStreamSsrc().
nisse08582ff2016-02-04 01:24:52 -08001351 default_unsignalled_ssrc_handler_.SetDefaultSink(this, sink);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001352 return true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001353 }
1354
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001355 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001356 std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it =
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001357 receive_streams_.find(ssrc);
1358 if (it == receive_streams_.end()) {
1359 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001360 }
1361
nisse08582ff2016-02-04 01:24:52 -08001362 it->second->SetSink(sink);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001363 return true;
1364}
1365
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00001366bool WebRtcVideoChannel2::GetStats(VideoMediaInfo* info) {
Peter Boströmca8b4042016-03-08 14:24:13 -08001367 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::GetStats");
asapersson2e5cfcd2016-08-11 08:41:18 -07001368
1369 // Log stats periodically.
1370 bool log_stats = false;
1371 int64_t now_ms = rtc::TimeMillis();
1372 if (last_stats_log_ms_ == -1 ||
1373 now_ms - last_stats_log_ms_ > kStatsLogIntervalMs) {
1374 last_stats_log_ms_ = now_ms;
1375 log_stats = true;
1376 }
1377
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001378 info->Clear();
asapersson2e5cfcd2016-08-11 08:41:18 -07001379 FillSenderStats(info, log_stats);
1380 FillReceiverStats(info, log_stats);
hbosa65704b2016-11-14 02:28:16 -08001381 FillSendAndReceiveCodecStats(info);
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00001382 webrtc::Call::Stats stats = call_->GetStats();
charujaind72098a2017-06-01 08:54:47 -07001383 FillBandwidthEstimationStats(stats, info);
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00001384 if (stats.rtt_ms != -1) {
1385 for (size_t i = 0; i < info->senders.size(); ++i) {
1386 info->senders[i].rtt_ms = stats.rtt_ms;
1387 }
1388 }
asapersson2e5cfcd2016-08-11 08:41:18 -07001389
1390 if (log_stats)
1391 LOG(LS_INFO) << stats.ToString(now_ms);
1392
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001393 return true;
1394}
1395
asapersson2e5cfcd2016-08-11 08:41:18 -07001396void WebRtcVideoChannel2::FillSenderStats(VideoMediaInfo* video_media_info,
1397 bool log_stats) {
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001398 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001399 for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator it =
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001400 send_streams_.begin();
Peter Boström0c4e06b2015-10-07 12:23:21 +02001401 it != send_streams_.end(); ++it) {
asapersson2e5cfcd2016-08-11 08:41:18 -07001402 video_media_info->senders.push_back(
1403 it->second->GetVideoSenderInfo(log_stats));
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001404 }
1405}
1406
asapersson2e5cfcd2016-08-11 08:41:18 -07001407void WebRtcVideoChannel2::FillReceiverStats(VideoMediaInfo* video_media_info,
1408 bool log_stats) {
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001409 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001410 for (std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it =
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001411 receive_streams_.begin();
Peter Boström0c4e06b2015-10-07 12:23:21 +02001412 it != receive_streams_.end(); ++it) {
asapersson2e5cfcd2016-08-11 08:41:18 -07001413 video_media_info->receivers.push_back(
1414 it->second->GetVideoReceiverInfo(log_stats));
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001415 }
1416}
1417
charujaind72098a2017-06-01 08:54:47 -07001418void WebRtcVideoChannel2::FillBandwidthEstimationStats(
1419 const webrtc::Call::Stats& stats,
1420 VideoMediaInfo* video_media_info) {
1421 BandwidthEstimationInfo bwe_info;
1422 bwe_info.available_send_bandwidth = stats.send_bandwidth_bps;
1423 bwe_info.available_recv_bandwidth = stats.recv_bandwidth_bps;
1424 bwe_info.bucket_delay = stats.pacer_delay_ms;
1425
1426 // Get send stream bitrate stats.
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001427 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001428 for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator stream =
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001429 send_streams_.begin();
Peter Boström0c4e06b2015-10-07 12:23:21 +02001430 stream != send_streams_.end(); ++stream) {
charujaind72098a2017-06-01 08:54:47 -07001431 stream->second->FillBandwidthEstimationInfo(&bwe_info);
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001432 }
charujaind72098a2017-06-01 08:54:47 -07001433 video_media_info->bw_estimations.push_back(bwe_info);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001434}
1435
hbosa65704b2016-11-14 02:28:16 -08001436void WebRtcVideoChannel2::FillSendAndReceiveCodecStats(
1437 VideoMediaInfo* video_media_info) {
1438 for (const VideoCodec& codec : send_params_.codecs) {
1439 webrtc::RtpCodecParameters codec_params = codec.ToCodecParameters();
1440 video_media_info->send_codecs.insert(
1441 std::make_pair(codec_params.payload_type, std::move(codec_params)));
1442 }
1443 for (const VideoCodec& codec : recv_params_.codecs) {
1444 webrtc::RtpCodecParameters codec_params = codec.ToCodecParameters();
1445 video_media_info->receive_codecs.insert(
1446 std::make_pair(codec_params.payload_type, std::move(codec_params)));
1447 }
1448}
1449
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001450void WebRtcVideoChannel2::OnPacketReceived(
jbaucheec21bd2016-03-20 06:15:43 -07001451 rtc::CopyOnWriteBuffer* packet,
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001452 const rtc::PacketTime& packet_time) {
stefan68786d22015-09-08 05:36:15 -07001453 const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp,
1454 packet_time.not_before);
pbos@webrtc.org4e545cc2014-05-14 13:58:13 +00001455 const webrtc::PacketReceiver::DeliveryStatus delivery_result =
stefan68786d22015-09-08 05:36:15 -07001456 call_->Receiver()->DeliverPacket(
1457 webrtc::MediaType::VIDEO,
jbaucheec21bd2016-03-20 06:15:43 -07001458 packet->cdata(), packet->size(),
stefan68786d22015-09-08 05:36:15 -07001459 webrtc_packet_time);
pbos@webrtc.org4e545cc2014-05-14 13:58:13 +00001460 switch (delivery_result) {
1461 case webrtc::PacketReceiver::DELIVERY_OK:
1462 return;
1463 case webrtc::PacketReceiver::DELIVERY_PACKET_ERROR:
1464 return;
1465 case webrtc::PacketReceiver::DELIVERY_UNKNOWN_SSRC:
1466 break;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001467 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001468
Peter Boström0c4e06b2015-10-07 12:23:21 +02001469 uint32_t ssrc = 0;
jbaucheec21bd2016-03-20 06:15:43 -07001470 if (!GetRtpSsrc(packet->cdata(), packet->size(), &ssrc)) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001471 return;
1472 }
1473
noahricd10a68e2015-07-10 11:27:55 -07001474 int payload_type = 0;
jbaucheec21bd2016-03-20 06:15:43 -07001475 if (!GetRtpPayloadType(packet->cdata(), packet->size(), &payload_type)) {
noahricd10a68e2015-07-10 11:27:55 -07001476 return;
1477 }
1478
1479 // See if this payload_type is registered as one that usually gets its own
brandtr468da7c2016-11-22 02:16:47 -08001480 // SSRC (RTX) or at least is safe to drop either way (FEC). If it is, and
noahricd10a68e2015-07-10 11:27:55 -07001481 // it wasn't handled above by DeliverPacket, that means we don't know what
1482 // stream it associates with, and we shouldn't ever create an implicit channel
1483 // for these.
1484 for (auto& codec : recv_codecs_) {
1485 if (payload_type == codec.rtx_payload_type ||
brandtrb5f2c3f2016-10-04 23:28:39 -07001486 payload_type == codec.ulpfec.red_rtx_payload_type ||
brandtr11fb4722017-05-30 01:31:37 -07001487 payload_type == codec.ulpfec.ulpfec_payload_type) {
noahricd10a68e2015-07-10 11:27:55 -07001488 return;
1489 }
1490 }
brandtr11fb4722017-05-30 01:31:37 -07001491 if (payload_type == recv_flexfec_payload_type_) {
1492 return;
1493 }
noahricd10a68e2015-07-10 11:27:55 -07001494
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001495 switch (unsignalled_ssrc_handler_->OnUnsignalledSsrc(this, ssrc)) {
1496 case UnsignalledSsrcHandler::kDropPacket:
1497 return;
1498 case UnsignalledSsrcHandler::kDeliverPacket:
1499 break;
1500 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001501
stefan68786d22015-09-08 05:36:15 -07001502 if (call_->Receiver()->DeliverPacket(
1503 webrtc::MediaType::VIDEO,
jbaucheec21bd2016-03-20 06:15:43 -07001504 packet->cdata(), packet->size(),
stefan68786d22015-09-08 05:36:15 -07001505 webrtc_packet_time) != webrtc::PacketReceiver::DELIVERY_OK) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001506 LOG(LS_WARNING) << "Failed to deliver RTP packet on re-delivery.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001507 return;
1508 }
1509}
1510
1511void WebRtcVideoChannel2::OnRtcpReceived(
jbaucheec21bd2016-03-20 06:15:43 -07001512 rtc::CopyOnWriteBuffer* packet,
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001513 const rtc::PacketTime& packet_time) {
stefan68786d22015-09-08 05:36:15 -07001514 const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp,
1515 packet_time.not_before);
Peter Boström2aff6152015-11-18 13:47:16 +01001516 // TODO(pbos): Check webrtc::PacketReceiver::DELIVERY_OK once we deliver
1517 // for both audio and video on the same path. Since BundleFilter doesn't
1518 // filter RTCP anymore incoming RTCP packets could've been going to audio (so
1519 // logging failures spam the log).
1520 call_->Receiver()->DeliverPacket(
1521 webrtc::MediaType::VIDEO,
jbaucheec21bd2016-03-20 06:15:43 -07001522 packet->cdata(), packet->size(),
Peter Boström2aff6152015-11-18 13:47:16 +01001523 webrtc_packet_time);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001524}
1525
1526void WebRtcVideoChannel2::OnReadyToSend(bool ready) {
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00001527 LOG(LS_VERBOSE) << "OnReadyToSend: " << (ready ? "Ready." : "Not ready.");
skvlad7a43d252016-03-22 15:32:27 -07001528 call_->SignalChannelNetworkState(
1529 webrtc::MediaType::VIDEO,
1530 ready ? webrtc::kNetworkUp : webrtc::kNetworkDown);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001531}
1532
Honghai Zhangcc411c02016-03-29 17:27:21 -07001533void WebRtcVideoChannel2::OnNetworkRouteChanged(
1534 const std::string& transport_name,
Honghai Zhang0e533ef2016-04-19 15:41:36 -07001535 const rtc::NetworkRoute& network_route) {
1536 call_->OnNetworkRouteChanged(transport_name, network_route);
Honghai Zhangcc411c02016-03-29 17:27:21 -07001537}
1538
michaelt79e05882016-11-08 02:50:09 -08001539void WebRtcVideoChannel2::OnTransportOverheadChanged(
1540 int transport_overhead_per_packet) {
1541 call_->OnTransportOverheadChanged(webrtc::MediaType::VIDEO,
1542 transport_overhead_per_packet);
1543}
1544
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001545void WebRtcVideoChannel2::SetInterface(NetworkInterface* iface) {
1546 MediaChannel::SetInterface(iface);
1547 // Set the RTP recv/send buffer to a bigger size
1548 MediaChannel::SetOption(NetworkInterface::ST_RTP,
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001549 rtc::Socket::OPT_RCVBUF,
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001550 kVideoRtpBufferSize);
1551
buildbot@webrtc.orgae694ef2014-10-28 17:37:17 +00001552 // Speculative change to increase the outbound socket buffer size.
1553 // In b/15152257, we are seeing a significant number of packets discarded
1554 // due to lack of socket buffer space, although it's not yet clear what the
1555 // ideal value should be.
1556 MediaChannel::SetOption(NetworkInterface::ST_RTP,
1557 rtc::Socket::OPT_SNDBUF,
1558 kVideoRtpBufferSize);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001559}
1560
brandtr0dc57ea2017-05-29 23:33:31 -07001561rtc::Optional<uint32_t> WebRtcVideoChannel2::GetDefaultReceiveStreamSsrc() {
1562 rtc::CritScope stream_lock(&stream_crit_);
1563 rtc::Optional<uint32_t> ssrc;
1564 for (auto it = receive_streams_.begin(); it != receive_streams_.end(); ++it) {
1565 if (it->second->IsDefaultStream()) {
1566 ssrc.emplace(it->first);
1567 break;
1568 }
1569 }
1570 return ssrc;
1571}
1572
stefan1d8a5062015-10-02 03:39:33 -07001573bool WebRtcVideoChannel2::SendRtp(const uint8_t* data,
1574 size_t len,
1575 const webrtc::PacketOptions& options) {
jbaucheec21bd2016-03-20 06:15:43 -07001576 rtc::CopyOnWriteBuffer packet(data, len, kMaxRtpPacketLen);
stefanc1aeaf02015-10-15 07:26:07 -07001577 rtc::PacketOptions rtc_options;
1578 rtc_options.packet_id = options.packet_id;
1579 return MediaChannel::SendPacket(&packet, rtc_options);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001580}
1581
1582bool WebRtcVideoChannel2::SendRtcp(const uint8_t* data, size_t len) {
jbaucheec21bd2016-03-20 06:15:43 -07001583 rtc::CopyOnWriteBuffer packet(data, len, kMaxRtpPacketLen);
stefanc1aeaf02015-10-15 07:26:07 -07001584 return MediaChannel::SendRtcp(&packet, rtc::PacketOptions());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001585}
1586
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001587WebRtcVideoChannel2::WebRtcVideoSendStream::VideoSendStreamParameters::
1588 VideoSendStreamParameters(
perkj26091b12016-09-01 01:17:40 -07001589 webrtc::VideoSendStream::Config config,
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001590 const VideoOptions& options,
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001591 int max_bitrate_bps,
Karl Wibergbe579832015-11-10 22:34:18 +01001592 const rtc::Optional<VideoCodecSettings>& codec_settings)
perkj26091b12016-09-01 01:17:40 -07001593 : config(std::move(config)),
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001594 options(options),
1595 max_bitrate_bps(max_bitrate_bps),
perkjfa10b552016-10-02 23:45:26 -07001596 conference_mode(false),
kwiberg102c6a62015-10-30 02:47:38 -07001597 codec_settings(codec_settings) {}
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001598
Peter Boström4d71ede2015-05-19 23:09:35 +02001599WebRtcVideoChannel2::WebRtcVideoSendStream::AllocatedEncoder::AllocatedEncoder(
1600 webrtc::VideoEncoder* encoder,
magjed509e4fe2016-11-18 01:34:11 -08001601 const cricket::VideoCodec& codec,
Peter Boström4d71ede2015-05-19 23:09:35 +02001602 bool external)
1603 : encoder(encoder),
1604 external_encoder(nullptr),
magjed509e4fe2016-11-18 01:34:11 -08001605 codec(codec),
Peter Boström4d71ede2015-05-19 23:09:35 +02001606 external(external) {
1607 if (external) {
1608 external_encoder = encoder;
1609 this->encoder =
magjed509e4fe2016-11-18 01:34:11 -08001610 new webrtc::VideoEncoderSoftwareFallbackWrapper(codec, encoder);
Peter Boström4d71ede2015-05-19 23:09:35 +02001611 }
1612}
1613
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001614WebRtcVideoChannel2::WebRtcVideoSendStream::WebRtcVideoSendStream(
1615 webrtc::Call* call,
solenberg4fbae2b2015-08-28 04:07:10 -07001616 const StreamParams& sp,
perkj26091b12016-09-01 01:17:40 -07001617 webrtc::VideoSendStream::Config config,
nisse05103312016-03-16 02:22:50 -07001618 const VideoOptions& options,
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001619 WebRtcVideoEncoderFactory* external_encoder_factory,
perkj2d5f0912016-02-29 00:04:41 -08001620 bool enable_cpu_overuse_detection,
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001621 int max_bitrate_bps,
Karl Wibergbe579832015-11-10 22:34:18 +01001622 const rtc::Optional<VideoCodecSettings>& codec_settings,
skvlad3abb7642016-06-16 12:08:03 -07001623 const rtc::Optional<std::vector<webrtc::RtpExtension>>& rtp_extensions,
deadbeef13871492015-12-09 12:37:51 -08001624 // TODO(deadbeef): Don't duplicate information between send_params,
1625 // rtp_extensions, options, etc.
1626 const VideoSendParameters& send_params)
perkj2d5f0912016-02-29 00:04:41 -08001627 : worker_thread_(rtc::Thread::Current()),
1628 ssrcs_(sp.ssrcs),
Peter Boström259bd202015-05-28 13:39:50 +02001629 ssrc_groups_(sp.ssrc_groups),
Henrik Kjellander7c027b62015-04-22 13:21:30 +02001630 call_(call),
perkj803d97f2016-11-01 11:45:46 -07001631 enable_cpu_overuse_detection_(enable_cpu_overuse_detection),
nisse2ded9b12016-04-08 02:23:55 -07001632 source_(nullptr),
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001633 external_encoder_factory_(external_encoder_factory),
sprang429600d2017-01-26 06:12:26 -08001634 internal_encoder_factory_(new InternalEncoderFactory()),
perkj2d5f0912016-02-29 00:04:41 -08001635 stream_(nullptr),
perkja49cbd32016-09-16 07:53:41 -07001636 encoder_sink_(nullptr),
perkj26091b12016-09-01 01:17:40 -07001637 parameters_(std::move(config), options, max_bitrate_bps, codec_settings),
skvladdc1c62c2016-03-16 19:07:43 -07001638 rtp_parameters_(CreateRtpParametersWithOneEncoding()),
magjed509e4fe2016-11-18 01:34:11 -08001639 allocated_encoder_(nullptr, cricket::VideoCodec(), false),
perkjd533aec2017-01-13 05:57:25 -08001640 sending_(false) {
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001641 parameters_.config.rtp.max_packet_size = kVideoMtu;
nisse4b4dc862016-02-17 05:25:36 -08001642 parameters_.conference_mode = send_params.conference_mode;
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001643
1644 sp.GetPrimarySsrcs(&parameters_.config.rtp.ssrcs);
brandtr468da7c2016-11-22 02:16:47 -08001645
deadbeeffb2aced2017-01-06 23:05:37 -08001646 // ValidateStreamParams should prevent this from happening.
1647 RTC_CHECK(!parameters_.config.rtp.ssrcs.empty());
1648 rtp_parameters_.encodings[0].ssrc =
1649 rtc::Optional<uint32_t>(parameters_.config.rtp.ssrcs[0]);
1650
brandtr468da7c2016-11-22 02:16:47 -08001651 // RTX.
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001652 sp.GetFidSsrcs(parameters_.config.rtp.ssrcs,
1653 &parameters_.config.rtp.rtx.ssrcs);
brandtr468da7c2016-11-22 02:16:47 -08001654
brandtr340e3fd2017-02-28 15:43:10 -08001655 // FlexFEC SSRCs.
brandtr468da7c2016-11-22 02:16:47 -08001656 // TODO(brandtr): This code needs to be generalized when we add support for
1657 // multistream protection.
1658 if (IsFlexfecFieldTrialEnabled()) {
1659 uint32_t flexfec_ssrc;
1660 bool flexfec_enabled = false;
1661 for (uint32_t primary_ssrc : parameters_.config.rtp.ssrcs) {
1662 if (sp.GetFecFrSsrc(primary_ssrc, &flexfec_ssrc)) {
1663 if (flexfec_enabled) {
brandtr31bd2242017-05-19 05:47:46 -07001664 LOG(LS_INFO) << "Multiple FlexFEC streams in local SDP, but "
brandtr468da7c2016-11-22 02:16:47 -08001665 "our implementation only supports a single FlexFEC "
1666 "stream. Will not enable FlexFEC for proposed "
1667 "stream with SSRC: "
1668 << flexfec_ssrc << ".";
1669 continue;
1670 }
1671
1672 flexfec_enabled = true;
brandtr3d200bd2017-01-16 06:59:19 -08001673 parameters_.config.rtp.flexfec.ssrc = flexfec_ssrc;
brandtr468da7c2016-11-22 02:16:47 -08001674 parameters_.config.rtp.flexfec.protected_media_ssrcs = {primary_ssrc};
1675 }
1676 }
1677 }
1678
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001679 parameters_.config.rtp.c_name = sp.cname;
skvlad3abb7642016-06-16 12:08:03 -07001680 if (rtp_extensions) {
1681 parameters_.config.rtp.extensions = *rtp_extensions;
1682 }
deadbeef13871492015-12-09 12:37:51 -08001683 parameters_.config.rtp.rtcp_mode = send_params.rtcp.reduced_size
1684 ? webrtc::RtcpMode::kReducedSize
1685 : webrtc::RtcpMode::kCompound;
kwiberg102c6a62015-10-30 02:47:38 -07001686 if (codec_settings) {
sprangf24a0642017-02-28 13:23:26 -08001687 bool force_encoder_allocation = false;
1688 SetCodec(*codec_settings, force_encoder_allocation);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001689 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001690}
1691
1692WebRtcVideoChannel2::WebRtcVideoSendStream::~WebRtcVideoSendStream() {
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001693 if (stream_ != NULL) {
1694 call_->DestroyVideoSendStream(stream_);
1695 }
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001696 DestroyVideoEncoder(&allocated_encoder_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001697}
1698
deadbeef5a4a75a2016-06-02 16:23:38 -07001699bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetVideoSend(
1700 bool enable,
1701 const VideoOptions* options,
nisseacd935b2016-11-11 03:55:13 -08001702 rtc::VideoSourceInterface<webrtc::VideoFrame>* source) {
deadbeef5a4a75a2016-06-02 16:23:38 -07001703 TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::SetVideoSend");
perkjfa10b552016-10-02 23:45:26 -07001704 RTC_DCHECK_RUN_ON(&thread_checker_);
nisse2ded9b12016-04-08 02:23:55 -07001705
deadbeef5a4a75a2016-06-02 16:23:38 -07001706 // Ignore |options| pointer if |enable| is false.
1707 bool options_present = enable && options;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001708
perkjfa10b552016-10-02 23:45:26 -07001709 if (options_present) {
1710 VideoOptions old_options = parameters_.options;
1711 parameters_.options.SetAll(*options);
sprangf24a0642017-02-28 13:23:26 -08001712 if (parameters_.options.is_screencast.value_or(false) !=
1713 old_options.is_screencast.value_or(false) &&
1714 parameters_.codec_settings) {
1715 // If screen content settings change, we may need to recreate the codec
1716 // instance so that the correct type is used.
1717
1718 bool force_encoder_allocation = true;
1719 SetCodec(*parameters_.codec_settings, force_encoder_allocation);
1720 // Mark screenshare parameter as being updated, then test for any other
1721 // changes that may require codec reconfiguration.
1722 old_options.is_screencast = options->is_screencast;
1723 }
perkjfa10b552016-10-02 23:45:26 -07001724 if (parameters_.options != old_options) {
1725 ReconfigureEncoder();
perkj3b703ed2016-09-29 23:25:40 -07001726 }
perkj26105b42016-09-29 22:39:10 -07001727 }
1728
perkj803d97f2016-11-01 11:45:46 -07001729 if (source_ && stream_) {
sprangc5d62e22017-04-02 23:53:04 -07001730 stream_->SetSource(nullptr, DegradationPreference::kDegradationDisabled);
perkj803d97f2016-11-01 11:45:46 -07001731 }
1732 // Switch to the new source.
1733 source_ = source;
1734 if (source && stream_) {
sprangc5d62e22017-04-02 23:53:04 -07001735 stream_->SetSource(this, GetDegradationPreference());
nisse2ded9b12016-04-08 02:23:55 -07001736 }
deadbeef5a4a75a2016-06-02 16:23:38 -07001737 return true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001738}
1739
sprangc5d62e22017-04-02 23:53:04 -07001740webrtc::VideoSendStream::DegradationPreference
1741WebRtcVideoChannel2::WebRtcVideoSendStream::GetDegradationPreference() const {
1742 // Do not adapt resolution for screen content as this will likely
1743 // result in blurry and unreadable text.
1744 // |this| acts like a VideoSource to make sure SinkWants are handled on the
1745 // correct thread.
1746 DegradationPreference degradation_preference;
1747 if (!enable_cpu_overuse_detection_) {
1748 degradation_preference = DegradationPreference::kDegradationDisabled;
1749 } else {
1750 if (parameters_.options.is_screencast.value_or(false)) {
1751 degradation_preference = DegradationPreference::kMaintainResolution;
1752 } else {
1753 degradation_preference = DegradationPreference::kMaintainFramerate;
1754 }
1755 }
1756 return degradation_preference;
1757}
1758
Peter Boström0c4e06b2015-10-07 12:23:21 +02001759const std::vector<uint32_t>&
Peter Boströmd6f4c252015-03-26 16:23:04 +01001760WebRtcVideoChannel2::WebRtcVideoSendStream::GetSsrcs() const {
1761 return ssrcs_;
1762}
1763
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001764WebRtcVideoChannel2::WebRtcVideoSendStream::AllocatedEncoder
1765WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoder(
sprangf24a0642017-02-28 13:23:26 -08001766 const VideoCodec& codec,
1767 bool force_encoder_allocation) {
perkjfa10b552016-10-02 23:45:26 -07001768 RTC_DCHECK_RUN_ON(&thread_checker_);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001769 // Do not re-create encoders of the same type.
sprangf24a0642017-02-28 13:23:26 -08001770 if (!force_encoder_allocation && codec == allocated_encoder_.codec &&
magjed509e4fe2016-11-18 01:34:11 -08001771 allocated_encoder_.encoder != nullptr) {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001772 return allocated_encoder_;
1773 }
1774
magjed509e4fe2016-11-18 01:34:11 -08001775 // Try creating external encoder.
1776 if (external_encoder_factory_ != nullptr &&
1777 FindMatchingCodec(external_encoder_factory_->supported_codecs(), codec)) {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001778 webrtc::VideoEncoder* encoder =
magjed1e45cc62016-10-28 07:43:45 -07001779 external_encoder_factory_->CreateVideoEncoder(codec);
magjed509e4fe2016-11-18 01:34:11 -08001780 if (encoder != nullptr)
1781 return AllocatedEncoder(encoder, codec, true /* is_external */);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001782 }
1783
magjed509e4fe2016-11-18 01:34:11 -08001784 // Try creating internal encoder.
sprang429600d2017-01-26 06:12:26 -08001785 if (FindMatchingCodec(internal_encoder_factory_->supported_codecs(), codec)) {
1786 if (parameters_.encoder_config.content_type ==
1787 webrtc::VideoEncoderConfig::ContentType::kScreen &&
1788 parameters_.conference_mode && UseSimulcastScreenshare()) {
1789 // TODO(sprang): Remove this adapter once libvpx supports simulcast with
1790 // same-resolution substreams.
1791 WebRtcSimulcastEncoderFactory adapter_factory(
1792 internal_encoder_factory_.get());
1793 return AllocatedEncoder(adapter_factory.CreateVideoEncoder(codec), codec,
1794 false /* is_external */);
1795 }
1796 return AllocatedEncoder(
1797 internal_encoder_factory_->CreateVideoEncoder(codec), codec,
1798 false /* is_external */);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001799 }
1800
1801 // This shouldn't happen, we should not be trying to create something we don't
1802 // support.
nisseeb4ca4e2017-01-12 02:24:27 -08001803 RTC_NOTREACHED();
magjed509e4fe2016-11-18 01:34:11 -08001804 return AllocatedEncoder(NULL, cricket::VideoCodec(), false);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001805}
1806
1807void WebRtcVideoChannel2::WebRtcVideoSendStream::DestroyVideoEncoder(
1808 AllocatedEncoder* encoder) {
perkjfa10b552016-10-02 23:45:26 -07001809 RTC_DCHECK_RUN_ON(&thread_checker_);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001810 if (encoder->external) {
Peter Boström4d71ede2015-05-19 23:09:35 +02001811 external_encoder_factory_->DestroyVideoEncoder(encoder->external_encoder);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001812 }
Peter Boström4d71ede2015-05-19 23:09:35 +02001813 delete encoder->encoder;
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001814}
1815
nisse0db023a2016-03-01 04:29:59 -08001816void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodec(
sprangf24a0642017-02-28 13:23:26 -08001817 const VideoCodecSettings& codec_settings,
1818 bool force_encoder_allocation) {
perkjfa10b552016-10-02 23:45:26 -07001819 RTC_DCHECK_RUN_ON(&thread_checker_);
skvlad3abb7642016-06-16 12:08:03 -07001820 parameters_.encoder_config = CreateVideoEncoderConfig(codec_settings.codec);
kwibergaf476c72016-11-28 15:21:39 -08001821 RTC_DCHECK_GT(parameters_.encoder_config.number_of_streams, 0);
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001822
sprangf24a0642017-02-28 13:23:26 -08001823 AllocatedEncoder new_encoder =
1824 CreateVideoEncoder(codec_settings.codec, force_encoder_allocation);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001825 parameters_.config.encoder_settings.encoder = new_encoder.encoder;
Peter Boströme4499152016-02-05 11:13:28 +01001826 parameters_.config.encoder_settings.full_overuse_time = new_encoder.external;
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001827 parameters_.config.encoder_settings.payload_name = codec_settings.codec.name;
1828 parameters_.config.encoder_settings.payload_type = codec_settings.codec.id;
sophiechang47d78cc2015-09-03 18:24:44 -07001829 if (new_encoder.external) {
magjed10165ab2016-11-22 10:16:57 -08001830 webrtc::VideoCodecType type =
1831 webrtc::PayloadNameToCodecType(codec_settings.codec.name)
1832 .value_or(webrtc::kVideoCodecUnknown);
sophiechang47d78cc2015-09-03 18:24:44 -07001833 parameters_.config.encoder_settings.internal_source =
1834 external_encoder_factory_->EncoderTypeHasInternalSource(type);
noahric5d3b28b2017-01-09 10:06:28 -08001835 } else {
1836 parameters_.config.encoder_settings.internal_source = false;
sophiechang47d78cc2015-09-03 18:24:44 -07001837 }
brandtrb5f2c3f2016-10-04 23:28:39 -07001838 parameters_.config.rtp.ulpfec = codec_settings.ulpfec;
brandtr31bd2242017-05-19 05:47:46 -07001839 parameters_.config.rtp.flexfec.payload_type =
1840 codec_settings.flexfec_payload_type;
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001841
1842 // Set RTX payload type if RTX is enabled.
1843 if (!parameters_.config.rtp.rtx.ssrcs.empty()) {
pbos@webrtc.orgb9557a92015-03-20 19:52:56 +00001844 if (codec_settings.rtx_payload_type == -1) {
1845 LOG(LS_WARNING) << "RTX SSRCs configured but there's no configured RTX "
1846 "payload type. Ignoring.";
1847 parameters_.config.rtp.rtx.ssrcs.clear();
1848 } else {
1849 parameters_.config.rtp.rtx.payload_type = codec_settings.rtx_payload_type;
1850 }
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001851 }
1852
Peter Boström67c9df72015-05-11 14:34:58 +02001853 parameters_.config.rtp.nack.rtp_history_ms =
1854 HasNack(codec_settings.codec) ? kNackHistoryMs : 0;
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001855
kwiberg102c6a62015-10-30 02:47:38 -07001856 parameters_.codec_settings =
Karl Wibergbe579832015-11-10 22:34:18 +01001857 rtc::Optional<WebRtcVideoChannel2::VideoCodecSettings>(codec_settings);
Niels Möller60653ba2016-03-02 11:41:36 +01001858
1859 LOG(LS_INFO) << "RecreateWebRtcStream (send) because of SetCodec.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001860 RecreateWebRtcStream();
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001861 if (allocated_encoder_.encoder != new_encoder.encoder) {
1862 DestroyVideoEncoder(&allocated_encoder_);
1863 allocated_encoder_ = new_encoder;
1864 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001865}
1866
deadbeef13871492015-12-09 12:37:51 -08001867void WebRtcVideoChannel2::WebRtcVideoSendStream::SetSendParameters(
Peter Boström3afc8c42016-01-27 16:45:21 +01001868 const ChangedSendParameters& params) {
perkjfa10b552016-10-02 23:45:26 -07001869 RTC_DCHECK_RUN_ON(&thread_checker_);
1870 // |recreate_stream| means construction-time parameters have changed and the
1871 // sending stream needs to be reset with the new config.
1872 bool recreate_stream = false;
1873 if (params.rtcp_mode) {
1874 parameters_.config.rtp.rtcp_mode = *params.rtcp_mode;
1875 recreate_stream = true;
1876 }
1877 if (params.rtp_header_extensions) {
1878 parameters_.config.rtp.extensions = *params.rtp_header_extensions;
1879 recreate_stream = true;
1880 }
1881 if (params.max_bandwidth_bps) {
1882 parameters_.max_bitrate_bps = *params.max_bandwidth_bps;
1883 ReconfigureEncoder();
1884 }
1885 if (params.conference_mode) {
1886 parameters_.conference_mode = *params.conference_mode;
1887 }
perkjf0dcfe22016-03-10 18:32:00 +01001888
perkjfa10b552016-10-02 23:45:26 -07001889 // Set codecs and options.
1890 if (params.codec) {
sprangf24a0642017-02-28 13:23:26 -08001891 bool force_encoder_allocation = false;
1892 SetCodec(*params.codec, force_encoder_allocation);
perkjfa10b552016-10-02 23:45:26 -07001893 recreate_stream = false; // SetCodec has already recreated the stream.
1894 } else if (params.conference_mode && parameters_.codec_settings) {
sprangf24a0642017-02-28 13:23:26 -08001895 bool force_encoder_allocation = false;
1896 SetCodec(*parameters_.codec_settings, force_encoder_allocation);
perkjfa10b552016-10-02 23:45:26 -07001897 recreate_stream = false; // SetCodec has already recreated the stream.
1898 }
1899 if (recreate_stream) {
1900 LOG(LS_INFO) << "RecreateWebRtcStream (send) because of SetSendParameters";
1901 RecreateWebRtcStream();
1902 }
deadbeef13871492015-12-09 12:37:51 -08001903}
1904
skvladdc1c62c2016-03-16 19:07:43 -07001905bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetRtpParameters(
1906 const webrtc::RtpParameters& new_parameters) {
perkjfa10b552016-10-02 23:45:26 -07001907 RTC_DCHECK_RUN_ON(&thread_checker_);
skvladdc1c62c2016-03-16 19:07:43 -07001908 if (!ValidateRtpParameters(new_parameters)) {
1909 return false;
1910 }
1911
perkjfa10b552016-10-02 23:45:26 -07001912 bool reconfigure_encoder = new_parameters.encodings[0].max_bitrate_bps !=
1913 rtp_parameters_.encodings[0].max_bitrate_bps;
skvladdc1c62c2016-03-16 19:07:43 -07001914 rtp_parameters_ = new_parameters;
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07001915 // Codecs are currently handled at the WebRtcVideoChannel2 level.
1916 rtp_parameters_.codecs.clear();
perkjfa10b552016-10-02 23:45:26 -07001917 if (reconfigure_encoder) {
1918 ReconfigureEncoder();
1919 }
deadbeefdbe2b872016-03-22 15:42:00 -07001920 // Encoding may have been activated/deactivated.
1921 UpdateSendState();
skvladdc1c62c2016-03-16 19:07:43 -07001922 return true;
1923}
1924
deadbeefdbe2b872016-03-22 15:42:00 -07001925webrtc::RtpParameters
1926WebRtcVideoChannel2::WebRtcVideoSendStream::GetRtpParameters() const {
perkjfa10b552016-10-02 23:45:26 -07001927 RTC_DCHECK_RUN_ON(&thread_checker_);
deadbeefdbe2b872016-03-22 15:42:00 -07001928 return rtp_parameters_;
1929}
1930
skvladdc1c62c2016-03-16 19:07:43 -07001931bool WebRtcVideoChannel2::WebRtcVideoSendStream::ValidateRtpParameters(
1932 const webrtc::RtpParameters& rtp_parameters) {
deadbeeffb2aced2017-01-06 23:05:37 -08001933 RTC_DCHECK_RUN_ON(&thread_checker_);
skvladdc1c62c2016-03-16 19:07:43 -07001934 if (rtp_parameters.encodings.size() != 1) {
1935 LOG(LS_ERROR)
1936 << "Attempted to set RtpParameters without exactly one encoding";
1937 return false;
1938 }
deadbeeffb2aced2017-01-06 23:05:37 -08001939 if (rtp_parameters.encodings[0].ssrc != rtp_parameters_.encodings[0].ssrc) {
1940 LOG(LS_ERROR) << "Attempted to set RtpParameters with modified SSRC";
1941 return false;
1942 }
skvladdc1c62c2016-03-16 19:07:43 -07001943 return true;
1944}
1945
deadbeefdbe2b872016-03-22 15:42:00 -07001946void WebRtcVideoChannel2::WebRtcVideoSendStream::UpdateSendState() {
perkjfa10b552016-10-02 23:45:26 -07001947 RTC_DCHECK_RUN_ON(&thread_checker_);
deadbeefdbe2b872016-03-22 15:42:00 -07001948 // TODO(deadbeef): Need to handle more than one encoding in the future.
1949 RTC_DCHECK(rtp_parameters_.encodings.size() == 1u);
1950 if (sending_ && rtp_parameters_.encodings[0].active) {
1951 RTC_DCHECK(stream_ != nullptr);
1952 stream_->Start();
1953 } else {
1954 if (stream_ != nullptr) {
1955 stream_->Stop();
1956 }
1957 }
1958}
1959
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001960webrtc::VideoEncoderConfig
1961WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoderConfig(
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001962 const VideoCodec& codec) const {
perkjfa10b552016-10-02 23:45:26 -07001963 RTC_DCHECK_RUN_ON(&thread_checker_);
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001964 webrtc::VideoEncoderConfig encoder_config;
Niels Möller60653ba2016-03-02 11:41:36 +01001965 bool is_screencast = parameters_.options.is_screencast.value_or(false);
1966 if (is_screencast) {
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001967 encoder_config.min_transmit_bitrate_bps =
nisse51542be2016-02-12 02:27:06 -08001968 1000 * parameters_.options.screencast_min_bitrate_kbps.value_or(0);
Erik Språng143cec12015-04-28 10:01:41 +02001969 encoder_config.content_type =
1970 webrtc::VideoEncoderConfig::ContentType::kScreen;
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001971 } else {
1972 encoder_config.min_transmit_bitrate_bps = 0;
Erik Språng143cec12015-04-28 10:01:41 +02001973 encoder_config.content_type =
1974 webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo;
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001975 }
1976
noahricfdac5162015-08-27 01:59:29 -07001977 // By default, the stream count for the codec configuration should match the
1978 // number of negotiated ssrcs. But if the codec is blacklisted for simulcast
sprang429600d2017-01-26 06:12:26 -08001979 // or a screencast (and not in simulcast screenshare experiment), only
1980 // configure a single stream.
perkjfa10b552016-10-02 23:45:26 -07001981 encoder_config.number_of_streams = parameters_.config.rtp.ssrcs.size();
sprang429600d2017-01-26 06:12:26 -08001982 if (IsCodecBlacklistedForSimulcast(codec.name) ||
sprangfe627f32017-03-29 08:24:59 -07001983 (is_screencast &&
1984 (!UseSimulcastScreenshare() || !parameters_.conference_mode))) {
perkjfa10b552016-10-02 23:45:26 -07001985 encoder_config.number_of_streams = 1;
noahricfdac5162015-08-27 01:59:29 -07001986 }
1987
deadbeefe702b302017-02-04 12:09:01 -08001988 int stream_max_bitrate = parameters_.max_bitrate_bps;
1989 if (rtp_parameters_.encodings[0].max_bitrate_bps) {
1990 stream_max_bitrate =
1991 MinPositive(*(rtp_parameters_.encodings[0].max_bitrate_bps),
1992 parameters_.max_bitrate_bps);
1993 }
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001994
perkjfa10b552016-10-02 23:45:26 -07001995 int codec_max_bitrate_kbps;
1996 if (codec.GetParam(kCodecParamMaxBitrate, &codec_max_bitrate_kbps)) {
1997 stream_max_bitrate = codec_max_bitrate_kbps * 1000;
1998 }
1999 encoder_config.max_bitrate_bps = stream_max_bitrate;
perkj3b703ed2016-09-29 23:25:40 -07002000
perkjfa10b552016-10-02 23:45:26 -07002001 int max_qp = kDefaultQpMax;
2002 codec.GetParam(kCodecParamMaxQuantization, &max_qp);
perkjfa10b552016-10-02 23:45:26 -07002003 encoder_config.video_stream_factory =
2004 new rtc::RefCountedObject<EncoderStreamFactory>(
perkj26752742016-10-24 01:21:16 -07002005 codec.name, max_qp, kDefaultVideoMaxFramerate, is_screencast,
perkjfa10b552016-10-02 23:45:26 -07002006 parameters_.conference_mode);
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002007 return encoder_config;
2008}
2009
skvlad3abb7642016-06-16 12:08:03 -07002010void WebRtcVideoChannel2::WebRtcVideoSendStream::ReconfigureEncoder() {
perkjfa10b552016-10-02 23:45:26 -07002011 RTC_DCHECK_RUN_ON(&thread_checker_);
2012 if (!stream_) {
sprangfe627f32017-03-29 08:24:59 -07002013 // The webrtc::VideoSendStream |stream_| has not yet been created but other
perkjfa10b552016-10-02 23:45:26 -07002014 // parameters has changed.
2015 return;
2016 }
2017
kwibergaf476c72016-11-28 15:21:39 -08002018 RTC_DCHECK_GT(parameters_.encoder_config.number_of_streams, 0);
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002019
kwiberg102c6a62015-10-30 02:47:38 -07002020 RTC_CHECK(parameters_.codec_settings);
2021 VideoCodecSettings codec_settings = *parameters_.codec_settings;
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002022
2023 webrtc::VideoEncoderConfig encoder_config =
skvlad3abb7642016-06-16 12:08:03 -07002024 CreateVideoEncoderConfig(codec_settings.codec);
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002025
Erik Språng143cec12015-04-28 10:01:41 +02002026 encoder_config.encoder_specific_settings = ConfigureVideoEncoderSettings(
Niels Möller60653ba2016-03-02 11:41:36 +01002027 codec_settings.codec);
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00002028
perkj26091b12016-09-01 01:17:40 -07002029 stream_->ReconfigureVideoEncoder(encoder_config.Copy());
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00002030
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00002031 encoder_config.encoder_specific_settings = NULL;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002032
perkj26091b12016-09-01 01:17:40 -07002033 parameters_.encoder_config = std::move(encoder_config);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002034}
2035
deadbeefdbe2b872016-03-22 15:42:00 -07002036void WebRtcVideoChannel2::WebRtcVideoSendStream::SetSend(bool send) {
perkjfa10b552016-10-02 23:45:26 -07002037 RTC_DCHECK_RUN_ON(&thread_checker_);
deadbeefdbe2b872016-03-22 15:42:00 -07002038 sending_ = send;
2039 UpdateSendState();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002040}
2041
perkj803d97f2016-11-01 11:45:46 -07002042void WebRtcVideoChannel2::WebRtcVideoSendStream::RemoveSink(
perkjd533aec2017-01-13 05:57:25 -08002043 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
perkj803d97f2016-11-01 11:45:46 -07002044 RTC_DCHECK_RUN_ON(&thread_checker_);
perkjd533aec2017-01-13 05:57:25 -08002045 RTC_DCHECK(encoder_sink_ == sink);
2046 encoder_sink_ = nullptr;
2047 source_->RemoveSink(sink);
perkj803d97f2016-11-01 11:45:46 -07002048}
2049
perkja49cbd32016-09-16 07:53:41 -07002050void WebRtcVideoChannel2::WebRtcVideoSendStream::AddOrUpdateSink(
perkjd533aec2017-01-13 05:57:25 -08002051 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink,
perkja49cbd32016-09-16 07:53:41 -07002052 const rtc::VideoSinkWants& wants) {
perkj803d97f2016-11-01 11:45:46 -07002053 if (worker_thread_ == rtc::Thread::Current()) {
2054 // AddOrUpdateSink is called on |worker_thread_| if this is the first
2055 // registration of |sink|.
2056 RTC_DCHECK_RUN_ON(&thread_checker_);
perkjd533aec2017-01-13 05:57:25 -08002057 encoder_sink_ = sink;
2058 source_->AddOrUpdateSink(encoder_sink_, wants);
perkjfa10b552016-10-02 23:45:26 -07002059 } else {
perkj803d97f2016-11-01 11:45:46 -07002060 // Subsequent calls to AddOrUpdateSink will happen on the encoder task
2061 // queue.
perkjd533aec2017-01-13 05:57:25 -08002062 invoker_.AsyncInvoke<void>(
2063 RTC_FROM_HERE, worker_thread_, [this, sink, wants] {
2064 RTC_DCHECK_RUN_ON(&thread_checker_);
2065 // |sink| may be invalidated after this task was posted since
2066 // RemoveSink is called on the worker thread.
2067 bool encoder_sink_valid = (sink == encoder_sink_);
2068 if (source_ && encoder_sink_valid) {
2069 source_->AddOrUpdateSink(encoder_sink_, wants);
2070 }
2071 });
perkj2d5f0912016-02-29 00:04:41 -08002072 }
perkj2d5f0912016-02-29 00:04:41 -08002073}
2074
asapersson2e5cfcd2016-08-11 08:41:18 -07002075VideoSenderInfo WebRtcVideoChannel2::WebRtcVideoSendStream::GetVideoSenderInfo(
2076 bool log_stats) {
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002077 VideoSenderInfo info;
perkjfa10b552016-10-02 23:45:26 -07002078 RTC_DCHECK_RUN_ON(&thread_checker_);
2079 for (uint32_t ssrc : parameters_.config.rtp.ssrcs)
2080 info.add_ssrc(ssrc);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002081
hbosa65704b2016-11-14 02:28:16 -08002082 if (parameters_.codec_settings) {
perkjfa10b552016-10-02 23:45:26 -07002083 info.codec_name = parameters_.codec_settings->codec.name;
hbos1acfbd22016-11-17 23:43:29 -08002084 info.codec_payload_type = rtc::Optional<int>(
2085 parameters_.codec_settings->codec.id);
hbosa65704b2016-11-14 02:28:16 -08002086 }
pbos@webrtc.orgc3d2bd22014-08-12 20:55:10 +00002087
perkjfa10b552016-10-02 23:45:26 -07002088 if (stream_ == NULL)
2089 return info;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002090
perkjfa10b552016-10-02 23:45:26 -07002091 webrtc::VideoSendStream::Stats stats = stream_->GetStats();
asapersson2e5cfcd2016-08-11 08:41:18 -07002092
2093 if (log_stats)
2094 LOG(LS_INFO) << stats.ToString(rtc::TimeMillis());
2095
perkj803d97f2016-11-01 11:45:46 -07002096 info.adapt_changes = stats.number_of_cpu_adapt_changes;
Per766ad3b2016-04-05 15:23:49 +02002097 info.adapt_reason =
perkj803d97f2016-11-01 11:45:46 -07002098 stats.cpu_limited_resolution ? ADAPTREASON_CPU : ADAPTREASON_NONE;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002099
asapersson17821db2015-12-14 02:08:12 -08002100 // Get bandwidth limitation info from stream_->GetStats().
2101 // Input resolution (output from video_adapter) can be further scaled down or
2102 // higher video layer(s) can be dropped due to bitrate constraints.
2103 // Note, adapt_changes only include changes from the video_adapter.
2104 if (stats.bw_limited_resolution)
Per766ad3b2016-04-05 15:23:49 +02002105 info.adapt_reason |= ADAPTREASON_BANDWIDTH;
asapersson17821db2015-12-14 02:08:12 -08002106
Peter Boströmb7d9a972015-12-18 16:01:11 +01002107 info.encoder_implementation_name = stats.encoder_implementation_name;
Peter Boström259bd202015-05-28 13:39:50 +02002108 info.ssrc_groups = ssrc_groups_;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002109 info.framerate_input = stats.input_frame_rate;
2110 info.framerate_sent = stats.encode_frame_rate;
pbos@webrtc.org3e6e2712015-02-26 12:19:31 +00002111 info.avg_encode_ms = stats.avg_encode_time_ms;
2112 info.encode_usage_percent = stats.encode_usage_percent;
sakal43536c32016-10-24 01:46:43 -07002113 info.frames_encoded = stats.frames_encoded;
sakal87da4042016-10-31 06:53:47 -07002114 info.qp_sum = stats.qp_sum;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002115
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002116 info.nominal_bitrate = stats.media_bitrate_bps;
Pera48ddb72016-09-29 11:48:50 +02002117 info.preferred_bitrate = stats.preferred_media_bitrate_bps;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002118
pbos@webrtc.org273a4142014-12-01 15:23:21 +00002119 info.send_frame_width = 0;
2120 info.send_frame_height = 0;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002121 for (std::map<uint32_t, webrtc::VideoSendStream::StreamStats>::iterator it =
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002122 stats.substreams.begin();
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002123 it != stats.substreams.end(); ++it) {
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002124 // TODO(pbos): Wire up additional stats, such as padding bytes.
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002125 webrtc::VideoSendStream::StreamStats stream_stats = it->second;
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59 +00002126 info.bytes_sent += stream_stats.rtp_stats.transmitted.payload_bytes +
2127 stream_stats.rtp_stats.transmitted.header_bytes +
2128 stream_stats.rtp_stats.transmitted.padding_bytes;
2129 info.packets_sent += stream_stats.rtp_stats.transmitted.packets;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002130 info.packets_lost += stream_stats.rtcp_stats.cumulative_lost;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002131 if (stream_stats.width > info.send_frame_width)
2132 info.send_frame_width = stream_stats.width;
2133 if (stream_stats.height > info.send_frame_height)
2134 info.send_frame_height = stream_stats.height;
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002135 info.firs_rcvd += stream_stats.rtcp_packet_type_counts.fir_packets;
2136 info.nacks_rcvd += stream_stats.rtcp_packet_type_counts.nack_packets;
2137 info.plis_rcvd += stream_stats.rtcp_packet_type_counts.pli_packets;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002138 }
2139
2140 if (!stats.substreams.empty()) {
2141 // TODO(pbos): Report fraction lost per SSRC.
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002142 webrtc::VideoSendStream::StreamStats first_stream_stats =
2143 stats.substreams.begin()->second;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002144 info.fraction_lost =
2145 static_cast<float>(first_stream_stats.rtcp_stats.fraction_lost) /
2146 (1 << 8);
2147 }
2148
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002149 return info;
2150}
2151
charujaind72098a2017-06-01 08:54:47 -07002152void WebRtcVideoChannel2::WebRtcVideoSendStream::FillBandwidthEstimationInfo(
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00002153 BandwidthEstimationInfo* bwe_info) {
perkjfa10b552016-10-02 23:45:26 -07002154 RTC_DCHECK_RUN_ON(&thread_checker_);
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00002155 if (stream_ == NULL) {
2156 return;
2157 }
2158 webrtc::VideoSendStream::Stats stats = stream_->GetStats();
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002159 for (std::map<uint32_t, webrtc::VideoSendStream::StreamStats>::iterator it =
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00002160 stats.substreams.begin();
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002161 it != stats.substreams.end(); ++it) {
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00002162 bwe_info->transmit_bitrate += it->second.total_bitrate_bps;
2163 bwe_info->retransmit_bitrate += it->second.retransmit_bitrate_bps;
2164 }
pbos@webrtc.org891d4832015-02-26 13:15:22 +00002165 bwe_info->target_enc_bitrate += stats.target_media_bitrate_bps;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002166 bwe_info->actual_enc_bitrate += stats.media_bitrate_bps;
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00002167}
2168
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002169void WebRtcVideoChannel2::WebRtcVideoSendStream::RecreateWebRtcStream() {
perkjfa10b552016-10-02 23:45:26 -07002170 RTC_DCHECK_RUN_ON(&thread_checker_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002171 if (stream_ != NULL) {
2172 call_->DestroyVideoSendStream(stream_);
2173 }
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00002174
kwiberg102c6a62015-10-30 02:47:38 -07002175 RTC_CHECK(parameters_.codec_settings);
Niels Möller60653ba2016-03-02 11:41:36 +01002176 RTC_DCHECK_EQ((parameters_.encoder_config.content_type ==
2177 webrtc::VideoEncoderConfig::ContentType::kScreen),
2178 parameters_.options.is_screencast.value_or(false))
2179 << "encoder content type inconsistent with screencast option";
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00002180 parameters_.encoder_config.encoder_specific_settings =
Niels Möller60653ba2016-03-02 11:41:36 +01002181 ConfigureVideoEncoderSettings(parameters_.codec_settings->codec);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002182
perkj26091b12016-09-01 01:17:40 -07002183 webrtc::VideoSendStream::Config config = parameters_.config.Copy();
pbos@webrtc.orgb9557a92015-03-20 19:52:56 +00002184 if (!config.rtp.rtx.ssrcs.empty() && config.rtp.rtx.payload_type == -1) {
2185 LOG(LS_WARNING) << "RTX SSRCs configured but there's no configured RTX "
2186 "payload type the set codec. Ignoring RTX.";
2187 config.rtp.rtx.ssrcs.clear();
2188 }
perkj26091b12016-09-01 01:17:40 -07002189 stream_ = call_->CreateVideoSendStream(std::move(config),
2190 parameters_.encoder_config.Copy());
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002191
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00002192 parameters_.encoder_config.encoder_specific_settings = NULL;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002193
perkj803d97f2016-11-01 11:45:46 -07002194 if (source_) {
sprangc5d62e22017-04-02 23:53:04 -07002195 stream_->SetSource(this, GetDegradationPreference());
perkj803d97f2016-11-01 11:45:46 -07002196 }
2197
Taylor Brandstetter14b9d792016-09-07 17:16:54 -07002198 // Call stream_->Start() if necessary conditions are met.
2199 UpdateSendState();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002200}
2201
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002202WebRtcVideoChannel2::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
2203 webrtc::Call* call,
Peter Boström259bd202015-05-28 13:39:50 +02002204 const StreamParams& sp,
Tommi733b5472016-06-10 17:58:01 +02002205 webrtc::VideoReceiveStream::Config config,
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002206 WebRtcVideoDecoderFactory* external_decoder_factory,
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00002207 bool default_stream,
brandtr468da7c2016-11-22 02:16:47 -08002208 const std::vector<VideoCodecSettings>& recv_codecs,
brandtr8313a6f2017-01-13 07:41:19 -08002209 const webrtc::FlexfecReceiveStream::Config& flexfec_config)
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002210 : call_(call),
sakal1fd95952016-06-22 00:46:15 -07002211 stream_params_(sp),
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002212 stream_(NULL),
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00002213 default_stream_(default_stream),
Tommi733b5472016-06-10 17:58:01 +02002214 config_(std::move(config)),
brandtr468da7c2016-11-22 02:16:47 -08002215 flexfec_config_(flexfec_config),
2216 flexfec_stream_(nullptr),
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002217 external_decoder_factory_(external_decoder_factory),
nissee73afba2016-01-28 04:47:08 -08002218 sink_(NULL),
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002219 first_frame_timestamp_(-1),
2220 estimated_remote_start_ntp_time_ms_(0) {
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002221 config_.renderer = this;
pbos378dc772016-01-28 15:58:41 -08002222 std::vector<AllocatedDecoder> old_decoders;
2223 ConfigureCodecs(recv_codecs, &old_decoders);
brandtr11fb4722017-05-30 01:31:37 -07002224 ConfigureFlexfecCodec(flexfec_config.payload_type);
2225 MaybeRecreateWebRtcFlexfecStream();
2226 RecreateWebRtcVideoStream();
pbos378dc772016-01-28 15:58:41 -08002227 RTC_DCHECK(old_decoders.empty());
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002228}
2229
Peter Boström7252a2b2015-05-18 19:42:03 +02002230WebRtcVideoChannel2::WebRtcVideoReceiveStream::AllocatedDecoder::
2231 AllocatedDecoder(webrtc::VideoDecoder* decoder,
2232 webrtc::VideoCodecType type,
2233 bool external)
2234 : decoder(decoder),
2235 external_decoder(nullptr),
2236 type(type),
2237 external(external) {
2238 if (external) {
2239 external_decoder = decoder;
2240 this->decoder =
2241 new webrtc::VideoDecoderSoftwareFallbackWrapper(type, external_decoder);
2242 }
2243}
2244
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002245WebRtcVideoChannel2::WebRtcVideoReceiveStream::~WebRtcVideoReceiveStream() {
brandtr9c3d4c42017-01-23 06:59:13 -08002246 if (flexfec_stream_) {
2247 call_->DestroyFlexfecReceiveStream(flexfec_stream_);
2248 }
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002249 call_->DestroyVideoReceiveStream(stream_);
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002250 ClearDecoders(&allocated_decoders_);
2251}
2252
Peter Boström0c4e06b2015-10-07 12:23:21 +02002253const std::vector<uint32_t>&
Peter Boströmd6f4c252015-03-26 16:23:04 +01002254WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetSsrcs() const {
sakal1fd95952016-06-22 00:46:15 -07002255 return stream_params_.ssrcs;
2256}
2257
2258rtc::Optional<uint32_t>
2259WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetFirstPrimarySsrc() const {
2260 std::vector<uint32_t> primary_ssrcs;
2261 stream_params_.GetPrimarySsrcs(&primary_ssrcs);
2262
2263 if (primary_ssrcs.empty()) {
2264 LOG(LS_WARNING) << "Empty primary ssrcs vector, returning empty optional";
2265 return rtc::Optional<uint32_t>();
2266 } else {
2267 return rtc::Optional<uint32_t>(primary_ssrcs[0]);
2268 }
Peter Boströmd6f4c252015-03-26 16:23:04 +01002269}
2270
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002271WebRtcVideoChannel2::WebRtcVideoReceiveStream::AllocatedDecoder
2272WebRtcVideoChannel2::WebRtcVideoReceiveStream::CreateOrReuseVideoDecoder(
2273 std::vector<AllocatedDecoder>* old_decoders,
2274 const VideoCodec& codec) {
magjed10165ab2016-11-22 10:16:57 -08002275 webrtc::VideoCodecType type = webrtc::PayloadNameToCodecType(codec.name)
2276 .value_or(webrtc::kVideoCodecUnknown);
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002277
2278 for (size_t i = 0; i < old_decoders->size(); ++i) {
2279 if ((*old_decoders)[i].type == type) {
2280 AllocatedDecoder decoder = (*old_decoders)[i];
2281 (*old_decoders)[i] = old_decoders->back();
2282 old_decoders->pop_back();
2283 return decoder;
2284 }
2285 }
2286
2287 if (external_decoder_factory_ != NULL) {
2288 webrtc::VideoDecoder* decoder =
sakal1fd95952016-06-22 00:46:15 -07002289 external_decoder_factory_->CreateVideoDecoderWithParams(
2290 type, {stream_params_.id});
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002291 if (decoder != NULL) {
magjeddd407022016-12-01 00:27:27 -08002292 return AllocatedDecoder(decoder, type, true /* is_external */);
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002293 }
2294 }
2295
magjeddd407022016-12-01 00:27:27 -08002296 InternalDecoderFactory internal_decoder_factory;
2297 return AllocatedDecoder(internal_decoder_factory.CreateVideoDecoderWithParams(
2298 type, {stream_params_.id}),
2299 type, false /* is_external */);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002300}
2301
pbos378dc772016-01-28 15:58:41 -08002302void WebRtcVideoChannel2::WebRtcVideoReceiveStream::ConfigureCodecs(
2303 const std::vector<VideoCodecSettings>& recv_codecs,
2304 std::vector<AllocatedDecoder>* old_decoders) {
2305 *old_decoders = allocated_decoders_;
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002306 allocated_decoders_.clear();
2307 config_.decoders.clear();
2308 for (size_t i = 0; i < recv_codecs.size(); ++i) {
2309 AllocatedDecoder allocated_decoder =
pbos378dc772016-01-28 15:58:41 -08002310 CreateOrReuseVideoDecoder(old_decoders, recv_codecs[i].codec);
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002311 allocated_decoders_.push_back(allocated_decoder);
2312
2313 webrtc::VideoReceiveStream::Decoder decoder;
2314 decoder.decoder = allocated_decoder.decoder;
2315 decoder.payload_type = recv_codecs[i].codec.id;
2316 decoder.payload_name = recv_codecs[i].codec.name;
magjed5dfac562016-11-25 03:56:37 -08002317 decoder.codec_params = recv_codecs[i].codec.params;
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002318 config_.decoders.push_back(decoder);
2319 }
2320
brandtr14742122017-01-27 04:53:07 -08002321 config_.rtp.rtx_payload_types.clear();
2322 for (const VideoCodecSettings& recv_codec : recv_codecs) {
2323 config_.rtp.rtx_payload_types[recv_codec.codec.id] =
2324 recv_codec.rtx_payload_type;
2325 }
2326
brandtrb5f2c3f2016-10-04 23:28:39 -07002327 config_.rtp.ulpfec = recv_codecs.front().ulpfec;
brandtrbb7066f2016-12-19 09:41:04 -08002328
pbos@webrtc.org257e1302014-07-25 19:01:32 +00002329 config_.rtp.nack.rtp_history_ms =
Shao Changbine62202f2015-04-21 20:24:50 +08002330 HasNack(recv_codecs.begin()->codec) ? kNackHistoryMs : 0;
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002331}
2332
brandtr11fb4722017-05-30 01:31:37 -07002333void WebRtcVideoChannel2::WebRtcVideoReceiveStream::ConfigureFlexfecCodec(
2334 int flexfec_payload_type) {
2335 flexfec_config_.payload_type = flexfec_payload_type;
2336}
2337
Peter Boström3548dd22015-05-22 18:48:36 +02002338void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetLocalSsrc(
2339 uint32_t local_ssrc) {
henrikg91d6ede2015-09-17 00:24:34 -07002340 // TODO(pbos): Consider turning this sanity check into a RTC_DCHECK. You
2341 // should not be able to create a sender with the same SSRC as a receiver, but
2342 // right now this can't be done due to unittests depending on receiving what
2343 // they are sending from the same MediaChannel.
deadbeef874ca3a2015-08-20 17:19:20 -07002344 if (local_ssrc == config_.rtp.remote_ssrc) {
2345 LOG(LS_INFO) << "Ignoring call to SetLocalSsrc because parameters are "
2346 "unchanged; local_ssrc=" << local_ssrc;
Peter Boström3548dd22015-05-22 18:48:36 +02002347 return;
deadbeef874ca3a2015-08-20 17:19:20 -07002348 }
Peter Boström3548dd22015-05-22 18:48:36 +02002349
2350 config_.rtp.local_ssrc = local_ssrc;
brandtrfa5a3682017-01-17 01:33:54 -08002351 flexfec_config_.local_ssrc = local_ssrc;
deadbeef874ca3a2015-08-20 17:19:20 -07002352 LOG(LS_INFO)
2353 << "RecreateWebRtcStream (recv) because of SetLocalSsrc; local_ssrc="
2354 << local_ssrc;
brandtr11fb4722017-05-30 01:31:37 -07002355 MaybeRecreateWebRtcFlexfecStream();
2356 RecreateWebRtcVideoStream();
Peter Boström3548dd22015-05-22 18:48:36 +02002357}
2358
stefan43edf0f2015-11-20 18:05:48 -08002359void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetFeedbackParameters(
2360 bool nack_enabled,
2361 bool remb_enabled,
Taylor Brandstetter5f0b83b2016-03-18 15:02:07 -07002362 bool transport_cc_enabled,
2363 webrtc::RtcpMode rtcp_mode) {
Peter Boström67c9df72015-05-11 14:34:58 +02002364 int nack_history_ms = nack_enabled ? kNackHistoryMs : 0;
2365 if (config_.rtp.nack.rtp_history_ms == nack_history_ms &&
stefan43edf0f2015-11-20 18:05:48 -08002366 config_.rtp.remb == remb_enabled &&
Taylor Brandstetter5f0b83b2016-03-18 15:02:07 -07002367 config_.rtp.transport_cc == transport_cc_enabled &&
2368 config_.rtp.rtcp_mode == rtcp_mode) {
stefan43edf0f2015-11-20 18:05:48 -08002369 LOG(LS_INFO)
2370 << "Ignoring call to SetFeedbackParameters because parameters are "
2371 "unchanged; nack="
2372 << nack_enabled << ", remb=" << remb_enabled
2373 << ", transport_cc=" << transport_cc_enabled;
Peter Boström126c03e2015-05-11 12:48:12 +02002374 return;
Peter Boström67c9df72015-05-11 14:34:58 +02002375 }
2376 config_.rtp.remb = remb_enabled;
2377 config_.rtp.nack.rtp_history_ms = nack_history_ms;
stefan43edf0f2015-11-20 18:05:48 -08002378 config_.rtp.transport_cc = transport_cc_enabled;
Taylor Brandstetter5f0b83b2016-03-18 15:02:07 -07002379 config_.rtp.rtcp_mode = rtcp_mode;
brandtr9d58d942017-02-03 04:43:41 -08002380 // TODO(brandtr): We should be spec-compliant and set |transport_cc| here
2381 // based on the rtcp-fb for the FlexFEC codec, not the media codec.
2382 flexfec_config_.transport_cc = config_.rtp.transport_cc;
2383 flexfec_config_.rtcp_mode = config_.rtp.rtcp_mode;
stefan43edf0f2015-11-20 18:05:48 -08002384 LOG(LS_INFO)
2385 << "RecreateWebRtcStream (recv) because of SetFeedbackParameters; nack="
2386 << nack_enabled << ", remb=" << remb_enabled
2387 << ", transport_cc=" << transport_cc_enabled;
brandtr11fb4722017-05-30 01:31:37 -07002388 MaybeRecreateWebRtcFlexfecStream();
2389 RecreateWebRtcVideoStream();
Peter Boström126c03e2015-05-11 12:48:12 +02002390}
2391
deadbeef13871492015-12-09 12:37:51 -08002392void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRecvParameters(
pbos378dc772016-01-28 15:58:41 -08002393 const ChangedRecvParameters& params) {
brandtr11fb4722017-05-30 01:31:37 -07002394 bool video_needs_recreation = false;
2395 bool flexfec_needs_recreation = false;
pbos378dc772016-01-28 15:58:41 -08002396 std::vector<AllocatedDecoder> old_decoders;
2397 if (params.codec_settings) {
2398 ConfigureCodecs(*params.codec_settings, &old_decoders);
brandtr11fb4722017-05-30 01:31:37 -07002399 video_needs_recreation = true;
pbos378dc772016-01-28 15:58:41 -08002400 }
2401 if (params.rtp_header_extensions) {
2402 config_.rtp.extensions = *params.rtp_header_extensions;
brandtr9d58d942017-02-03 04:43:41 -08002403 flexfec_config_.rtp_header_extensions = *params.rtp_header_extensions;
brandtr11fb4722017-05-30 01:31:37 -07002404 video_needs_recreation = true;
2405 flexfec_needs_recreation = true;
pbos378dc772016-01-28 15:58:41 -08002406 }
brandtr11fb4722017-05-30 01:31:37 -07002407 if (params.flexfec_payload_type) {
2408 ConfigureFlexfecCodec(*params.flexfec_payload_type);
2409 flexfec_needs_recreation = true;
2410 }
2411 if (flexfec_needs_recreation) {
2412 LOG(LS_INFO) << "MaybeRecreateWebRtcFlexfecStream (recv) because of "
2413 "SetRecvParameters";
2414 MaybeRecreateWebRtcFlexfecStream();
2415 }
2416 if (video_needs_recreation) {
2417 LOG(LS_INFO)
2418 << "RecreateWebRtcVideoStream (recv) because of SetRecvParameters";
2419 RecreateWebRtcVideoStream();
pbos378dc772016-01-28 15:58:41 -08002420 ClearDecoders(&old_decoders);
2421 }
deadbeef13871492015-12-09 12:37:51 -08002422}
2423
brandtr11fb4722017-05-30 01:31:37 -07002424void WebRtcVideoChannel2::WebRtcVideoReceiveStream::
2425 RecreateWebRtcVideoStream() {
brandtrfb45c6c2017-01-27 06:47:55 -08002426 if (stream_) {
2427 call_->DestroyVideoReceiveStream(stream_);
2428 stream_ = nullptr;
2429 }
brandtr11fb4722017-05-30 01:31:37 -07002430 webrtc::VideoReceiveStream::Config config = config_.Copy();
2431 config.rtp.protected_by_flexfec = (flexfec_stream_ != nullptr);
2432 stream_ = call_->CreateVideoReceiveStream(std::move(config));
2433 stream_->Start();
2434}
2435
2436void WebRtcVideoChannel2::WebRtcVideoReceiveStream::
2437 MaybeRecreateWebRtcFlexfecStream() {
brandtr468da7c2016-11-22 02:16:47 -08002438 if (flexfec_stream_) {
2439 call_->DestroyFlexfecReceiveStream(flexfec_stream_);
2440 flexfec_stream_ = nullptr;
2441 }
brandtr11fb4722017-05-30 01:31:37 -07002442 if (flexfec_config_.IsCompleteAndEnabled()) {
brandtr8313a6f2017-01-13 07:41:19 -08002443 flexfec_stream_ = call_->CreateFlexfecReceiveStream(flexfec_config_);
brandtr468da7c2016-11-22 02:16:47 -08002444 flexfec_stream_->Start();
2445 }
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002446}
2447
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002448void WebRtcVideoChannel2::WebRtcVideoReceiveStream::ClearDecoders(
2449 std::vector<AllocatedDecoder>* allocated_decoders) {
2450 for (size_t i = 0; i < allocated_decoders->size(); ++i) {
2451 if ((*allocated_decoders)[i].external) {
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002452 external_decoder_factory_->DestroyVideoDecoder(
Peter Boström7252a2b2015-05-18 19:42:03 +02002453 (*allocated_decoders)[i].external_decoder);
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002454 }
Peter Boström7252a2b2015-05-18 19:42:03 +02002455 delete (*allocated_decoders)[i].decoder;
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002456 }
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002457 allocated_decoders->clear();
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002458}
2459
nisseeb83a1a2016-03-21 01:27:56 -07002460void WebRtcVideoChannel2::WebRtcVideoReceiveStream::OnFrame(
2461 const webrtc::VideoFrame& frame) {
nissee73afba2016-01-28 04:47:08 -08002462 rtc::CritScope crit(&sink_lock_);
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002463
2464 if (first_frame_timestamp_ < 0)
2465 first_frame_timestamp_ = frame.timestamp();
2466 int64_t rtp_time_elapsed_since_first_frame =
2467 (timestamp_wraparound_handler_.Unwrap(frame.timestamp()) -
2468 first_frame_timestamp_);
2469 int64_t elapsed_time_ms = rtp_time_elapsed_since_first_frame /
2470 (cricket::kVideoCodecClockrate / 1000);
2471 if (frame.ntp_time_ms() > 0)
2472 estimated_remote_start_ntp_time_ms_ = frame.ntp_time_ms() - elapsed_time_ms;
2473
nissee73afba2016-01-28 04:47:08 -08002474 if (sink_ == NULL) {
2475 LOG(LS_WARNING) << "VideoReceiveStream not connected to a VideoSink.";
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002476 return;
2477 }
2478
nisse09347852016-10-19 00:30:30 -07002479 sink_->OnFrame(frame);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002480}
2481
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00002482bool WebRtcVideoChannel2::WebRtcVideoReceiveStream::IsDefaultStream() const {
2483 return default_stream_;
2484}
2485
nissee73afba2016-01-28 04:47:08 -08002486void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetSink(
nisseacd935b2016-11-11 03:55:13 -08002487 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
nissee73afba2016-01-28 04:47:08 -08002488 rtc::CritScope crit(&sink_lock_);
2489 sink_ = sink;
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002490}
2491
pbosf42376c2015-08-28 07:35:32 -07002492std::string
2493WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetCodecNameFromPayloadType(
2494 int payload_type) {
2495 for (const webrtc::VideoReceiveStream::Decoder& decoder : config_.decoders) {
2496 if (decoder.payload_type == payload_type) {
2497 return decoder.payload_name;
2498 }
2499 }
2500 return "";
2501}
2502
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002503VideoReceiverInfo
asapersson2e5cfcd2016-08-11 08:41:18 -07002504WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetVideoReceiverInfo(
2505 bool log_stats) {
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002506 VideoReceiverInfo info;
sakal1fd95952016-06-22 00:46:15 -07002507 info.ssrc_groups = stream_params_.ssrc_groups;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002508 info.add_ssrc(config_.rtp.remote_ssrc);
2509 webrtc::VideoReceiveStream::Stats stats = stream_->GetStats();
Peter Boströmb7d9a972015-12-18 16:01:11 +01002510 info.decoder_implementation_name = stats.decoder_implementation_name;
hbosa65704b2016-11-14 02:28:16 -08002511 if (stats.current_payload_type != -1) {
hbos1acfbd22016-11-17 23:43:29 -08002512 info.codec_payload_type = rtc::Optional<int>(
2513 stats.current_payload_type);
hbosa65704b2016-11-14 02:28:16 -08002514 }
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59 +00002515 info.bytes_rcvd = stats.rtp_stats.transmitted.payload_bytes +
2516 stats.rtp_stats.transmitted.header_bytes +
2517 stats.rtp_stats.transmitted.padding_bytes;
2518 info.packets_rcvd = stats.rtp_stats.transmitted.packets;
Peter Boström393347f2015-04-22 14:52:45 +02002519 info.packets_lost = stats.rtcp_stats.cumulative_lost;
2520 info.fraction_lost =
2521 static_cast<float>(stats.rtcp_stats.fraction_lost) / (1 << 8);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002522
2523 info.framerate_rcvd = stats.network_frame_rate;
2524 info.framerate_decoded = stats.decode_frame_rate;
2525 info.framerate_output = stats.render_frame_rate;
asapersson26dd92b2016-08-30 00:45:45 -07002526 info.frame_width = stats.width;
2527 info.frame_height = stats.height;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002528
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002529 {
nissee73afba2016-01-28 04:47:08 -08002530 rtc::CritScope frame_cs(&sink_lock_);
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002531 info.capture_start_ntp_time_ms = estimated_remote_start_ntp_time_ms_;
2532 }
2533
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002534 info.decode_ms = stats.decode_ms;
2535 info.max_decode_ms = stats.max_decode_ms;
2536 info.current_delay_ms = stats.current_delay_ms;
2537 info.target_delay_ms = stats.target_delay_ms;
2538 info.jitter_buffer_ms = stats.jitter_buffer_ms;
2539 info.min_playout_delay_ms = stats.min_playout_delay_ms;
2540 info.render_delay_ms = stats.render_delay_ms;
hbos42f6d2f2017-01-20 03:56:50 -08002541 info.frames_received = stats.frame_counts.key_frames +
2542 stats.frame_counts.delta_frames;
sakale5ba44e2016-10-26 07:09:24 -07002543 info.frames_decoded = stats.frames_decoded;
hbos50cfe1f2017-01-23 07:21:55 -08002544 info.frames_rendered = stats.frames_rendered;
sakalcc452e12017-02-09 04:53:45 -08002545 info.qp_sum = stats.qp_sum;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002546
pbosf42376c2015-08-28 07:35:32 -07002547 info.codec_name = GetCodecNameFromPayloadType(stats.current_payload_type);
2548
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002549 info.firs_sent = stats.rtcp_packet_type_counts.fir_packets;
2550 info.plis_sent = stats.rtcp_packet_type_counts.pli_packets;
2551 info.nacks_sent = stats.rtcp_packet_type_counts.nack_packets;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002552
asapersson2e5cfcd2016-08-11 08:41:18 -07002553 if (log_stats)
2554 LOG(LS_INFO) << stats.ToString(rtc::TimeMillis());
2555
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002556 return info;
2557}
2558
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002559WebRtcVideoChannel2::VideoCodecSettings::VideoCodecSettings()
brandtrbb7066f2016-12-19 09:41:04 -08002560 : flexfec_payload_type(-1), rtx_payload_type(-1) {}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002561
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002562bool WebRtcVideoChannel2::VideoCodecSettings::operator==(
2563 const WebRtcVideoChannel2::VideoCodecSettings& other) const {
brandtr468da7c2016-11-22 02:16:47 -08002564 return codec == other.codec && ulpfec == other.ulpfec &&
brandtrbb7066f2016-12-19 09:41:04 -08002565 flexfec_payload_type == other.flexfec_payload_type &&
2566 rtx_payload_type == other.rtx_payload_type;
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002567}
2568
brandtr11fb4722017-05-30 01:31:37 -07002569bool WebRtcVideoChannel2::VideoCodecSettings::EqualsDisregardingFlexfec(
2570 const WebRtcVideoChannel2::VideoCodecSettings& a,
2571 const WebRtcVideoChannel2::VideoCodecSettings& b) {
2572 return a.codec == b.codec && a.ulpfec == b.ulpfec &&
2573 a.rtx_payload_type == b.rtx_payload_type;
2574}
2575
Peter Boströmee0b00e2015-04-22 18:41:14 +02002576bool WebRtcVideoChannel2::VideoCodecSettings::operator!=(
2577 const WebRtcVideoChannel2::VideoCodecSettings& other) const {
2578 return !(*this == other);
2579}
2580
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002581std::vector<WebRtcVideoChannel2::VideoCodecSettings>
2582WebRtcVideoChannel2::MapCodecs(const std::vector<VideoCodec>& codecs) {
henrikg91d6ede2015-09-17 00:24:34 -07002583 RTC_DCHECK(!codecs.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002584
2585 std::vector<VideoCodecSettings> video_codecs;
2586 std::map<int, bool> payload_used;
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002587 std::map<int, VideoCodec::CodecType> payload_codec_type;
pkasting@chromium.orgd3245462015-02-23 21:28:22 +00002588 // |rtx_mapping| maps video payload type to rtx payload type.
2589 std::map<int, int> rtx_mapping;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002590
brandtrb5f2c3f2016-10-04 23:28:39 -07002591 webrtc::UlpfecConfig ulpfec_config;
brandtr468da7c2016-11-22 02:16:47 -08002592 int flexfec_payload_type = -1;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002593
2594 for (size_t i = 0; i < codecs.size(); ++i) {
2595 const VideoCodec& in_codec = codecs[i];
2596 int payload_type = in_codec.id;
2597
2598 if (payload_used[payload_type]) {
2599 LOG(LS_ERROR) << "Payload type already registered: "
2600 << in_codec.ToString();
2601 return std::vector<VideoCodecSettings>();
2602 }
2603 payload_used[payload_type] = true;
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002604 payload_codec_type[payload_type] = in_codec.GetCodecType();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002605
2606 switch (in_codec.GetCodecType()) {
2607 case VideoCodec::CODEC_RED: {
2608 // RED payload type, should not have duplicates.
brandtr468da7c2016-11-22 02:16:47 -08002609 RTC_DCHECK_EQ(-1, ulpfec_config.red_payload_type);
brandtrb5f2c3f2016-10-04 23:28:39 -07002610 ulpfec_config.red_payload_type = in_codec.id;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002611 continue;
2612 }
2613
2614 case VideoCodec::CODEC_ULPFEC: {
2615 // ULPFEC payload type, should not have duplicates.
brandtr468da7c2016-11-22 02:16:47 -08002616 RTC_DCHECK_EQ(-1, ulpfec_config.ulpfec_payload_type);
brandtrb5f2c3f2016-10-04 23:28:39 -07002617 ulpfec_config.ulpfec_payload_type = in_codec.id;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002618 continue;
2619 }
2620
brandtr87d7d772016-11-07 03:03:41 -08002621 case VideoCodec::CODEC_FLEXFEC: {
brandtr468da7c2016-11-22 02:16:47 -08002622 // FlexFEC payload type, should not have duplicates.
2623 RTC_DCHECK_EQ(-1, flexfec_payload_type);
2624 flexfec_payload_type = in_codec.id;
brandtr87d7d772016-11-07 03:03:41 -08002625 continue;
2626 }
2627
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002628 case VideoCodec::CODEC_RTX: {
2629 int associated_payload_type;
2630 if (!in_codec.GetParam(kCodecParamAssociatedPayloadType,
pkasting@chromium.orge9facf82015-02-17 20:36:28 +00002631 &associated_payload_type) ||
2632 !IsValidRtpPayloadType(associated_payload_type)) {
2633 LOG(LS_ERROR)
2634 << "RTX codec with invalid or no associated payload type: "
2635 << in_codec.ToString();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002636 return std::vector<VideoCodecSettings>();
2637 }
2638 rtx_mapping[associated_payload_type] = in_codec.id;
2639 continue;
2640 }
2641
2642 case VideoCodec::CODEC_VIDEO:
2643 break;
2644 }
2645
2646 video_codecs.push_back(VideoCodecSettings());
2647 video_codecs.back().codec = in_codec;
2648 }
2649
2650 // One of these codecs should have been a video codec. Only having FEC
2651 // parameters into this code is a logic error.
henrikg91d6ede2015-09-17 00:24:34 -07002652 RTC_DCHECK(!video_codecs.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002653
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002654 for (std::map<int, int>::const_iterator it = rtx_mapping.begin();
2655 it != rtx_mapping.end();
2656 ++it) {
2657 if (!payload_used[it->first]) {
2658 LOG(LS_ERROR) << "RTX mapped to payload not in codec list.";
2659 return std::vector<VideoCodecSettings>();
2660 }
Shao Changbine62202f2015-04-21 20:24:50 +08002661 if (payload_codec_type[it->first] != VideoCodec::CODEC_VIDEO &&
2662 payload_codec_type[it->first] != VideoCodec::CODEC_RED) {
2663 LOG(LS_ERROR) << "RTX not mapped to regular video codec or RED codec.";
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002664 return std::vector<VideoCodecSettings>();
2665 }
Shao Changbine62202f2015-04-21 20:24:50 +08002666
brandtrb5f2c3f2016-10-04 23:28:39 -07002667 if (it->first == ulpfec_config.red_payload_type) {
2668 ulpfec_config.red_rtx_payload_type = it->second;
Shao Changbine62202f2015-04-21 20:24:50 +08002669 }
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002670 }
2671
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002672 for (size_t i = 0; i < video_codecs.size(); ++i) {
brandtrb5f2c3f2016-10-04 23:28:39 -07002673 video_codecs[i].ulpfec = ulpfec_config;
brandtrbb7066f2016-12-19 09:41:04 -08002674 video_codecs[i].flexfec_payload_type = flexfec_payload_type;
Shao Changbine62202f2015-04-21 20:24:50 +08002675 if (rtx_mapping[video_codecs[i].codec.id] != 0 &&
2676 rtx_mapping[video_codecs[i].codec.id] !=
brandtrb5f2c3f2016-10-04 23:28:39 -07002677 ulpfec_config.red_payload_type) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002678 video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
2679 }
2680 }
2681
2682 return video_codecs;
2683}
2684
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002685} // namespace cricket