blob: 3f9d5f6596bfdc8031c3b3eff81f5ac7fc1cb726 [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
jbaucheec21bd2016-03-20 06:15:43 -070019#include "webrtc/base/copyonwritebuffer.h"
buildbot@webrtc.orga09a9992014-08-13 17:26:08 +000020#include "webrtc/base/logging.h"
21#include "webrtc/base/stringutils.h"
qiangchenc27d89f2015-07-16 10:27:16 -070022#include "webrtc/base/timeutils.h"
tommie4f96502015-10-20 23:00:48 -070023#include "webrtc/base/trace_event.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000024#include "webrtc/call.h"
magjed725e4842016-11-16 00:48:13 -080025#include "webrtc/common_video/h264/profile_level_id.h"
kjellander@webrtc.org5ad12972016-02-12 06:39:40 +010026#include "webrtc/media/engine/constants.h"
magjed509e4fe2016-11-18 01:34:11 -080027#include "webrtc/media/engine/internalencoderfactory.h"
kjellander@webrtc.org5ad12972016-02-12 06:39:40 +010028#include "webrtc/media/engine/simulcast.h"
magjed614d5b72016-11-15 06:30:54 -080029#include "webrtc/media/engine/videoencodersoftwarefallbackwrapper.h"
magjedf6acc2a2016-11-22 01:43:03 -080030#include "webrtc/media/engine/videodecodersoftwarefallbackwrapper.h"
kjellander@webrtc.org5ad12972016-02-12 06:39:40 +010031#include "webrtc/media/engine/webrtcmediaengine.h"
32#include "webrtc/media/engine/webrtcvideoencoderfactory.h"
kjellander@webrtc.org5ad12972016-02-12 06:39:40 +010033#include "webrtc/media/engine/webrtcvoiceengine.h"
Peter Boström81ea54e2015-05-07 11:41:09 +020034#include "webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h"
Henrik Kjellander98f53512015-10-28 18:17:40 +010035#include "webrtc/system_wrappers/include/field_trial.h"
pbos@webrtc.org776e6f22014-10-29 15:28:39 +000036#include "webrtc/video_decoder.h"
pbos@webrtc.orgab990ae2014-09-17 09:02:25 +000037#include "webrtc/video_encoder.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000038
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000039namespace cricket {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +000040namespace {
Peter Boström81ea54e2015-05-07 11:41:09 +020041
brandtr468da7c2016-11-22 02:16:47 -080042// Three things happen when the FlexFEC field trial is enabled:
43// 1) FlexFEC is exposed in the default codec list, eventually showing up
44// in the default SDP. (See InternalEncoderFactory ctor.)
45// 2) FlexFEC send parameters are set in the VideoSendStream config.
46// 3) FlexFEC receive parameters are set in the FlexfecReceiveStream config,
47// and the corresponding object is instantiated.
48const char kFlexfecFieldTrialName[] = "WebRTC-FlexFEC-03";
49
50bool IsFlexfecFieldTrialEnabled() {
51 return webrtc::field_trial::FindFullName(kFlexfecFieldTrialName) == "Enabled";
52}
53
Peter Boström81ea54e2015-05-07 11:41:09 +020054// Wrap cricket::WebRtcVideoEncoderFactory as a webrtc::VideoEncoderFactory.
55class EncoderFactoryAdapter : public webrtc::VideoEncoderFactory {
56 public:
57 // EncoderFactoryAdapter doesn't take ownership of |factory|, which is owned
58 // by e.g. PeerConnectionFactory.
59 explicit EncoderFactoryAdapter(cricket::WebRtcVideoEncoderFactory* factory)
60 : factory_(factory) {}
61 virtual ~EncoderFactoryAdapter() {}
62
63 // Implement webrtc::VideoEncoderFactory.
64 webrtc::VideoEncoder* Create() override {
magjed1e45cc62016-10-28 07:43:45 -070065 return factory_->CreateVideoEncoder(VideoCodec(kVp8CodecName));
Peter Boström81ea54e2015-05-07 11:41:09 +020066 }
67
68 void Destroy(webrtc::VideoEncoder* encoder) override {
69 return factory_->DestroyVideoEncoder(encoder);
70 }
71
72 private:
73 cricket::WebRtcVideoEncoderFactory* const factory_;
74};
75
Peter Boström3afc8c42016-01-27 16:45:21 +010076webrtc::Call::Config::BitrateConfig GetBitrateConfigForCodec(
77 const VideoCodec& codec) {
78 webrtc::Call::Config::BitrateConfig config;
79 int bitrate_kbps;
80 if (codec.GetParam(kCodecParamMinBitrate, &bitrate_kbps) &&
81 bitrate_kbps > 0) {
82 config.min_bitrate_bps = bitrate_kbps * 1000;
83 } else {
84 config.min_bitrate_bps = 0;
85 }
86 if (codec.GetParam(kCodecParamStartBitrate, &bitrate_kbps) &&
87 bitrate_kbps > 0) {
88 config.start_bitrate_bps = bitrate_kbps * 1000;
89 } else {
90 // Do not reconfigure start bitrate unless it's specified and positive.
91 config.start_bitrate_bps = -1;
92 }
93 if (codec.GetParam(kCodecParamMaxBitrate, &bitrate_kbps) &&
94 bitrate_kbps > 0) {
95 config.max_bitrate_bps = bitrate_kbps * 1000;
96 } else {
97 config.max_bitrate_bps = -1;
98 }
99 return config;
100}
101
Peter Boström81ea54e2015-05-07 11:41:09 +0200102// An encoder factory that wraps Create requests for simulcastable codec types
103// with a webrtc::SimulcastEncoderAdapter. Non simulcastable codec type
104// requests are just passed through to the contained encoder factory.
105class WebRtcSimulcastEncoderFactory
106 : public cricket::WebRtcVideoEncoderFactory {
107 public:
108 // WebRtcSimulcastEncoderFactory doesn't take ownership of |factory|, which is
109 // owned by e.g. PeerConnectionFactory.
110 explicit WebRtcSimulcastEncoderFactory(
111 cricket::WebRtcVideoEncoderFactory* factory)
112 : factory_(factory) {}
113
114 static bool UseSimulcastEncoderFactory(
magjed1e45cc62016-10-28 07:43:45 -0700115 const std::vector<cricket::VideoCodec>& codecs) {
Peter Boström81ea54e2015-05-07 11:41:09 +0200116 // If any codec is VP8, use the simulcast factory. If asked to create a
117 // non-VP8 codec, we'll just return a contained factory encoder directly.
118 for (const auto& codec : codecs) {
magjed1e45cc62016-10-28 07:43:45 -0700119 if (CodecNamesEq(codec.name.c_str(), kVp8CodecName)) {
Peter Boström81ea54e2015-05-07 11:41:09 +0200120 return true;
121 }
122 }
123 return false;
124 }
125
126 webrtc::VideoEncoder* CreateVideoEncoder(
magjed1e45cc62016-10-28 07:43:45 -0700127 const cricket::VideoCodec& codec) override {
henrikg91d6ede2015-09-17 00:24:34 -0700128 RTC_DCHECK(factory_ != NULL);
Peter Boström81ea54e2015-05-07 11:41:09 +0200129 // If it's a codec type we can simulcast, create a wrapped encoder.
magjed1e45cc62016-10-28 07:43:45 -0700130 if (CodecNamesEq(codec.name.c_str(), kVp8CodecName)) {
Peter Boström81ea54e2015-05-07 11:41:09 +0200131 return new webrtc::SimulcastEncoderAdapter(
132 new EncoderFactoryAdapter(factory_));
133 }
magjed1e45cc62016-10-28 07:43:45 -0700134 webrtc::VideoEncoder* encoder = factory_->CreateVideoEncoder(codec);
Peter Boström81ea54e2015-05-07 11:41:09 +0200135 if (encoder) {
136 non_simulcast_encoders_.push_back(encoder);
137 }
138 return encoder;
139 }
140
magjed1e45cc62016-10-28 07:43:45 -0700141 const std::vector<cricket::VideoCodec>& supported_codecs() const override {
142 return factory_->supported_codecs();
Peter Boström81ea54e2015-05-07 11:41:09 +0200143 }
144
145 bool EncoderTypeHasInternalSource(
146 webrtc::VideoCodecType type) const override {
147 return factory_->EncoderTypeHasInternalSource(type);
148 }
149
150 void DestroyVideoEncoder(webrtc::VideoEncoder* encoder) override {
151 // Check first to see if the encoder wasn't wrapped in a
152 // SimulcastEncoderAdapter. In that case, ask the factory to destroy it.
153 if (std::remove(non_simulcast_encoders_.begin(),
154 non_simulcast_encoders_.end(),
155 encoder) != non_simulcast_encoders_.end()) {
156 factory_->DestroyVideoEncoder(encoder);
157 return;
158 }
159
160 // Otherwise, SimulcastEncoderAdapter can be deleted directly, and will call
161 // DestroyVideoEncoder on the factory for individual encoder instances.
162 delete encoder;
163 }
164
165 private:
magjedd2fce172016-11-02 11:08:29 -0700166 // Disable overloaded virtual function warning. TODO(magjed): Remove once
167 // http://crbug/webrtc/6402 is fixed.
168 using cricket::WebRtcVideoEncoderFactory::CreateVideoEncoder;
169
Peter Boström81ea54e2015-05-07 11:41:09 +0200170 cricket::WebRtcVideoEncoderFactory* factory_;
171 // A list of encoders that were created without being wrapped in a
172 // SimulcastEncoderAdapter.
173 std::vector<webrtc::VideoEncoder*> non_simulcast_encoders_;
174};
175
Peter Boström81ea54e2015-05-07 11:41:09 +0200176void AddDefaultFeedbackParams(VideoCodec* codec) {
177 codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamCcm, kRtcpFbCcmParamFir));
178 codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamNack, kParamValueEmpty));
179 codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamNack, kRtcpFbNackParamPli));
180 codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamRemb, kParamValueEmpty));
stefan43edf0f2015-11-20 18:05:48 -0800181 codec->AddFeedbackParam(
182 FeedbackParam(kRtcpFbParamTransportCc, kParamValueEmpty));
Peter Boström81ea54e2015-05-07 11:41:09 +0200183}
184
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000185static std::string CodecVectorToString(const std::vector<VideoCodec>& codecs) {
186 std::stringstream out;
187 out << '{';
188 for (size_t i = 0; i < codecs.size(); ++i) {
189 out << codecs[i].ToString();
190 if (i != codecs.size() - 1) {
191 out << ", ";
192 }
193 }
194 out << '}';
195 return out.str();
196}
197
198static bool ValidateCodecFormats(const std::vector<VideoCodec>& codecs) {
199 bool has_video = false;
200 for (size_t i = 0; i < codecs.size(); ++i) {
201 if (!codecs[i].ValidateCodecFormat()) {
202 return false;
203 }
204 if (codecs[i].GetCodecType() == VideoCodec::CODEC_VIDEO) {
205 has_video = true;
206 }
207 }
208 if (!has_video) {
209 LOG(LS_ERROR) << "Setting codecs without a video codec is invalid: "
210 << CodecVectorToString(codecs);
211 return false;
212 }
213 return true;
214}
215
Peter Boströmd4362cd2015-03-25 14:17:23 +0100216static bool ValidateStreamParams(const StreamParams& sp) {
217 if (sp.ssrcs.empty()) {
218 LOG(LS_ERROR) << "No SSRCs in stream parameters: " << sp.ToString();
219 return false;
220 }
221
Peter Boström0c4e06b2015-10-07 12:23:21 +0200222 std::vector<uint32_t> primary_ssrcs;
Peter Boströmd4362cd2015-03-25 14:17:23 +0100223 sp.GetPrimarySsrcs(&primary_ssrcs);
Peter Boström0c4e06b2015-10-07 12:23:21 +0200224 std::vector<uint32_t> rtx_ssrcs;
Peter Boströmd4362cd2015-03-25 14:17:23 +0100225 sp.GetFidSsrcs(primary_ssrcs, &rtx_ssrcs);
226 for (uint32_t rtx_ssrc : rtx_ssrcs) {
227 bool rtx_ssrc_present = false;
228 for (uint32_t sp_ssrc : sp.ssrcs) {
229 if (sp_ssrc == rtx_ssrc) {
230 rtx_ssrc_present = true;
231 break;
232 }
233 }
234 if (!rtx_ssrc_present) {
235 LOG(LS_ERROR) << "RTX SSRC '" << rtx_ssrc
236 << "' missing from StreamParams ssrcs: " << sp.ToString();
237 return false;
238 }
239 }
240 if (!rtx_ssrcs.empty() && primary_ssrcs.size() != rtx_ssrcs.size()) {
241 LOG(LS_ERROR)
242 << "RTX SSRCs exist, but don't cover all SSRCs (unsupported): "
243 << sp.ToString();
244 return false;
245 }
246
247 return true;
248}
249
noahricfdac5162015-08-27 01:59:29 -0700250// Returns true if the given codec is disallowed from doing simulcast.
251bool IsCodecBlacklistedForSimulcast(const std::string& codec_name) {
asapersson3ed34872015-11-10 05:16:26 -0800252 return CodecNamesEq(codec_name, kH264CodecName) ||
253 CodecNamesEq(codec_name, kVp9CodecName);
noahricfdac5162015-08-27 01:59:29 -0700254}
255
Åsa Persson1c7d48d2015-09-08 09:21:43 +0200256// The selected thresholds for QVGA and VGA corresponded to a QP around 10.
257// The change in QP declined above the selected bitrates.
258static int GetMaxDefaultVideoBitrateKbps(int width, int height) {
259 if (width * height <= 320 * 240) {
260 return 600;
261 } else if (width * height <= 640 * 480) {
262 return 1700;
263 } else if (width * height <= 960 * 540) {
264 return 2000;
265 } else {
266 return 2500;
267 }
268}
perkj2d5f0912016-02-29 00:04:41 -0800269
asaperssonc5dabdd2016-03-21 04:15:50 -0700270bool GetVp9LayersFromFieldTrialGroup(int* num_spatial_layers,
271 int* num_temporal_layers) {
272 std::string group = webrtc::field_trial::FindFullName("WebRTC-SupportVP9SVC");
273 if (group.empty())
274 return false;
275
276 if (sscanf(group.c_str(), "EnabledByFlag_%dSL%dTL", num_spatial_layers,
277 num_temporal_layers) != 2) {
278 return false;
279 }
asaperssonaf9e4ac2016-03-31 00:36:49 -0700280 const int kMaxSpatialLayers = 2;
asaperssonc5dabdd2016-03-21 04:15:50 -0700281 if (*num_spatial_layers > kMaxSpatialLayers || *num_spatial_layers < 1)
282 return false;
283
284 const int kMaxTemporalLayers = 3;
285 if (*num_temporal_layers > kMaxTemporalLayers || *num_temporal_layers < 1)
286 return false;
287
288 return true;
289}
290
291int GetDefaultVp9SpatialLayers() {
292 int num_sl;
293 int num_tl;
294 if (GetVp9LayersFromFieldTrialGroup(&num_sl, &num_tl)) {
295 return num_sl;
296 }
297 return 1;
298}
299
300int GetDefaultVp9TemporalLayers() {
301 int num_sl;
302 int num_tl;
303 if (GetVp9LayersFromFieldTrialGroup(&num_sl, &num_tl)) {
304 return num_tl;
305 }
306 return 1;
307}
perkjfa10b552016-10-02 23:45:26 -0700308
309class EncoderStreamFactory
310 : public webrtc::VideoEncoderConfig::VideoStreamFactoryInterface {
311 public:
312 EncoderStreamFactory(std::string codec_name,
313 int max_qp,
314 int max_framerate,
315 bool is_screencast,
316 bool conference_mode)
317 : codec_name_(codec_name),
318 max_qp_(max_qp),
319 max_framerate_(max_framerate),
320 is_screencast_(is_screencast),
321 conference_mode_(conference_mode) {}
322
323 private:
324 std::vector<webrtc::VideoStream> CreateEncoderStreams(
325 int width,
326 int height,
327 const webrtc::VideoEncoderConfig& encoder_config) override {
328 RTC_DCHECK(encoder_config.number_of_streams > 1 ? !is_screencast_ : true);
329 if (encoder_config.number_of_streams > 1) {
330 return GetSimulcastConfig(encoder_config.number_of_streams, width, height,
331 encoder_config.max_bitrate_bps, max_qp_,
332 max_framerate_);
333 }
334
335 // For unset max bitrates set default bitrate for non-simulcast.
336 int max_bitrate_bps =
337 (encoder_config.max_bitrate_bps > 0)
338 ? encoder_config.max_bitrate_bps
339 : GetMaxDefaultVideoBitrateKbps(width, height) * 1000;
340
341 webrtc::VideoStream stream;
342 stream.width = width;
343 stream.height = height;
344 stream.max_framerate = max_framerate_;
345 stream.min_bitrate_bps = kMinVideoBitrateKbps * 1000;
346 stream.target_bitrate_bps = stream.max_bitrate_bps = max_bitrate_bps;
347 stream.max_qp = max_qp_;
348
349 // Conference mode screencast uses 2 temporal layers split at 100kbit.
350 if (conference_mode_ && is_screencast_) {
351 ScreenshareLayerConfig config = ScreenshareLayerConfig::GetDefault();
352 // For screenshare in conference mode, tl0 and tl1 bitrates are
353 // piggybacked
354 // on the VideoCodec struct as target and max bitrates, respectively.
355 // See eg. webrtc::VP8EncoderImpl::SetRates().
356 stream.target_bitrate_bps = config.tl0_bitrate_kbps * 1000;
357 stream.max_bitrate_bps = config.tl1_bitrate_kbps * 1000;
358 stream.temporal_layer_thresholds_bps.clear();
359 stream.temporal_layer_thresholds_bps.push_back(config.tl0_bitrate_kbps *
360 1000);
361 }
362
363 if (CodecNamesEq(codec_name_, kVp9CodecName) && !is_screencast_) {
364 stream.temporal_layer_thresholds_bps.resize(
365 GetDefaultVp9TemporalLayers() - 1);
366 }
367
368 std::vector<webrtc::VideoStream> streams;
369 streams.push_back(stream);
370 return streams;
371 }
372
373 const std::string codec_name_;
374 const int max_qp_;
375 const int max_framerate_;
376 const bool is_screencast_;
377 const bool conference_mode_;
378};
379
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000380} // namespace
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000381
kjellander@webrtc.org5ad12972016-02-12 06:39:40 +0100382// Constants defined in webrtc/media/engine/constants.h
Peter Boström81ea54e2015-05-07 11:41:09 +0200383// TODO(pbos): Move these to a separate constants.cc file.
perkjfa10b552016-10-02 23:45:26 -0700384const int kMinVideoBitrateKbps = 30;
Peter Boström81ea54e2015-05-07 11:41:09 +0200385
386const int kVideoMtu = 1200;
387const int kVideoRtpBufferSize = 65536;
388
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000389// This constant is really an on/off, lower-level configurable NACK history
390// duration hasn't been implemented.
391static const int kNackHistoryMs = 1000;
392
buildbot@webrtc.org933d88a2014-09-18 20:23:05 +0000393static const int kDefaultQpMax = 56;
394
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000395static const int kDefaultRtcpReceiverReportSsrc = 1;
396
asapersson2e5cfcd2016-08-11 08:41:18 -0700397// Minimum time interval for logging stats.
398static const int64_t kStatsLogIntervalMs = 10000;
399
magjed1e45cc62016-10-28 07:43:45 -0700400static std::vector<VideoCodec> GetSupportedCodecs(
401 const WebRtcVideoEncoderFactory* external_encoder_factory);
402
kthelgason29a44e32016-09-27 03:52:02 -0700403rtc::scoped_refptr<webrtc::VideoEncoderConfig::EncoderSpecificSettings>
404WebRtcVideoChannel2::WebRtcVideoSendStream::ConfigureVideoEncoderSettings(
Niels Möller60653ba2016-03-02 11:41:36 +0100405 const VideoCodec& codec) {
perkjfa10b552016-10-02 23:45:26 -0700406 RTC_DCHECK_RUN_ON(&thread_checker_);
Niels Möller60653ba2016-03-02 11:41:36 +0100407 bool is_screencast = parameters_.options.is_screencast.value_or(false);
Peter Boström2feafdb2015-09-09 14:32:14 +0200408 // No automatic resizing when using simulcast or screencast.
409 bool automatic_resize =
410 !is_screencast && parameters_.config.rtp.ssrcs.size() == 1;
Erik Språng143cec12015-04-28 10:01:41 +0200411 bool frame_dropping = !is_screencast;
412 bool denoising;
pbos4cba4eb2015-10-26 11:18:18 -0700413 bool codec_default_denoising = false;
Erik Språng143cec12015-04-28 10:01:41 +0200414 if (is_screencast) {
415 denoising = false;
416 } else {
pbos4cba4eb2015-10-26 11:18:18 -0700417 // Use codec default if video_noise_reduction is unset.
Niels Möller60653ba2016-03-02 11:41:36 +0100418 codec_default_denoising = !parameters_.options.video_noise_reduction;
419 denoising = parameters_.options.video_noise_reduction.value_or(false);
Erik Språng143cec12015-04-28 10:01:41 +0200420 }
421
hbosbab934b2016-01-27 01:36:03 -0800422 if (CodecNamesEq(codec.name, kH264CodecName)) {
kthelgason29a44e32016-09-27 03:52:02 -0700423 webrtc::VideoCodecH264 h264_settings =
424 webrtc::VideoEncoder::GetDefaultH264Settings();
425 h264_settings.frameDroppingOn = frame_dropping;
426 return new rtc::RefCountedObject<
427 webrtc::VideoEncoderConfig::H264EncoderSpecificSettings>(h264_settings);
hbosbab934b2016-01-27 01:36:03 -0800428 }
Shao Changbine62202f2015-04-21 20:24:50 +0800429 if (CodecNamesEq(codec.name, kVp8CodecName)) {
kthelgason29a44e32016-09-27 03:52:02 -0700430 webrtc::VideoCodecVP8 vp8_settings =
431 webrtc::VideoEncoder::GetDefaultVp8Settings();
432 vp8_settings.automaticResizeOn = automatic_resize;
pbos4cba4eb2015-10-26 11:18:18 -0700433 // VP8 denoising is enabled by default.
kthelgason29a44e32016-09-27 03:52:02 -0700434 vp8_settings.denoisingOn = codec_default_denoising ? true : denoising;
435 vp8_settings.frameDroppingOn = frame_dropping;
436 return new rtc::RefCountedObject<
437 webrtc::VideoEncoderConfig::Vp8EncoderSpecificSettings>(vp8_settings);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000438 }
Shao Changbine62202f2015-04-21 20:24:50 +0800439 if (CodecNamesEq(codec.name, kVp9CodecName)) {
kthelgason29a44e32016-09-27 03:52:02 -0700440 webrtc::VideoCodecVP9 vp9_settings =
441 webrtc::VideoEncoder::GetDefaultVp9Settings();
asaperssonc5dabdd2016-03-21 04:15:50 -0700442 if (is_screencast) {
443 // TODO(asapersson): Set to 2 for now since there is a DCHECK in
444 // VideoSendStream::ReconfigureVideoEncoder.
kthelgason29a44e32016-09-27 03:52:02 -0700445 vp9_settings.numberOfSpatialLayers = 2;
asaperssonc5dabdd2016-03-21 04:15:50 -0700446 } else {
kthelgason29a44e32016-09-27 03:52:02 -0700447 vp9_settings.numberOfSpatialLayers = GetDefaultVp9SpatialLayers();
asaperssonc5dabdd2016-03-21 04:15:50 -0700448 }
pbos4cba4eb2015-10-26 11:18:18 -0700449 // VP9 denoising is disabled by default.
kthelgason29a44e32016-09-27 03:52:02 -0700450 vp9_settings.denoisingOn = codec_default_denoising ? false : denoising;
451 vp9_settings.frameDroppingOn = frame_dropping;
452 return new rtc::RefCountedObject<
453 webrtc::VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings);
andresp@webrtc.org188d3b22014-11-07 13:21:04 +0000454 }
kthelgason29a44e32016-09-27 03:52:02 -0700455 return nullptr;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000456}
457
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000458DefaultUnsignalledSsrcHandler::DefaultUnsignalledSsrcHandler()
nisse08582ff2016-02-04 01:24:52 -0800459 : default_recv_ssrc_(0), default_sink_(NULL) {}
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000460
461UnsignalledSsrcHandler::Action DefaultUnsignalledSsrcHandler::OnUnsignalledSsrc(
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +0000462 WebRtcVideoChannel2* channel,
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000463 uint32_t ssrc) {
464 if (default_recv_ssrc_ != 0) { // Already one default stream.
465 LOG(LS_WARNING) << "Unknown SSRC, but default receive stream already set.";
466 return kDropPacket;
467 }
468
469 StreamParams sp;
470 sp.ssrcs.push_back(ssrc);
471 LOG(LS_INFO) << "Creating default receive stream for SSRC=" << ssrc << ".";
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +0000472 if (!channel->AddRecvStream(sp, true)) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000473 LOG(LS_WARNING) << "Could not create default receive stream.";
474 }
475
nisse08582ff2016-02-04 01:24:52 -0800476 channel->SetSink(ssrc, default_sink_);
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000477 default_recv_ssrc_ = ssrc;
478 return kDeliverPacket;
479}
480
nisseacd935b2016-11-11 03:55:13 -0800481rtc::VideoSinkInterface<webrtc::VideoFrame>*
nisse08582ff2016-02-04 01:24:52 -0800482DefaultUnsignalledSsrcHandler::GetDefaultSink() const {
483 return default_sink_;
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000484}
485
nisse08582ff2016-02-04 01:24:52 -0800486void DefaultUnsignalledSsrcHandler::SetDefaultSink(
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000487 VideoMediaChannel* channel,
nisseacd935b2016-11-11 03:55:13 -0800488 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
nisse08582ff2016-02-04 01:24:52 -0800489 default_sink_ = sink;
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000490 if (default_recv_ssrc_ != 0) {
nisse08582ff2016-02-04 01:24:52 -0800491 channel->SetSink(default_recv_ssrc_, default_sink_);
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000492 }
493}
494
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200495WebRtcVideoEngine2::WebRtcVideoEngine2()
496 : initialized_(false),
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000497 external_decoder_factory_(NULL),
498 external_encoder_factory_(NULL) {
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +0000499 LOG(LS_INFO) << "WebRtcVideoEngine2::WebRtcVideoEngine2()";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000500}
501
502WebRtcVideoEngine2::~WebRtcVideoEngine2() {
503 LOG(LS_INFO) << "WebRtcVideoEngine2::~WebRtcVideoEngine2";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000504}
505
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200506void WebRtcVideoEngine2::Init() {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000507 LOG(LS_INFO) << "WebRtcVideoEngine2::Init";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000508 initialized_ = true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000509}
510
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000511WebRtcVideoChannel2* WebRtcVideoEngine2::CreateChannel(
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200512 webrtc::Call* call,
nisse51542be2016-02-12 02:27:06 -0800513 const MediaConfig& config,
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200514 const VideoOptions& options) {
henrikg91d6ede2015-09-17 00:24:34 -0700515 RTC_DCHECK(initialized_);
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200516 LOG(LS_INFO) << "CreateChannel. Options: " << options.ToString();
magjed23b7a4a2016-11-08 01:12:54 -0800517 return new WebRtcVideoChannel2(call, config, options,
nisse51542be2016-02-12 02:27:06 -0800518 external_encoder_factory_,
519 external_decoder_factory_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000520}
521
brandtrffc61182016-11-28 06:02:22 -0800522std::vector<VideoCodec> WebRtcVideoEngine2::codecs() const {
523 return GetSupportedCodecs(external_encoder_factory_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000524}
525
Stefan Holmer9d69c3f2015-12-07 10:45:43 +0100526RtpCapabilities WebRtcVideoEngine2::GetCapabilities() const {
527 RtpCapabilities capabilities;
528 capabilities.header_extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -0700529 webrtc::RtpExtension(webrtc::RtpExtension::kTimestampOffsetUri,
530 webrtc::RtpExtension::kTimestampOffsetDefaultId));
Stefan Holmer9d69c3f2015-12-07 10:45:43 +0100531 capabilities.header_extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -0700532 webrtc::RtpExtension(webrtc::RtpExtension::kAbsSendTimeUri,
533 webrtc::RtpExtension::kAbsSendTimeDefaultId));
Stefan Holmer9d69c3f2015-12-07 10:45:43 +0100534 capabilities.header_extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -0700535 webrtc::RtpExtension(webrtc::RtpExtension::kVideoRotationUri,
536 webrtc::RtpExtension::kVideoRotationDefaultId));
Stefan Holmer06a5e1a2016-09-02 12:36:49 +0200537 capabilities.header_extensions.push_back(webrtc::RtpExtension(
538 webrtc::RtpExtension::kTransportSequenceNumberUri,
539 webrtc::RtpExtension::kTransportSequenceNumberDefaultId));
isheriff6b4b5f32016-06-08 00:24:21 -0700540 capabilities.header_extensions.push_back(
541 webrtc::RtpExtension(webrtc::RtpExtension::kPlayoutDelayUri,
542 webrtc::RtpExtension::kPlayoutDelayDefaultId));
Stefan Holmer9d69c3f2015-12-07 10:45:43 +0100543 return capabilities;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000544}
545
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000546void WebRtcVideoEngine2::SetExternalDecoderFactory(
547 WebRtcVideoDecoderFactory* decoder_factory) {
henrikg91d6ede2015-09-17 00:24:34 -0700548 RTC_DCHECK(!initialized_);
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000549 external_decoder_factory_ = decoder_factory;
550}
551
552void WebRtcVideoEngine2::SetExternalEncoderFactory(
553 WebRtcVideoEncoderFactory* encoder_factory) {
henrikg91d6ede2015-09-17 00:24:34 -0700554 RTC_DCHECK(!initialized_);
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000555 if (external_encoder_factory_ == encoder_factory)
556 return;
557
558 // No matter what happens we shouldn't hold on to a stale
559 // WebRtcSimulcastEncoderFactory.
560 simulcast_encoder_factory_.reset();
561
562 if (encoder_factory &&
563 WebRtcSimulcastEncoderFactory::UseSimulcastEncoderFactory(
magjed1e45cc62016-10-28 07:43:45 -0700564 encoder_factory->supported_codecs())) {
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000565 simulcast_encoder_factory_.reset(
566 new WebRtcSimulcastEncoderFactory(encoder_factory));
567 encoder_factory = simulcast_encoder_factory_.get();
568 }
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000569 external_encoder_factory_ = encoder_factory;
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000570}
571
magjed509e4fe2016-11-18 01:34:11 -0800572// This is a helper function for AppendVideoCodecs below. It will return the
573// first unused dynamic payload type (in the range [96, 127]), or nothing if no
574// payload type is unused.
575static rtc::Optional<int> NextFreePayloadType(
576 const std::vector<VideoCodec>& codecs) {
577 static const int kFirstDynamicPayloadType = 96;
578 static const int kLastDynamicPayloadType = 127;
579 bool is_payload_used[1 + kLastDynamicPayloadType - kFirstDynamicPayloadType] =
580 {false};
581 for (const VideoCodec& codec : codecs) {
582 if (kFirstDynamicPayloadType <= codec.id &&
583 codec.id <= kLastDynamicPayloadType) {
584 is_payload_used[codec.id - kFirstDynamicPayloadType] = true;
magjedeacbaea2016-11-17 08:51:59 -0800585 }
magjed509e4fe2016-11-18 01:34:11 -0800586 }
587 for (int i = kFirstDynamicPayloadType; i <= kLastDynamicPayloadType; ++i) {
588 if (!is_payload_used[i - kFirstDynamicPayloadType])
589 return rtc::Optional<int>(i);
590 }
591 // No free payload type.
592 return rtc::Optional<int>();
593}
594
595// This is a helper function for GetSupportedCodecs below. It will append new
596// unique codecs from |input_codecs| to |unified_codecs|. It will add default
597// feedback params to the codecs and will also add an associated RTX codec for
598// recognized codecs (VP8, VP9, H264, and Red).
599static void AppendVideoCodecs(const std::vector<VideoCodec>& input_codecs,
600 std::vector<VideoCodec>* unified_codecs) {
601 for (VideoCodec codec : input_codecs) {
602 const rtc::Optional<int> payload_type =
603 NextFreePayloadType(*unified_codecs);
604 if (!payload_type)
605 return;
606 codec.id = *payload_type;
607 // TODO(magjed): Move the responsibility of setting these parameters to the
608 // encoder factories instead.
609 if (codec.name != kRedCodecName && codec.name != kUlpfecCodecName)
610 AddDefaultFeedbackParams(&codec);
611 // Don't add same codec twice.
612 if (FindMatchingCodec(*unified_codecs, codec))
magjedeacbaea2016-11-17 08:51:59 -0800613 continue;
614
magjed509e4fe2016-11-18 01:34:11 -0800615 unified_codecs->push_back(codec);
magjedeacbaea2016-11-17 08:51:59 -0800616
magjed509e4fe2016-11-18 01:34:11 -0800617 // Add associated RTX codec for recognized codecs.
618 // TODO(deadbeef): Should we add RTX codecs for external codecs whose names
619 // we don't recognize?
620 if (CodecNamesEq(codec.name, kVp8CodecName) ||
621 CodecNamesEq(codec.name, kVp9CodecName) ||
622 CodecNamesEq(codec.name, kH264CodecName) ||
623 CodecNamesEq(codec.name, kRedCodecName)) {
624 const rtc::Optional<int> rtx_payload_type =
625 NextFreePayloadType(*unified_codecs);
626 if (!rtx_payload_type)
627 return;
628 unified_codecs->push_back(
629 VideoCodec::CreateRtxCodec(*rtx_payload_type, codec.id));
630 }
magjedeacbaea2016-11-17 08:51:59 -0800631 }
magjed509e4fe2016-11-18 01:34:11 -0800632}
633
634static std::vector<VideoCodec> GetSupportedCodecs(
635 const WebRtcVideoEncoderFactory* external_encoder_factory) {
636 const std::vector<VideoCodec> internal_codecs =
637 InternalEncoderFactory().supported_codecs();
638 LOG(LS_INFO) << "Internally supported codecs: "
639 << CodecVectorToString(internal_codecs);
640
641 std::vector<VideoCodec> unified_codecs;
642 AppendVideoCodecs(internal_codecs, &unified_codecs);
643
644 if (external_encoder_factory != nullptr) {
645 const std::vector<VideoCodec>& external_codecs =
646 external_encoder_factory->supported_codecs();
647 AppendVideoCodecs(external_codecs, &unified_codecs);
648 LOG(LS_INFO) << "Codecs supported by the external encoder factory: "
649 << CodecVectorToString(external_codecs);
650 }
651
652 return unified_codecs;
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000653}
654
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000655WebRtcVideoChannel2::WebRtcVideoChannel2(
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200656 webrtc::Call* call,
nisse51542be2016-02-12 02:27:06 -0800657 const MediaConfig& config,
pbos@webrtc.orgfa553ef2014-10-20 11:07:07 +0000658 const VideoOptions& options,
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000659 WebRtcVideoEncoderFactory* external_encoder_factory,
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000660 WebRtcVideoDecoderFactory* external_decoder_factory)
nisse51542be2016-02-12 02:27:06 -0800661 : VideoMediaChannel(config),
662 call_(call),
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200663 unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
nisse0db023a2016-03-01 04:29:59 -0800664 video_config_(config.video),
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000665 external_encoder_factory_(external_encoder_factory),
nisse05103312016-03-16 02:22:50 -0700666 external_decoder_factory_(external_decoder_factory),
Stefan Holmer2b1f6512016-05-17 16:33:30 +0200667 default_send_options_(options),
asapersson2e5cfcd2016-08-11 08:41:18 -0700668 last_stats_log_ms_(-1) {
henrikg91d6ede2015-09-17 00:24:34 -0700669 RTC_DCHECK(thread_checker_.CalledOnValidThread());
nissea293ef02016-02-17 07:24:50 -0800670
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000671 rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc;
672 sending_ = false;
magjed23b7a4a2016-11-08 01:12:54 -0800673 recv_codecs_ = MapCodecs(GetSupportedCodecs(external_encoder_factory));
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000674}
675
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000676WebRtcVideoChannel2::~WebRtcVideoChannel2() {
Peter Boströmdfd53fe2015-03-27 15:58:11 +0100677 for (auto& kv : send_streams_)
678 delete kv.second;
679 for (auto& kv : receive_streams_)
680 delete kv.second;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000681}
682
magjed23b7a4a2016-11-08 01:12:54 -0800683rtc::Optional<WebRtcVideoChannel2::VideoCodecSettings>
684WebRtcVideoChannel2::SelectSendVideoCodec(
685 const std::vector<VideoCodecSettings>& remote_mapped_codecs) const {
686 const std::vector<VideoCodec> local_supported_codecs =
magjed1e45cc62016-10-28 07:43:45 -0700687 GetSupportedCodecs(external_encoder_factory_);
magjed23b7a4a2016-11-08 01:12:54 -0800688 // Select the first remote codec that is supported locally.
689 for (const VideoCodecSettings& remote_mapped_codec : remote_mapped_codecs) {
magjedf823ede2016-11-12 09:53:04 -0800690 // For H264, we will limit the encode level to the remote offered level
691 // regardless if level asymmetry is allowed or not. This is strictly not
692 // following the spec in https://tools.ietf.org/html/rfc6184#section-8.2.2
693 // since we should limit the encode level to the lower of local and remote
694 // level when level asymmetry is not allowed.
695 if (FindMatchingCodec(local_supported_codecs, remote_mapped_codec.codec))
magjed23b7a4a2016-11-08 01:12:54 -0800696 return rtc::Optional<VideoCodecSettings>(remote_mapped_codec);
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000697 }
magjed23b7a4a2016-11-08 01:12:54 -0800698 // No remote codec was supported.
699 return rtc::Optional<VideoCodecSettings>();
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000700}
701
deadbeef874ca3a2015-08-20 17:19:20 -0700702bool WebRtcVideoChannel2::ReceiveCodecsHaveChanged(
703 std::vector<VideoCodecSettings> before,
704 std::vector<VideoCodecSettings> after) {
705 if (before.size() != after.size()) {
706 return true;
707 }
708 // The receive codec order doesn't matter, so we sort the codecs before
709 // comparing. This is necessary because currently the
710 // only way to change the send codec is to munge SDP, which causes
711 // the receive codec list to change order, which causes the streams
712 // to be recreates which causes a "blink" of black video. In order
713 // to support munging the SDP in this way without recreating receive
714 // streams, we ignore the order of the received codecs so that
715 // changing the order doesn't cause this "blink".
716 auto comparison =
717 [](const VideoCodecSettings& codec1, const VideoCodecSettings& codec2) {
718 return codec1.codec.id > codec2.codec.id;
719 };
720 std::sort(before.begin(), before.end(), comparison);
721 std::sort(after.begin(), after.end(), comparison);
deadbeef67cf2c12016-04-13 10:07:16 -0700722 return before != after;
deadbeef874ca3a2015-08-20 17:19:20 -0700723}
724
Peter Boström3afc8c42016-01-27 16:45:21 +0100725bool WebRtcVideoChannel2::GetChangedSendParameters(
726 const VideoSendParameters& params,
727 ChangedSendParameters* changed_params) const {
728 if (!ValidateCodecFormats(params.codecs) ||
729 !ValidateRtpExtensions(params.extensions)) {
730 return false;
731 }
732
magjed23b7a4a2016-11-08 01:12:54 -0800733 // Select one of the remote codecs that will be used as send codec.
734 const rtc::Optional<VideoCodecSettings> selected_send_codec =
735 SelectSendVideoCodec(MapCodecs(params.codecs));
Peter Boström3afc8c42016-01-27 16:45:21 +0100736
magjed23b7a4a2016-11-08 01:12:54 -0800737 if (!selected_send_codec) {
Peter Boström3afc8c42016-01-27 16:45:21 +0100738 LOG(LS_ERROR) << "No video codecs supported.";
739 return false;
740 }
741
magjed23b7a4a2016-11-08 01:12:54 -0800742 if (!send_codec_ || *selected_send_codec != *send_codec_)
743 changed_params->codec = selected_send_codec;
Peter Boström3afc8c42016-01-27 16:45:21 +0100744
pbos378dc772016-01-28 15:58:41 -0800745 // Handle RTP header extensions.
Peter Boström3afc8c42016-01-27 16:45:21 +0100746 std::vector<webrtc::RtpExtension> filtered_extensions = FilterRtpExtensions(
747 params.extensions, webrtc::RtpExtension::IsSupportedForVideo, true);
skvlad3abb7642016-06-16 12:08:03 -0700748 if (!send_rtp_extensions_ || (*send_rtp_extensions_ != filtered_extensions)) {
Peter Boström3afc8c42016-01-27 16:45:21 +0100749 changed_params->rtp_header_extensions =
750 rtc::Optional<std::vector<webrtc::RtpExtension>>(filtered_extensions);
751 }
752
pbos378dc772016-01-28 15:58:41 -0800753 // Handle max bitrate.
Taylor Brandstetter58f2bd92016-04-26 17:15:23 -0700754 if (params.max_bandwidth_bps != send_params_.max_bandwidth_bps &&
Peter Boström3afc8c42016-01-27 16:45:21 +0100755 params.max_bandwidth_bps >= 0) {
756 // 0 uncaps max bitrate (-1).
757 changed_params->max_bandwidth_bps = rtc::Optional<int>(
758 params.max_bandwidth_bps == 0 ? -1 : params.max_bandwidth_bps);
759 }
760
nisse4b4dc862016-02-17 05:25:36 -0800761 // Handle conference mode.
762 if (params.conference_mode != send_params_.conference_mode) {
763 changed_params->conference_mode =
764 rtc::Optional<bool>(params.conference_mode);
765 }
766
pbos378dc772016-01-28 15:58:41 -0800767 // Handle RTCP mode.
Peter Boström3afc8c42016-01-27 16:45:21 +0100768 if (params.rtcp.reduced_size != send_params_.rtcp.reduced_size) {
769 changed_params->rtcp_mode = rtc::Optional<webrtc::RtcpMode>(
770 params.rtcp.reduced_size ? webrtc::RtcpMode::kReducedSize
771 : webrtc::RtcpMode::kCompound);
772 }
773
774 return true;
775}
776
nisse51542be2016-02-12 02:27:06 -0800777rtc::DiffServCodePoint WebRtcVideoChannel2::PreferredDscp() const {
778 return rtc::DSCP_AF41;
779}
780
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700781bool WebRtcVideoChannel2::SetSendParameters(const VideoSendParameters& params) {
Peter Boström9f45a452015-12-08 13:25:57 +0100782 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetSendParameters");
solenberg7e4e01a2015-12-02 08:05:01 -0800783 LOG(LS_INFO) << "SetSendParameters: " << params.ToString();
Peter Boström3afc8c42016-01-27 16:45:21 +0100784 ChangedSendParameters changed_params;
785 if (!GetChangedSendParameters(params, &changed_params)) {
deadbeef13871492015-12-09 12:37:51 -0800786 return false;
787 }
Peter Boström3afc8c42016-01-27 16:45:21 +0100788
Peter Boström3afc8c42016-01-27 16:45:21 +0100789 if (changed_params.codec) {
790 const VideoCodecSettings& codec_settings = *changed_params.codec;
791 send_codec_ = rtc::Optional<VideoCodecSettings>(codec_settings);
Peter Boström3afc8c42016-01-27 16:45:21 +0100792 LOG(LS_INFO) << "Using codec: " << codec_settings.codec.ToString();
Peter Boström3afc8c42016-01-27 16:45:21 +0100793 }
794
795 if (changed_params.rtp_header_extensions) {
skvlad3abb7642016-06-16 12:08:03 -0700796 send_rtp_extensions_ = changed_params.rtp_header_extensions;
Peter Boström3afc8c42016-01-27 16:45:21 +0100797 }
798
Taylor Brandstetter58f2bd92016-04-26 17:15:23 -0700799 if (changed_params.codec || changed_params.max_bandwidth_bps) {
800 if (send_codec_) {
801 // TODO(holmer): Changing the codec parameters shouldn't necessarily mean
802 // that we change the min/max of bandwidth estimation. Reevaluate this.
803 bitrate_config_ = GetBitrateConfigForCodec(send_codec_->codec);
804 if (!changed_params.codec) {
805 // If the codec isn't changing, set the start bitrate to -1 which means
806 // "unchanged" so that BWE isn't affected.
807 bitrate_config_.start_bitrate_bps = -1;
808 }
Peter Boström3afc8c42016-01-27 16:45:21 +0100809 }
Taylor Brandstetter58f2bd92016-04-26 17:15:23 -0700810 if (params.max_bandwidth_bps >= 0) {
811 // Note that max_bandwidth_bps intentionally takes priority over the
812 // bitrate config for the codec. This allows FEC to be applied above the
813 // codec target bitrate.
814 // TODO(pbos): Figure out whether b=AS means max bitrate for this
815 // WebRtcVideoChannel2 (in which case we're good), or per sender (SSRC),
816 // in which case this should not set a Call::BitrateConfig but rather
817 // reconfigure all senders.
818 bitrate_config_.max_bitrate_bps =
819 params.max_bandwidth_bps == 0 ? -1 : params.max_bandwidth_bps;
820 }
Peter Boström3afc8c42016-01-27 16:45:21 +0100821 call_->SetBitrateConfig(bitrate_config_);
822 }
823
Peter Boström3afc8c42016-01-27 16:45:21 +0100824 {
deadbeef13871492015-12-09 12:37:51 -0800825 rtc::CritScope stream_lock(&stream_crit_);
826 for (auto& kv : send_streams_) {
Peter Boström3afc8c42016-01-27 16:45:21 +0100827 kv.second->SetSendParameters(changed_params);
828 }
Taylor Brandstetter5f0b83b2016-03-18 15:02:07 -0700829 if (changed_params.codec || changed_params.rtcp_mode) {
830 // Update receive feedback parameters from new codec or RTCP mode.
Peter Boström3afc8c42016-01-27 16:45:21 +0100831 LOG(LS_INFO)
832 << "SetFeedbackOptions on all the receive streams because the send "
Taylor Brandstetter5f0b83b2016-03-18 15:02:07 -0700833 "codec or RTCP mode has changed.";
Peter Boström3afc8c42016-01-27 16:45:21 +0100834 for (auto& kv : receive_streams_) {
835 RTC_DCHECK(kv.second != nullptr);
Taylor Brandstetter5f0b83b2016-03-18 15:02:07 -0700836 kv.second->SetFeedbackParameters(
837 HasNack(send_codec_->codec), HasRemb(send_codec_->codec),
838 HasTransportCc(send_codec_->codec),
839 params.rtcp.reduced_size ? webrtc::RtcpMode::kReducedSize
840 : webrtc::RtcpMode::kCompound);
Peter Boström3afc8c42016-01-27 16:45:21 +0100841 }
deadbeef13871492015-12-09 12:37:51 -0800842 }
843 }
844 send_params_ = params;
845 return true;
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700846}
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700847
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700848webrtc::RtpParameters WebRtcVideoChannel2::GetRtpSendParameters(
skvladdc1c62c2016-03-16 19:07:43 -0700849 uint32_t ssrc) const {
850 rtc::CritScope stream_lock(&stream_crit_);
851 auto it = send_streams_.find(ssrc);
852 if (it == send_streams_.end()) {
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700853 LOG(LS_WARNING) << "Attempting to get RTP send parameters for stream "
854 << "with ssrc " << ssrc << " which doesn't exist.";
skvladdc1c62c2016-03-16 19:07:43 -0700855 return webrtc::RtpParameters();
856 }
857
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700858 webrtc::RtpParameters rtp_params = it->second->GetRtpParameters();
859 // Need to add the common list of codecs to the send stream-specific
860 // RTP parameters.
861 for (const VideoCodec& codec : send_params_.codecs) {
862 rtp_params.codecs.push_back(codec.ToCodecParameters());
863 }
864 return rtp_params;
skvladdc1c62c2016-03-16 19:07:43 -0700865}
866
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700867bool WebRtcVideoChannel2::SetRtpSendParameters(
skvladdc1c62c2016-03-16 19:07:43 -0700868 uint32_t ssrc,
869 const webrtc::RtpParameters& parameters) {
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700870 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRtpSendParameters");
skvladdc1c62c2016-03-16 19:07:43 -0700871 rtc::CritScope stream_lock(&stream_crit_);
872 auto it = send_streams_.find(ssrc);
873 if (it == send_streams_.end()) {
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700874 LOG(LS_ERROR) << "Attempting to set RTP send parameters for stream "
875 << "with ssrc " << ssrc << " which doesn't exist.";
skvladdc1c62c2016-03-16 19:07:43 -0700876 return false;
877 }
878
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700879 // TODO(deadbeef): Handle setting parameters with a list of codecs in a
880 // different order (which should change the send codec).
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700881 webrtc::RtpParameters current_parameters = GetRtpSendParameters(ssrc);
882 if (current_parameters.codecs != parameters.codecs) {
883 LOG(LS_ERROR) << "Using SetParameters to change the set of codecs "
884 << "is not currently supported.";
885 return false;
886 }
887
skvladdc1c62c2016-03-16 19:07:43 -0700888 return it->second->SetRtpParameters(parameters);
889}
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700890
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700891webrtc::RtpParameters WebRtcVideoChannel2::GetRtpReceiveParameters(
892 uint32_t ssrc) const {
893 rtc::CritScope stream_lock(&stream_crit_);
894 auto it = receive_streams_.find(ssrc);
895 if (it == receive_streams_.end()) {
896 LOG(LS_WARNING) << "Attempting to get RTP receive parameters for stream "
897 << "with ssrc " << ssrc << " which doesn't exist.";
898 return webrtc::RtpParameters();
899 }
900
901 // TODO(deadbeef): Return stream-specific parameters.
902 webrtc::RtpParameters rtp_params = CreateRtpParametersWithOneEncoding();
903 for (const VideoCodec& codec : recv_params_.codecs) {
904 rtp_params.codecs.push_back(codec.ToCodecParameters());
905 }
sakal1fd95952016-06-22 00:46:15 -0700906 rtp_params.encodings[0].ssrc = it->second->GetFirstPrimarySsrc();
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700907 return rtp_params;
908}
909
910bool WebRtcVideoChannel2::SetRtpReceiveParameters(
911 uint32_t ssrc,
912 const webrtc::RtpParameters& parameters) {
913 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRtpReceiveParameters");
914 rtc::CritScope stream_lock(&stream_crit_);
915 auto it = receive_streams_.find(ssrc);
916 if (it == receive_streams_.end()) {
917 LOG(LS_ERROR) << "Attempting to set RTP receive parameters for stream "
918 << "with ssrc " << ssrc << " which doesn't exist.";
919 return false;
920 }
921
922 webrtc::RtpParameters current_parameters = GetRtpReceiveParameters(ssrc);
923 if (current_parameters != parameters) {
924 LOG(LS_ERROR) << "Changing the RTP receive parameters is currently "
925 << "unsupported.";
926 return false;
927 }
928 return true;
929}
930
pbos378dc772016-01-28 15:58:41 -0800931bool WebRtcVideoChannel2::GetChangedRecvParameters(
932 const VideoRecvParameters& params,
933 ChangedRecvParameters* changed_params) const {
934 if (!ValidateCodecFormats(params.codecs) ||
935 !ValidateRtpExtensions(params.extensions)) {
936 return false;
937 }
938
939 // Handle receive codecs.
940 const std::vector<VideoCodecSettings> mapped_codecs =
941 MapCodecs(params.codecs);
942 if (mapped_codecs.empty()) {
943 LOG(LS_ERROR) << "SetRecvParameters called without any video codecs.";
944 return false;
945 }
946
magjed23b7a4a2016-11-08 01:12:54 -0800947 // Verify that every mapped codec is supported locally.
948 const std::vector<VideoCodec> local_supported_codecs =
949 GetSupportedCodecs(external_encoder_factory_);
950 for (const VideoCodecSettings& mapped_codec : mapped_codecs) {
magjedf823ede2016-11-12 09:53:04 -0800951 if (!FindMatchingCodec(local_supported_codecs, mapped_codec.codec)) {
magjed23b7a4a2016-11-08 01:12:54 -0800952 LOG(LS_ERROR) << "SetRecvParameters called with unsupported video codec: "
953 << mapped_codec.codec.ToString();
954 return false;
955 }
pbos378dc772016-01-28 15:58:41 -0800956 }
957
magjed23b7a4a2016-11-08 01:12:54 -0800958 if (ReceiveCodecsHaveChanged(recv_codecs_, mapped_codecs)) {
pbos378dc772016-01-28 15:58:41 -0800959 changed_params->codec_settings =
magjed23b7a4a2016-11-08 01:12:54 -0800960 rtc::Optional<std::vector<VideoCodecSettings>>(mapped_codecs);
pbos378dc772016-01-28 15:58:41 -0800961 }
962
963 // Handle RTP header extensions.
964 std::vector<webrtc::RtpExtension> filtered_extensions = FilterRtpExtensions(
965 params.extensions, webrtc::RtpExtension::IsSupportedForVideo, false);
966 if (filtered_extensions != recv_rtp_extensions_) {
967 changed_params->rtp_header_extensions =
968 rtc::Optional<std::vector<webrtc::RtpExtension>>(filtered_extensions);
969 }
970
pbos378dc772016-01-28 15:58:41 -0800971 return true;
972}
973
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700974bool WebRtcVideoChannel2::SetRecvParameters(const VideoRecvParameters& params) {
Peter Boström9f45a452015-12-08 13:25:57 +0100975 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRecvParameters");
solenberg7e4e01a2015-12-02 08:05:01 -0800976 LOG(LS_INFO) << "SetRecvParameters: " << params.ToString();
pbos378dc772016-01-28 15:58:41 -0800977 ChangedRecvParameters changed_params;
978 if (!GetChangedRecvParameters(params, &changed_params)) {
deadbeef13871492015-12-09 12:37:51 -0800979 return false;
980 }
pbos378dc772016-01-28 15:58:41 -0800981 if (changed_params.rtp_header_extensions) {
982 recv_rtp_extensions_ = *changed_params.rtp_header_extensions;
983 }
984 if (changed_params.codec_settings) {
985 LOG(LS_INFO) << "Changing recv codecs from "
986 << CodecSettingsVectorToString(recv_codecs_) << " to "
987 << CodecSettingsVectorToString(*changed_params.codec_settings);
988 recv_codecs_ = *changed_params.codec_settings;
989 }
990
991 {
deadbeef13871492015-12-09 12:37:51 -0800992 rtc::CritScope stream_lock(&stream_crit_);
993 for (auto& kv : receive_streams_) {
pbos378dc772016-01-28 15:58:41 -0800994 kv.second->SetRecvParameters(changed_params);
deadbeef13871492015-12-09 12:37:51 -0800995 }
996 }
997 recv_params_ = params;
998 return true;
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700999}
1000
deadbeef874ca3a2015-08-20 17:19:20 -07001001std::string WebRtcVideoChannel2::CodecSettingsVectorToString(
1002 const std::vector<VideoCodecSettings>& codecs) {
1003 std::stringstream out;
1004 out << '{';
1005 for (size_t i = 0; i < codecs.size(); ++i) {
1006 out << codecs[i].codec.ToString();
1007 if (i != codecs.size() - 1) {
1008 out << ", ";
1009 }
1010 }
1011 out << '}';
1012 return out.str();
1013}
1014
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001015bool WebRtcVideoChannel2::GetSendCodec(VideoCodec* codec) {
kwiberg102c6a62015-10-30 02:47:38 -07001016 if (!send_codec_) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001017 LOG(LS_VERBOSE) << "GetSendCodec: No send codec set.";
1018 return false;
1019 }
kwiberg102c6a62015-10-30 02:47:38 -07001020 *codec = send_codec_->codec;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001021 return true;
1022}
1023
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001024bool WebRtcVideoChannel2::SetSend(bool send) {
Peter Boströmdabc9442016-04-11 11:45:14 +02001025 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetSend");
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001026 LOG(LS_VERBOSE) << "SetSend: " << (send ? "true" : "false");
kwiberg102c6a62015-10-30 02:47:38 -07001027 if (send && !send_codec_) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001028 LOG(LS_ERROR) << "SetSend(true) called before setting codec.";
1029 return false;
1030 }
deadbeefdbe2b872016-03-22 15:42:00 -07001031 {
1032 rtc::CritScope stream_lock(&stream_crit_);
1033 for (const auto& kv : send_streams_) {
1034 kv.second->SetSend(send);
1035 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001036 }
1037 sending_ = send;
1038 return true;
1039}
1040
nisse2ded9b12016-04-08 02:23:55 -07001041// TODO(nisse): The enable argument was used for mute logic which has
deadbeef5a4a75a2016-06-02 16:23:38 -07001042// been moved to VideoBroadcaster. So remove the argument from this
1043// method.
1044bool WebRtcVideoChannel2::SetVideoSend(
1045 uint32_t ssrc,
1046 bool enable,
1047 const VideoOptions* options,
nisseacd935b2016-11-11 03:55:13 -08001048 rtc::VideoSourceInterface<webrtc::VideoFrame>* source) {
Peter Boström3afc8c42016-01-27 16:45:21 +01001049 TRACE_EVENT0("webrtc", "SetVideoSend");
deadbeef5a4a75a2016-06-02 16:23:38 -07001050 RTC_DCHECK(ssrc != 0);
Peter Boström3afc8c42016-01-27 16:45:21 +01001051 LOG(LS_INFO) << "SetVideoSend (ssrc= " << ssrc << ", enable = " << enable
deadbeef5a4a75a2016-06-02 16:23:38 -07001052 << ", options: " << (options ? options->ToString() : "nullptr")
1053 << ", source = " << (source ? "(source)" : "nullptr") << ")";
Peter Boström3afc8c42016-01-27 16:45:21 +01001054
deadbeef5a4a75a2016-06-02 16:23:38 -07001055 rtc::CritScope stream_lock(&stream_crit_);
1056 const auto& kv = send_streams_.find(ssrc);
1057 if (kv == send_streams_.end()) {
1058 // Allow unknown ssrc only if source is null.
1059 RTC_CHECK(source == nullptr);
1060 LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc;
1061 return false;
solenberg1dd98f32015-09-10 01:57:14 -07001062 }
deadbeef5a4a75a2016-06-02 16:23:38 -07001063
1064 return kv->second->SetVideoSend(enable, options, source);
solenberg1dd98f32015-09-10 01:57:14 -07001065}
1066
Peter Boströmd6f4c252015-03-26 16:23:04 +01001067bool WebRtcVideoChannel2::ValidateSendSsrcAvailability(
1068 const StreamParams& sp) const {
Pera5092412016-02-12 13:30:57 +01001069 for (uint32_t ssrc : sp.ssrcs) {
Peter Boströmd6f4c252015-03-26 16:23:04 +01001070 if (send_ssrcs_.find(ssrc) != send_ssrcs_.end()) {
1071 LOG(LS_ERROR) << "Send stream with SSRC '" << ssrc << "' already exists.";
1072 return false;
1073 }
1074 }
1075 return true;
1076}
1077
1078bool WebRtcVideoChannel2::ValidateReceiveSsrcAvailability(
1079 const StreamParams& sp) const {
Pera5092412016-02-12 13:30:57 +01001080 for (uint32_t ssrc : sp.ssrcs) {
Peter Boströmd6f4c252015-03-26 16:23:04 +01001081 if (receive_ssrcs_.find(ssrc) != receive_ssrcs_.end()) {
1082 LOG(LS_ERROR) << "Receive stream with SSRC '" << ssrc
1083 << "' already exists.";
1084 return false;
1085 }
1086 }
1087 return true;
1088}
1089
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001090bool WebRtcVideoChannel2::AddSendStream(const StreamParams& sp) {
1091 LOG(LS_INFO) << "AddSendStream: " << sp.ToString();
Peter Boströmd4362cd2015-03-25 14:17:23 +01001092 if (!ValidateStreamParams(sp))
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001093 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001094
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001095 rtc::CritScope stream_lock(&stream_crit_);
Peter Boströmd6f4c252015-03-26 16:23:04 +01001096
1097 if (!ValidateSendSsrcAvailability(sp))
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001098 return false;
Peter Boströmd6f4c252015-03-26 16:23:04 +01001099
Peter Boström0c4e06b2015-10-07 12:23:21 +02001100 for (uint32_t used_ssrc : sp.ssrcs)
Peter Boströmd6f4c252015-03-26 16:23:04 +01001101 send_ssrcs_.insert(used_ssrc);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001102
solenberge5269742015-09-08 05:13:22 -07001103 webrtc::VideoSendStream::Config config(this);
nisse0db023a2016-03-01 04:29:59 -08001104 config.suspend_below_min_bitrate = video_config_.suspend_below_min_bitrate;
sergeyu80ed35e2016-11-28 13:11:13 -08001105 config.periodic_alr_bandwidth_probing =
1106 video_config_.periodic_alr_bandwidth_probing;
nisse05103312016-03-16 02:22:50 -07001107 WebRtcVideoSendStream* stream = new WebRtcVideoSendStream(
perkj26091b12016-09-01 01:17:40 -07001108 call_, sp, std::move(config), default_send_options_,
1109 external_encoder_factory_, video_config_.enable_cpu_overuse_detection,
nisse05103312016-03-16 02:22:50 -07001110 bitrate_config_.max_bitrate_bps, send_codec_, send_rtp_extensions_,
1111 send_params_);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001112
Peter Boström0c4e06b2015-10-07 12:23:21 +02001113 uint32_t ssrc = sp.first_ssrc();
henrikg91d6ede2015-09-17 00:24:34 -07001114 RTC_DCHECK(ssrc != 0);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001115 send_streams_[ssrc] = stream;
1116
1117 if (rtcp_receiver_report_ssrc_ == kDefaultRtcpReceiverReportSsrc) {
1118 rtcp_receiver_report_ssrc_ = ssrc;
deadbeef874ca3a2015-08-20 17:19:20 -07001119 LOG(LS_INFO) << "SetLocalSsrc on all the receive streams because we added "
1120 "a send stream.";
Peter Boström3548dd22015-05-22 18:48:36 +02001121 for (auto& kv : receive_streams_)
1122 kv.second->SetLocalSsrc(ssrc);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001123 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001124 if (sending_) {
deadbeefdbe2b872016-03-22 15:42:00 -07001125 stream->SetSend(true);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001126 }
1127
1128 return true;
1129}
1130
Peter Boström0c4e06b2015-10-07 12:23:21 +02001131bool WebRtcVideoChannel2::RemoveSendStream(uint32_t ssrc) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001132 LOG(LS_INFO) << "RemoveSendStream: " << ssrc;
1133
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001134 WebRtcVideoSendStream* removed_stream;
1135 {
1136 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001137 std::map<uint32_t, WebRtcVideoSendStream*>::iterator it =
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001138 send_streams_.find(ssrc);
1139 if (it == send_streams_.end()) {
1140 return false;
1141 }
1142
Peter Boström0c4e06b2015-10-07 12:23:21 +02001143 for (uint32_t old_ssrc : it->second->GetSsrcs())
Peter Boströmd6f4c252015-03-26 16:23:04 +01001144 send_ssrcs_.erase(old_ssrc);
1145
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001146 removed_stream = it->second;
1147 send_streams_.erase(it);
Peter Boströmdfa28152015-10-21 17:21:10 +02001148
1149 // Switch receiver report SSRCs, the one in use is no longer valid.
1150 if (rtcp_receiver_report_ssrc_ == ssrc) {
1151 rtcp_receiver_report_ssrc_ = send_streams_.empty()
1152 ? kDefaultRtcpReceiverReportSsrc
1153 : send_streams_.begin()->first;
1154 LOG(LS_INFO) << "SetLocalSsrc on all the receive streams because the "
1155 "previous local SSRC was removed.";
1156
1157 for (auto& kv : receive_streams_) {
1158 kv.second->SetLocalSsrc(rtcp_receiver_report_ssrc_);
1159 }
1160 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001161 }
1162
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001163 delete removed_stream;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001164
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001165 return true;
1166}
1167
Peter Boströmd6f4c252015-03-26 16:23:04 +01001168void WebRtcVideoChannel2::DeleteReceiveStream(
1169 WebRtcVideoChannel2::WebRtcVideoReceiveStream* stream) {
Peter Boström0c4e06b2015-10-07 12:23:21 +02001170 for (uint32_t old_ssrc : stream->GetSsrcs())
Peter Boströmd6f4c252015-03-26 16:23:04 +01001171 receive_ssrcs_.erase(old_ssrc);
1172 delete stream;
1173}
1174
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001175bool WebRtcVideoChannel2::AddRecvStream(const StreamParams& sp) {
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00001176 return AddRecvStream(sp, false);
1177}
1178
1179bool WebRtcVideoChannel2::AddRecvStream(const StreamParams& sp,
1180 bool default_stream) {
henrikg91d6ede2015-09-17 00:24:34 -07001181 RTC_DCHECK(thread_checker_.CalledOnValidThread());
Fredrik Solenberg4b60c732015-05-07 14:07:48 +02001182
Peter Boströmd4362cd2015-03-25 14:17:23 +01001183 LOG(LS_INFO) << "AddRecvStream" << (default_stream ? " (default stream)" : "")
1184 << ": " << sp.ToString();
1185 if (!ValidateStreamParams(sp))
1186 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001187
Peter Boström0c4e06b2015-10-07 12:23:21 +02001188 uint32_t ssrc = sp.first_ssrc();
henrikg91d6ede2015-09-17 00:24:34 -07001189 RTC_DCHECK(ssrc != 0); // TODO(pbos): Is this ever valid?
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001190
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001191 rtc::CritScope stream_lock(&stream_crit_);
Peter Boströmd6f4c252015-03-26 16:23:04 +01001192 // Remove running stream if this was a default stream.
nissea293ef02016-02-17 07:24:50 -08001193 const auto& prev_stream = receive_streams_.find(ssrc);
Peter Boströmd6f4c252015-03-26 16:23:04 +01001194 if (prev_stream != receive_streams_.end()) {
1195 if (default_stream || !prev_stream->second->IsDefaultStream()) {
1196 LOG(LS_ERROR) << "Receive stream for SSRC '" << ssrc
1197 << "' already exists.";
1198 return false;
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00001199 }
Peter Boströmd6f4c252015-03-26 16:23:04 +01001200 DeleteReceiveStream(prev_stream->second);
1201 receive_streams_.erase(prev_stream);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001202 }
1203
Peter Boströmd6f4c252015-03-26 16:23:04 +01001204 if (!ValidateReceiveSsrcAvailability(sp))
1205 return false;
1206
Peter Boström0c4e06b2015-10-07 12:23:21 +02001207 for (uint32_t used_ssrc : sp.ssrcs)
Peter Boströmd6f4c252015-03-26 16:23:04 +01001208 receive_ssrcs_.insert(used_ssrc);
1209
solenberg4fbae2b2015-08-28 04:07:10 -07001210 webrtc::VideoReceiveStream::Config config(this);
brandtr468da7c2016-11-22 02:16:47 -08001211 webrtc::FlexfecConfig flexfec_config;
1212 ConfigureReceiverRtp(&config, &flexfec_config, sp);
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +00001213
pbos8fc7fa72015-07-15 08:02:58 -07001214 // Set up A/V sync group based on sync label.
1215 config.sync_group = sp.sync_label;
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +00001216
kwiberg102c6a62015-10-30 02:47:38 -07001217 config.rtp.remb = send_codec_ ? HasRemb(send_codec_->codec) : false;
stefan43edf0f2015-11-20 18:05:48 -08001218 config.rtp.transport_cc =
1219 send_codec_ ? HasTransportCc(send_codec_->codec) : false;
nisse7ade7b32016-03-23 04:48:10 -07001220 config.disable_prerenderer_smoothing =
1221 video_config_.disable_prerenderer_smoothing;
Peter Boström126c03e2015-05-11 12:48:12 +02001222
Peter Boströmd6f4c252015-03-26 16:23:04 +01001223 receive_streams_[ssrc] = new WebRtcVideoReceiveStream(
Tommi733b5472016-06-10 17:58:01 +02001224 call_, sp, std::move(config), external_decoder_factory_, default_stream,
brandtr468da7c2016-11-22 02:16:47 -08001225 recv_codecs_, flexfec_config);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001226
1227 return true;
1228}
1229
1230void WebRtcVideoChannel2::ConfigureReceiverRtp(
1231 webrtc::VideoReceiveStream::Config* config,
brandtr468da7c2016-11-22 02:16:47 -08001232 webrtc::FlexfecConfig* flexfec_config,
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001233 const StreamParams& sp) const {
Peter Boström0c4e06b2015-10-07 12:23:21 +02001234 uint32_t ssrc = sp.first_ssrc();
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001235
1236 config->rtp.remote_ssrc = ssrc;
1237 config->rtp.local_ssrc = rtcp_receiver_report_ssrc_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001238
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001239 config->rtp.extensions = recv_rtp_extensions_;
Taylor Brandstetter5f0b83b2016-03-18 15:02:07 -07001240 // Whether or not the receive stream sends reduced size RTCP is determined
1241 // by the send params.
1242 // TODO(deadbeef): Once we change "send_params" to "sender_params" and
1243 // "recv_params" to "receiver_params", we should get this out of
1244 // receiver_params_.
1245 config->rtp.rtcp_mode = send_params_.rtcp.reduced_size
deadbeef13871492015-12-09 12:37:51 -08001246 ? webrtc::RtcpMode::kReducedSize
1247 : webrtc::RtcpMode::kCompound;
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001248
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001249 // TODO(pbos): This protection is against setting the same local ssrc as
1250 // remote which is not permitted by the lower-level API. RTCP requires a
1251 // corresponding sender SSRC. Figure out what to do when we don't have
1252 // (receive-only) or know a good local SSRC.
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001253 if (config->rtp.remote_ssrc == config->rtp.local_ssrc) {
1254 if (config->rtp.local_ssrc != kDefaultRtcpReceiverReportSsrc) {
1255 config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001256 } else {
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001257 config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc + 1;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001258 }
1259 }
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001260
1261 for (size_t i = 0; i < recv_codecs_.size(); ++i) {
Peter Boström0c4e06b2015-10-07 12:23:21 +02001262 uint32_t rtx_ssrc;
andresp@webrtc.org82775b12014-11-07 09:37:54 +00001263 if (recv_codecs_[i].rtx_payload_type != -1 &&
1264 sp.GetFidSsrc(ssrc, &rtx_ssrc)) {
1265 webrtc::VideoReceiveStream::Config::Rtp::Rtx& rtx =
1266 config->rtp.rtx[recv_codecs_[i].codec.id];
1267 rtx.ssrc = rtx_ssrc;
1268 rtx.payload_type = recv_codecs_[i].rtx_payload_type;
1269 }
1270 }
brandtr468da7c2016-11-22 02:16:47 -08001271
1272 // TODO(brandtr): This code needs to be generalized when we add support for
1273 // multistream protection.
1274 uint32_t flexfec_ssrc;
1275 if (sp.GetFecFrSsrc(ssrc, &flexfec_ssrc)) {
1276 flexfec_config->flexfec_ssrc = flexfec_ssrc;
1277 flexfec_config->protected_media_ssrcs = {ssrc};
1278 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001279}
1280
Peter Boström0c4e06b2015-10-07 12:23:21 +02001281bool WebRtcVideoChannel2::RemoveRecvStream(uint32_t ssrc) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001282 LOG(LS_INFO) << "RemoveRecvStream: " << ssrc;
1283 if (ssrc == 0) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001284 LOG(LS_ERROR) << "RemoveRecvStream with 0 ssrc is not supported.";
1285 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001286 }
1287
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001288 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001289 std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator stream =
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001290 receive_streams_.find(ssrc);
1291 if (stream == receive_streams_.end()) {
1292 LOG(LS_ERROR) << "Stream not found for ssrc: " << ssrc;
1293 return false;
1294 }
Peter Boströmd6f4c252015-03-26 16:23:04 +01001295 DeleteReceiveStream(stream->second);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001296 receive_streams_.erase(stream);
1297
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001298 return true;
1299}
1300
nisseacd935b2016-11-11 03:55:13 -08001301bool WebRtcVideoChannel2::SetSink(
1302 uint32_t ssrc,
1303 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
deadbeef5a4a75a2016-06-02 16:23:38 -07001304 LOG(LS_INFO) << "SetSink: ssrc:" << ssrc << " "
1305 << (sink ? "(ptr)" : "nullptr");
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001306 if (ssrc == 0) {
nisse08582ff2016-02-04 01:24:52 -08001307 default_unsignalled_ssrc_handler_.SetDefaultSink(this, sink);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001308 return true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001309 }
1310
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001311 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001312 std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it =
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001313 receive_streams_.find(ssrc);
1314 if (it == receive_streams_.end()) {
1315 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001316 }
1317
nisse08582ff2016-02-04 01:24:52 -08001318 it->second->SetSink(sink);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001319 return true;
1320}
1321
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00001322bool WebRtcVideoChannel2::GetStats(VideoMediaInfo* info) {
Peter Boströmca8b4042016-03-08 14:24:13 -08001323 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::GetStats");
asapersson2e5cfcd2016-08-11 08:41:18 -07001324
1325 // Log stats periodically.
1326 bool log_stats = false;
1327 int64_t now_ms = rtc::TimeMillis();
1328 if (last_stats_log_ms_ == -1 ||
1329 now_ms - last_stats_log_ms_ > kStatsLogIntervalMs) {
1330 last_stats_log_ms_ = now_ms;
1331 log_stats = true;
1332 }
1333
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001334 info->Clear();
asapersson2e5cfcd2016-08-11 08:41:18 -07001335 FillSenderStats(info, log_stats);
1336 FillReceiverStats(info, log_stats);
hbosa65704b2016-11-14 02:28:16 -08001337 FillSendAndReceiveCodecStats(info);
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00001338 webrtc::Call::Stats stats = call_->GetStats();
1339 FillBandwidthEstimationStats(stats, info);
1340 if (stats.rtt_ms != -1) {
1341 for (size_t i = 0; i < info->senders.size(); ++i) {
1342 info->senders[i].rtt_ms = stats.rtt_ms;
1343 }
1344 }
asapersson2e5cfcd2016-08-11 08:41:18 -07001345
1346 if (log_stats)
1347 LOG(LS_INFO) << stats.ToString(now_ms);
1348
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001349 return true;
1350}
1351
asapersson2e5cfcd2016-08-11 08:41:18 -07001352void WebRtcVideoChannel2::FillSenderStats(VideoMediaInfo* video_media_info,
1353 bool log_stats) {
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001354 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001355 for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator it =
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001356 send_streams_.begin();
Peter Boström0c4e06b2015-10-07 12:23:21 +02001357 it != send_streams_.end(); ++it) {
asapersson2e5cfcd2016-08-11 08:41:18 -07001358 video_media_info->senders.push_back(
1359 it->second->GetVideoSenderInfo(log_stats));
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001360 }
1361}
1362
asapersson2e5cfcd2016-08-11 08:41:18 -07001363void WebRtcVideoChannel2::FillReceiverStats(VideoMediaInfo* video_media_info,
1364 bool log_stats) {
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001365 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001366 for (std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it =
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001367 receive_streams_.begin();
Peter Boström0c4e06b2015-10-07 12:23:21 +02001368 it != receive_streams_.end(); ++it) {
asapersson2e5cfcd2016-08-11 08:41:18 -07001369 video_media_info->receivers.push_back(
1370 it->second->GetVideoReceiverInfo(log_stats));
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001371 }
1372}
1373
1374void WebRtcVideoChannel2::FillBandwidthEstimationStats(
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00001375 const webrtc::Call::Stats& stats,
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001376 VideoMediaInfo* video_media_info) {
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001377 BandwidthEstimationInfo bwe_info;
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001378 bwe_info.available_send_bandwidth = stats.send_bandwidth_bps;
1379 bwe_info.available_recv_bandwidth = stats.recv_bandwidth_bps;
1380 bwe_info.bucket_delay = stats.pacer_delay_ms;
1381
1382 // Get send stream bitrate stats.
1383 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001384 for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator stream =
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001385 send_streams_.begin();
Peter Boström0c4e06b2015-10-07 12:23:21 +02001386 stream != send_streams_.end(); ++stream) {
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001387 stream->second->FillBandwidthEstimationInfo(&bwe_info);
1388 }
1389 video_media_info->bw_estimations.push_back(bwe_info);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001390}
1391
hbosa65704b2016-11-14 02:28:16 -08001392void WebRtcVideoChannel2::FillSendAndReceiveCodecStats(
1393 VideoMediaInfo* video_media_info) {
1394 for (const VideoCodec& codec : send_params_.codecs) {
1395 webrtc::RtpCodecParameters codec_params = codec.ToCodecParameters();
1396 video_media_info->send_codecs.insert(
1397 std::make_pair(codec_params.payload_type, std::move(codec_params)));
1398 }
1399 for (const VideoCodec& codec : recv_params_.codecs) {
1400 webrtc::RtpCodecParameters codec_params = codec.ToCodecParameters();
1401 video_media_info->receive_codecs.insert(
1402 std::make_pair(codec_params.payload_type, std::move(codec_params)));
1403 }
1404}
1405
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001406void WebRtcVideoChannel2::OnPacketReceived(
jbaucheec21bd2016-03-20 06:15:43 -07001407 rtc::CopyOnWriteBuffer* packet,
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001408 const rtc::PacketTime& packet_time) {
stefan68786d22015-09-08 05:36:15 -07001409 const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp,
1410 packet_time.not_before);
pbos@webrtc.org4e545cc2014-05-14 13:58:13 +00001411 const webrtc::PacketReceiver::DeliveryStatus delivery_result =
stefan68786d22015-09-08 05:36:15 -07001412 call_->Receiver()->DeliverPacket(
1413 webrtc::MediaType::VIDEO,
jbaucheec21bd2016-03-20 06:15:43 -07001414 packet->cdata(), packet->size(),
stefan68786d22015-09-08 05:36:15 -07001415 webrtc_packet_time);
pbos@webrtc.org4e545cc2014-05-14 13:58:13 +00001416 switch (delivery_result) {
1417 case webrtc::PacketReceiver::DELIVERY_OK:
1418 return;
1419 case webrtc::PacketReceiver::DELIVERY_PACKET_ERROR:
1420 return;
1421 case webrtc::PacketReceiver::DELIVERY_UNKNOWN_SSRC:
1422 break;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001423 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001424
Peter Boström0c4e06b2015-10-07 12:23:21 +02001425 uint32_t ssrc = 0;
jbaucheec21bd2016-03-20 06:15:43 -07001426 if (!GetRtpSsrc(packet->cdata(), packet->size(), &ssrc)) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001427 return;
1428 }
1429
noahricd10a68e2015-07-10 11:27:55 -07001430 int payload_type = 0;
jbaucheec21bd2016-03-20 06:15:43 -07001431 if (!GetRtpPayloadType(packet->cdata(), packet->size(), &payload_type)) {
noahricd10a68e2015-07-10 11:27:55 -07001432 return;
1433 }
1434
1435 // See if this payload_type is registered as one that usually gets its own
brandtr468da7c2016-11-22 02:16:47 -08001436 // SSRC (RTX) or at least is safe to drop either way (FEC). If it is, and
noahricd10a68e2015-07-10 11:27:55 -07001437 // it wasn't handled above by DeliverPacket, that means we don't know what
1438 // stream it associates with, and we shouldn't ever create an implicit channel
1439 // for these.
1440 for (auto& codec : recv_codecs_) {
1441 if (payload_type == codec.rtx_payload_type ||
brandtrb5f2c3f2016-10-04 23:28:39 -07001442 payload_type == codec.ulpfec.red_rtx_payload_type ||
brandtr468da7c2016-11-22 02:16:47 -08001443 payload_type == codec.ulpfec.ulpfec_payload_type ||
1444 payload_type == codec.flexfec.flexfec_payload_type) {
noahricd10a68e2015-07-10 11:27:55 -07001445 return;
1446 }
1447 }
1448
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001449 switch (unsignalled_ssrc_handler_->OnUnsignalledSsrc(this, ssrc)) {
1450 case UnsignalledSsrcHandler::kDropPacket:
1451 return;
1452 case UnsignalledSsrcHandler::kDeliverPacket:
1453 break;
1454 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001455
stefan68786d22015-09-08 05:36:15 -07001456 if (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) != webrtc::PacketReceiver::DELIVERY_OK) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001460 LOG(LS_WARNING) << "Failed to deliver RTP packet on re-delivery.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001461 return;
1462 }
1463}
1464
1465void WebRtcVideoChannel2::OnRtcpReceived(
jbaucheec21bd2016-03-20 06:15:43 -07001466 rtc::CopyOnWriteBuffer* packet,
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001467 const rtc::PacketTime& packet_time) {
stefan68786d22015-09-08 05:36:15 -07001468 const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp,
1469 packet_time.not_before);
Peter Boström2aff6152015-11-18 13:47:16 +01001470 // TODO(pbos): Check webrtc::PacketReceiver::DELIVERY_OK once we deliver
1471 // for both audio and video on the same path. Since BundleFilter doesn't
1472 // filter RTCP anymore incoming RTCP packets could've been going to audio (so
1473 // logging failures spam the log).
1474 call_->Receiver()->DeliverPacket(
1475 webrtc::MediaType::VIDEO,
jbaucheec21bd2016-03-20 06:15:43 -07001476 packet->cdata(), packet->size(),
Peter Boström2aff6152015-11-18 13:47:16 +01001477 webrtc_packet_time);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001478}
1479
1480void WebRtcVideoChannel2::OnReadyToSend(bool ready) {
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00001481 LOG(LS_VERBOSE) << "OnReadyToSend: " << (ready ? "Ready." : "Not ready.");
skvlad7a43d252016-03-22 15:32:27 -07001482 call_->SignalChannelNetworkState(
1483 webrtc::MediaType::VIDEO,
1484 ready ? webrtc::kNetworkUp : webrtc::kNetworkDown);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001485}
1486
Honghai Zhangcc411c02016-03-29 17:27:21 -07001487void WebRtcVideoChannel2::OnNetworkRouteChanged(
1488 const std::string& transport_name,
Honghai Zhang0e533ef2016-04-19 15:41:36 -07001489 const rtc::NetworkRoute& network_route) {
1490 call_->OnNetworkRouteChanged(transport_name, network_route);
Honghai Zhangcc411c02016-03-29 17:27:21 -07001491}
1492
michaelt79e05882016-11-08 02:50:09 -08001493void WebRtcVideoChannel2::OnTransportOverheadChanged(
1494 int transport_overhead_per_packet) {
1495 call_->OnTransportOverheadChanged(webrtc::MediaType::VIDEO,
1496 transport_overhead_per_packet);
1497}
1498
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001499void WebRtcVideoChannel2::SetInterface(NetworkInterface* iface) {
1500 MediaChannel::SetInterface(iface);
1501 // Set the RTP recv/send buffer to a bigger size
1502 MediaChannel::SetOption(NetworkInterface::ST_RTP,
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001503 rtc::Socket::OPT_RCVBUF,
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001504 kVideoRtpBufferSize);
1505
buildbot@webrtc.orgae694ef2014-10-28 17:37:17 +00001506 // Speculative change to increase the outbound socket buffer size.
1507 // In b/15152257, we are seeing a significant number of packets discarded
1508 // due to lack of socket buffer space, although it's not yet clear what the
1509 // ideal value should be.
1510 MediaChannel::SetOption(NetworkInterface::ST_RTP,
1511 rtc::Socket::OPT_SNDBUF,
1512 kVideoRtpBufferSize);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001513}
1514
stefan1d8a5062015-10-02 03:39:33 -07001515bool WebRtcVideoChannel2::SendRtp(const uint8_t* data,
1516 size_t len,
1517 const webrtc::PacketOptions& options) {
jbaucheec21bd2016-03-20 06:15:43 -07001518 rtc::CopyOnWriteBuffer packet(data, len, kMaxRtpPacketLen);
stefanc1aeaf02015-10-15 07:26:07 -07001519 rtc::PacketOptions rtc_options;
1520 rtc_options.packet_id = options.packet_id;
1521 return MediaChannel::SendPacket(&packet, rtc_options);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001522}
1523
1524bool WebRtcVideoChannel2::SendRtcp(const uint8_t* data, size_t len) {
jbaucheec21bd2016-03-20 06:15:43 -07001525 rtc::CopyOnWriteBuffer packet(data, len, kMaxRtpPacketLen);
stefanc1aeaf02015-10-15 07:26:07 -07001526 return MediaChannel::SendRtcp(&packet, rtc::PacketOptions());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001527}
1528
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001529WebRtcVideoChannel2::WebRtcVideoSendStream::VideoSendStreamParameters::
1530 VideoSendStreamParameters(
perkj26091b12016-09-01 01:17:40 -07001531 webrtc::VideoSendStream::Config config,
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001532 const VideoOptions& options,
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001533 int max_bitrate_bps,
Karl Wibergbe579832015-11-10 22:34:18 +01001534 const rtc::Optional<VideoCodecSettings>& codec_settings)
perkj26091b12016-09-01 01:17:40 -07001535 : config(std::move(config)),
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001536 options(options),
1537 max_bitrate_bps(max_bitrate_bps),
perkjfa10b552016-10-02 23:45:26 -07001538 conference_mode(false),
kwiberg102c6a62015-10-30 02:47:38 -07001539 codec_settings(codec_settings) {}
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001540
Peter Boström4d71ede2015-05-19 23:09:35 +02001541WebRtcVideoChannel2::WebRtcVideoSendStream::AllocatedEncoder::AllocatedEncoder(
1542 webrtc::VideoEncoder* encoder,
magjed509e4fe2016-11-18 01:34:11 -08001543 const cricket::VideoCodec& codec,
Peter Boström4d71ede2015-05-19 23:09:35 +02001544 bool external)
1545 : encoder(encoder),
1546 external_encoder(nullptr),
magjed509e4fe2016-11-18 01:34:11 -08001547 codec(codec),
Peter Boström4d71ede2015-05-19 23:09:35 +02001548 external(external) {
1549 if (external) {
1550 external_encoder = encoder;
1551 this->encoder =
magjed509e4fe2016-11-18 01:34:11 -08001552 new webrtc::VideoEncoderSoftwareFallbackWrapper(codec, encoder);
Peter Boström4d71ede2015-05-19 23:09:35 +02001553 }
1554}
1555
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001556WebRtcVideoChannel2::WebRtcVideoSendStream::WebRtcVideoSendStream(
1557 webrtc::Call* call,
solenberg4fbae2b2015-08-28 04:07:10 -07001558 const StreamParams& sp,
perkj26091b12016-09-01 01:17:40 -07001559 webrtc::VideoSendStream::Config config,
nisse05103312016-03-16 02:22:50 -07001560 const VideoOptions& options,
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001561 WebRtcVideoEncoderFactory* external_encoder_factory,
perkj2d5f0912016-02-29 00:04:41 -08001562 bool enable_cpu_overuse_detection,
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001563 int max_bitrate_bps,
Karl Wibergbe579832015-11-10 22:34:18 +01001564 const rtc::Optional<VideoCodecSettings>& codec_settings,
skvlad3abb7642016-06-16 12:08:03 -07001565 const rtc::Optional<std::vector<webrtc::RtpExtension>>& rtp_extensions,
deadbeef13871492015-12-09 12:37:51 -08001566 // TODO(deadbeef): Don't duplicate information between send_params,
1567 // rtp_extensions, options, etc.
1568 const VideoSendParameters& send_params)
perkj2d5f0912016-02-29 00:04:41 -08001569 : worker_thread_(rtc::Thread::Current()),
1570 ssrcs_(sp.ssrcs),
Peter Boström259bd202015-05-28 13:39:50 +02001571 ssrc_groups_(sp.ssrc_groups),
Henrik Kjellander7c027b62015-04-22 13:21:30 +02001572 call_(call),
perkj803d97f2016-11-01 11:45:46 -07001573 enable_cpu_overuse_detection_(enable_cpu_overuse_detection),
nisse2ded9b12016-04-08 02:23:55 -07001574 source_(nullptr),
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001575 external_encoder_factory_(external_encoder_factory),
perkj2d5f0912016-02-29 00:04:41 -08001576 stream_(nullptr),
perkja49cbd32016-09-16 07:53:41 -07001577 encoder_sink_(nullptr),
perkj26091b12016-09-01 01:17:40 -07001578 parameters_(std::move(config), options, max_bitrate_bps, codec_settings),
skvladdc1c62c2016-03-16 19:07:43 -07001579 rtp_parameters_(CreateRtpParametersWithOneEncoding()),
magjed509e4fe2016-11-18 01:34:11 -08001580 allocated_encoder_(nullptr, cricket::VideoCodec(), false),
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001581 sending_(false),
nisse74c10b52016-09-05 00:51:16 -07001582 last_frame_timestamp_us_(0) {
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001583 parameters_.config.rtp.max_packet_size = kVideoMtu;
nisse4b4dc862016-02-17 05:25:36 -08001584 parameters_.conference_mode = send_params.conference_mode;
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001585
1586 sp.GetPrimarySsrcs(&parameters_.config.rtp.ssrcs);
brandtr468da7c2016-11-22 02:16:47 -08001587
1588 // RTX.
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001589 sp.GetFidSsrcs(parameters_.config.rtp.ssrcs,
1590 &parameters_.config.rtp.rtx.ssrcs);
brandtr468da7c2016-11-22 02:16:47 -08001591
1592 // FlexFEC.
1593 // TODO(brandtr): This code needs to be generalized when we add support for
1594 // multistream protection.
1595 if (IsFlexfecFieldTrialEnabled()) {
1596 uint32_t flexfec_ssrc;
1597 bool flexfec_enabled = false;
1598 for (uint32_t primary_ssrc : parameters_.config.rtp.ssrcs) {
1599 if (sp.GetFecFrSsrc(primary_ssrc, &flexfec_ssrc)) {
1600 if (flexfec_enabled) {
1601 LOG(LS_INFO) << "Multiple FlexFEC streams proposed by remote, but "
1602 "our implementation only supports a single FlexFEC "
1603 "stream. Will not enable FlexFEC for proposed "
1604 "stream with SSRC: "
1605 << flexfec_ssrc << ".";
1606 continue;
1607 }
1608
1609 flexfec_enabled = true;
1610 parameters_.config.rtp.flexfec.flexfec_ssrc = flexfec_ssrc;
1611 parameters_.config.rtp.flexfec.protected_media_ssrcs = {primary_ssrc};
1612 }
1613 }
1614 }
1615
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001616 parameters_.config.rtp.c_name = sp.cname;
skvlad3abb7642016-06-16 12:08:03 -07001617 if (rtp_extensions) {
1618 parameters_.config.rtp.extensions = *rtp_extensions;
1619 }
deadbeef13871492015-12-09 12:37:51 -08001620 parameters_.config.rtp.rtcp_mode = send_params.rtcp.reduced_size
1621 ? webrtc::RtcpMode::kReducedSize
1622 : webrtc::RtcpMode::kCompound;
kwiberg102c6a62015-10-30 02:47:38 -07001623 if (codec_settings) {
nisse0db023a2016-03-01 04:29:59 -08001624 SetCodec(*codec_settings);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001625 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001626}
1627
1628WebRtcVideoChannel2::WebRtcVideoSendStream::~WebRtcVideoSendStream() {
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001629 if (stream_ != NULL) {
1630 call_->DestroyVideoSendStream(stream_);
1631 }
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001632 DestroyVideoEncoder(&allocated_encoder_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001633}
1634
Pera5092412016-02-12 13:30:57 +01001635void WebRtcVideoChannel2::WebRtcVideoSendStream::OnFrame(
nisseacd935b2016-11-11 03:55:13 -08001636 const webrtc::VideoFrame& frame) {
Pera5092412016-02-12 13:30:57 +01001637 TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::OnFrame");
nisse74c10b52016-09-05 00:51:16 -07001638 webrtc::VideoFrame video_frame(frame.video_frame_buffer(),
1639 frame.rotation(),
1640 frame.timestamp_us());
1641
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001642 rtc::CritScope cs(&lock_);
skvlad3abb7642016-06-16 12:08:03 -07001643
1644 if (video_frame.width() != last_frame_info_.width ||
1645 video_frame.height() != last_frame_info_.height ||
1646 video_frame.rotation() != last_frame_info_.rotation ||
1647 video_frame.is_texture() != last_frame_info_.is_texture) {
1648 last_frame_info_.width = video_frame.width();
1649 last_frame_info_.height = video_frame.height();
1650 last_frame_info_.rotation = video_frame.rotation();
1651 last_frame_info_.is_texture = video_frame.is_texture();
skvlad3abb7642016-06-16 12:08:03 -07001652
1653 LOG(LS_INFO) << "Video frame parameters changed: dimensions="
1654 << last_frame_info_.width << "x" << last_frame_info_.height
1655 << ", rotation=" << last_frame_info_.rotation
1656 << ", texture=" << last_frame_info_.is_texture;
1657 }
1658
perkja49cbd32016-09-16 07:53:41 -07001659 if (encoder_sink_ == NULL) {
Peter Boströmad1f9b62015-04-08 14:04:01 +02001660 // Frame input before send codecs are configured, dropping frame.
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001661 return;
1662 }
pbos@webrtc.org86196c42015-02-16 21:02:00 +00001663
nisse74c10b52016-09-05 00:51:16 -07001664 last_frame_timestamp_us_ = video_frame.timestamp_us();
skvlad3abb7642016-06-16 12:08:03 -07001665
perkjfa10b552016-10-02 23:45:26 -07001666 // Forward frame to the encoder regardless if we are sending or not. This is
1667 // to ensure that the encoder can be reconfigured with the correct frame size
1668 // as quickly as possible.
perkja49cbd32016-09-16 07:53:41 -07001669 encoder_sink_->OnFrame(video_frame);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001670}
1671
deadbeef5a4a75a2016-06-02 16:23:38 -07001672bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetVideoSend(
1673 bool enable,
1674 const VideoOptions* options,
nisseacd935b2016-11-11 03:55:13 -08001675 rtc::VideoSourceInterface<webrtc::VideoFrame>* source) {
deadbeef5a4a75a2016-06-02 16:23:38 -07001676 TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::SetVideoSend");
perkjfa10b552016-10-02 23:45:26 -07001677 RTC_DCHECK_RUN_ON(&thread_checker_);
nisse2ded9b12016-04-08 02:23:55 -07001678
deadbeef5a4a75a2016-06-02 16:23:38 -07001679 // Ignore |options| pointer if |enable| is false.
1680 bool options_present = enable && options;
1681 bool source_changing = source_ != source;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001682
perkjfa10b552016-10-02 23:45:26 -07001683 if (options_present) {
1684 VideoOptions old_options = parameters_.options;
1685 parameters_.options.SetAll(*options);
1686 if (parameters_.options != old_options) {
1687 ReconfigureEncoder();
perkj3b703ed2016-09-29 23:25:40 -07001688 }
perkj26105b42016-09-29 22:39:10 -07001689 }
1690
perkjfa10b552016-10-02 23:45:26 -07001691 if (source_changing) {
1692 rtc::CritScope cs(&lock_);
perkj803d97f2016-11-01 11:45:46 -07001693 if (source == nullptr && last_frame_info_.width > 0 && encoder_sink_) {
perkjfa10b552016-10-02 23:45:26 -07001694 LOG(LS_VERBOSE) << "Disabling capturer, sending black frame.";
1695 // Force this black frame not to be dropped due to timestamp order
1696 // check. As IncomingCapturedFrame will drop the frame if this frame's
1697 // timestamp is less than or equal to last frame's timestamp, it is
1698 // necessary to give this black frame a larger timestamp than the
1699 // previous one.
1700 last_frame_timestamp_us_ += rtc::kNumMicrosecsPerMillisec;
1701 rtc::scoped_refptr<webrtc::I420Buffer> black_buffer(
1702 webrtc::I420Buffer::Create(last_frame_info_.width,
1703 last_frame_info_.height));
1704 black_buffer->SetToBlack();
1705
1706 encoder_sink_->OnFrame(webrtc::VideoFrame(
1707 black_buffer, last_frame_info_.rotation, last_frame_timestamp_us_));
1708 }
perkjfa10b552016-10-02 23:45:26 -07001709 }
1710
perkj803d97f2016-11-01 11:45:46 -07001711 // TODO(perkj, nisse): Remove |source_| and directly call
1712 // |stream_|->SetSource(source) once the video frame types have been
1713 // merged.
1714 if (source_ && stream_) {
1715 stream_->SetSource(
1716 nullptr, webrtc::VideoSendStream::DegradationPreference::kBalanced);
1717 }
1718 // Switch to the new source.
1719 source_ = source;
1720 if (source && stream_) {
1721 // Do not adapt resolution for screen content as this will likely
1722 // result in blurry and unreadable text.
1723 stream_->SetSource(
1724 this, enable_cpu_overuse_detection_ &&
1725 !parameters_.options.is_screencast.value_or(false)
1726 ? webrtc::VideoSendStream::DegradationPreference::kBalanced
1727 : webrtc::VideoSendStream::DegradationPreference::
1728 kMaintainResolution);
nisse2ded9b12016-04-08 02:23:55 -07001729 }
deadbeef5a4a75a2016-06-02 16:23:38 -07001730 return true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001731}
1732
Peter Boström0c4e06b2015-10-07 12:23:21 +02001733const std::vector<uint32_t>&
Peter Boströmd6f4c252015-03-26 16:23:04 +01001734WebRtcVideoChannel2::WebRtcVideoSendStream::GetSsrcs() const {
1735 return ssrcs_;
1736}
1737
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001738WebRtcVideoChannel2::WebRtcVideoSendStream::AllocatedEncoder
1739WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoder(
1740 const VideoCodec& codec) {
perkjfa10b552016-10-02 23:45:26 -07001741 RTC_DCHECK_RUN_ON(&thread_checker_);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001742 // Do not re-create encoders of the same type.
magjed509e4fe2016-11-18 01:34:11 -08001743 if (codec == allocated_encoder_.codec &&
1744 allocated_encoder_.encoder != nullptr) {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001745 return allocated_encoder_;
1746 }
1747
magjed509e4fe2016-11-18 01:34:11 -08001748 // Try creating external encoder.
1749 if (external_encoder_factory_ != nullptr &&
1750 FindMatchingCodec(external_encoder_factory_->supported_codecs(), codec)) {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001751 webrtc::VideoEncoder* encoder =
magjed1e45cc62016-10-28 07:43:45 -07001752 external_encoder_factory_->CreateVideoEncoder(codec);
magjed509e4fe2016-11-18 01:34:11 -08001753 if (encoder != nullptr)
1754 return AllocatedEncoder(encoder, codec, true /* is_external */);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001755 }
1756
magjed509e4fe2016-11-18 01:34:11 -08001757 // Try creating internal encoder.
1758 InternalEncoderFactory internal_encoder_factory;
1759 if (FindMatchingCodec(internal_encoder_factory.supported_codecs(), codec)) {
1760 return AllocatedEncoder(internal_encoder_factory.CreateVideoEncoder(codec),
1761 codec, false /* is_external */);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001762 }
1763
1764 // This shouldn't happen, we should not be trying to create something we don't
1765 // support.
henrikg91d6ede2015-09-17 00:24:34 -07001766 RTC_DCHECK(false);
magjed509e4fe2016-11-18 01:34:11 -08001767 return AllocatedEncoder(NULL, cricket::VideoCodec(), false);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001768}
1769
1770void WebRtcVideoChannel2::WebRtcVideoSendStream::DestroyVideoEncoder(
1771 AllocatedEncoder* encoder) {
perkjfa10b552016-10-02 23:45:26 -07001772 RTC_DCHECK_RUN_ON(&thread_checker_);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001773 if (encoder->external) {
Peter Boström4d71ede2015-05-19 23:09:35 +02001774 external_encoder_factory_->DestroyVideoEncoder(encoder->external_encoder);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001775 }
Peter Boström4d71ede2015-05-19 23:09:35 +02001776 delete encoder->encoder;
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001777}
1778
nisse0db023a2016-03-01 04:29:59 -08001779void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodec(
1780 const VideoCodecSettings& codec_settings) {
perkjfa10b552016-10-02 23:45:26 -07001781 RTC_DCHECK_RUN_ON(&thread_checker_);
skvlad3abb7642016-06-16 12:08:03 -07001782 parameters_.encoder_config = CreateVideoEncoderConfig(codec_settings.codec);
kwibergaf476c72016-11-28 15:21:39 -08001783 RTC_DCHECK_GT(parameters_.encoder_config.number_of_streams, 0);
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001784
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001785 AllocatedEncoder new_encoder = CreateVideoEncoder(codec_settings.codec);
1786 parameters_.config.encoder_settings.encoder = new_encoder.encoder;
Peter Boströme4499152016-02-05 11:13:28 +01001787 parameters_.config.encoder_settings.full_overuse_time = new_encoder.external;
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001788 parameters_.config.encoder_settings.payload_name = codec_settings.codec.name;
1789 parameters_.config.encoder_settings.payload_type = codec_settings.codec.id;
sophiechang47d78cc2015-09-03 18:24:44 -07001790 if (new_encoder.external) {
magjed10165ab2016-11-22 10:16:57 -08001791 webrtc::VideoCodecType type =
1792 webrtc::PayloadNameToCodecType(codec_settings.codec.name)
1793 .value_or(webrtc::kVideoCodecUnknown);
sophiechang47d78cc2015-09-03 18:24:44 -07001794 parameters_.config.encoder_settings.internal_source =
1795 external_encoder_factory_->EncoderTypeHasInternalSource(type);
1796 }
brandtrb5f2c3f2016-10-04 23:28:39 -07001797 parameters_.config.rtp.ulpfec = codec_settings.ulpfec;
brandtr468da7c2016-11-22 02:16:47 -08001798 parameters_.config.rtp.flexfec.flexfec_payload_type =
1799 codec_settings.flexfec.flexfec_payload_type;
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001800
1801 // Set RTX payload type if RTX is enabled.
1802 if (!parameters_.config.rtp.rtx.ssrcs.empty()) {
pbos@webrtc.orgb9557a92015-03-20 19:52:56 +00001803 if (codec_settings.rtx_payload_type == -1) {
1804 LOG(LS_WARNING) << "RTX SSRCs configured but there's no configured RTX "
1805 "payload type. Ignoring.";
1806 parameters_.config.rtp.rtx.ssrcs.clear();
1807 } else {
1808 parameters_.config.rtp.rtx.payload_type = codec_settings.rtx_payload_type;
1809 }
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001810 }
1811
Peter Boström67c9df72015-05-11 14:34:58 +02001812 parameters_.config.rtp.nack.rtp_history_ms =
1813 HasNack(codec_settings.codec) ? kNackHistoryMs : 0;
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001814
kwiberg102c6a62015-10-30 02:47:38 -07001815 parameters_.codec_settings =
Karl Wibergbe579832015-11-10 22:34:18 +01001816 rtc::Optional<WebRtcVideoChannel2::VideoCodecSettings>(codec_settings);
Niels Möller60653ba2016-03-02 11:41:36 +01001817
1818 LOG(LS_INFO) << "RecreateWebRtcStream (send) because of SetCodec.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001819 RecreateWebRtcStream();
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001820 if (allocated_encoder_.encoder != new_encoder.encoder) {
1821 DestroyVideoEncoder(&allocated_encoder_);
1822 allocated_encoder_ = new_encoder;
1823 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001824}
1825
deadbeef13871492015-12-09 12:37:51 -08001826void WebRtcVideoChannel2::WebRtcVideoSendStream::SetSendParameters(
Peter Boström3afc8c42016-01-27 16:45:21 +01001827 const ChangedSendParameters& params) {
perkjfa10b552016-10-02 23:45:26 -07001828 RTC_DCHECK_RUN_ON(&thread_checker_);
1829 // |recreate_stream| means construction-time parameters have changed and the
1830 // sending stream needs to be reset with the new config.
1831 bool recreate_stream = false;
1832 if (params.rtcp_mode) {
1833 parameters_.config.rtp.rtcp_mode = *params.rtcp_mode;
1834 recreate_stream = true;
1835 }
1836 if (params.rtp_header_extensions) {
1837 parameters_.config.rtp.extensions = *params.rtp_header_extensions;
1838 recreate_stream = true;
1839 }
1840 if (params.max_bandwidth_bps) {
1841 parameters_.max_bitrate_bps = *params.max_bandwidth_bps;
1842 ReconfigureEncoder();
1843 }
1844 if (params.conference_mode) {
1845 parameters_.conference_mode = *params.conference_mode;
1846 }
perkjf0dcfe22016-03-10 18:32:00 +01001847
perkjfa10b552016-10-02 23:45:26 -07001848 // Set codecs and options.
1849 if (params.codec) {
1850 SetCodec(*params.codec);
1851 recreate_stream = false; // SetCodec has already recreated the stream.
1852 } else if (params.conference_mode && parameters_.codec_settings) {
1853 SetCodec(*parameters_.codec_settings);
1854 recreate_stream = false; // SetCodec has already recreated the stream.
1855 }
1856 if (recreate_stream) {
1857 LOG(LS_INFO) << "RecreateWebRtcStream (send) because of SetSendParameters";
1858 RecreateWebRtcStream();
1859 }
deadbeef13871492015-12-09 12:37:51 -08001860}
1861
skvladdc1c62c2016-03-16 19:07:43 -07001862bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetRtpParameters(
1863 const webrtc::RtpParameters& new_parameters) {
perkjfa10b552016-10-02 23:45:26 -07001864 RTC_DCHECK_RUN_ON(&thread_checker_);
skvladdc1c62c2016-03-16 19:07:43 -07001865 if (!ValidateRtpParameters(new_parameters)) {
1866 return false;
1867 }
1868
perkjfa10b552016-10-02 23:45:26 -07001869 bool reconfigure_encoder = new_parameters.encodings[0].max_bitrate_bps !=
1870 rtp_parameters_.encodings[0].max_bitrate_bps;
skvladdc1c62c2016-03-16 19:07:43 -07001871 rtp_parameters_ = new_parameters;
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07001872 // Codecs are currently handled at the WebRtcVideoChannel2 level.
1873 rtp_parameters_.codecs.clear();
perkjfa10b552016-10-02 23:45:26 -07001874 if (reconfigure_encoder) {
1875 ReconfigureEncoder();
1876 }
deadbeefdbe2b872016-03-22 15:42:00 -07001877 // Encoding may have been activated/deactivated.
1878 UpdateSendState();
skvladdc1c62c2016-03-16 19:07:43 -07001879 return true;
1880}
1881
deadbeefdbe2b872016-03-22 15:42:00 -07001882webrtc::RtpParameters
1883WebRtcVideoChannel2::WebRtcVideoSendStream::GetRtpParameters() const {
perkjfa10b552016-10-02 23:45:26 -07001884 RTC_DCHECK_RUN_ON(&thread_checker_);
deadbeefdbe2b872016-03-22 15:42:00 -07001885 return rtp_parameters_;
1886}
1887
skvladdc1c62c2016-03-16 19:07:43 -07001888bool WebRtcVideoChannel2::WebRtcVideoSendStream::ValidateRtpParameters(
1889 const webrtc::RtpParameters& rtp_parameters) {
1890 if (rtp_parameters.encodings.size() != 1) {
1891 LOG(LS_ERROR)
1892 << "Attempted to set RtpParameters without exactly one encoding";
1893 return false;
1894 }
1895 return true;
1896}
1897
deadbeefdbe2b872016-03-22 15:42:00 -07001898void WebRtcVideoChannel2::WebRtcVideoSendStream::UpdateSendState() {
perkjfa10b552016-10-02 23:45:26 -07001899 RTC_DCHECK_RUN_ON(&thread_checker_);
deadbeefdbe2b872016-03-22 15:42:00 -07001900 // TODO(deadbeef): Need to handle more than one encoding in the future.
1901 RTC_DCHECK(rtp_parameters_.encodings.size() == 1u);
1902 if (sending_ && rtp_parameters_.encodings[0].active) {
1903 RTC_DCHECK(stream_ != nullptr);
1904 stream_->Start();
1905 } else {
1906 if (stream_ != nullptr) {
1907 stream_->Stop();
1908 }
1909 }
1910}
1911
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001912webrtc::VideoEncoderConfig
1913WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoderConfig(
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001914 const VideoCodec& codec) const {
perkjfa10b552016-10-02 23:45:26 -07001915 RTC_DCHECK_RUN_ON(&thread_checker_);
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001916 webrtc::VideoEncoderConfig encoder_config;
Niels Möller60653ba2016-03-02 11:41:36 +01001917 bool is_screencast = parameters_.options.is_screencast.value_or(false);
1918 if (is_screencast) {
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001919 encoder_config.min_transmit_bitrate_bps =
nisse51542be2016-02-12 02:27:06 -08001920 1000 * parameters_.options.screencast_min_bitrate_kbps.value_or(0);
Erik Språng143cec12015-04-28 10:01:41 +02001921 encoder_config.content_type =
1922 webrtc::VideoEncoderConfig::ContentType::kScreen;
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001923 } else {
1924 encoder_config.min_transmit_bitrate_bps = 0;
Erik Språng143cec12015-04-28 10:01:41 +02001925 encoder_config.content_type =
1926 webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo;
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001927 }
1928
noahricfdac5162015-08-27 01:59:29 -07001929 // By default, the stream count for the codec configuration should match the
1930 // number of negotiated ssrcs. But if the codec is blacklisted for simulcast
1931 // or a screencast, only configure a single stream.
perkjfa10b552016-10-02 23:45:26 -07001932 encoder_config.number_of_streams = parameters_.config.rtp.ssrcs.size();
Niels Möller60653ba2016-03-02 11:41:36 +01001933 if (IsCodecBlacklistedForSimulcast(codec.name) || is_screencast) {
perkjfa10b552016-10-02 23:45:26 -07001934 encoder_config.number_of_streams = 1;
noahricfdac5162015-08-27 01:59:29 -07001935 }
1936
skvladdc1c62c2016-03-16 19:07:43 -07001937 int stream_max_bitrate =
1938 MinPositive(rtp_parameters_.encodings[0].max_bitrate_bps,
1939 parameters_.max_bitrate_bps);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001940
perkjfa10b552016-10-02 23:45:26 -07001941 int codec_max_bitrate_kbps;
1942 if (codec.GetParam(kCodecParamMaxBitrate, &codec_max_bitrate_kbps)) {
1943 stream_max_bitrate = codec_max_bitrate_kbps * 1000;
1944 }
1945 encoder_config.max_bitrate_bps = stream_max_bitrate;
perkj3b703ed2016-09-29 23:25:40 -07001946
perkjfa10b552016-10-02 23:45:26 -07001947 int max_qp = kDefaultQpMax;
1948 codec.GetParam(kCodecParamMaxQuantization, &max_qp);
perkjfa10b552016-10-02 23:45:26 -07001949 encoder_config.video_stream_factory =
1950 new rtc::RefCountedObject<EncoderStreamFactory>(
perkj26752742016-10-24 01:21:16 -07001951 codec.name, max_qp, kDefaultVideoMaxFramerate, is_screencast,
perkjfa10b552016-10-02 23:45:26 -07001952 parameters_.conference_mode);
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001953 return encoder_config;
1954}
1955
skvlad3abb7642016-06-16 12:08:03 -07001956void WebRtcVideoChannel2::WebRtcVideoSendStream::ReconfigureEncoder() {
perkjfa10b552016-10-02 23:45:26 -07001957 RTC_DCHECK_RUN_ON(&thread_checker_);
1958 if (!stream_) {
1959 // The webrtc::VideoSendStream |stream_|has not yet been created but other
1960 // parameters has changed.
1961 return;
1962 }
1963
kwibergaf476c72016-11-28 15:21:39 -08001964 RTC_DCHECK_GT(parameters_.encoder_config.number_of_streams, 0);
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001965
kwiberg102c6a62015-10-30 02:47:38 -07001966 RTC_CHECK(parameters_.codec_settings);
1967 VideoCodecSettings codec_settings = *parameters_.codec_settings;
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001968
1969 webrtc::VideoEncoderConfig encoder_config =
skvlad3abb7642016-06-16 12:08:03 -07001970 CreateVideoEncoderConfig(codec_settings.codec);
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001971
Erik Språng143cec12015-04-28 10:01:41 +02001972 encoder_config.encoder_specific_settings = ConfigureVideoEncoderSettings(
Niels Möller60653ba2016-03-02 11:41:36 +01001973 codec_settings.codec);
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001974
perkj26091b12016-09-01 01:17:40 -07001975 stream_->ReconfigureVideoEncoder(encoder_config.Copy());
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00001976
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00001977 encoder_config.encoder_specific_settings = NULL;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001978
perkj26091b12016-09-01 01:17:40 -07001979 parameters_.encoder_config = std::move(encoder_config);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001980}
1981
deadbeefdbe2b872016-03-22 15:42:00 -07001982void WebRtcVideoChannel2::WebRtcVideoSendStream::SetSend(bool send) {
perkjfa10b552016-10-02 23:45:26 -07001983 RTC_DCHECK_RUN_ON(&thread_checker_);
deadbeefdbe2b872016-03-22 15:42:00 -07001984 sending_ = send;
1985 UpdateSendState();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001986}
1987
perkj803d97f2016-11-01 11:45:46 -07001988void WebRtcVideoChannel2::WebRtcVideoSendStream::RemoveSink(
1989 VideoSinkInterface<webrtc::VideoFrame>* sink) {
1990 RTC_DCHECK_RUN_ON(&thread_checker_);
1991 {
1992 rtc::CritScope cs(&lock_);
1993 RTC_DCHECK(encoder_sink_ == sink);
1994 encoder_sink_ = nullptr;
1995 }
1996 source_->RemoveSink(this);
1997}
1998
perkja49cbd32016-09-16 07:53:41 -07001999void WebRtcVideoChannel2::WebRtcVideoSendStream::AddOrUpdateSink(
2000 VideoSinkInterface<webrtc::VideoFrame>* sink,
2001 const rtc::VideoSinkWants& wants) {
perkj803d97f2016-11-01 11:45:46 -07002002 if (worker_thread_ == rtc::Thread::Current()) {
2003 // AddOrUpdateSink is called on |worker_thread_| if this is the first
2004 // registration of |sink|.
2005 RTC_DCHECK_RUN_ON(&thread_checker_);
2006 {
2007 rtc::CritScope cs(&lock_);
2008 encoder_sink_ = sink;
perkj2d5f0912016-02-29 00:04:41 -08002009 }
perkj803d97f2016-11-01 11:45:46 -07002010 source_->AddOrUpdateSink(this, wants);
perkjfa10b552016-10-02 23:45:26 -07002011 } else {
perkj803d97f2016-11-01 11:45:46 -07002012 // Subsequent calls to AddOrUpdateSink will happen on the encoder task
2013 // queue.
2014 invoker_.AsyncInvoke<void>(RTC_FROM_HERE, worker_thread_, [this, wants] {
2015 RTC_DCHECK_RUN_ON(&thread_checker_);
2016 bool encoder_sink_valid = true;
2017 {
2018 rtc::CritScope cs(&lock_);
2019 encoder_sink_valid = encoder_sink_ != nullptr;
2020 }
2021 // Since |source_| is still valid after a call to RemoveSink, check if
2022 // |encoder_sink_| is still valid to check if this call should be
2023 // cancelled.
2024 if (source_ && encoder_sink_valid) {
2025 source_->AddOrUpdateSink(this, wants);
2026 }
2027 });
perkj2d5f0912016-02-29 00:04:41 -08002028 }
perkj2d5f0912016-02-29 00:04:41 -08002029}
2030
asapersson2e5cfcd2016-08-11 08:41:18 -07002031VideoSenderInfo WebRtcVideoChannel2::WebRtcVideoSendStream::GetVideoSenderInfo(
2032 bool log_stats) {
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002033 VideoSenderInfo info;
perkjfa10b552016-10-02 23:45:26 -07002034 RTC_DCHECK_RUN_ON(&thread_checker_);
2035 for (uint32_t ssrc : parameters_.config.rtp.ssrcs)
2036 info.add_ssrc(ssrc);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002037
hbosa65704b2016-11-14 02:28:16 -08002038 if (parameters_.codec_settings) {
perkjfa10b552016-10-02 23:45:26 -07002039 info.codec_name = parameters_.codec_settings->codec.name;
hbos1acfbd22016-11-17 23:43:29 -08002040 info.codec_payload_type = rtc::Optional<int>(
2041 parameters_.codec_settings->codec.id);
hbosa65704b2016-11-14 02:28:16 -08002042 }
pbos@webrtc.orgc3d2bd22014-08-12 20:55:10 +00002043
perkjfa10b552016-10-02 23:45:26 -07002044 if (stream_ == NULL)
2045 return info;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002046
perkjfa10b552016-10-02 23:45:26 -07002047 webrtc::VideoSendStream::Stats stats = stream_->GetStats();
asapersson2e5cfcd2016-08-11 08:41:18 -07002048
2049 if (log_stats)
2050 LOG(LS_INFO) << stats.ToString(rtc::TimeMillis());
2051
perkj803d97f2016-11-01 11:45:46 -07002052 info.adapt_changes = stats.number_of_cpu_adapt_changes;
Per766ad3b2016-04-05 15:23:49 +02002053 info.adapt_reason =
perkj803d97f2016-11-01 11:45:46 -07002054 stats.cpu_limited_resolution ? ADAPTREASON_CPU : ADAPTREASON_NONE;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002055
asapersson17821db2015-12-14 02:08:12 -08002056 // Get bandwidth limitation info from stream_->GetStats().
2057 // Input resolution (output from video_adapter) can be further scaled down or
2058 // higher video layer(s) can be dropped due to bitrate constraints.
2059 // Note, adapt_changes only include changes from the video_adapter.
2060 if (stats.bw_limited_resolution)
Per766ad3b2016-04-05 15:23:49 +02002061 info.adapt_reason |= ADAPTREASON_BANDWIDTH;
asapersson17821db2015-12-14 02:08:12 -08002062
Peter Boströmb7d9a972015-12-18 16:01:11 +01002063 info.encoder_implementation_name = stats.encoder_implementation_name;
Peter Boström259bd202015-05-28 13:39:50 +02002064 info.ssrc_groups = ssrc_groups_;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002065 info.framerate_input = stats.input_frame_rate;
2066 info.framerate_sent = stats.encode_frame_rate;
pbos@webrtc.org3e6e2712015-02-26 12:19:31 +00002067 info.avg_encode_ms = stats.avg_encode_time_ms;
2068 info.encode_usage_percent = stats.encode_usage_percent;
sakal43536c32016-10-24 01:46:43 -07002069 info.frames_encoded = stats.frames_encoded;
sakal87da4042016-10-31 06:53:47 -07002070 info.qp_sum = stats.qp_sum;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002071
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002072 info.nominal_bitrate = stats.media_bitrate_bps;
Pera48ddb72016-09-29 11:48:50 +02002073 info.preferred_bitrate = stats.preferred_media_bitrate_bps;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002074
pbos@webrtc.org273a4142014-12-01 15:23:21 +00002075 info.send_frame_width = 0;
2076 info.send_frame_height = 0;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002077 for (std::map<uint32_t, webrtc::VideoSendStream::StreamStats>::iterator it =
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002078 stats.substreams.begin();
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002079 it != stats.substreams.end(); ++it) {
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002080 // TODO(pbos): Wire up additional stats, such as padding bytes.
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002081 webrtc::VideoSendStream::StreamStats stream_stats = it->second;
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59 +00002082 info.bytes_sent += stream_stats.rtp_stats.transmitted.payload_bytes +
2083 stream_stats.rtp_stats.transmitted.header_bytes +
2084 stream_stats.rtp_stats.transmitted.padding_bytes;
2085 info.packets_sent += stream_stats.rtp_stats.transmitted.packets;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002086 info.packets_lost += stream_stats.rtcp_stats.cumulative_lost;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002087 if (stream_stats.width > info.send_frame_width)
2088 info.send_frame_width = stream_stats.width;
2089 if (stream_stats.height > info.send_frame_height)
2090 info.send_frame_height = stream_stats.height;
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002091 info.firs_rcvd += stream_stats.rtcp_packet_type_counts.fir_packets;
2092 info.nacks_rcvd += stream_stats.rtcp_packet_type_counts.nack_packets;
2093 info.plis_rcvd += stream_stats.rtcp_packet_type_counts.pli_packets;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002094 }
2095
2096 if (!stats.substreams.empty()) {
2097 // TODO(pbos): Report fraction lost per SSRC.
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002098 webrtc::VideoSendStream::StreamStats first_stream_stats =
2099 stats.substreams.begin()->second;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002100 info.fraction_lost =
2101 static_cast<float>(first_stream_stats.rtcp_stats.fraction_lost) /
2102 (1 << 8);
2103 }
2104
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002105 return info;
2106}
2107
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00002108void WebRtcVideoChannel2::WebRtcVideoSendStream::FillBandwidthEstimationInfo(
2109 BandwidthEstimationInfo* bwe_info) {
perkjfa10b552016-10-02 23:45:26 -07002110 RTC_DCHECK_RUN_ON(&thread_checker_);
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00002111 if (stream_ == NULL) {
2112 return;
2113 }
2114 webrtc::VideoSendStream::Stats stats = stream_->GetStats();
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002115 for (std::map<uint32_t, webrtc::VideoSendStream::StreamStats>::iterator it =
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00002116 stats.substreams.begin();
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002117 it != stats.substreams.end(); ++it) {
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00002118 bwe_info->transmit_bitrate += it->second.total_bitrate_bps;
2119 bwe_info->retransmit_bitrate += it->second.retransmit_bitrate_bps;
2120 }
pbos@webrtc.org891d4832015-02-26 13:15:22 +00002121 bwe_info->target_enc_bitrate += stats.target_media_bitrate_bps;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002122 bwe_info->actual_enc_bitrate += stats.media_bitrate_bps;
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00002123}
2124
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002125void WebRtcVideoChannel2::WebRtcVideoSendStream::RecreateWebRtcStream() {
perkjfa10b552016-10-02 23:45:26 -07002126 RTC_DCHECK_RUN_ON(&thread_checker_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002127 if (stream_ != NULL) {
2128 call_->DestroyVideoSendStream(stream_);
2129 }
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00002130
kwiberg102c6a62015-10-30 02:47:38 -07002131 RTC_CHECK(parameters_.codec_settings);
Niels Möller60653ba2016-03-02 11:41:36 +01002132 RTC_DCHECK_EQ((parameters_.encoder_config.content_type ==
2133 webrtc::VideoEncoderConfig::ContentType::kScreen),
2134 parameters_.options.is_screencast.value_or(false))
2135 << "encoder content type inconsistent with screencast option";
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00002136 parameters_.encoder_config.encoder_specific_settings =
Niels Möller60653ba2016-03-02 11:41:36 +01002137 ConfigureVideoEncoderSettings(parameters_.codec_settings->codec);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002138
perkj26091b12016-09-01 01:17:40 -07002139 webrtc::VideoSendStream::Config config = parameters_.config.Copy();
pbos@webrtc.orgb9557a92015-03-20 19:52:56 +00002140 if (!config.rtp.rtx.ssrcs.empty() && config.rtp.rtx.payload_type == -1) {
2141 LOG(LS_WARNING) << "RTX SSRCs configured but there's no configured RTX "
2142 "payload type the set codec. Ignoring RTX.";
2143 config.rtp.rtx.ssrcs.clear();
2144 }
perkj26091b12016-09-01 01:17:40 -07002145 stream_ = call_->CreateVideoSendStream(std::move(config),
2146 parameters_.encoder_config.Copy());
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002147
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00002148 parameters_.encoder_config.encoder_specific_settings = NULL;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002149
perkj803d97f2016-11-01 11:45:46 -07002150 if (source_) {
2151 // TODO(perkj, nisse): Remove |source_| and directly call
2152 // |stream_|->SetSource(source) once the video frame types have been
2153 // merged and |stream_| internally reconfigure the encoder on frame
2154 // resolution change.
2155 // Do not adapt resolution for screen content as this will likely result in
2156 // blurry and unreadable text.
2157 stream_->SetSource(
2158 this, enable_cpu_overuse_detection_ &&
2159 !parameters_.options.is_screencast.value_or(false)
2160 ? webrtc::VideoSendStream::DegradationPreference::kBalanced
2161 : webrtc::VideoSendStream::DegradationPreference::
2162 kMaintainResolution);
2163 }
2164
Taylor Brandstetter14b9d792016-09-07 17:16:54 -07002165 // Call stream_->Start() if necessary conditions are met.
2166 UpdateSendState();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002167}
2168
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002169WebRtcVideoChannel2::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
2170 webrtc::Call* call,
Peter Boström259bd202015-05-28 13:39:50 +02002171 const StreamParams& sp,
Tommi733b5472016-06-10 17:58:01 +02002172 webrtc::VideoReceiveStream::Config config,
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002173 WebRtcVideoDecoderFactory* external_decoder_factory,
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00002174 bool default_stream,
brandtr468da7c2016-11-22 02:16:47 -08002175 const std::vector<VideoCodecSettings>& recv_codecs,
2176 const webrtc::FlexfecConfig& flexfec_config)
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002177 : call_(call),
sakal1fd95952016-06-22 00:46:15 -07002178 stream_params_(sp),
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002179 stream_(NULL),
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00002180 default_stream_(default_stream),
Tommi733b5472016-06-10 17:58:01 +02002181 config_(std::move(config)),
brandtr468da7c2016-11-22 02:16:47 -08002182 flexfec_config_(flexfec_config),
2183 flexfec_stream_(nullptr),
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002184 external_decoder_factory_(external_decoder_factory),
nissee73afba2016-01-28 04:47:08 -08002185 sink_(NULL),
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002186 first_frame_timestamp_(-1),
2187 estimated_remote_start_ntp_time_ms_(0) {
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002188 config_.renderer = this;
pbos378dc772016-01-28 15:58:41 -08002189 std::vector<AllocatedDecoder> old_decoders;
2190 ConfigureCodecs(recv_codecs, &old_decoders);
2191 RecreateWebRtcStream();
2192 RTC_DCHECK(old_decoders.empty());
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002193}
2194
Peter Boström7252a2b2015-05-18 19:42:03 +02002195WebRtcVideoChannel2::WebRtcVideoReceiveStream::AllocatedDecoder::
2196 AllocatedDecoder(webrtc::VideoDecoder* decoder,
2197 webrtc::VideoCodecType type,
2198 bool external)
2199 : decoder(decoder),
2200 external_decoder(nullptr),
2201 type(type),
2202 external(external) {
2203 if (external) {
2204 external_decoder = decoder;
2205 this->decoder =
2206 new webrtc::VideoDecoderSoftwareFallbackWrapper(type, external_decoder);
2207 }
2208}
2209
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002210WebRtcVideoChannel2::WebRtcVideoReceiveStream::~WebRtcVideoReceiveStream() {
2211 call_->DestroyVideoReceiveStream(stream_);
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002212 ClearDecoders(&allocated_decoders_);
2213}
2214
Peter Boström0c4e06b2015-10-07 12:23:21 +02002215const std::vector<uint32_t>&
Peter Boströmd6f4c252015-03-26 16:23:04 +01002216WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetSsrcs() const {
sakal1fd95952016-06-22 00:46:15 -07002217 return stream_params_.ssrcs;
2218}
2219
2220rtc::Optional<uint32_t>
2221WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetFirstPrimarySsrc() const {
2222 std::vector<uint32_t> primary_ssrcs;
2223 stream_params_.GetPrimarySsrcs(&primary_ssrcs);
2224
2225 if (primary_ssrcs.empty()) {
2226 LOG(LS_WARNING) << "Empty primary ssrcs vector, returning empty optional";
2227 return rtc::Optional<uint32_t>();
2228 } else {
2229 return rtc::Optional<uint32_t>(primary_ssrcs[0]);
2230 }
Peter Boströmd6f4c252015-03-26 16:23:04 +01002231}
2232
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002233WebRtcVideoChannel2::WebRtcVideoReceiveStream::AllocatedDecoder
2234WebRtcVideoChannel2::WebRtcVideoReceiveStream::CreateOrReuseVideoDecoder(
2235 std::vector<AllocatedDecoder>* old_decoders,
2236 const VideoCodec& codec) {
magjed10165ab2016-11-22 10:16:57 -08002237 webrtc::VideoCodecType type = webrtc::PayloadNameToCodecType(codec.name)
2238 .value_or(webrtc::kVideoCodecUnknown);
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002239
2240 for (size_t i = 0; i < old_decoders->size(); ++i) {
2241 if ((*old_decoders)[i].type == type) {
2242 AllocatedDecoder decoder = (*old_decoders)[i];
2243 (*old_decoders)[i] = old_decoders->back();
2244 old_decoders->pop_back();
2245 return decoder;
2246 }
2247 }
2248
2249 if (external_decoder_factory_ != NULL) {
2250 webrtc::VideoDecoder* decoder =
sakal1fd95952016-06-22 00:46:15 -07002251 external_decoder_factory_->CreateVideoDecoderWithParams(
2252 type, {stream_params_.id});
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002253 if (decoder != NULL) {
2254 return AllocatedDecoder(decoder, type, true);
2255 }
2256 }
2257
2258 if (type == webrtc::kVideoCodecVP8) {
2259 return AllocatedDecoder(
2260 webrtc::VideoDecoder::Create(webrtc::VideoDecoder::kVp8), type, false);
2261 }
2262
pbos@webrtc.orgb9557a92015-03-20 19:52:56 +00002263 if (type == webrtc::kVideoCodecVP9) {
2264 return AllocatedDecoder(
2265 webrtc::VideoDecoder::Create(webrtc::VideoDecoder::kVp9), type, false);
2266 }
2267
Zeke Chin71f6f442015-06-29 14:34:58 -07002268 if (type == webrtc::kVideoCodecH264) {
2269 return AllocatedDecoder(
2270 webrtc::VideoDecoder::Create(webrtc::VideoDecoder::kH264), type, false);
2271 }
2272
jbauche03ac512016-02-03 05:51:48 -08002273 return AllocatedDecoder(
2274 webrtc::VideoDecoder::Create(webrtc::VideoDecoder::kUnsupportedCodec),
2275 webrtc::kVideoCodecUnknown, false);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002276}
2277
pbos378dc772016-01-28 15:58:41 -08002278void WebRtcVideoChannel2::WebRtcVideoReceiveStream::ConfigureCodecs(
2279 const std::vector<VideoCodecSettings>& recv_codecs,
2280 std::vector<AllocatedDecoder>* old_decoders) {
2281 *old_decoders = allocated_decoders_;
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002282 allocated_decoders_.clear();
2283 config_.decoders.clear();
2284 for (size_t i = 0; i < recv_codecs.size(); ++i) {
2285 AllocatedDecoder allocated_decoder =
pbos378dc772016-01-28 15:58:41 -08002286 CreateOrReuseVideoDecoder(old_decoders, recv_codecs[i].codec);
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002287 allocated_decoders_.push_back(allocated_decoder);
2288
2289 webrtc::VideoReceiveStream::Decoder decoder;
2290 decoder.decoder = allocated_decoder.decoder;
2291 decoder.payload_type = recv_codecs[i].codec.id;
2292 decoder.payload_name = recv_codecs[i].codec.name;
magjed5dfac562016-11-25 03:56:37 -08002293 decoder.codec_params = recv_codecs[i].codec.params;
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002294 config_.decoders.push_back(decoder);
2295 }
2296
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002297 // TODO(pbos): Reconfigure RTX based on incoming recv_codecs.
brandtrb5f2c3f2016-10-04 23:28:39 -07002298 config_.rtp.ulpfec = recv_codecs.front().ulpfec;
brandtr468da7c2016-11-22 02:16:47 -08002299 flexfec_config_.flexfec_payload_type =
2300 recv_codecs.front().flexfec.flexfec_payload_type;
pbos@webrtc.org257e1302014-07-25 19:01:32 +00002301 config_.rtp.nack.rtp_history_ms =
Shao Changbine62202f2015-04-21 20:24:50 +08002302 HasNack(recv_codecs.begin()->codec) ? kNackHistoryMs : 0;
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002303}
2304
Peter Boström3548dd22015-05-22 18:48:36 +02002305void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetLocalSsrc(
2306 uint32_t local_ssrc) {
henrikg91d6ede2015-09-17 00:24:34 -07002307 // TODO(pbos): Consider turning this sanity check into a RTC_DCHECK. You
2308 // should not be able to create a sender with the same SSRC as a receiver, but
2309 // right now this can't be done due to unittests depending on receiving what
2310 // they are sending from the same MediaChannel.
deadbeef874ca3a2015-08-20 17:19:20 -07002311 if (local_ssrc == config_.rtp.remote_ssrc) {
2312 LOG(LS_INFO) << "Ignoring call to SetLocalSsrc because parameters are "
2313 "unchanged; local_ssrc=" << local_ssrc;
Peter Boström3548dd22015-05-22 18:48:36 +02002314 return;
deadbeef874ca3a2015-08-20 17:19:20 -07002315 }
Peter Boström3548dd22015-05-22 18:48:36 +02002316
2317 config_.rtp.local_ssrc = local_ssrc;
deadbeef874ca3a2015-08-20 17:19:20 -07002318 LOG(LS_INFO)
2319 << "RecreateWebRtcStream (recv) because of SetLocalSsrc; local_ssrc="
2320 << local_ssrc;
Peter Boström3548dd22015-05-22 18:48:36 +02002321 RecreateWebRtcStream();
2322}
2323
stefan43edf0f2015-11-20 18:05:48 -08002324void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetFeedbackParameters(
2325 bool nack_enabled,
2326 bool remb_enabled,
Taylor Brandstetter5f0b83b2016-03-18 15:02:07 -07002327 bool transport_cc_enabled,
2328 webrtc::RtcpMode rtcp_mode) {
Peter Boström67c9df72015-05-11 14:34:58 +02002329 int nack_history_ms = nack_enabled ? kNackHistoryMs : 0;
2330 if (config_.rtp.nack.rtp_history_ms == nack_history_ms &&
stefan43edf0f2015-11-20 18:05:48 -08002331 config_.rtp.remb == remb_enabled &&
Taylor Brandstetter5f0b83b2016-03-18 15:02:07 -07002332 config_.rtp.transport_cc == transport_cc_enabled &&
2333 config_.rtp.rtcp_mode == rtcp_mode) {
stefan43edf0f2015-11-20 18:05:48 -08002334 LOG(LS_INFO)
2335 << "Ignoring call to SetFeedbackParameters because parameters are "
2336 "unchanged; nack="
2337 << nack_enabled << ", remb=" << remb_enabled
2338 << ", transport_cc=" << transport_cc_enabled;
Peter Boström126c03e2015-05-11 12:48:12 +02002339 return;
Peter Boström67c9df72015-05-11 14:34:58 +02002340 }
2341 config_.rtp.remb = remb_enabled;
2342 config_.rtp.nack.rtp_history_ms = nack_history_ms;
stefan43edf0f2015-11-20 18:05:48 -08002343 config_.rtp.transport_cc = transport_cc_enabled;
Taylor Brandstetter5f0b83b2016-03-18 15:02:07 -07002344 config_.rtp.rtcp_mode = rtcp_mode;
stefan43edf0f2015-11-20 18:05:48 -08002345 LOG(LS_INFO)
2346 << "RecreateWebRtcStream (recv) because of SetFeedbackParameters; nack="
2347 << nack_enabled << ", remb=" << remb_enabled
2348 << ", transport_cc=" << transport_cc_enabled;
Peter Boström126c03e2015-05-11 12:48:12 +02002349 RecreateWebRtcStream();
2350}
2351
deadbeef13871492015-12-09 12:37:51 -08002352void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRecvParameters(
pbos378dc772016-01-28 15:58:41 -08002353 const ChangedRecvParameters& params) {
2354 bool needs_recreation = false;
2355 std::vector<AllocatedDecoder> old_decoders;
2356 if (params.codec_settings) {
2357 ConfigureCodecs(*params.codec_settings, &old_decoders);
2358 needs_recreation = true;
2359 }
2360 if (params.rtp_header_extensions) {
2361 config_.rtp.extensions = *params.rtp_header_extensions;
2362 needs_recreation = true;
2363 }
pbos378dc772016-01-28 15:58:41 -08002364 if (needs_recreation) {
2365 LOG(LS_INFO) << "RecreateWebRtcStream (recv) because of SetRecvParameters";
2366 RecreateWebRtcStream();
2367 ClearDecoders(&old_decoders);
2368 }
deadbeef13871492015-12-09 12:37:51 -08002369}
2370
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002371void WebRtcVideoChannel2::WebRtcVideoReceiveStream::RecreateWebRtcStream() {
brandtr468da7c2016-11-22 02:16:47 -08002372 if (flexfec_stream_) {
2373 call_->DestroyFlexfecReceiveStream(flexfec_stream_);
2374 flexfec_stream_ = nullptr;
2375 }
2376 if (stream_) {
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002377 call_->DestroyVideoReceiveStream(stream_);
2378 }
brandtre6f98c72016-11-11 03:28:30 -08002379 stream_ = call_->CreateVideoReceiveStream(config_.Copy());
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002380 stream_->Start();
brandtr468da7c2016-11-22 02:16:47 -08002381 if (IsFlexfecFieldTrialEnabled() && flexfec_config_.IsCompleteAndEnabled()) {
2382 flexfec_stream_ = call_->CreateFlexfecReceiveStream(flexfec_config_);
2383 flexfec_stream_->Start();
2384 }
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002385}
2386
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002387void WebRtcVideoChannel2::WebRtcVideoReceiveStream::ClearDecoders(
2388 std::vector<AllocatedDecoder>* allocated_decoders) {
2389 for (size_t i = 0; i < allocated_decoders->size(); ++i) {
2390 if ((*allocated_decoders)[i].external) {
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002391 external_decoder_factory_->DestroyVideoDecoder(
Peter Boström7252a2b2015-05-18 19:42:03 +02002392 (*allocated_decoders)[i].external_decoder);
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002393 }
Peter Boström7252a2b2015-05-18 19:42:03 +02002394 delete (*allocated_decoders)[i].decoder;
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002395 }
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002396 allocated_decoders->clear();
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002397}
2398
nisseeb83a1a2016-03-21 01:27:56 -07002399void WebRtcVideoChannel2::WebRtcVideoReceiveStream::OnFrame(
2400 const webrtc::VideoFrame& frame) {
nissee73afba2016-01-28 04:47:08 -08002401 rtc::CritScope crit(&sink_lock_);
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002402
2403 if (first_frame_timestamp_ < 0)
2404 first_frame_timestamp_ = frame.timestamp();
2405 int64_t rtp_time_elapsed_since_first_frame =
2406 (timestamp_wraparound_handler_.Unwrap(frame.timestamp()) -
2407 first_frame_timestamp_);
2408 int64_t elapsed_time_ms = rtp_time_elapsed_since_first_frame /
2409 (cricket::kVideoCodecClockrate / 1000);
2410 if (frame.ntp_time_ms() > 0)
2411 estimated_remote_start_ntp_time_ms_ = frame.ntp_time_ms() - elapsed_time_ms;
2412
nissee73afba2016-01-28 04:47:08 -08002413 if (sink_ == NULL) {
2414 LOG(LS_WARNING) << "VideoReceiveStream not connected to a VideoSink.";
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002415 return;
2416 }
2417
nisse09347852016-10-19 00:30:30 -07002418 sink_->OnFrame(frame);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002419}
2420
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00002421bool WebRtcVideoChannel2::WebRtcVideoReceiveStream::IsDefaultStream() const {
2422 return default_stream_;
2423}
2424
nissee73afba2016-01-28 04:47:08 -08002425void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetSink(
nisseacd935b2016-11-11 03:55:13 -08002426 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
nissee73afba2016-01-28 04:47:08 -08002427 rtc::CritScope crit(&sink_lock_);
2428 sink_ = sink;
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002429}
2430
pbosf42376c2015-08-28 07:35:32 -07002431std::string
2432WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetCodecNameFromPayloadType(
2433 int payload_type) {
2434 for (const webrtc::VideoReceiveStream::Decoder& decoder : config_.decoders) {
2435 if (decoder.payload_type == payload_type) {
2436 return decoder.payload_name;
2437 }
2438 }
2439 return "";
2440}
2441
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002442VideoReceiverInfo
asapersson2e5cfcd2016-08-11 08:41:18 -07002443WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetVideoReceiverInfo(
2444 bool log_stats) {
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002445 VideoReceiverInfo info;
sakal1fd95952016-06-22 00:46:15 -07002446 info.ssrc_groups = stream_params_.ssrc_groups;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002447 info.add_ssrc(config_.rtp.remote_ssrc);
2448 webrtc::VideoReceiveStream::Stats stats = stream_->GetStats();
Peter Boströmb7d9a972015-12-18 16:01:11 +01002449 info.decoder_implementation_name = stats.decoder_implementation_name;
hbosa65704b2016-11-14 02:28:16 -08002450 if (stats.current_payload_type != -1) {
hbos1acfbd22016-11-17 23:43:29 -08002451 info.codec_payload_type = rtc::Optional<int>(
2452 stats.current_payload_type);
hbosa65704b2016-11-14 02:28:16 -08002453 }
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59 +00002454 info.bytes_rcvd = stats.rtp_stats.transmitted.payload_bytes +
2455 stats.rtp_stats.transmitted.header_bytes +
2456 stats.rtp_stats.transmitted.padding_bytes;
2457 info.packets_rcvd = stats.rtp_stats.transmitted.packets;
Peter Boström393347f2015-04-22 14:52:45 +02002458 info.packets_lost = stats.rtcp_stats.cumulative_lost;
2459 info.fraction_lost =
2460 static_cast<float>(stats.rtcp_stats.fraction_lost) / (1 << 8);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002461
2462 info.framerate_rcvd = stats.network_frame_rate;
2463 info.framerate_decoded = stats.decode_frame_rate;
2464 info.framerate_output = stats.render_frame_rate;
asapersson26dd92b2016-08-30 00:45:45 -07002465 info.frame_width = stats.width;
2466 info.frame_height = stats.height;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002467
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002468 {
nissee73afba2016-01-28 04:47:08 -08002469 rtc::CritScope frame_cs(&sink_lock_);
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002470 info.capture_start_ntp_time_ms = estimated_remote_start_ntp_time_ms_;
2471 }
2472
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002473 info.decode_ms = stats.decode_ms;
2474 info.max_decode_ms = stats.max_decode_ms;
2475 info.current_delay_ms = stats.current_delay_ms;
2476 info.target_delay_ms = stats.target_delay_ms;
2477 info.jitter_buffer_ms = stats.jitter_buffer_ms;
2478 info.min_playout_delay_ms = stats.min_playout_delay_ms;
2479 info.render_delay_ms = stats.render_delay_ms;
sakale5ba44e2016-10-26 07:09:24 -07002480 info.frames_decoded = stats.frames_decoded;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002481
pbosf42376c2015-08-28 07:35:32 -07002482 info.codec_name = GetCodecNameFromPayloadType(stats.current_payload_type);
2483
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002484 info.firs_sent = stats.rtcp_packet_type_counts.fir_packets;
2485 info.plis_sent = stats.rtcp_packet_type_counts.pli_packets;
2486 info.nacks_sent = stats.rtcp_packet_type_counts.nack_packets;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002487
asapersson2e5cfcd2016-08-11 08:41:18 -07002488 if (log_stats)
2489 LOG(LS_INFO) << stats.ToString(rtc::TimeMillis());
2490
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002491 return info;
2492}
2493
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002494WebRtcVideoChannel2::VideoCodecSettings::VideoCodecSettings()
2495 : rtx_payload_type(-1) {}
2496
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002497bool WebRtcVideoChannel2::VideoCodecSettings::operator==(
2498 const WebRtcVideoChannel2::VideoCodecSettings& other) const {
brandtr468da7c2016-11-22 02:16:47 -08002499 return codec == other.codec && ulpfec == other.ulpfec &&
2500 flexfec == other.flexfec && rtx_payload_type == other.rtx_payload_type;
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002501}
2502
Peter Boströmee0b00e2015-04-22 18:41:14 +02002503bool WebRtcVideoChannel2::VideoCodecSettings::operator!=(
2504 const WebRtcVideoChannel2::VideoCodecSettings& other) const {
2505 return !(*this == other);
2506}
2507
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002508std::vector<WebRtcVideoChannel2::VideoCodecSettings>
2509WebRtcVideoChannel2::MapCodecs(const std::vector<VideoCodec>& codecs) {
henrikg91d6ede2015-09-17 00:24:34 -07002510 RTC_DCHECK(!codecs.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002511
2512 std::vector<VideoCodecSettings> video_codecs;
2513 std::map<int, bool> payload_used;
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002514 std::map<int, VideoCodec::CodecType> payload_codec_type;
pkasting@chromium.orgd3245462015-02-23 21:28:22 +00002515 // |rtx_mapping| maps video payload type to rtx payload type.
2516 std::map<int, int> rtx_mapping;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002517
brandtrb5f2c3f2016-10-04 23:28:39 -07002518 webrtc::UlpfecConfig ulpfec_config;
brandtr468da7c2016-11-22 02:16:47 -08002519 int flexfec_payload_type = -1;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002520
2521 for (size_t i = 0; i < codecs.size(); ++i) {
2522 const VideoCodec& in_codec = codecs[i];
2523 int payload_type = in_codec.id;
2524
2525 if (payload_used[payload_type]) {
2526 LOG(LS_ERROR) << "Payload type already registered: "
2527 << in_codec.ToString();
2528 return std::vector<VideoCodecSettings>();
2529 }
2530 payload_used[payload_type] = true;
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002531 payload_codec_type[payload_type] = in_codec.GetCodecType();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002532
2533 switch (in_codec.GetCodecType()) {
2534 case VideoCodec::CODEC_RED: {
2535 // RED payload type, should not have duplicates.
brandtr468da7c2016-11-22 02:16:47 -08002536 RTC_DCHECK_EQ(-1, ulpfec_config.red_payload_type);
brandtrb5f2c3f2016-10-04 23:28:39 -07002537 ulpfec_config.red_payload_type = in_codec.id;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002538 continue;
2539 }
2540
2541 case VideoCodec::CODEC_ULPFEC: {
2542 // ULPFEC payload type, should not have duplicates.
brandtr468da7c2016-11-22 02:16:47 -08002543 RTC_DCHECK_EQ(-1, ulpfec_config.ulpfec_payload_type);
brandtrb5f2c3f2016-10-04 23:28:39 -07002544 ulpfec_config.ulpfec_payload_type = in_codec.id;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002545 continue;
2546 }
2547
brandtr87d7d772016-11-07 03:03:41 -08002548 case VideoCodec::CODEC_FLEXFEC: {
brandtr468da7c2016-11-22 02:16:47 -08002549 // FlexFEC payload type, should not have duplicates.
2550 RTC_DCHECK_EQ(-1, flexfec_payload_type);
2551 flexfec_payload_type = in_codec.id;
brandtr87d7d772016-11-07 03:03:41 -08002552 continue;
2553 }
2554
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002555 case VideoCodec::CODEC_RTX: {
2556 int associated_payload_type;
2557 if (!in_codec.GetParam(kCodecParamAssociatedPayloadType,
pkasting@chromium.orge9facf82015-02-17 20:36:28 +00002558 &associated_payload_type) ||
2559 !IsValidRtpPayloadType(associated_payload_type)) {
2560 LOG(LS_ERROR)
2561 << "RTX codec with invalid or no associated payload type: "
2562 << in_codec.ToString();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002563 return std::vector<VideoCodecSettings>();
2564 }
2565 rtx_mapping[associated_payload_type] = in_codec.id;
2566 continue;
2567 }
2568
2569 case VideoCodec::CODEC_VIDEO:
2570 break;
2571 }
2572
2573 video_codecs.push_back(VideoCodecSettings());
2574 video_codecs.back().codec = in_codec;
2575 }
2576
2577 // One of these codecs should have been a video codec. Only having FEC
2578 // parameters into this code is a logic error.
henrikg91d6ede2015-09-17 00:24:34 -07002579 RTC_DCHECK(!video_codecs.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002580
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002581 for (std::map<int, int>::const_iterator it = rtx_mapping.begin();
2582 it != rtx_mapping.end();
2583 ++it) {
2584 if (!payload_used[it->first]) {
2585 LOG(LS_ERROR) << "RTX mapped to payload not in codec list.";
2586 return std::vector<VideoCodecSettings>();
2587 }
Shao Changbine62202f2015-04-21 20:24:50 +08002588 if (payload_codec_type[it->first] != VideoCodec::CODEC_VIDEO &&
2589 payload_codec_type[it->first] != VideoCodec::CODEC_RED) {
2590 LOG(LS_ERROR) << "RTX not mapped to regular video codec or RED codec.";
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002591 return std::vector<VideoCodecSettings>();
2592 }
Shao Changbine62202f2015-04-21 20:24:50 +08002593
brandtrb5f2c3f2016-10-04 23:28:39 -07002594 if (it->first == ulpfec_config.red_payload_type) {
2595 ulpfec_config.red_rtx_payload_type = it->second;
Shao Changbine62202f2015-04-21 20:24:50 +08002596 }
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002597 }
2598
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002599 for (size_t i = 0; i < video_codecs.size(); ++i) {
brandtrb5f2c3f2016-10-04 23:28:39 -07002600 video_codecs[i].ulpfec = ulpfec_config;
brandtr468da7c2016-11-22 02:16:47 -08002601 video_codecs[i].flexfec.flexfec_payload_type = flexfec_payload_type;
Shao Changbine62202f2015-04-21 20:24:50 +08002602 if (rtx_mapping[video_codecs[i].codec.id] != 0 &&
2603 rtx_mapping[video_codecs[i].codec.id] !=
brandtrb5f2c3f2016-10-04 23:28:39 -07002604 ulpfec_config.red_payload_type) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002605 video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
2606 }
2607 }
2608
2609 return video_codecs;
2610}
2611
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002612} // namespace cricket