blob: 1fc9dd52d42b714de72d62fcf583cec74dfc1b44 [file] [log] [blame]
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001/*
2 * libjingle
3 * Copyright 2014 Google Inc.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
13 * 3. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28#ifdef HAVE_WEBRTC_VIDEO
29#include "talk/media/webrtc/webrtcvideoengine2.h"
30
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +000031#include <algorithm>
pbos@webrtc.org3c107582014-07-20 15:27:35 +000032#include <set>
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000033#include <string>
34
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000035#include "talk/media/base/videocapturer.h"
36#include "talk/media/base/videorenderer.h"
buildbot@webrtc.orgdf9bbbe2014-06-19 19:54:33 +000037#include "talk/media/webrtc/constants.h"
buildbot@webrtc.orga8530772014-12-10 09:01:18 +000038#include "talk/media/webrtc/simulcast.h"
Stefan Holmerbbaf3632015-10-29 18:53:23 +010039#include "talk/media/webrtc/webrtcmediaengine.h"
Peter Boström81ea54e2015-05-07 11:41:09 +020040#include "talk/media/webrtc/webrtcvideoencoderfactory.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000041#include "talk/media/webrtc/webrtcvideoframe.h"
42#include "talk/media/webrtc/webrtcvoiceengine.h"
buildbot@webrtc.orga09a9992014-08-13 17:26:08 +000043#include "webrtc/base/buffer.h"
44#include "webrtc/base/logging.h"
45#include "webrtc/base/stringutils.h"
qiangchenc27d89f2015-07-16 10:27:16 -070046#include "webrtc/base/timeutils.h"
tommie4f96502015-10-20 23:00:48 -070047#include "webrtc/base/trace_event.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000048#include "webrtc/call.h"
Zeke Chin71f6f442015-06-29 14:34:58 -070049#include "webrtc/modules/video_coding/codecs/h264/include/h264.h"
Peter Boström81ea54e2015-05-07 11:41:09 +020050#include "webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h"
Henrik Kjellander98f53512015-10-28 18:17:40 +010051#include "webrtc/system_wrappers/include/field_trial.h"
pbos@webrtc.org776e6f22014-10-29 15:28:39 +000052#include "webrtc/video_decoder.h"
pbos@webrtc.orgab990ae2014-09-17 09:02:25 +000053#include "webrtc/video_encoder.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000054
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000055namespace cricket {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +000056namespace {
Peter Boström81ea54e2015-05-07 11:41:09 +020057
58// Wrap cricket::WebRtcVideoEncoderFactory as a webrtc::VideoEncoderFactory.
59class EncoderFactoryAdapter : public webrtc::VideoEncoderFactory {
60 public:
61 // EncoderFactoryAdapter doesn't take ownership of |factory|, which is owned
62 // by e.g. PeerConnectionFactory.
63 explicit EncoderFactoryAdapter(cricket::WebRtcVideoEncoderFactory* factory)
64 : factory_(factory) {}
65 virtual ~EncoderFactoryAdapter() {}
66
67 // Implement webrtc::VideoEncoderFactory.
68 webrtc::VideoEncoder* Create() override {
69 return factory_->CreateVideoEncoder(webrtc::kVideoCodecVP8);
70 }
71
72 void Destroy(webrtc::VideoEncoder* encoder) override {
73 return factory_->DestroyVideoEncoder(encoder);
74 }
75
76 private:
77 cricket::WebRtcVideoEncoderFactory* const factory_;
78};
79
Peter Boström3afc8c42016-01-27 16:45:21 +010080webrtc::Call::Config::BitrateConfig GetBitrateConfigForCodec(
81 const VideoCodec& codec) {
82 webrtc::Call::Config::BitrateConfig config;
83 int bitrate_kbps;
84 if (codec.GetParam(kCodecParamMinBitrate, &bitrate_kbps) &&
85 bitrate_kbps > 0) {
86 config.min_bitrate_bps = bitrate_kbps * 1000;
87 } else {
88 config.min_bitrate_bps = 0;
89 }
90 if (codec.GetParam(kCodecParamStartBitrate, &bitrate_kbps) &&
91 bitrate_kbps > 0) {
92 config.start_bitrate_bps = bitrate_kbps * 1000;
93 } else {
94 // Do not reconfigure start bitrate unless it's specified and positive.
95 config.start_bitrate_bps = -1;
96 }
97 if (codec.GetParam(kCodecParamMaxBitrate, &bitrate_kbps) &&
98 bitrate_kbps > 0) {
99 config.max_bitrate_bps = bitrate_kbps * 1000;
100 } else {
101 config.max_bitrate_bps = -1;
102 }
103 return config;
104}
105
Peter Boström81ea54e2015-05-07 11:41:09 +0200106// An encoder factory that wraps Create requests for simulcastable codec types
107// with a webrtc::SimulcastEncoderAdapter. Non simulcastable codec type
108// requests are just passed through to the contained encoder factory.
109class WebRtcSimulcastEncoderFactory
110 : public cricket::WebRtcVideoEncoderFactory {
111 public:
112 // WebRtcSimulcastEncoderFactory doesn't take ownership of |factory|, which is
113 // owned by e.g. PeerConnectionFactory.
114 explicit WebRtcSimulcastEncoderFactory(
115 cricket::WebRtcVideoEncoderFactory* factory)
116 : factory_(factory) {}
117
118 static bool UseSimulcastEncoderFactory(
119 const std::vector<VideoCodec>& codecs) {
120 // If any codec is VP8, use the simulcast factory. If asked to create a
121 // non-VP8 codec, we'll just return a contained factory encoder directly.
122 for (const auto& codec : codecs) {
123 if (codec.type == webrtc::kVideoCodecVP8) {
124 return true;
125 }
126 }
127 return false;
128 }
129
130 webrtc::VideoEncoder* CreateVideoEncoder(
131 webrtc::VideoCodecType type) override {
henrikg91d6ede2015-09-17 00:24:34 -0700132 RTC_DCHECK(factory_ != NULL);
Peter Boström81ea54e2015-05-07 11:41:09 +0200133 // If it's a codec type we can simulcast, create a wrapped encoder.
134 if (type == webrtc::kVideoCodecVP8) {
135 return new webrtc::SimulcastEncoderAdapter(
136 new EncoderFactoryAdapter(factory_));
137 }
138 webrtc::VideoEncoder* encoder = factory_->CreateVideoEncoder(type);
139 if (encoder) {
140 non_simulcast_encoders_.push_back(encoder);
141 }
142 return encoder;
143 }
144
145 const std::vector<VideoCodec>& codecs() const override {
146 return factory_->codecs();
147 }
148
149 bool EncoderTypeHasInternalSource(
150 webrtc::VideoCodecType type) const override {
151 return factory_->EncoderTypeHasInternalSource(type);
152 }
153
154 void DestroyVideoEncoder(webrtc::VideoEncoder* encoder) override {
155 // Check first to see if the encoder wasn't wrapped in a
156 // SimulcastEncoderAdapter. In that case, ask the factory to destroy it.
157 if (std::remove(non_simulcast_encoders_.begin(),
158 non_simulcast_encoders_.end(),
159 encoder) != non_simulcast_encoders_.end()) {
160 factory_->DestroyVideoEncoder(encoder);
161 return;
162 }
163
164 // Otherwise, SimulcastEncoderAdapter can be deleted directly, and will call
165 // DestroyVideoEncoder on the factory for individual encoder instances.
166 delete encoder;
167 }
168
169 private:
170 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
176bool CodecIsInternallySupported(const std::string& codec_name) {
177 if (CodecNamesEq(codec_name, kVp8CodecName)) {
178 return true;
179 }
180 if (CodecNamesEq(codec_name, kVp9CodecName)) {
asapersson3ed34872015-11-10 05:16:26 -0800181 return true;
Peter Boström81ea54e2015-05-07 11:41:09 +0200182 }
Zeke Chin71f6f442015-06-29 14:34:58 -0700183 if (CodecNamesEq(codec_name, kH264CodecName)) {
184 return webrtc::H264Encoder::IsSupported() &&
185 webrtc::H264Decoder::IsSupported();
186 }
Peter Boström81ea54e2015-05-07 11:41:09 +0200187 return false;
188}
189
190void AddDefaultFeedbackParams(VideoCodec* codec) {
191 codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamCcm, kRtcpFbCcmParamFir));
192 codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamNack, kParamValueEmpty));
193 codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamNack, kRtcpFbNackParamPli));
194 codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamRemb, kParamValueEmpty));
stefan43edf0f2015-11-20 18:05:48 -0800195 codec->AddFeedbackParam(
196 FeedbackParam(kRtcpFbParamTransportCc, kParamValueEmpty));
Peter Boström81ea54e2015-05-07 11:41:09 +0200197}
198
199static VideoCodec MakeVideoCodecWithDefaultFeedbackParams(int payload_type,
200 const char* name) {
201 VideoCodec codec(payload_type, name, kDefaultVideoMaxWidth,
202 kDefaultVideoMaxHeight, kDefaultVideoMaxFramerate, 0);
203 AddDefaultFeedbackParams(&codec);
204 return codec;
205}
206
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000207static std::string CodecVectorToString(const std::vector<VideoCodec>& codecs) {
208 std::stringstream out;
209 out << '{';
210 for (size_t i = 0; i < codecs.size(); ++i) {
211 out << codecs[i].ToString();
212 if (i != codecs.size() - 1) {
213 out << ", ";
214 }
215 }
216 out << '}';
217 return out.str();
218}
219
220static bool ValidateCodecFormats(const std::vector<VideoCodec>& codecs) {
221 bool has_video = false;
222 for (size_t i = 0; i < codecs.size(); ++i) {
223 if (!codecs[i].ValidateCodecFormat()) {
224 return false;
225 }
226 if (codecs[i].GetCodecType() == VideoCodec::CODEC_VIDEO) {
227 has_video = true;
228 }
229 }
230 if (!has_video) {
231 LOG(LS_ERROR) << "Setting codecs without a video codec is invalid: "
232 << CodecVectorToString(codecs);
233 return false;
234 }
235 return true;
236}
237
Peter Boströmd4362cd2015-03-25 14:17:23 +0100238static bool ValidateStreamParams(const StreamParams& sp) {
239 if (sp.ssrcs.empty()) {
240 LOG(LS_ERROR) << "No SSRCs in stream parameters: " << sp.ToString();
241 return false;
242 }
243
Peter Boström0c4e06b2015-10-07 12:23:21 +0200244 std::vector<uint32_t> primary_ssrcs;
Peter Boströmd4362cd2015-03-25 14:17:23 +0100245 sp.GetPrimarySsrcs(&primary_ssrcs);
Peter Boström0c4e06b2015-10-07 12:23:21 +0200246 std::vector<uint32_t> rtx_ssrcs;
Peter Boströmd4362cd2015-03-25 14:17:23 +0100247 sp.GetFidSsrcs(primary_ssrcs, &rtx_ssrcs);
248 for (uint32_t rtx_ssrc : rtx_ssrcs) {
249 bool rtx_ssrc_present = false;
250 for (uint32_t sp_ssrc : sp.ssrcs) {
251 if (sp_ssrc == rtx_ssrc) {
252 rtx_ssrc_present = true;
253 break;
254 }
255 }
256 if (!rtx_ssrc_present) {
257 LOG(LS_ERROR) << "RTX SSRC '" << rtx_ssrc
258 << "' missing from StreamParams ssrcs: " << sp.ToString();
259 return false;
260 }
261 }
262 if (!rtx_ssrcs.empty() && primary_ssrcs.size() != rtx_ssrcs.size()) {
263 LOG(LS_ERROR)
264 << "RTX SSRCs exist, but don't cover all SSRCs (unsupported): "
265 << sp.ToString();
266 return false;
267 }
268
269 return true;
270}
271
Peter Boström3afc8c42016-01-27 16:45:21 +0100272inline bool ContainsHeaderExtension(
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700273 const std::vector<webrtc::RtpExtension>& extensions,
274 const std::string& name) {
275 for (const auto& kv : extensions) {
276 if (kv.name == name) {
Peter Boström3afc8c42016-01-27 16:45:21 +0100277 return true;
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700278 }
279 }
Peter Boström3afc8c42016-01-27 16:45:21 +0100280 return false;
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700281}
282
andresp@webrtc.org82775b12014-11-07 09:37:54 +0000283// Merges two fec configs and logs an error if a conflict arises
Shao Changbine62202f2015-04-21 20:24:50 +0800284// such that merging in different order would trigger a different output.
andresp@webrtc.org82775b12014-11-07 09:37:54 +0000285static void MergeFecConfig(const webrtc::FecConfig& other,
286 webrtc::FecConfig* output) {
287 if (other.ulpfec_payload_type != -1) {
288 if (output->ulpfec_payload_type != -1 &&
289 output->ulpfec_payload_type != other.ulpfec_payload_type) {
290 LOG(LS_WARNING) << "Conflict merging ulpfec_payload_type configs: "
291 << output->ulpfec_payload_type << " and "
292 << other.ulpfec_payload_type;
293 }
294 output->ulpfec_payload_type = other.ulpfec_payload_type;
295 }
296 if (other.red_payload_type != -1) {
297 if (output->red_payload_type != -1 &&
298 output->red_payload_type != other.red_payload_type) {
299 LOG(LS_WARNING) << "Conflict merging red_payload_type configs: "
300 << output->red_payload_type << " and "
301 << other.red_payload_type;
302 }
303 output->red_payload_type = other.red_payload_type;
304 }
Shao Changbine62202f2015-04-21 20:24:50 +0800305 if (other.red_rtx_payload_type != -1) {
306 if (output->red_rtx_payload_type != -1 &&
307 output->red_rtx_payload_type != other.red_rtx_payload_type) {
308 LOG(LS_WARNING) << "Conflict merging red_rtx_payload_type configs: "
309 << output->red_rtx_payload_type << " and "
310 << other.red_rtx_payload_type;
311 }
312 output->red_rtx_payload_type = other.red_rtx_payload_type;
313 }
andresp@webrtc.org82775b12014-11-07 09:37:54 +0000314}
noahricfdac5162015-08-27 01:59:29 -0700315
316// Returns true if the given codec is disallowed from doing simulcast.
317bool IsCodecBlacklistedForSimulcast(const std::string& codec_name) {
asapersson3ed34872015-11-10 05:16:26 -0800318 return CodecNamesEq(codec_name, kH264CodecName) ||
319 CodecNamesEq(codec_name, kVp9CodecName);
noahricfdac5162015-08-27 01:59:29 -0700320}
321
Åsa Persson1c7d48d2015-09-08 09:21:43 +0200322// The selected thresholds for QVGA and VGA corresponded to a QP around 10.
323// The change in QP declined above the selected bitrates.
324static int GetMaxDefaultVideoBitrateKbps(int width, int height) {
325 if (width * height <= 320 * 240) {
326 return 600;
327 } else if (width * height <= 640 * 480) {
328 return 1700;
329 } else if (width * height <= 960 * 540) {
330 return 2000;
331 } else {
332 return 2500;
333 }
334}
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000335} // namespace
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000336
Peter Boström81ea54e2015-05-07 11:41:09 +0200337// Constants defined in talk/media/webrtc/constants.h
338// TODO(pbos): Move these to a separate constants.cc file.
339const int kMinVideoBitrate = 30;
340const int kStartVideoBitrate = 300;
Peter Boström81ea54e2015-05-07 11:41:09 +0200341
342const int kVideoMtu = 1200;
343const int kVideoRtpBufferSize = 65536;
344
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000345// This constant is really an on/off, lower-level configurable NACK history
346// duration hasn't been implemented.
347static const int kNackHistoryMs = 1000;
348
buildbot@webrtc.org933d88a2014-09-18 20:23:05 +0000349static const int kDefaultQpMax = 56;
350
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000351static const int kDefaultRtcpReceiverReportSsrc = 1;
352
Peter Boström81ea54e2015-05-07 11:41:09 +0200353std::vector<VideoCodec> DefaultVideoCodecList() {
354 std::vector<VideoCodec> codecs;
asapersson3ed34872015-11-10 05:16:26 -0800355 codecs.push_back(MakeVideoCodecWithDefaultFeedbackParams(kDefaultVp8PlType,
356 kVp8CodecName));
Peter Boström81ea54e2015-05-07 11:41:09 +0200357 if (CodecIsInternallySupported(kVp9CodecName)) {
358 codecs.push_back(MakeVideoCodecWithDefaultFeedbackParams(kDefaultVp9PlType,
359 kVp9CodecName));
360 // TODO(andresp): Add rtx codec for vp9 and verify it works.
361 }
Zeke Chin71f6f442015-06-29 14:34:58 -0700362 if (CodecIsInternallySupported(kH264CodecName)) {
363 codecs.push_back(MakeVideoCodecWithDefaultFeedbackParams(kDefaultH264PlType,
364 kH264CodecName));
365 }
Peter Boström81ea54e2015-05-07 11:41:09 +0200366 codecs.push_back(
367 VideoCodec::CreateRtxCodec(kDefaultRtxVp8PlType, kDefaultVp8PlType));
368 codecs.push_back(VideoCodec(kDefaultRedPlType, kRedCodecName));
369 codecs.push_back(VideoCodec(kDefaultUlpfecType, kUlpfecCodecName));
370 return codecs;
371}
372
buildbot@webrtc.orga8530772014-12-10 09:01:18 +0000373std::vector<webrtc::VideoStream>
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000374WebRtcVideoChannel2::WebRtcVideoSendStream::CreateSimulcastVideoStreams(
buildbot@webrtc.orga8530772014-12-10 09:01:18 +0000375 const VideoCodec& codec,
376 const VideoOptions& options,
Peter Boströmdfd53fe2015-03-27 15:58:11 +0100377 int max_bitrate_bps,
buildbot@webrtc.orga8530772014-12-10 09:01:18 +0000378 size_t num_streams) {
buildbot@webrtc.orga8530772014-12-10 09:01:18 +0000379 int max_qp = kDefaultQpMax;
380 codec.GetParam(kCodecParamMaxQuantization, &max_qp);
381
buildbot@webrtc.orga8530772014-12-10 09:01:18 +0000382 return GetSimulcastConfig(
pbosbe16f792015-10-16 12:49:39 -0700383 num_streams, codec.width, codec.height, max_bitrate_bps, max_qp,
buildbot@webrtc.orga8530772014-12-10 09:01:18 +0000384 codec.framerate != 0 ? codec.framerate : kDefaultVideoMaxFramerate);
385}
386
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000387std::vector<webrtc::VideoStream>
388WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoStreams(
buildbot@webrtc.orgd41eaeb2014-06-12 07:13:26 +0000389 const VideoCodec& codec,
390 const VideoOptions& options,
Peter Boströmdfd53fe2015-03-27 15:58:11 +0100391 int max_bitrate_bps,
buildbot@webrtc.orgd41eaeb2014-06-12 07:13:26 +0000392 size_t num_streams) {
Peter Boströmdfd53fe2015-03-27 15:58:11 +0100393 int codec_max_bitrate_kbps;
394 if (codec.GetParam(kCodecParamMaxBitrate, &codec_max_bitrate_kbps)) {
395 max_bitrate_bps = codec_max_bitrate_kbps * 1000;
396 }
397 if (num_streams != 1) {
398 return CreateSimulcastVideoStreams(codec, options, max_bitrate_bps,
399 num_streams);
400 }
401
402 // For unset max bitrates set default bitrate for non-simulcast.
Åsa Persson1c7d48d2015-09-08 09:21:43 +0200403 if (max_bitrate_bps <= 0) {
404 max_bitrate_bps =
405 GetMaxDefaultVideoBitrateKbps(codec.width, codec.height) * 1000;
406 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000407
buildbot@webrtc.orgd41eaeb2014-06-12 07:13:26 +0000408 webrtc::VideoStream stream;
409 stream.width = codec.width;
410 stream.height = codec.height;
411 stream.max_framerate =
andresp@webrtc.org82775b12014-11-07 09:37:54 +0000412 codec.framerate != 0 ? codec.framerate : kDefaultVideoMaxFramerate;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000413
pbos@webrtc.org00873182014-11-25 14:03:34 +0000414 stream.min_bitrate_bps = kMinVideoBitrate * 1000;
Peter Boströmdfd53fe2015-03-27 15:58:11 +0100415 stream.target_bitrate_bps = stream.max_bitrate_bps = max_bitrate_bps;
buildbot@webrtc.orgd41eaeb2014-06-12 07:13:26 +0000416
buildbot@webrtc.org933d88a2014-09-18 20:23:05 +0000417 int max_qp = kDefaultQpMax;
buildbot@webrtc.orgd41eaeb2014-06-12 07:13:26 +0000418 codec.GetParam(kCodecParamMaxQuantization, &max_qp);
419 stream.max_qp = max_qp;
420 std::vector<webrtc::VideoStream> streams;
421 streams.push_back(stream);
422 return streams;
423}
424
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000425void* WebRtcVideoChannel2::WebRtcVideoSendStream::ConfigureVideoEncoderSettings(
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000426 const VideoCodec& codec,
Erik Språng143cec12015-04-28 10:01:41 +0200427 const VideoOptions& options,
428 bool is_screencast) {
Peter Boström2feafdb2015-09-09 14:32:14 +0200429 // No automatic resizing when using simulcast or screencast.
430 bool automatic_resize =
431 !is_screencast && parameters_.config.rtp.ssrcs.size() == 1;
Erik Språng143cec12015-04-28 10:01:41 +0200432 bool frame_dropping = !is_screencast;
433 bool denoising;
pbos4cba4eb2015-10-26 11:18:18 -0700434 bool codec_default_denoising = false;
Erik Språng143cec12015-04-28 10:01:41 +0200435 if (is_screencast) {
436 denoising = false;
437 } else {
pbos4cba4eb2015-10-26 11:18:18 -0700438 // Use codec default if video_noise_reduction is unset.
kwiberg102c6a62015-10-30 02:47:38 -0700439 codec_default_denoising = !options.video_noise_reduction;
440 denoising = options.video_noise_reduction.value_or(false);
Erik Språng143cec12015-04-28 10:01:41 +0200441 }
442
hbosbab934b2016-01-27 01:36:03 -0800443 if (CodecNamesEq(codec.name, kH264CodecName)) {
444 encoder_settings_.h264 = webrtc::VideoEncoder::GetDefaultH264Settings();
445 encoder_settings_.h264.frameDroppingOn = frame_dropping;
446 return &encoder_settings_.h264;
447 }
Shao Changbine62202f2015-04-21 20:24:50 +0800448 if (CodecNamesEq(codec.name, kVp8CodecName)) {
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000449 encoder_settings_.vp8 = webrtc::VideoEncoder::GetDefaultVp8Settings();
Erik Språng143cec12015-04-28 10:01:41 +0200450 encoder_settings_.vp8.automaticResizeOn = automatic_resize;
pbos4cba4eb2015-10-26 11:18:18 -0700451 // VP8 denoising is enabled by default.
452 encoder_settings_.vp8.denoisingOn =
453 codec_default_denoising ? true : denoising;
Erik Språng143cec12015-04-28 10:01:41 +0200454 encoder_settings_.vp8.frameDroppingOn = frame_dropping;
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000455 return &encoder_settings_.vp8;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000456 }
Shao Changbine62202f2015-04-21 20:24:50 +0800457 if (CodecNamesEq(codec.name, kVp9CodecName)) {
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000458 encoder_settings_.vp9 = webrtc::VideoEncoder::GetDefaultVp9Settings();
pbos4cba4eb2015-10-26 11:18:18 -0700459 // VP9 denoising is disabled by default.
460 encoder_settings_.vp9.denoisingOn =
461 codec_default_denoising ? false : denoising;
Erik Språng143cec12015-04-28 10:01:41 +0200462 encoder_settings_.vp9.frameDroppingOn = frame_dropping;
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000463 return &encoder_settings_.vp9;
andresp@webrtc.org188d3b22014-11-07 13:21:04 +0000464 }
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000465 return NULL;
466}
467
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000468DefaultUnsignalledSsrcHandler::DefaultUnsignalledSsrcHandler()
469 : default_recv_ssrc_(0), default_renderer_(NULL) {}
470
471UnsignalledSsrcHandler::Action DefaultUnsignalledSsrcHandler::OnUnsignalledSsrc(
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +0000472 WebRtcVideoChannel2* channel,
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000473 uint32_t ssrc) {
474 if (default_recv_ssrc_ != 0) { // Already one default stream.
475 LOG(LS_WARNING) << "Unknown SSRC, but default receive stream already set.";
476 return kDropPacket;
477 }
478
479 StreamParams sp;
480 sp.ssrcs.push_back(ssrc);
481 LOG(LS_INFO) << "Creating default receive stream for SSRC=" << ssrc << ".";
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +0000482 if (!channel->AddRecvStream(sp, true)) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000483 LOG(LS_WARNING) << "Could not create default receive stream.";
484 }
485
486 channel->SetRenderer(ssrc, default_renderer_);
487 default_recv_ssrc_ = ssrc;
488 return kDeliverPacket;
489}
490
491VideoRenderer* DefaultUnsignalledSsrcHandler::GetDefaultRenderer() const {
492 return default_renderer_;
493}
494
495void DefaultUnsignalledSsrcHandler::SetDefaultRenderer(
496 VideoMediaChannel* channel,
497 VideoRenderer* renderer) {
498 default_renderer_ = renderer;
499 if (default_recv_ssrc_ != 0) {
500 channel->SetRenderer(default_recv_ssrc_, default_renderer_);
501 }
502}
503
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200504WebRtcVideoEngine2::WebRtcVideoEngine2()
505 : initialized_(false),
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000506 external_decoder_factory_(NULL),
507 external_encoder_factory_(NULL) {
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +0000508 LOG(LS_INFO) << "WebRtcVideoEngine2::WebRtcVideoEngine2()";
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000509 video_codecs_ = GetSupportedCodecs();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000510}
511
512WebRtcVideoEngine2::~WebRtcVideoEngine2() {
513 LOG(LS_INFO) << "WebRtcVideoEngine2::~WebRtcVideoEngine2";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000514}
515
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200516void WebRtcVideoEngine2::Init() {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000517 LOG(LS_INFO) << "WebRtcVideoEngine2::Init";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000518 initialized_ = true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000519}
520
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000521WebRtcVideoChannel2* WebRtcVideoEngine2::CreateChannel(
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200522 webrtc::Call* call,
523 const VideoOptions& options) {
henrikg91d6ede2015-09-17 00:24:34 -0700524 RTC_DCHECK(initialized_);
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200525 LOG(LS_INFO) << "CreateChannel. Options: " << options.ToString();
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200526 return new WebRtcVideoChannel2(call, options, video_codecs_,
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200527 external_encoder_factory_, external_decoder_factory_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000528}
529
530const std::vector<VideoCodec>& WebRtcVideoEngine2::codecs() const {
531 return video_codecs_;
532}
533
Stefan Holmer9d69c3f2015-12-07 10:45:43 +0100534RtpCapabilities WebRtcVideoEngine2::GetCapabilities() const {
535 RtpCapabilities capabilities;
536 capabilities.header_extensions.push_back(
537 RtpHeaderExtension(kRtpTimestampOffsetHeaderExtension,
538 kRtpTimestampOffsetHeaderExtensionDefaultId));
539 capabilities.header_extensions.push_back(
540 RtpHeaderExtension(kRtpAbsoluteSenderTimeHeaderExtension,
541 kRtpAbsoluteSenderTimeHeaderExtensionDefaultId));
542 capabilities.header_extensions.push_back(
543 RtpHeaderExtension(kRtpVideoRotationHeaderExtension,
544 kRtpVideoRotationHeaderExtensionDefaultId));
545 if (webrtc::field_trial::FindFullName("WebRTC-SendSideBwe") == "Enabled") {
546 capabilities.header_extensions.push_back(RtpHeaderExtension(
547 kRtpTransportSequenceNumberHeaderExtension,
548 kRtpTransportSequenceNumberHeaderExtensionDefaultId));
549 }
550 return capabilities;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000551}
552
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000553void WebRtcVideoEngine2::SetExternalDecoderFactory(
554 WebRtcVideoDecoderFactory* decoder_factory) {
henrikg91d6ede2015-09-17 00:24:34 -0700555 RTC_DCHECK(!initialized_);
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000556 external_decoder_factory_ = decoder_factory;
557}
558
559void WebRtcVideoEngine2::SetExternalEncoderFactory(
560 WebRtcVideoEncoderFactory* encoder_factory) {
henrikg91d6ede2015-09-17 00:24:34 -0700561 RTC_DCHECK(!initialized_);
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000562 if (external_encoder_factory_ == encoder_factory)
563 return;
564
565 // No matter what happens we shouldn't hold on to a stale
566 // WebRtcSimulcastEncoderFactory.
567 simulcast_encoder_factory_.reset();
568
569 if (encoder_factory &&
570 WebRtcSimulcastEncoderFactory::UseSimulcastEncoderFactory(
571 encoder_factory->codecs())) {
572 simulcast_encoder_factory_.reset(
573 new WebRtcSimulcastEncoderFactory(encoder_factory));
574 encoder_factory = simulcast_encoder_factory_.get();
575 }
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000576 external_encoder_factory_ = encoder_factory;
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000577
578 video_codecs_ = GetSupportedCodecs();
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000579}
580
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000581// Checks to see whether we comprehend and could receive a particular codec
582bool WebRtcVideoEngine2::FindCodec(const VideoCodec& in) {
583 // TODO(pbos): Probe encoder factory to figure out that the codec is supported
584 // if supported by the encoder factory. Add a corresponding test that fails
585 // with this code (that doesn't ask the factory).
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000586 for (size_t j = 0; j < video_codecs_.size(); ++j) {
587 VideoCodec codec(video_codecs_[j].id, video_codecs_[j].name, 0, 0, 0, 0);
588 if (codec.Matches(in)) {
589 return true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000590 }
591 }
592 return false;
593}
594
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000595// Ignore spammy trace messages, mostly from the stats API when we haven't
596// gotten RTCP info yet from the remote side.
597bool WebRtcVideoEngine2::ShouldIgnoreTrace(const std::string& trace) {
598 static const char* const kTracesToIgnore[] = {NULL};
599 for (const char* const* p = kTracesToIgnore; *p; ++p) {
600 if (trace.find(*p) == 0) {
601 return true;
602 }
603 }
604 return false;
605}
606
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000607std::vector<VideoCodec> WebRtcVideoEngine2::GetSupportedCodecs() const {
andresp@webrtc.org82775b12014-11-07 09:37:54 +0000608 std::vector<VideoCodec> supported_codecs = DefaultVideoCodecList();
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000609
610 if (external_encoder_factory_ == NULL) {
611 return supported_codecs;
612 }
613
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000614 const std::vector<WebRtcVideoEncoderFactory::VideoCodec>& codecs =
615 external_encoder_factory_->codecs();
616 for (size_t i = 0; i < codecs.size(); ++i) {
617 // Don't add internally-supported codecs twice.
618 if (CodecIsInternallySupported(codecs[i].name)) {
619 continue;
620 }
621
pkasting@chromium.orgd3245462015-02-23 21:28:22 +0000622 // External video encoders are given payloads 120-127. This also means that
623 // we only support up to 8 external payload types.
624 const int kExternalVideoPayloadTypeBase = 120;
625 size_t payload_type = kExternalVideoPayloadTypeBase + i;
henrikg91d6ede2015-09-17 00:24:34 -0700626 RTC_DCHECK(payload_type < 128);
pkasting@chromium.orgd3245462015-02-23 21:28:22 +0000627 VideoCodec codec(static_cast<int>(payload_type),
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000628 codecs[i].name,
629 codecs[i].max_width,
630 codecs[i].max_height,
631 codecs[i].max_fps,
632 0);
633
634 AddDefaultFeedbackParams(&codec);
635 supported_codecs.push_back(codec);
636 }
637 return supported_codecs;
638}
639
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000640WebRtcVideoChannel2::WebRtcVideoChannel2(
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200641 webrtc::Call* call,
pbos@webrtc.orgfa553ef2014-10-20 11:07:07 +0000642 const VideoOptions& options,
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200643 const std::vector<VideoCodec>& recv_codecs,
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000644 WebRtcVideoEncoderFactory* external_encoder_factory,
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000645 WebRtcVideoDecoderFactory* external_decoder_factory)
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200646 : call_(call),
647 unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000648 external_encoder_factory_(external_encoder_factory),
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000649 external_decoder_factory_(external_decoder_factory) {
henrikg91d6ede2015-09-17 00:24:34 -0700650 RTC_DCHECK(thread_checker_.CalledOnValidThread());
pbos@webrtc.orgfa553ef2014-10-20 11:07:07 +0000651 SetDefaultOptions();
652 options_.SetAll(options);
kwiberg102c6a62015-10-30 02:47:38 -0700653 if (options_.cpu_overuse_detection)
654 signal_cpu_adaptation_ = *options_.cpu_overuse_detection;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000655 rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc;
656 sending_ = false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000657 default_send_ssrc_ = 0;
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200658 SetRecvCodecs(recv_codecs);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000659}
660
661void WebRtcVideoChannel2::SetDefaultOptions() {
Karl Wibergbe579832015-11-10 22:34:18 +0100662 options_.cpu_overuse_detection = rtc::Optional<bool>(true);
663 options_.dscp = rtc::Optional<bool>(false);
664 options_.suspend_below_min_bitrate = rtc::Optional<bool>(false);
665 options_.screencast_min_bitrate = rtc::Optional<int>(0);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000666}
667
668WebRtcVideoChannel2::~WebRtcVideoChannel2() {
Peter Boströmdfd53fe2015-03-27 15:58:11 +0100669 for (auto& kv : send_streams_)
670 delete kv.second;
671 for (auto& kv : receive_streams_)
672 delete kv.second;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000673}
674
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000675bool WebRtcVideoChannel2::CodecIsExternallySupported(
676 const std::string& name) const {
677 if (external_encoder_factory_ == NULL) {
678 return false;
679 }
680
681 const std::vector<WebRtcVideoEncoderFactory::VideoCodec> external_codecs =
682 external_encoder_factory_->codecs();
683 for (size_t c = 0; c < external_codecs.size(); ++c) {
Shao Changbine62202f2015-04-21 20:24:50 +0800684 if (CodecNamesEq(name, external_codecs[c].name)) {
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000685 return true;
686 }
687 }
688 return false;
689}
690
691std::vector<WebRtcVideoChannel2::VideoCodecSettings>
692WebRtcVideoChannel2::FilterSupportedCodecs(
693 const std::vector<WebRtcVideoChannel2::VideoCodecSettings>& mapped_codecs)
694 const {
695 std::vector<VideoCodecSettings> supported_codecs;
696 for (size_t i = 0; i < mapped_codecs.size(); ++i) {
697 const VideoCodecSettings& codec = mapped_codecs[i];
698 if (CodecIsInternallySupported(codec.codec.name) ||
699 CodecIsExternallySupported(codec.codec.name)) {
700 supported_codecs.push_back(codec);
701 }
702 }
703 return supported_codecs;
704}
705
deadbeef874ca3a2015-08-20 17:19:20 -0700706bool WebRtcVideoChannel2::ReceiveCodecsHaveChanged(
707 std::vector<VideoCodecSettings> before,
708 std::vector<VideoCodecSettings> after) {
709 if (before.size() != after.size()) {
710 return true;
711 }
712 // The receive codec order doesn't matter, so we sort the codecs before
713 // comparing. This is necessary because currently the
714 // only way to change the send codec is to munge SDP, which causes
715 // the receive codec list to change order, which causes the streams
716 // to be recreates which causes a "blink" of black video. In order
717 // to support munging the SDP in this way without recreating receive
718 // streams, we ignore the order of the received codecs so that
719 // changing the order doesn't cause this "blink".
720 auto comparison =
721 [](const VideoCodecSettings& codec1, const VideoCodecSettings& codec2) {
722 return codec1.codec.id > codec2.codec.id;
723 };
724 std::sort(before.begin(), before.end(), comparison);
725 std::sort(after.begin(), after.end(), comparison);
726 for (size_t i = 0; i < before.size(); ++i) {
727 // For the same reason that we sort the codecs, we also ignore the
728 // preference. We don't want a preference change on the receive
729 // side to cause recreation of the stream.
730 before[i].codec.preference = 0;
731 after[i].codec.preference = 0;
732 if (before[i] != after[i]) {
733 return true;
734 }
735 }
736 return false;
737}
738
Peter Boström3afc8c42016-01-27 16:45:21 +0100739bool WebRtcVideoChannel2::GetChangedSendParameters(
740 const VideoSendParameters& params,
741 ChangedSendParameters* changed_params) const {
742 if (!ValidateCodecFormats(params.codecs) ||
743 !ValidateRtpExtensions(params.extensions)) {
744 return false;
745 }
746
747 // ==== SEND CODEC ====
748 const std::vector<VideoCodecSettings> supported_codecs =
749 FilterSupportedCodecs(MapCodecs(params.codecs));
750
751 if (supported_codecs.empty()) {
752 LOG(LS_ERROR) << "No video codecs supported.";
753 return false;
754 }
755
756 if (!send_codec_ || supported_codecs.front() != *send_codec_) {
757 // Send codec has changed.
758 changed_params->codec =
759 rtc::Optional<VideoCodecSettings>(supported_codecs.front());
760 }
761
762 // ==== RTP HEADER EXTENSIONS ====
763 std::vector<webrtc::RtpExtension> filtered_extensions = FilterRtpExtensions(
764 params.extensions, webrtc::RtpExtension::IsSupportedForVideo, true);
765 if (send_rtp_extensions_ != filtered_extensions) {
766 changed_params->rtp_header_extensions =
767 rtc::Optional<std::vector<webrtc::RtpExtension>>(filtered_extensions);
768 }
769
770 // ==== MAX BITRATE ====
771 if (params.max_bandwidth_bps != bitrate_config_.max_bitrate_bps &&
772 params.max_bandwidth_bps >= 0) {
773 // 0 uncaps max bitrate (-1).
774 changed_params->max_bandwidth_bps = rtc::Optional<int>(
775 params.max_bandwidth_bps == 0 ? -1 : params.max_bandwidth_bps);
776 }
777
778 // ==== OPTIONS ====
779 // TODO(pbos): Require VideoSendParameters to contain a full set of options
780 // and check if params.options != options_ instead of applying a delta.
781 VideoOptions new_options = options_;
782 new_options.SetAll(params.options);
783 if (!(new_options == options_)) {
784 changed_params->options = rtc::Optional<VideoOptions>(new_options);
785 }
786
787 if (params.rtcp.reduced_size != send_params_.rtcp.reduced_size) {
788 changed_params->rtcp_mode = rtc::Optional<webrtc::RtcpMode>(
789 params.rtcp.reduced_size ? webrtc::RtcpMode::kReducedSize
790 : webrtc::RtcpMode::kCompound);
791 }
792
793 return true;
794}
795
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700796bool WebRtcVideoChannel2::SetSendParameters(const VideoSendParameters& params) {
Peter Boström9f45a452015-12-08 13:25:57 +0100797 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetSendParameters");
solenberg7e4e01a2015-12-02 08:05:01 -0800798 LOG(LS_INFO) << "SetSendParameters: " << params.ToString();
Peter Boström3afc8c42016-01-27 16:45:21 +0100799 ChangedSendParameters changed_params;
800 if (!GetChangedSendParameters(params, &changed_params)) {
deadbeef13871492015-12-09 12:37:51 -0800801 return false;
802 }
Peter Boström3afc8c42016-01-27 16:45:21 +0100803
804 bool bitrate_config_changed = false;
805
806 if (changed_params.codec) {
807 const VideoCodecSettings& codec_settings = *changed_params.codec;
808 send_codec_ = rtc::Optional<VideoCodecSettings>(codec_settings);
809
810 LOG(LS_INFO) << "Using codec: " << codec_settings.codec.ToString();
811 // TODO(holmer): Changing the codec parameters shouldn't necessarily mean
812 // that we change the min/max of bandwidth estimation. Reevaluate this.
813 bitrate_config_ = GetBitrateConfigForCodec(codec_settings.codec);
814 bitrate_config_changed = true;
815 }
816
817 if (changed_params.rtp_header_extensions) {
818 send_rtp_extensions_ = *changed_params.rtp_header_extensions;
819 }
820
821 if (changed_params.max_bandwidth_bps) {
822 // TODO(pbos): Figure out whether b=AS means max bitrate for this
823 // WebRtcVideoChannel2 (in which case we're good), or per sender (SSRC), in
824 // which case this should not set a Call::BitrateConfig but rather
825 // reconfigure all senders.
826 int max_bitrate_bps = *changed_params.max_bandwidth_bps;
827 bitrate_config_.start_bitrate_bps = -1;
828 bitrate_config_.max_bitrate_bps = max_bitrate_bps;
829 if (max_bitrate_bps > 0 &&
830 bitrate_config_.min_bitrate_bps > max_bitrate_bps) {
831 bitrate_config_.min_bitrate_bps = max_bitrate_bps;
832 }
833 bitrate_config_changed = true;
834 }
835
836 if (bitrate_config_changed) {
837 call_->SetBitrateConfig(bitrate_config_);
838 }
839
840 if (changed_params.options) {
841 options_.SetAll(*changed_params.options);
842 {
843 rtc::CritScope lock(&capturer_crit_);
844 if (options_.cpu_overuse_detection) {
845 signal_cpu_adaptation_ = *options_.cpu_overuse_detection;
846 }
847 }
848 rtc::DiffServCodePoint dscp =
849 options_.dscp.value_or(false) ? rtc::DSCP_AF41 : rtc::DSCP_DEFAULT;
850 MediaChannel::SetDscp(dscp);
851 }
852
853 {
deadbeef13871492015-12-09 12:37:51 -0800854 rtc::CritScope stream_lock(&stream_crit_);
855 for (auto& kv : send_streams_) {
Peter Boström3afc8c42016-01-27 16:45:21 +0100856 kv.second->SetSendParameters(changed_params);
857 }
858 if (changed_params.codec) {
859 // Update receive feedback parameters from new codec.
860 LOG(LS_INFO)
861 << "SetFeedbackOptions on all the receive streams because the send "
862 "codec has changed.";
863 for (auto& kv : receive_streams_) {
864 RTC_DCHECK(kv.second != nullptr);
865 kv.second->SetFeedbackParameters(HasNack(send_codec_->codec),
866 HasRemb(send_codec_->codec),
867 HasTransportCc(send_codec_->codec));
868 }
deadbeef13871492015-12-09 12:37:51 -0800869 }
870 }
871 send_params_ = params;
872 return true;
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700873}
874
875bool WebRtcVideoChannel2::SetRecvParameters(const VideoRecvParameters& params) {
Peter Boström9f45a452015-12-08 13:25:57 +0100876 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRecvParameters");
solenberg7e4e01a2015-12-02 08:05:01 -0800877 LOG(LS_INFO) << "SetRecvParameters: " << params.ToString();
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700878 // TODO(pbos): Refactor this to only recreate the recv streams once
879 // instead of twice.
deadbeef13871492015-12-09 12:37:51 -0800880 if (!SetRecvCodecs(params.codecs) ||
881 !SetRecvRtpHeaderExtensions(params.extensions)) {
882 return false;
883 }
884 if (recv_params_.rtcp.reduced_size != params.rtcp.reduced_size) {
885 rtc::CritScope stream_lock(&stream_crit_);
886 for (auto& kv : receive_streams_) {
887 kv.second->SetRecvParameters(params);
888 }
889 }
890 recv_params_ = params;
891 return true;
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700892}
893
deadbeef874ca3a2015-08-20 17:19:20 -0700894std::string WebRtcVideoChannel2::CodecSettingsVectorToString(
895 const std::vector<VideoCodecSettings>& codecs) {
896 std::stringstream out;
897 out << '{';
898 for (size_t i = 0; i < codecs.size(); ++i) {
899 out << codecs[i].codec.ToString();
900 if (i != codecs.size() - 1) {
901 out << ", ";
902 }
903 }
904 out << '}';
905 return out.str();
906}
907
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000908bool WebRtcVideoChannel2::SetRecvCodecs(const std::vector<VideoCodec>& codecs) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +0000909 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRecvCodecs");
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000910 LOG(LS_INFO) << "SetRecvCodecs: " << CodecVectorToString(codecs);
911 if (!ValidateCodecFormats(codecs)) {
912 return false;
913 }
914
915 const std::vector<VideoCodecSettings> mapped_codecs = MapCodecs(codecs);
916 if (mapped_codecs.empty()) {
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000917 LOG(LS_ERROR) << "SetRecvCodecs called without any video codecs.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000918 return false;
919 }
920
deadbeef874ca3a2015-08-20 17:19:20 -0700921 std::vector<VideoCodecSettings> supported_codecs =
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000922 FilterSupportedCodecs(mapped_codecs);
923
924 if (mapped_codecs.size() != supported_codecs.size()) {
925 LOG(LS_ERROR) << "SetRecvCodecs called with unsupported video codecs.";
926 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000927 }
928
Peter Boströmee0b00e2015-04-22 18:41:14 +0200929 // Prevent reconfiguration when setting identical receive codecs.
deadbeef874ca3a2015-08-20 17:19:20 -0700930 if (!ReceiveCodecsHaveChanged(recv_codecs_, supported_codecs)) {
931 LOG(LS_INFO)
932 << "Ignoring call to SetRecvCodecs because codecs haven't changed.";
933 return true;
Peter Boströmee0b00e2015-04-22 18:41:14 +0200934 }
935
deadbeef874ca3a2015-08-20 17:19:20 -0700936 LOG(LS_INFO) << "Changing recv codecs from "
937 << CodecSettingsVectorToString(recv_codecs_) << " to "
938 << CodecSettingsVectorToString(supported_codecs);
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000939 recv_codecs_ = supported_codecs;
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000940
pbos@webrtc.org575d1262014-10-08 14:48:08 +0000941 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +0200942 for (std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it =
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000943 receive_streams_.begin();
Peter Boström0c4e06b2015-10-07 12:23:21 +0200944 it != receive_streams_.end(); ++it) {
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000945 it->second->SetRecvCodecs(recv_codecs_);
946 }
947
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000948 return true;
949}
950
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000951bool WebRtcVideoChannel2::GetSendCodec(VideoCodec* codec) {
kwiberg102c6a62015-10-30 02:47:38 -0700952 if (!send_codec_) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000953 LOG(LS_VERBOSE) << "GetSendCodec: No send codec set.";
954 return false;
955 }
kwiberg102c6a62015-10-30 02:47:38 -0700956 *codec = send_codec_->codec;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000957 return true;
958}
959
Peter Boström0c4e06b2015-10-07 12:23:21 +0200960bool WebRtcVideoChannel2::SetSendStreamFormat(uint32_t ssrc,
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000961 const VideoFormat& format) {
962 LOG(LS_VERBOSE) << "SetSendStreamFormat:" << ssrc << " -> "
963 << format.ToString();
pbos@webrtc.org575d1262014-10-08 14:48:08 +0000964 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000965 if (send_streams_.find(ssrc) == send_streams_.end()) {
966 return false;
967 }
968 return send_streams_[ssrc]->SetVideoFormat(format);
969}
970
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000971bool WebRtcVideoChannel2::SetSend(bool send) {
972 LOG(LS_VERBOSE) << "SetSend: " << (send ? "true" : "false");
kwiberg102c6a62015-10-30 02:47:38 -0700973 if (send && !send_codec_) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000974 LOG(LS_ERROR) << "SetSend(true) called before setting codec.";
975 return false;
976 }
977 if (send) {
978 StartAllSendStreams();
979 } else {
980 StopAllSendStreams();
981 }
982 sending_ = send;
983 return true;
984}
985
Peter Boström0c4e06b2015-10-07 12:23:21 +0200986bool WebRtcVideoChannel2::SetVideoSend(uint32_t ssrc, bool enable,
solenberg1dd98f32015-09-10 01:57:14 -0700987 const VideoOptions* options) {
Peter Boström3afc8c42016-01-27 16:45:21 +0100988 TRACE_EVENT0("webrtc", "SetVideoSend");
989 LOG(LS_INFO) << "SetVideoSend (ssrc= " << ssrc << ", enable = " << enable
990 << "options: " << (options ? options->ToString() : "nullptr")
991 << ").";
992
solenberg1dd98f32015-09-10 01:57:14 -0700993 // TODO(solenberg): The state change should be fully rolled back if any one of
994 // these calls fail.
solenbergdfc8f4f2015-10-01 02:31:10 -0700995 if (!MuteStream(ssrc, !enable)) {
solenberg1dd98f32015-09-10 01:57:14 -0700996 return false;
997 }
solenbergdfc8f4f2015-10-01 02:31:10 -0700998 if (enable && options) {
Peter Boström3afc8c42016-01-27 16:45:21 +0100999 VideoSendParameters new_params = send_params_;
1000 new_params.options.SetAll(*options);
1001 SetSendParameters(send_params_);
solenberg1dd98f32015-09-10 01:57:14 -07001002 }
Peter Boström3afc8c42016-01-27 16:45:21 +01001003 return true;
solenberg1dd98f32015-09-10 01:57:14 -07001004}
1005
Peter Boströmd6f4c252015-03-26 16:23:04 +01001006bool WebRtcVideoChannel2::ValidateSendSsrcAvailability(
1007 const StreamParams& sp) const {
1008 for (uint32_t ssrc: sp.ssrcs) {
1009 if (send_ssrcs_.find(ssrc) != send_ssrcs_.end()) {
1010 LOG(LS_ERROR) << "Send stream with SSRC '" << ssrc << "' already exists.";
1011 return false;
1012 }
1013 }
1014 return true;
1015}
1016
1017bool WebRtcVideoChannel2::ValidateReceiveSsrcAvailability(
1018 const StreamParams& sp) const {
1019 for (uint32_t ssrc: sp.ssrcs) {
1020 if (receive_ssrcs_.find(ssrc) != receive_ssrcs_.end()) {
1021 LOG(LS_ERROR) << "Receive stream with SSRC '" << ssrc
1022 << "' already exists.";
1023 return false;
1024 }
1025 }
1026 return true;
1027}
1028
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001029bool WebRtcVideoChannel2::AddSendStream(const StreamParams& sp) {
1030 LOG(LS_INFO) << "AddSendStream: " << sp.ToString();
Peter Boströmd4362cd2015-03-25 14:17:23 +01001031 if (!ValidateStreamParams(sp))
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001032 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001033
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001034 rtc::CritScope stream_lock(&stream_crit_);
Peter Boströmd6f4c252015-03-26 16:23:04 +01001035
1036 if (!ValidateSendSsrcAvailability(sp))
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001037 return false;
Peter Boströmd6f4c252015-03-26 16:23:04 +01001038
Peter Boström0c4e06b2015-10-07 12:23:21 +02001039 for (uint32_t used_ssrc : sp.ssrcs)
Peter Boströmd6f4c252015-03-26 16:23:04 +01001040 send_ssrcs_.insert(used_ssrc);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001041
solenberge5269742015-09-08 05:13:22 -07001042 webrtc::VideoSendStream::Config config(this);
1043 config.overuse_callback = this;
1044
deadbeef13871492015-12-09 12:37:51 -08001045 WebRtcVideoSendStream* stream = new WebRtcVideoSendStream(
1046 call_, sp, config, external_encoder_factory_, options_,
1047 bitrate_config_.max_bitrate_bps, send_codec_, send_rtp_extensions_,
1048 send_params_);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001049
Peter Boström0c4e06b2015-10-07 12:23:21 +02001050 uint32_t ssrc = sp.first_ssrc();
henrikg91d6ede2015-09-17 00:24:34 -07001051 RTC_DCHECK(ssrc != 0);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001052 send_streams_[ssrc] = stream;
1053
1054 if (rtcp_receiver_report_ssrc_ == kDefaultRtcpReceiverReportSsrc) {
1055 rtcp_receiver_report_ssrc_ = ssrc;
deadbeef874ca3a2015-08-20 17:19:20 -07001056 LOG(LS_INFO) << "SetLocalSsrc on all the receive streams because we added "
1057 "a send stream.";
Peter Boström3548dd22015-05-22 18:48:36 +02001058 for (auto& kv : receive_streams_)
1059 kv.second->SetLocalSsrc(ssrc);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001060 }
1061 if (default_send_ssrc_ == 0) {
1062 default_send_ssrc_ = ssrc;
1063 }
1064 if (sending_) {
1065 stream->Start();
1066 }
1067
1068 return true;
1069}
1070
Peter Boström0c4e06b2015-10-07 12:23:21 +02001071bool WebRtcVideoChannel2::RemoveSendStream(uint32_t ssrc) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001072 LOG(LS_INFO) << "RemoveSendStream: " << ssrc;
1073
1074 if (ssrc == 0) {
1075 if (default_send_ssrc_ == 0) {
1076 LOG(LS_ERROR) << "No default send stream active.";
1077 return false;
1078 }
1079
1080 LOG(LS_VERBOSE) << "Removing default stream: " << default_send_ssrc_;
1081 ssrc = default_send_ssrc_;
1082 }
1083
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001084 WebRtcVideoSendStream* removed_stream;
1085 {
1086 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001087 std::map<uint32_t, WebRtcVideoSendStream*>::iterator it =
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001088 send_streams_.find(ssrc);
1089 if (it == send_streams_.end()) {
1090 return false;
1091 }
1092
Peter Boström0c4e06b2015-10-07 12:23:21 +02001093 for (uint32_t old_ssrc : it->second->GetSsrcs())
Peter Boströmd6f4c252015-03-26 16:23:04 +01001094 send_ssrcs_.erase(old_ssrc);
1095
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001096 removed_stream = it->second;
1097 send_streams_.erase(it);
Peter Boströmdfa28152015-10-21 17:21:10 +02001098
1099 // Switch receiver report SSRCs, the one in use is no longer valid.
1100 if (rtcp_receiver_report_ssrc_ == ssrc) {
1101 rtcp_receiver_report_ssrc_ = send_streams_.empty()
1102 ? kDefaultRtcpReceiverReportSsrc
1103 : send_streams_.begin()->first;
1104 LOG(LS_INFO) << "SetLocalSsrc on all the receive streams because the "
1105 "previous local SSRC was removed.";
1106
1107 for (auto& kv : receive_streams_) {
1108 kv.second->SetLocalSsrc(rtcp_receiver_report_ssrc_);
1109 }
1110 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001111 }
1112
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001113 delete removed_stream;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001114
1115 if (ssrc == default_send_ssrc_) {
1116 default_send_ssrc_ = 0;
1117 }
1118
1119 return true;
1120}
1121
Peter Boströmd6f4c252015-03-26 16:23:04 +01001122void WebRtcVideoChannel2::DeleteReceiveStream(
1123 WebRtcVideoChannel2::WebRtcVideoReceiveStream* stream) {
Peter Boström0c4e06b2015-10-07 12:23:21 +02001124 for (uint32_t old_ssrc : stream->GetSsrcs())
Peter Boströmd6f4c252015-03-26 16:23:04 +01001125 receive_ssrcs_.erase(old_ssrc);
1126 delete stream;
1127}
1128
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001129bool WebRtcVideoChannel2::AddRecvStream(const StreamParams& sp) {
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00001130 return AddRecvStream(sp, false);
1131}
1132
1133bool WebRtcVideoChannel2::AddRecvStream(const StreamParams& sp,
1134 bool default_stream) {
henrikg91d6ede2015-09-17 00:24:34 -07001135 RTC_DCHECK(thread_checker_.CalledOnValidThread());
Fredrik Solenberg4b60c732015-05-07 14:07:48 +02001136
Peter Boströmd4362cd2015-03-25 14:17:23 +01001137 LOG(LS_INFO) << "AddRecvStream" << (default_stream ? " (default stream)" : "")
1138 << ": " << sp.ToString();
1139 if (!ValidateStreamParams(sp))
1140 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001141
Peter Boström0c4e06b2015-10-07 12:23:21 +02001142 uint32_t ssrc = sp.first_ssrc();
henrikg91d6ede2015-09-17 00:24:34 -07001143 RTC_DCHECK(ssrc != 0); // TODO(pbos): Is this ever valid?
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001144
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001145 rtc::CritScope stream_lock(&stream_crit_);
Peter Boströmd6f4c252015-03-26 16:23:04 +01001146 // Remove running stream if this was a default stream.
1147 auto prev_stream = receive_streams_.find(ssrc);
1148 if (prev_stream != receive_streams_.end()) {
1149 if (default_stream || !prev_stream->second->IsDefaultStream()) {
1150 LOG(LS_ERROR) << "Receive stream for SSRC '" << ssrc
1151 << "' already exists.";
1152 return false;
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00001153 }
Peter Boströmd6f4c252015-03-26 16:23:04 +01001154 DeleteReceiveStream(prev_stream->second);
1155 receive_streams_.erase(prev_stream);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001156 }
1157
Peter Boströmd6f4c252015-03-26 16:23:04 +01001158 if (!ValidateReceiveSsrcAvailability(sp))
1159 return false;
1160
Peter Boström0c4e06b2015-10-07 12:23:21 +02001161 for (uint32_t used_ssrc : sp.ssrcs)
Peter Boströmd6f4c252015-03-26 16:23:04 +01001162 receive_ssrcs_.insert(used_ssrc);
1163
solenberg4fbae2b2015-08-28 04:07:10 -07001164 webrtc::VideoReceiveStream::Config config(this);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001165 ConfigureReceiverRtp(&config, sp);
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +00001166
pbos8fc7fa72015-07-15 08:02:58 -07001167 // Set up A/V sync group based on sync label.
1168 config.sync_group = sp.sync_label;
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +00001169
kwiberg102c6a62015-10-30 02:47:38 -07001170 config.rtp.remb = send_codec_ ? HasRemb(send_codec_->codec) : false;
stefan43edf0f2015-11-20 18:05:48 -08001171 config.rtp.transport_cc =
1172 send_codec_ ? HasTransportCc(send_codec_->codec) : false;
Peter Boström126c03e2015-05-11 12:48:12 +02001173
Peter Boströmd6f4c252015-03-26 16:23:04 +01001174 receive_streams_[ssrc] = new WebRtcVideoReceiveStream(
Fredrik Solenberg709ed672015-09-15 12:26:33 +02001175 call_, sp, config, external_decoder_factory_, default_stream,
qiangchen444682a2015-11-24 18:07:56 -08001176 recv_codecs_, options_.disable_prerenderer_smoothing.value_or(false));
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001177
1178 return true;
1179}
1180
1181void WebRtcVideoChannel2::ConfigureReceiverRtp(
1182 webrtc::VideoReceiveStream::Config* config,
1183 const StreamParams& sp) const {
Peter Boström0c4e06b2015-10-07 12:23:21 +02001184 uint32_t ssrc = sp.first_ssrc();
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001185
1186 config->rtp.remote_ssrc = ssrc;
1187 config->rtp.local_ssrc = rtcp_receiver_report_ssrc_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001188
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001189 config->rtp.extensions = recv_rtp_extensions_;
deadbeef13871492015-12-09 12:37:51 -08001190 config->rtp.rtcp_mode = recv_params_.rtcp.reduced_size
1191 ? webrtc::RtcpMode::kReducedSize
1192 : webrtc::RtcpMode::kCompound;
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001193
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001194 // TODO(pbos): This protection is against setting the same local ssrc as
1195 // remote which is not permitted by the lower-level API. RTCP requires a
1196 // corresponding sender SSRC. Figure out what to do when we don't have
1197 // (receive-only) or know a good local SSRC.
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001198 if (config->rtp.remote_ssrc == config->rtp.local_ssrc) {
1199 if (config->rtp.local_ssrc != kDefaultRtcpReceiverReportSsrc) {
1200 config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001201 } else {
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001202 config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc + 1;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001203 }
1204 }
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001205
1206 for (size_t i = 0; i < recv_codecs_.size(); ++i) {
andresp@webrtc.org82775b12014-11-07 09:37:54 +00001207 MergeFecConfig(recv_codecs_[i].fec, &config->rtp.fec);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001208 }
1209
andresp@webrtc.org82775b12014-11-07 09:37:54 +00001210 for (size_t i = 0; i < recv_codecs_.size(); ++i) {
Peter Boström0c4e06b2015-10-07 12:23:21 +02001211 uint32_t rtx_ssrc;
andresp@webrtc.org82775b12014-11-07 09:37:54 +00001212 if (recv_codecs_[i].rtx_payload_type != -1 &&
1213 sp.GetFidSsrc(ssrc, &rtx_ssrc)) {
1214 webrtc::VideoReceiveStream::Config::Rtp::Rtx& rtx =
1215 config->rtp.rtx[recv_codecs_[i].codec.id];
1216 rtx.ssrc = rtx_ssrc;
1217 rtx.payload_type = recv_codecs_[i].rtx_payload_type;
1218 }
1219 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001220}
1221
Peter Boström0c4e06b2015-10-07 12:23:21 +02001222bool WebRtcVideoChannel2::RemoveRecvStream(uint32_t ssrc) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001223 LOG(LS_INFO) << "RemoveRecvStream: " << ssrc;
1224 if (ssrc == 0) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001225 LOG(LS_ERROR) << "RemoveRecvStream with 0 ssrc is not supported.";
1226 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001227 }
1228
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001229 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001230 std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator stream =
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001231 receive_streams_.find(ssrc);
1232 if (stream == receive_streams_.end()) {
1233 LOG(LS_ERROR) << "Stream not found for ssrc: " << ssrc;
1234 return false;
1235 }
Peter Boströmd6f4c252015-03-26 16:23:04 +01001236 DeleteReceiveStream(stream->second);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001237 receive_streams_.erase(stream);
1238
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001239 return true;
1240}
1241
Peter Boström0c4e06b2015-10-07 12:23:21 +02001242bool WebRtcVideoChannel2::SetRenderer(uint32_t ssrc, VideoRenderer* renderer) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001243 LOG(LS_INFO) << "SetRenderer: ssrc:" << ssrc << " "
1244 << (renderer ? "(ptr)" : "NULL");
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001245 if (ssrc == 0) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001246 default_unsignalled_ssrc_handler_.SetDefaultRenderer(this, renderer);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001247 return true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001248 }
1249
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001250 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001251 std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it =
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001252 receive_streams_.find(ssrc);
1253 if (it == receive_streams_.end()) {
1254 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001255 }
1256
nissee73afba2016-01-28 04:47:08 -08001257 it->second->SetSink(renderer);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001258 return true;
1259}
1260
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00001261bool WebRtcVideoChannel2::GetStats(VideoMediaInfo* info) {
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001262 info->Clear();
1263 FillSenderStats(info);
1264 FillReceiverStats(info);
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00001265 webrtc::Call::Stats stats = call_->GetStats();
1266 FillBandwidthEstimationStats(stats, info);
1267 if (stats.rtt_ms != -1) {
1268 for (size_t i = 0; i < info->senders.size(); ++i) {
1269 info->senders[i].rtt_ms = stats.rtt_ms;
1270 }
1271 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001272 return true;
1273}
1274
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001275void WebRtcVideoChannel2::FillSenderStats(VideoMediaInfo* video_media_info) {
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001276 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001277 for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator it =
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001278 send_streams_.begin();
Peter Boström0c4e06b2015-10-07 12:23:21 +02001279 it != send_streams_.end(); ++it) {
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001280 video_media_info->senders.push_back(it->second->GetVideoSenderInfo());
1281 }
1282}
1283
1284void WebRtcVideoChannel2::FillReceiverStats(VideoMediaInfo* video_media_info) {
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001285 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001286 for (std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it =
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001287 receive_streams_.begin();
Peter Boström0c4e06b2015-10-07 12:23:21 +02001288 it != receive_streams_.end(); ++it) {
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001289 video_media_info->receivers.push_back(it->second->GetVideoReceiverInfo());
1290 }
1291}
1292
1293void WebRtcVideoChannel2::FillBandwidthEstimationStats(
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00001294 const webrtc::Call::Stats& stats,
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001295 VideoMediaInfo* video_media_info) {
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001296 BandwidthEstimationInfo bwe_info;
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001297 bwe_info.available_send_bandwidth = stats.send_bandwidth_bps;
1298 bwe_info.available_recv_bandwidth = stats.recv_bandwidth_bps;
1299 bwe_info.bucket_delay = stats.pacer_delay_ms;
1300
1301 // Get send stream bitrate stats.
1302 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001303 for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator stream =
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001304 send_streams_.begin();
Peter Boström0c4e06b2015-10-07 12:23:21 +02001305 stream != send_streams_.end(); ++stream) {
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001306 stream->second->FillBandwidthEstimationInfo(&bwe_info);
1307 }
1308 video_media_info->bw_estimations.push_back(bwe_info);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001309}
1310
Peter Boström0c4e06b2015-10-07 12:23:21 +02001311bool WebRtcVideoChannel2::SetCapturer(uint32_t ssrc, VideoCapturer* capturer) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001312 LOG(LS_INFO) << "SetCapturer: " << ssrc << " -> "
1313 << (capturer != NULL ? "(capturer)" : "NULL");
henrikg91d6ede2015-09-17 00:24:34 -07001314 RTC_DCHECK(ssrc != 0);
Peter Boströme7b221f2015-04-13 15:34:32 +02001315 {
1316 rtc::CritScope stream_lock(&stream_crit_);
1317 if (send_streams_.find(ssrc) == send_streams_.end()) {
1318 LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc;
1319 return false;
1320 }
1321 if (!send_streams_[ssrc]->SetCapturer(capturer)) {
1322 return false;
1323 }
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001324 }
1325
1326 if (capturer) {
Peter Boström3afc8c42016-01-27 16:45:21 +01001327 capturer->SetApplyRotation(!ContainsHeaderExtension(
1328 send_rtp_extensions_, kRtpVideoRotationHeaderExtension));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001329 }
Peter Boströme7b221f2015-04-13 15:34:32 +02001330 {
1331 rtc::CritScope lock(&capturer_crit_);
1332 capturers_[ssrc] = capturer;
1333 }
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001334 return true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001335}
1336
1337bool WebRtcVideoChannel2::SendIntraFrame() {
1338 // TODO(pbos): Implement.
1339 LOG(LS_VERBOSE) << "SendIntraFrame().";
1340 return true;
1341}
1342
1343bool WebRtcVideoChannel2::RequestIntraFrame() {
1344 // TODO(pbos): Implement.
1345 LOG(LS_VERBOSE) << "SendIntraFrame().";
1346 return true;
1347}
1348
1349void WebRtcVideoChannel2::OnPacketReceived(
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001350 rtc::Buffer* packet,
1351 const rtc::PacketTime& packet_time) {
stefan68786d22015-09-08 05:36:15 -07001352 const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp,
1353 packet_time.not_before);
pbos@webrtc.org4e545cc2014-05-14 13:58:13 +00001354 const webrtc::PacketReceiver::DeliveryStatus delivery_result =
stefan68786d22015-09-08 05:36:15 -07001355 call_->Receiver()->DeliverPacket(
1356 webrtc::MediaType::VIDEO,
1357 reinterpret_cast<const uint8_t*>(packet->data()), packet->size(),
1358 webrtc_packet_time);
pbos@webrtc.org4e545cc2014-05-14 13:58:13 +00001359 switch (delivery_result) {
1360 case webrtc::PacketReceiver::DELIVERY_OK:
1361 return;
1362 case webrtc::PacketReceiver::DELIVERY_PACKET_ERROR:
1363 return;
1364 case webrtc::PacketReceiver::DELIVERY_UNKNOWN_SSRC:
1365 break;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001366 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001367
Peter Boström0c4e06b2015-10-07 12:23:21 +02001368 uint32_t ssrc = 0;
kwiberg@webrtc.orgeebcab52015-03-24 09:19:06 +00001369 if (!GetRtpSsrc(packet->data(), packet->size(), &ssrc)) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001370 return;
1371 }
1372
noahricd10a68e2015-07-10 11:27:55 -07001373 int payload_type = 0;
1374 if (!GetRtpPayloadType(packet->data(), packet->size(), &payload_type)) {
1375 return;
1376 }
1377
1378 // See if this payload_type is registered as one that usually gets its own
1379 // SSRC (RTX) or at least is safe to drop either way (ULPFEC). If it is, and
1380 // it wasn't handled above by DeliverPacket, that means we don't know what
1381 // stream it associates with, and we shouldn't ever create an implicit channel
1382 // for these.
1383 for (auto& codec : recv_codecs_) {
1384 if (payload_type == codec.rtx_payload_type ||
1385 payload_type == codec.fec.red_rtx_payload_type ||
1386 payload_type == codec.fec.ulpfec_payload_type) {
1387 return;
1388 }
1389 }
1390
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001391 switch (unsignalled_ssrc_handler_->OnUnsignalledSsrc(this, ssrc)) {
1392 case UnsignalledSsrcHandler::kDropPacket:
1393 return;
1394 case UnsignalledSsrcHandler::kDeliverPacket:
1395 break;
1396 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001397
stefan68786d22015-09-08 05:36:15 -07001398 if (call_->Receiver()->DeliverPacket(
1399 webrtc::MediaType::VIDEO,
1400 reinterpret_cast<const uint8_t*>(packet->data()), packet->size(),
1401 webrtc_packet_time) != webrtc::PacketReceiver::DELIVERY_OK) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001402 LOG(LS_WARNING) << "Failed to deliver RTP packet on re-delivery.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001403 return;
1404 }
1405}
1406
1407void WebRtcVideoChannel2::OnRtcpReceived(
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001408 rtc::Buffer* packet,
1409 const rtc::PacketTime& packet_time) {
stefan68786d22015-09-08 05:36:15 -07001410 const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp,
1411 packet_time.not_before);
Peter Boström2aff6152015-11-18 13:47:16 +01001412 // TODO(pbos): Check webrtc::PacketReceiver::DELIVERY_OK once we deliver
1413 // for both audio and video on the same path. Since BundleFilter doesn't
1414 // filter RTCP anymore incoming RTCP packets could've been going to audio (so
1415 // logging failures spam the log).
1416 call_->Receiver()->DeliverPacket(
1417 webrtc::MediaType::VIDEO,
1418 reinterpret_cast<const uint8_t*>(packet->data()), packet->size(),
1419 webrtc_packet_time);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001420}
1421
1422void WebRtcVideoChannel2::OnReadyToSend(bool ready) {
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00001423 LOG(LS_VERBOSE) << "OnReadyToSend: " << (ready ? "Ready." : "Not ready.");
Jelena Marusiccd670222015-07-16 09:30:09 +02001424 call_->SignalNetworkState(ready ? webrtc::kNetworkUp : webrtc::kNetworkDown);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001425}
1426
Peter Boström0c4e06b2015-10-07 12:23:21 +02001427bool WebRtcVideoChannel2::MuteStream(uint32_t ssrc, bool mute) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001428 LOG(LS_VERBOSE) << "MuteStream: " << ssrc << " -> "
1429 << (mute ? "mute" : "unmute");
henrikg91d6ede2015-09-17 00:24:34 -07001430 RTC_DCHECK(ssrc != 0);
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001431 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001432 if (send_streams_.find(ssrc) == send_streams_.end()) {
1433 LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc;
1434 return false;
1435 }
pbos@webrtc.orgef8bb8d2014-08-13 21:36:18 +00001436
1437 send_streams_[ssrc]->MuteStream(mute);
1438 return true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001439}
1440
1441bool WebRtcVideoChannel2::SetRecvRtpHeaderExtensions(
1442 const std::vector<RtpHeaderExtension>& extensions) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +00001443 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRecvRtpHeaderExtensions");
solenberg7e4e01a2015-12-02 08:05:01 -08001444 if (!ValidateRtpExtensions(extensions)) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001445 return false;
solenberg7e4e01a2015-12-02 08:05:01 -08001446 }
1447 std::vector<webrtc::RtpExtension> filtered_extensions = FilterRtpExtensions(
1448 extensions, webrtc::RtpExtension::IsSupportedForVideo, false);
1449 if (recv_rtp_extensions_ == filtered_extensions) {
deadbeef874ca3a2015-08-20 17:19:20 -07001450 LOG(LS_INFO) << "Ignoring call to SetRecvRtpHeaderExtensions because "
1451 "header extensions haven't changed.";
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001452 return true;
deadbeef874ca3a2015-08-20 17:19:20 -07001453 }
solenberg7e4e01a2015-12-02 08:05:01 -08001454 recv_rtp_extensions_.swap(filtered_extensions);
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001455
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001456 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001457 for (std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it =
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001458 receive_streams_.begin();
Peter Boström0c4e06b2015-10-07 12:23:21 +02001459 it != receive_streams_.end(); ++it) {
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001460 it->second->SetRtpExtensions(recv_rtp_extensions_);
1461 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001462 return true;
1463}
1464
Peter Boström3afc8c42016-01-27 16:45:21 +01001465// TODO(pbos): Remove SetOptions in favor of SetSendParameters.
1466void WebRtcVideoChannel2::SetOptions(const VideoOptions& options) {
1467 VideoSendParameters new_params = send_params_;
1468 new_params.options.SetAll(options);
1469 SetSendParameters(send_params_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001470}
1471
1472void WebRtcVideoChannel2::SetInterface(NetworkInterface* iface) {
1473 MediaChannel::SetInterface(iface);
1474 // Set the RTP recv/send buffer to a bigger size
1475 MediaChannel::SetOption(NetworkInterface::ST_RTP,
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001476 rtc::Socket::OPT_RCVBUF,
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001477 kVideoRtpBufferSize);
1478
buildbot@webrtc.orgae694ef2014-10-28 17:37:17 +00001479 // Speculative change to increase the outbound socket buffer size.
1480 // In b/15152257, we are seeing a significant number of packets discarded
1481 // due to lack of socket buffer space, although it's not yet clear what the
1482 // ideal value should be.
1483 MediaChannel::SetOption(NetworkInterface::ST_RTP,
1484 rtc::Socket::OPT_SNDBUF,
1485 kVideoRtpBufferSize);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001486}
1487
1488void WebRtcVideoChannel2::UpdateAspectRatio(int ratio_w, int ratio_h) {
1489 // TODO(pbos): Implement.
1490}
1491
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001492void WebRtcVideoChannel2::OnMessage(rtc::Message* msg) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001493 // Ignored.
1494}
1495
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001496void WebRtcVideoChannel2::OnLoadUpdate(Load load) {
Peter Boströme7b221f2015-04-13 15:34:32 +02001497 // OnLoadUpdate can not take any locks that are held while creating streams
1498 // etc. Doing so establishes lock-order inversions between the webrtc process
1499 // thread on stream creation and locks such as stream_crit_ while calling out.
1500 rtc::CritScope stream_lock(&capturer_crit_);
1501 if (!signal_cpu_adaptation_)
1502 return;
Erik Språngefbde372015-04-29 16:21:28 +02001503 // Do not adapt resolution for screen content as this will likely result in
1504 // blurry and unreadable text.
Peter Boströme7b221f2015-04-13 15:34:32 +02001505 for (auto& kv : capturers_) {
Erik Språngefbde372015-04-29 16:21:28 +02001506 if (kv.second != nullptr
1507 && !kv.second->IsScreencast()
1508 && kv.second->video_adapter() != nullptr) {
Peter Boströme7b221f2015-04-13 15:34:32 +02001509 kv.second->video_adapter()->OnCpuResolutionRequest(
1510 load == kOveruse ? CoordinatedVideoAdapter::DOWNGRADE
1511 : CoordinatedVideoAdapter::UPGRADE);
1512 }
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001513 }
1514}
1515
stefan1d8a5062015-10-02 03:39:33 -07001516bool WebRtcVideoChannel2::SendRtp(const uint8_t* data,
1517 size_t len,
1518 const webrtc::PacketOptions& options) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001519 rtc::Buffer packet(data, len, kMaxRtpPacketLen);
stefanc1aeaf02015-10-15 07:26:07 -07001520 rtc::PacketOptions rtc_options;
1521 rtc_options.packet_id = options.packet_id;
1522 return MediaChannel::SendPacket(&packet, rtc_options);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001523}
1524
1525bool WebRtcVideoChannel2::SendRtcp(const uint8_t* data, size_t len) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001526 rtc::Buffer packet(data, len, kMaxRtpPacketLen);
stefanc1aeaf02015-10-15 07:26:07 -07001527 return MediaChannel::SendRtcp(&packet, rtc::PacketOptions());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001528}
1529
1530void WebRtcVideoChannel2::StartAllSendStreams() {
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001531 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001532 for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator it =
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001533 send_streams_.begin();
Peter Boström0c4e06b2015-10-07 12:23:21 +02001534 it != send_streams_.end(); ++it) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001535 it->second->Start();
1536 }
1537}
1538
1539void WebRtcVideoChannel2::StopAllSendStreams() {
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001540 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001541 for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator it =
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001542 send_streams_.begin();
Peter Boström0c4e06b2015-10-07 12:23:21 +02001543 it != send_streams_.end(); ++it) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001544 it->second->Stop();
1545 }
1546}
1547
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001548WebRtcVideoChannel2::WebRtcVideoSendStream::VideoSendStreamParameters::
1549 VideoSendStreamParameters(
1550 const webrtc::VideoSendStream::Config& config,
1551 const VideoOptions& options,
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001552 int max_bitrate_bps,
Karl Wibergbe579832015-11-10 22:34:18 +01001553 const rtc::Optional<VideoCodecSettings>& codec_settings)
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001554 : config(config),
1555 options(options),
1556 max_bitrate_bps(max_bitrate_bps),
kwiberg102c6a62015-10-30 02:47:38 -07001557 codec_settings(codec_settings) {}
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001558
Peter Boström4d71ede2015-05-19 23:09:35 +02001559WebRtcVideoChannel2::WebRtcVideoSendStream::AllocatedEncoder::AllocatedEncoder(
1560 webrtc::VideoEncoder* encoder,
1561 webrtc::VideoCodecType type,
1562 bool external)
1563 : encoder(encoder),
1564 external_encoder(nullptr),
1565 type(type),
1566 external(external) {
1567 if (external) {
1568 external_encoder = encoder;
1569 this->encoder =
1570 new webrtc::VideoEncoderSoftwareFallbackWrapper(type, encoder);
1571 }
1572}
1573
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001574WebRtcVideoChannel2::WebRtcVideoSendStream::WebRtcVideoSendStream(
1575 webrtc::Call* call,
solenberg4fbae2b2015-08-28 04:07:10 -07001576 const StreamParams& sp,
1577 const webrtc::VideoSendStream::Config& config,
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001578 WebRtcVideoEncoderFactory* external_encoder_factory,
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001579 const VideoOptions& options,
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001580 int max_bitrate_bps,
Karl Wibergbe579832015-11-10 22:34:18 +01001581 const rtc::Optional<VideoCodecSettings>& codec_settings,
deadbeef13871492015-12-09 12:37:51 -08001582 const std::vector<webrtc::RtpExtension>& rtp_extensions,
1583 // TODO(deadbeef): Don't duplicate information between send_params,
1584 // rtp_extensions, options, etc.
1585 const VideoSendParameters& send_params)
Henrik Kjellander7c027b62015-04-22 13:21:30 +02001586 : ssrcs_(sp.ssrcs),
Peter Boström259bd202015-05-28 13:39:50 +02001587 ssrc_groups_(sp.ssrc_groups),
Henrik Kjellander7c027b62015-04-22 13:21:30 +02001588 call_(call),
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001589 external_encoder_factory_(external_encoder_factory),
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001590 stream_(NULL),
solenberg4fbae2b2015-08-28 04:07:10 -07001591 parameters_(config, options, max_bitrate_bps, codec_settings),
Peter Boström3afc8c42016-01-27 16:45:21 +01001592 pending_encoder_reconfiguration_(false),
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001593 allocated_encoder_(NULL, webrtc::kVideoCodecUnknown, false),
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +00001594 capturer_(NULL),
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001595 sending_(false),
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00001596 muted_(false),
qiangchenc27d89f2015-07-16 10:27:16 -07001597 old_adapt_changes_(0),
1598 first_frame_timestamp_ms_(0),
1599 last_frame_timestamp_ms_(0) {
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001600 parameters_.config.rtp.max_packet_size = kVideoMtu;
1601
1602 sp.GetPrimarySsrcs(&parameters_.config.rtp.ssrcs);
1603 sp.GetFidSsrcs(parameters_.config.rtp.ssrcs,
1604 &parameters_.config.rtp.rtx.ssrcs);
1605 parameters_.config.rtp.c_name = sp.cname;
1606 parameters_.config.rtp.extensions = rtp_extensions;
deadbeef13871492015-12-09 12:37:51 -08001607 parameters_.config.rtp.rtcp_mode = send_params.rtcp.reduced_size
1608 ? webrtc::RtcpMode::kReducedSize
1609 : webrtc::RtcpMode::kCompound;
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001610
kwiberg102c6a62015-10-30 02:47:38 -07001611 if (codec_settings) {
Peter Boström3afc8c42016-01-27 16:45:21 +01001612 SetCodecAndOptions(*codec_settings, parameters_.options);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001613 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001614}
1615
1616WebRtcVideoChannel2::WebRtcVideoSendStream::~WebRtcVideoSendStream() {
1617 DisconnectCapturer();
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001618 if (stream_ != NULL) {
1619 call_->DestroyVideoSendStream(stream_);
1620 }
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001621 DestroyVideoEncoder(&allocated_encoder_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001622}
1623
Miguel Casas-Sanchez47650702015-05-29 17:21:40 -07001624static void CreateBlackFrame(webrtc::VideoFrame* video_frame,
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001625 int width,
1626 int height) {
pbos@webrtc.orgb4987bf2015-02-18 10:13:09 +00001627 video_frame->CreateEmptyFrame(width, height, width, (width + 1) / 2,
1628 (width + 1) / 2);
1629 memset(video_frame->buffer(webrtc::kYPlane), 16,
1630 video_frame->allocated_size(webrtc::kYPlane));
1631 memset(video_frame->buffer(webrtc::kUPlane), 128,
1632 video_frame->allocated_size(webrtc::kUPlane));
1633 memset(video_frame->buffer(webrtc::kVPlane), 128,
1634 video_frame->allocated_size(webrtc::kVPlane));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001635}
1636
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001637void WebRtcVideoChannel2::WebRtcVideoSendStream::InputFrame(
1638 VideoCapturer* capturer,
1639 const VideoFrame* frame) {
pbos@webrtc.org86196c42015-02-16 21:02:00 +00001640 TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::InputFrame");
Miguel Casas-Sanchez47650702015-05-29 17:21:40 -07001641 webrtc::VideoFrame video_frame(frame->GetVideoFrameBuffer(), 0, 0,
1642 frame->GetVideoRotation());
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001643 rtc::CritScope cs(&lock_);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001644 if (stream_ == NULL) {
Peter Boströmad1f9b62015-04-08 14:04:01 +02001645 // Frame input before send codecs are configured, dropping frame.
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001646 return;
1647 }
pbos@webrtc.org86196c42015-02-16 21:02:00 +00001648
1649 // Not sending, abort early to prevent expensive reconfigurations while
1650 // setting up codecs etc.
1651 if (!sending_)
1652 return;
1653
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001654 if (format_.width == 0) { // Dropping frames.
henrikg91d6ede2015-09-17 00:24:34 -07001655 RTC_DCHECK(format_.height == 0);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001656 LOG(LS_VERBOSE) << "VideoFormat 0x0 set, Dropping frame.";
1657 return;
1658 }
pbos@webrtc.orgd60d79a2014-09-24 07:10:57 +00001659 if (muted_) {
1660 // Create a black frame to transmit instead.
magjed@webrtc.orgafdd5dd2015-03-12 13:11:25 +00001661 CreateBlackFrame(&video_frame,
pbos@webrtc.orgd60d79a2014-09-24 07:10:57 +00001662 static_cast<int>(frame->GetWidth()),
1663 static_cast<int>(frame->GetHeight()));
1664 }
qiangchenc27d89f2015-07-16 10:27:16 -07001665
1666 int64_t frame_delta_ms = frame->GetTimeStamp() / rtc::kNumNanosecsPerMillisec;
1667 // frame->GetTimeStamp() is essentially a delta, align to webrtc time
1668 if (first_frame_timestamp_ms_ == 0) {
1669 first_frame_timestamp_ms_ = rtc::Time() - frame_delta_ms;
1670 }
1671
1672 last_frame_timestamp_ms_ = first_frame_timestamp_ms_ + frame_delta_ms;
1673 video_frame.set_render_time_ms(last_frame_timestamp_ms_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001674 // Reconfigure codec if necessary.
pbos@webrtc.orgc4175b92014-09-03 15:25:49 +00001675 SetDimensions(
magjed@webrtc.orgafdd5dd2015-03-12 13:11:25 +00001676 video_frame.width(), video_frame.height(), capturer->IsScreencast());
pbos@webrtc.orgc4175b92014-09-03 15:25:49 +00001677
perkj@webrtc.orgaf612d52015-03-18 09:51:05 +00001678 stream_->Input()->IncomingCapturedFrame(video_frame);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001679}
1680
1681bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetCapturer(
1682 VideoCapturer* capturer) {
pbos@webrtc.orgb4987bf2015-02-18 10:13:09 +00001683 TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::SetCapturer");
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001684 if (!DisconnectCapturer() && capturer == NULL) {
1685 return false;
1686 }
1687
1688 {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001689 rtc::CritScope cs(&lock_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001690
pbos1cb121d2015-09-14 11:38:38 -07001691 // Reset timestamps to realign new incoming frames to a webrtc timestamp. A
1692 // new capturer may have a different timestamp delta than the previous one.
1693 first_frame_timestamp_ms_ = 0;
1694
pbos@webrtc.org9359cb32014-07-23 15:44:48 +00001695 if (capturer == NULL) {
1696 if (stream_ != NULL) {
1697 LOG(LS_VERBOSE) << "Disabling capturer, sending black frame.";
Miguel Casas-Sanchez47650702015-05-29 17:21:40 -07001698 webrtc::VideoFrame black_frame;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001699
pbos@webrtc.orgb4987bf2015-02-18 10:13:09 +00001700 CreateBlackFrame(&black_frame, last_dimensions_.width,
1701 last_dimensions_.height);
qiangchenc27d89f2015-07-16 10:27:16 -07001702
1703 // Force this black frame not to be dropped due to timestamp order
1704 // check. As IncomingCapturedFrame will drop the frame if this frame's
1705 // timestamp is less than or equal to last frame's timestamp, it is
1706 // necessary to give this black frame a larger timestamp than the
1707 // previous one.
1708 last_frame_timestamp_ms_ +=
1709 format_.interval / rtc::kNumNanosecsPerMillisec;
1710 black_frame.set_render_time_ms(last_frame_timestamp_ms_);
perkj@webrtc.orgaf612d52015-03-18 09:51:05 +00001711 stream_->Input()->IncomingCapturedFrame(black_frame);
pbos@webrtc.org9359cb32014-07-23 15:44:48 +00001712 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001713
1714 capturer_ = NULL;
1715 return true;
1716 }
1717
1718 capturer_ = capturer;
1719 }
1720 // Lock cannot be held while connecting the capturer to prevent lock-order
1721 // violations.
1722 capturer->SignalVideoFrame.connect(this, &WebRtcVideoSendStream::InputFrame);
1723 return true;
1724}
1725
Peter Boström3afc8c42016-01-27 16:45:21 +01001726// TODO(pbos): Apply this on the VideoAdapter instead!
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001727bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetVideoFormat(
1728 const VideoFormat& format) {
1729 if ((format.width == 0 || format.height == 0) &&
1730 format.width != format.height) {
1731 LOG(LS_ERROR) << "Can't set VideoFormat, width or height is zero (but not "
1732 "both, 0x0 drops frames).";
1733 return false;
1734 }
1735
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001736 rtc::CritScope cs(&lock_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001737 if (format.width == 0 && format.height == 0) {
1738 LOG(LS_INFO)
1739 << "0x0 resolution selected. Captured frames will be dropped for ssrc: "
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001740 << parameters_.config.rtp.ssrcs[0] << ".";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001741 } else {
1742 // TODO(pbos): Fix me, this only affects the last stream!
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00001743 parameters_.encoder_config.streams.back().max_framerate =
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001744 VideoFormat::IntervalToFps(format.interval);
pbos@webrtc.orgc4175b92014-09-03 15:25:49 +00001745 SetDimensions(format.width, format.height, false);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001746 }
1747
1748 format_ = format;
1749 return true;
1750}
1751
pbos@webrtc.orgef8bb8d2014-08-13 21:36:18 +00001752void WebRtcVideoChannel2::WebRtcVideoSendStream::MuteStream(bool mute) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001753 rtc::CritScope cs(&lock_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001754 muted_ = mute;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001755}
1756
1757bool WebRtcVideoChannel2::WebRtcVideoSendStream::DisconnectCapturer() {
pbos@webrtc.org963b9792014-10-07 14:27:27 +00001758 cricket::VideoCapturer* capturer;
1759 {
1760 rtc::CritScope cs(&lock_);
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00001761 if (capturer_ == NULL)
pbos@webrtc.org963b9792014-10-07 14:27:27 +00001762 return false;
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00001763
1764 if (capturer_->video_adapter() != nullptr)
1765 old_adapt_changes_ += capturer_->video_adapter()->adaptation_changes();
1766
pbos@webrtc.org963b9792014-10-07 14:27:27 +00001767 capturer = capturer_;
1768 capturer_ = NULL;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001769 }
pbos@webrtc.org963b9792014-10-07 14:27:27 +00001770 capturer->SignalVideoFrame.disconnect(this);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001771 return true;
1772}
1773
Peter Boström0c4e06b2015-10-07 12:23:21 +02001774const std::vector<uint32_t>&
Peter Boströmd6f4c252015-03-26 16:23:04 +01001775WebRtcVideoChannel2::WebRtcVideoSendStream::GetSsrcs() const {
1776 return ssrcs_;
1777}
1778
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001779void WebRtcVideoChannel2::WebRtcVideoSendStream::SetOptions(
1780 const VideoOptions& options) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001781 rtc::CritScope cs(&lock_);
kwiberg102c6a62015-10-30 02:47:38 -07001782 if (parameters_.codec_settings) {
deadbeef874ca3a2015-08-20 17:19:20 -07001783 LOG(LS_INFO) << "SetCodecAndOptions because of SetOptions; options="
1784 << options.ToString();
kwiberg102c6a62015-10-30 02:47:38 -07001785 SetCodecAndOptions(*parameters_.codec_settings, options);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001786 } else {
1787 parameters_.options = options;
1788 }
1789}
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001790
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001791webrtc::VideoCodecType CodecTypeFromName(const std::string& name) {
Shao Changbine62202f2015-04-21 20:24:50 +08001792 if (CodecNamesEq(name, kVp8CodecName)) {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001793 return webrtc::kVideoCodecVP8;
Shao Changbine62202f2015-04-21 20:24:50 +08001794 } else if (CodecNamesEq(name, kVp9CodecName)) {
andresp@webrtc.org188d3b22014-11-07 13:21:04 +00001795 return webrtc::kVideoCodecVP9;
Shao Changbine62202f2015-04-21 20:24:50 +08001796 } else if (CodecNamesEq(name, kH264CodecName)) {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001797 return webrtc::kVideoCodecH264;
1798 }
1799 return webrtc::kVideoCodecUnknown;
1800}
1801
1802WebRtcVideoChannel2::WebRtcVideoSendStream::AllocatedEncoder
1803WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoder(
1804 const VideoCodec& codec) {
1805 webrtc::VideoCodecType type = CodecTypeFromName(codec.name);
1806
1807 // Do not re-create encoders of the same type.
1808 if (type == allocated_encoder_.type && allocated_encoder_.encoder != NULL) {
1809 return allocated_encoder_;
1810 }
1811
1812 if (external_encoder_factory_ != NULL) {
1813 webrtc::VideoEncoder* encoder =
1814 external_encoder_factory_->CreateVideoEncoder(type);
1815 if (encoder != NULL) {
1816 return AllocatedEncoder(encoder, type, true);
1817 }
1818 }
1819
1820 if (type == webrtc::kVideoCodecVP8) {
1821 return AllocatedEncoder(
1822 webrtc::VideoEncoder::Create(webrtc::VideoEncoder::kVp8), type, false);
andresp@webrtc.org188d3b22014-11-07 13:21:04 +00001823 } else if (type == webrtc::kVideoCodecVP9) {
1824 return AllocatedEncoder(
1825 webrtc::VideoEncoder::Create(webrtc::VideoEncoder::kVp9), type, false);
Zeke Chin71f6f442015-06-29 14:34:58 -07001826 } else if (type == webrtc::kVideoCodecH264) {
1827 return AllocatedEncoder(
1828 webrtc::VideoEncoder::Create(webrtc::VideoEncoder::kH264), type, false);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001829 }
1830
1831 // This shouldn't happen, we should not be trying to create something we don't
1832 // support.
henrikg91d6ede2015-09-17 00:24:34 -07001833 RTC_DCHECK(false);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001834 return AllocatedEncoder(NULL, webrtc::kVideoCodecUnknown, false);
1835}
1836
1837void WebRtcVideoChannel2::WebRtcVideoSendStream::DestroyVideoEncoder(
1838 AllocatedEncoder* encoder) {
1839 if (encoder->external) {
Peter Boström4d71ede2015-05-19 23:09:35 +02001840 external_encoder_factory_->DestroyVideoEncoder(encoder->external_encoder);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001841 }
Peter Boström4d71ede2015-05-19 23:09:35 +02001842 delete encoder->encoder;
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001843}
1844
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001845void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodecAndOptions(
1846 const VideoCodecSettings& codec_settings,
1847 const VideoOptions& options) {
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001848 parameters_.encoder_config =
1849 CreateVideoEncoderConfig(last_dimensions_, codec_settings.codec);
Peter Boström3afc8c42016-01-27 16:45:21 +01001850 RTC_DCHECK(!parameters_.encoder_config.streams.empty());
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001851
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001852 format_ = VideoFormat(codec_settings.codec.width,
1853 codec_settings.codec.height,
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001854 VideoFormat::FpsToInterval(30),
1855 FOURCC_I420);
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001856
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001857 AllocatedEncoder new_encoder = CreateVideoEncoder(codec_settings.codec);
1858 parameters_.config.encoder_settings.encoder = new_encoder.encoder;
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001859 parameters_.config.encoder_settings.payload_name = codec_settings.codec.name;
1860 parameters_.config.encoder_settings.payload_type = codec_settings.codec.id;
sophiechang47d78cc2015-09-03 18:24:44 -07001861 if (new_encoder.external) {
1862 webrtc::VideoCodecType type = CodecTypeFromName(codec_settings.codec.name);
1863 parameters_.config.encoder_settings.internal_source =
1864 external_encoder_factory_->EncoderTypeHasInternalSource(type);
1865 }
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001866 parameters_.config.rtp.fec = codec_settings.fec;
1867
1868 // Set RTX payload type if RTX is enabled.
1869 if (!parameters_.config.rtp.rtx.ssrcs.empty()) {
pbos@webrtc.orgb9557a92015-03-20 19:52:56 +00001870 if (codec_settings.rtx_payload_type == -1) {
1871 LOG(LS_WARNING) << "RTX SSRCs configured but there's no configured RTX "
1872 "payload type. Ignoring.";
1873 parameters_.config.rtp.rtx.ssrcs.clear();
1874 } else {
1875 parameters_.config.rtp.rtx.payload_type = codec_settings.rtx_payload_type;
1876 }
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001877 }
1878
Peter Boström67c9df72015-05-11 14:34:58 +02001879 parameters_.config.rtp.nack.rtp_history_ms =
1880 HasNack(codec_settings.codec) ? kNackHistoryMs : 0;
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001881
kwiberg102c6a62015-10-30 02:47:38 -07001882 RTC_CHECK(options.suspend_below_min_bitrate);
1883 parameters_.config.suspend_below_min_bitrate =
1884 *options.suspend_below_min_bitrate;
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00001885
kwiberg102c6a62015-10-30 02:47:38 -07001886 parameters_.codec_settings =
Karl Wibergbe579832015-11-10 22:34:18 +01001887 rtc::Optional<WebRtcVideoChannel2::VideoCodecSettings>(codec_settings);
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001888 parameters_.options = options;
pbos@webrtc.org543e5892014-07-23 07:01:31 +00001889
deadbeef874ca3a2015-08-20 17:19:20 -07001890 LOG(LS_INFO)
1891 << "RecreateWebRtcStream (send) because of SetCodecAndOptions; options="
1892 << options.ToString();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001893 RecreateWebRtcStream();
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001894 if (allocated_encoder_.encoder != new_encoder.encoder) {
1895 DestroyVideoEncoder(&allocated_encoder_);
1896 allocated_encoder_ = new_encoder;
1897 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001898}
1899
deadbeef13871492015-12-09 12:37:51 -08001900void WebRtcVideoChannel2::WebRtcVideoSendStream::SetSendParameters(
Peter Boström3afc8c42016-01-27 16:45:21 +01001901 const ChangedSendParameters& params) {
deadbeef13871492015-12-09 12:37:51 -08001902 rtc::CritScope cs(&lock_);
Peter Boström3afc8c42016-01-27 16:45:21 +01001903 // |recreate_stream| means construction-time parameters have changed and the
1904 // sending stream needs to be reset with the new config.
1905 bool recreate_stream = false;
1906 if (params.rtcp_mode) {
1907 parameters_.config.rtp.rtcp_mode = *params.rtcp_mode;
1908 recreate_stream = true;
1909 }
1910 if (params.rtp_header_extensions) {
1911 parameters_.config.rtp.extensions = *params.rtp_header_extensions;
1912 if (capturer_) {
1913 capturer_->SetApplyRotation(!ContainsHeaderExtension(
1914 *params.rtp_header_extensions, kRtpVideoRotationHeaderExtension));
1915 }
1916 recreate_stream = true;
1917 }
1918 if (params.max_bandwidth_bps) {
1919 // Max bitrate has changed, reconfigure encoder settings on the next frame
1920 // or stream recreation.
1921 parameters_.max_bitrate_bps = *params.max_bandwidth_bps;
1922 pending_encoder_reconfiguration_ = true;
1923 }
1924 // Set codecs and options.
1925 if (params.codec) {
1926 SetCodecAndOptions(*params.codec,
1927 params.options ? *params.options : parameters_.options);
1928 return;
1929 } else if (params.options) {
1930 // Reconfigure if codecs are already set.
1931 if (parameters_.codec_settings) {
1932 SetCodecAndOptions(*parameters_.codec_settings, *params.options);
1933 return;
1934 } else {
1935 parameters_.options = *params.options;
1936 }
1937 }
1938 if (recreate_stream) {
deadbeef13871492015-12-09 12:37:51 -08001939 LOG(LS_INFO) << "RecreateWebRtcStream (send) because of SetSendParameters";
1940 RecreateWebRtcStream();
1941 }
1942}
1943
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001944webrtc::VideoEncoderConfig
1945WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoderConfig(
1946 const Dimensions& dimensions,
1947 const VideoCodec& codec) const {
1948 webrtc::VideoEncoderConfig encoder_config;
1949 if (dimensions.is_screencast) {
kwiberg102c6a62015-10-30 02:47:38 -07001950 RTC_CHECK(parameters_.options.screencast_min_bitrate);
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001951 encoder_config.min_transmit_bitrate_bps =
kwiberg102c6a62015-10-30 02:47:38 -07001952 *parameters_.options.screencast_min_bitrate * 1000;
Erik Språng143cec12015-04-28 10:01:41 +02001953 encoder_config.content_type =
1954 webrtc::VideoEncoderConfig::ContentType::kScreen;
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001955 } else {
1956 encoder_config.min_transmit_bitrate_bps = 0;
Erik Språng143cec12015-04-28 10:01:41 +02001957 encoder_config.content_type =
1958 webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo;
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001959 }
1960
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001961 // Restrict dimensions according to codec max.
1962 int width = dimensions.width;
1963 int height = dimensions.height;
1964 if (!dimensions.is_screencast) {
1965 if (codec.width < width)
1966 width = codec.width;
1967 if (codec.height < height)
1968 height = codec.height;
1969 }
1970
1971 VideoCodec clamped_codec = codec;
1972 clamped_codec.width = width;
1973 clamped_codec.height = height;
pbos@webrtc.orgcddd17c2014-09-16 16:33:13 +00001974
noahricfdac5162015-08-27 01:59:29 -07001975 // By default, the stream count for the codec configuration should match the
1976 // number of negotiated ssrcs. But if the codec is blacklisted for simulcast
1977 // or a screencast, only configure a single stream.
1978 size_t stream_count = parameters_.config.rtp.ssrcs.size();
1979 if (IsCodecBlacklistedForSimulcast(codec.name) || dimensions.is_screencast) {
1980 stream_count = 1;
1981 }
1982
1983 encoder_config.streams =
1984 CreateVideoStreams(clamped_codec, parameters_.options,
1985 parameters_.max_bitrate_bps, stream_count);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001986
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001987 // Conference mode screencast uses 2 temporal layers split at 100kbit.
kwiberg102c6a62015-10-30 02:47:38 -07001988 if (parameters_.options.conference_mode.value_or(false) &&
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001989 dimensions.is_screencast && encoder_config.streams.size() == 1) {
sprang@webrtc.org46d4d292014-12-23 15:19:35 +00001990 ScreenshareLayerConfig config = ScreenshareLayerConfig::GetDefault();
1991
1992 // For screenshare in conference mode, tl0 and tl1 bitrates are piggybacked
1993 // on the VideoCodec struct as target and max bitrates, respectively.
1994 // See eg. webrtc::VP8EncoderImpl::SetRates().
1995 encoder_config.streams[0].target_bitrate_bps =
1996 config.tl0_bitrate_kbps * 1000;
1997 encoder_config.streams[0].max_bitrate_bps = config.tl1_bitrate_kbps * 1000;
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001998 encoder_config.streams[0].temporal_layer_thresholds_bps.clear();
1999 encoder_config.streams[0].temporal_layer_thresholds_bps.push_back(
sprang@webrtc.org46d4d292014-12-23 15:19:35 +00002000 config.tl0_bitrate_kbps * 1000);
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00002001 }
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002002 return encoder_config;
2003}
2004
2005void WebRtcVideoChannel2::WebRtcVideoSendStream::SetDimensions(
2006 int width,
2007 int height,
2008 bool is_screencast) {
2009 if (last_dimensions_.width == width && last_dimensions_.height == height &&
Peter Boström3afc8c42016-01-27 16:45:21 +01002010 last_dimensions_.is_screencast == is_screencast &&
2011 !pending_encoder_reconfiguration_) {
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002012 // Configured using the same parameters, do not reconfigure.
2013 return;
2014 }
2015 LOG(LS_INFO) << "SetDimensions: " << width << "x" << height
2016 << (is_screencast ? " (screencast)" : " (not screencast)");
2017
2018 last_dimensions_.width = width;
2019 last_dimensions_.height = height;
2020 last_dimensions_.is_screencast = is_screencast;
2021
henrikg91d6ede2015-09-17 00:24:34 -07002022 RTC_DCHECK(!parameters_.encoder_config.streams.empty());
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002023
kwiberg102c6a62015-10-30 02:47:38 -07002024 RTC_CHECK(parameters_.codec_settings);
2025 VideoCodecSettings codec_settings = *parameters_.codec_settings;
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002026
2027 webrtc::VideoEncoderConfig encoder_config =
2028 CreateVideoEncoderConfig(last_dimensions_, codec_settings.codec);
2029
Erik Språng143cec12015-04-28 10:01:41 +02002030 encoder_config.encoder_specific_settings = ConfigureVideoEncoderSettings(
2031 codec_settings.codec, parameters_.options, is_screencast);
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00002032
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00002033 bool stream_reconfigured = stream_->ReconfigureVideoEncoder(encoder_config);
2034
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00002035 encoder_config.encoder_specific_settings = NULL;
Peter Boström3afc8c42016-01-27 16:45:21 +01002036 pending_encoder_reconfiguration_ = false;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002037
2038 if (!stream_reconfigured) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002039 LOG(LS_WARNING) << "Failed to reconfigure video encoder for dimensions: "
2040 << width << "x" << height;
2041 return;
2042 }
pbos@webrtc.orgcddd17c2014-09-16 16:33:13 +00002043
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00002044 parameters_.encoder_config = encoder_config;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002045}
2046
2047void WebRtcVideoChannel2::WebRtcVideoSendStream::Start() {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00002048 rtc::CritScope cs(&lock_);
henrikg91d6ede2015-09-17 00:24:34 -07002049 RTC_DCHECK(stream_ != NULL);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002050 stream_->Start();
2051 sending_ = true;
2052}
2053
2054void WebRtcVideoChannel2::WebRtcVideoSendStream::Stop() {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00002055 rtc::CritScope cs(&lock_);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00002056 if (stream_ != NULL) {
2057 stream_->Stop();
2058 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002059 sending_ = false;
2060}
2061
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002062VideoSenderInfo
2063WebRtcVideoChannel2::WebRtcVideoSendStream::GetVideoSenderInfo() {
2064 VideoSenderInfo info;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002065 webrtc::VideoSendStream::Stats stats;
2066 {
2067 rtc::CritScope cs(&lock_);
2068 for (uint32_t ssrc : parameters_.config.rtp.ssrcs)
2069 info.add_ssrc(ssrc);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002070
kwiberg102c6a62015-10-30 02:47:38 -07002071 if (parameters_.codec_settings)
2072 info.codec_name = parameters_.codec_settings->codec.name;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002073 for (size_t i = 0; i < parameters_.encoder_config.streams.size(); ++i) {
2074 if (i == parameters_.encoder_config.streams.size() - 1) {
2075 info.preferred_bitrate +=
2076 parameters_.encoder_config.streams[i].max_bitrate_bps;
2077 } else {
2078 info.preferred_bitrate +=
2079 parameters_.encoder_config.streams[i].target_bitrate_bps;
2080 }
2081 }
pbos@webrtc.orgc3d2bd22014-08-12 20:55:10 +00002082
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002083 if (stream_ == NULL)
2084 return info;
2085
2086 stats = stream_->GetStats();
2087
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002088 info.adapt_changes = old_adapt_changes_;
2089 info.adapt_reason = CoordinatedVideoAdapter::ADAPTREASON_NONE;
2090
2091 if (capturer_ != NULL) {
2092 if (!capturer_->IsMuted()) {
2093 VideoFormat last_captured_frame_format;
2094 capturer_->GetStats(&info.adapt_frame_drops, &info.effects_frame_drops,
2095 &info.capturer_frame_time,
2096 &last_captured_frame_format);
2097 info.input_frame_width = last_captured_frame_format.width;
2098 info.input_frame_height = last_captured_frame_format.height;
2099 }
2100 if (capturer_->video_adapter() != nullptr) {
2101 info.adapt_changes += capturer_->video_adapter()->adaptation_changes();
2102 info.adapt_reason = capturer_->video_adapter()->adapt_reason();
2103 }
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002104 }
2105 }
asapersson17821db2015-12-14 02:08:12 -08002106
2107 // Get bandwidth limitation info from stream_->GetStats().
2108 // Input resolution (output from video_adapter) can be further scaled down or
2109 // higher video layer(s) can be dropped due to bitrate constraints.
2110 // Note, adapt_changes only include changes from the video_adapter.
2111 if (stats.bw_limited_resolution)
2112 info.adapt_reason |= CoordinatedVideoAdapter::ADAPTREASON_BANDWIDTH;
2113
Peter Boströmb7d9a972015-12-18 16:01:11 +01002114 info.encoder_implementation_name = stats.encoder_implementation_name;
Peter Boström259bd202015-05-28 13:39:50 +02002115 info.ssrc_groups = ssrc_groups_;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002116 info.framerate_input = stats.input_frame_rate;
2117 info.framerate_sent = stats.encode_frame_rate;
pbos@webrtc.org3e6e2712015-02-26 12:19:31 +00002118 info.avg_encode_ms = stats.avg_encode_time_ms;
2119 info.encode_usage_percent = stats.encode_usage_percent;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002120
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002121 info.nominal_bitrate = stats.media_bitrate_bps;
2122
pbos@webrtc.org273a4142014-12-01 15:23:21 +00002123 info.send_frame_width = 0;
2124 info.send_frame_height = 0;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002125 for (std::map<uint32_t, webrtc::VideoSendStream::StreamStats>::iterator it =
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002126 stats.substreams.begin();
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002127 it != stats.substreams.end(); ++it) {
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002128 // TODO(pbos): Wire up additional stats, such as padding bytes.
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002129 webrtc::VideoSendStream::StreamStats stream_stats = it->second;
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59 +00002130 info.bytes_sent += stream_stats.rtp_stats.transmitted.payload_bytes +
2131 stream_stats.rtp_stats.transmitted.header_bytes +
2132 stream_stats.rtp_stats.transmitted.padding_bytes;
2133 info.packets_sent += stream_stats.rtp_stats.transmitted.packets;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002134 info.packets_lost += stream_stats.rtcp_stats.cumulative_lost;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002135 if (stream_stats.width > info.send_frame_width)
2136 info.send_frame_width = stream_stats.width;
2137 if (stream_stats.height > info.send_frame_height)
2138 info.send_frame_height = stream_stats.height;
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002139 info.firs_rcvd += stream_stats.rtcp_packet_type_counts.fir_packets;
2140 info.nacks_rcvd += stream_stats.rtcp_packet_type_counts.nack_packets;
2141 info.plis_rcvd += stream_stats.rtcp_packet_type_counts.pli_packets;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002142 }
2143
2144 if (!stats.substreams.empty()) {
2145 // TODO(pbos): Report fraction lost per SSRC.
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002146 webrtc::VideoSendStream::StreamStats first_stream_stats =
2147 stats.substreams.begin()->second;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002148 info.fraction_lost =
2149 static_cast<float>(first_stream_stats.rtcp_stats.fraction_lost) /
2150 (1 << 8);
2151 }
2152
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002153 return info;
2154}
2155
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00002156void WebRtcVideoChannel2::WebRtcVideoSendStream::FillBandwidthEstimationInfo(
2157 BandwidthEstimationInfo* bwe_info) {
2158 rtc::CritScope cs(&lock_);
2159 if (stream_ == NULL) {
2160 return;
2161 }
2162 webrtc::VideoSendStream::Stats stats = stream_->GetStats();
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002163 for (std::map<uint32_t, webrtc::VideoSendStream::StreamStats>::iterator it =
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00002164 stats.substreams.begin();
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002165 it != stats.substreams.end(); ++it) {
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00002166 bwe_info->transmit_bitrate += it->second.total_bitrate_bps;
2167 bwe_info->retransmit_bitrate += it->second.retransmit_bitrate_bps;
2168 }
pbos@webrtc.org891d4832015-02-26 13:15:22 +00002169 bwe_info->target_enc_bitrate += stats.target_media_bitrate_bps;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002170 bwe_info->actual_enc_bitrate += stats.media_bitrate_bps;
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00002171}
2172
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002173void WebRtcVideoChannel2::WebRtcVideoSendStream::RecreateWebRtcStream() {
2174 if (stream_ != NULL) {
2175 call_->DestroyVideoSendStream(stream_);
2176 }
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00002177
kwiberg102c6a62015-10-30 02:47:38 -07002178 RTC_CHECK(parameters_.codec_settings);
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00002179 parameters_.encoder_config.encoder_specific_settings =
Erik Språng143cec12015-04-28 10:01:41 +02002180 ConfigureVideoEncoderSettings(
kwiberg102c6a62015-10-30 02:47:38 -07002181 parameters_.codec_settings->codec, parameters_.options,
Erik Språng143cec12015-04-28 10:01:41 +02002182 parameters_.encoder_config.content_type ==
2183 webrtc::VideoEncoderConfig::ContentType::kScreen);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002184
pbos@webrtc.orgb9557a92015-03-20 19:52:56 +00002185 webrtc::VideoSendStream::Config config = parameters_.config;
2186 if (!config.rtp.rtx.ssrcs.empty() && config.rtp.rtx.payload_type == -1) {
2187 LOG(LS_WARNING) << "RTX SSRCs configured but there's no configured RTX "
2188 "payload type the set codec. Ignoring RTX.";
2189 config.rtp.rtx.ssrcs.clear();
2190 }
2191 stream_ = call_->CreateVideoSendStream(config, parameters_.encoder_config);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002192
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00002193 parameters_.encoder_config.encoder_specific_settings = NULL;
Peter Boström3afc8c42016-01-27 16:45:21 +01002194 pending_encoder_reconfiguration_ = false;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002195
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002196 if (sending_) {
2197 stream_->Start();
2198 }
2199}
2200
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002201WebRtcVideoChannel2::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
2202 webrtc::Call* call,
Peter Boström259bd202015-05-28 13:39:50 +02002203 const StreamParams& sp,
solenberg4fbae2b2015-08-28 04:07:10 -07002204 const webrtc::VideoReceiveStream::Config& config,
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002205 WebRtcVideoDecoderFactory* external_decoder_factory,
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00002206 bool default_stream,
qiangchen444682a2015-11-24 18:07:56 -08002207 const std::vector<VideoCodecSettings>& recv_codecs,
2208 bool disable_prerenderer_smoothing)
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002209 : call_(call),
Peter Boström259bd202015-05-28 13:39:50 +02002210 ssrcs_(sp.ssrcs),
2211 ssrc_groups_(sp.ssrc_groups),
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002212 stream_(NULL),
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00002213 default_stream_(default_stream),
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +00002214 config_(config),
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002215 external_decoder_factory_(external_decoder_factory),
qiangchen444682a2015-11-24 18:07:56 -08002216 disable_prerenderer_smoothing_(disable_prerenderer_smoothing),
nissee73afba2016-01-28 04:47:08 -08002217 sink_(NULL),
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002218 last_width_(-1),
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002219 last_height_(-1),
2220 first_frame_timestamp_(-1),
2221 estimated_remote_start_ntp_time_ms_(0) {
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002222 config_.renderer = this;
2223 // SetRecvCodecs will also reset (start) the VideoReceiveStream.
deadbeef874ca3a2015-08-20 17:19:20 -07002224 LOG(LS_INFO) << "SetRecvCodecs (recv) because we are creating the receive "
2225 "stream for the first time: "
2226 << CodecSettingsVectorToString(recv_codecs);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002227 SetRecvCodecs(recv_codecs);
2228}
2229
Peter Boström7252a2b2015-05-18 19:42:03 +02002230WebRtcVideoChannel2::WebRtcVideoReceiveStream::AllocatedDecoder::
2231 AllocatedDecoder(webrtc::VideoDecoder* decoder,
2232 webrtc::VideoCodecType type,
2233 bool external)
2234 : decoder(decoder),
2235 external_decoder(nullptr),
2236 type(type),
2237 external(external) {
2238 if (external) {
2239 external_decoder = decoder;
2240 this->decoder =
2241 new webrtc::VideoDecoderSoftwareFallbackWrapper(type, external_decoder);
2242 }
2243}
2244
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002245WebRtcVideoChannel2::WebRtcVideoReceiveStream::~WebRtcVideoReceiveStream() {
2246 call_->DestroyVideoReceiveStream(stream_);
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002247 ClearDecoders(&allocated_decoders_);
2248}
2249
Peter Boström0c4e06b2015-10-07 12:23:21 +02002250const std::vector<uint32_t>&
Peter Boströmd6f4c252015-03-26 16:23:04 +01002251WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetSsrcs() const {
2252 return ssrcs_;
2253}
2254
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002255WebRtcVideoChannel2::WebRtcVideoReceiveStream::AllocatedDecoder
2256WebRtcVideoChannel2::WebRtcVideoReceiveStream::CreateOrReuseVideoDecoder(
2257 std::vector<AllocatedDecoder>* old_decoders,
2258 const VideoCodec& codec) {
2259 webrtc::VideoCodecType type = CodecTypeFromName(codec.name);
2260
2261 for (size_t i = 0; i < old_decoders->size(); ++i) {
2262 if ((*old_decoders)[i].type == type) {
2263 AllocatedDecoder decoder = (*old_decoders)[i];
2264 (*old_decoders)[i] = old_decoders->back();
2265 old_decoders->pop_back();
2266 return decoder;
2267 }
2268 }
2269
2270 if (external_decoder_factory_ != NULL) {
2271 webrtc::VideoDecoder* decoder =
2272 external_decoder_factory_->CreateVideoDecoder(type);
2273 if (decoder != NULL) {
2274 return AllocatedDecoder(decoder, type, true);
2275 }
2276 }
2277
2278 if (type == webrtc::kVideoCodecVP8) {
2279 return AllocatedDecoder(
2280 webrtc::VideoDecoder::Create(webrtc::VideoDecoder::kVp8), type, false);
2281 }
2282
pbos@webrtc.orgb9557a92015-03-20 19:52:56 +00002283 if (type == webrtc::kVideoCodecVP9) {
2284 return AllocatedDecoder(
2285 webrtc::VideoDecoder::Create(webrtc::VideoDecoder::kVp9), type, false);
2286 }
2287
Zeke Chin71f6f442015-06-29 14:34:58 -07002288 if (type == webrtc::kVideoCodecH264) {
2289 return AllocatedDecoder(
2290 webrtc::VideoDecoder::Create(webrtc::VideoDecoder::kH264), type, false);
2291 }
2292
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002293 // This shouldn't happen, we should not be trying to create something we don't
2294 // support.
henrikg91d6ede2015-09-17 00:24:34 -07002295 RTC_DCHECK(false);
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002296 return AllocatedDecoder(NULL, webrtc::kVideoCodecUnknown, false);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002297}
2298
2299void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRecvCodecs(
2300 const std::vector<VideoCodecSettings>& recv_codecs) {
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002301 std::vector<AllocatedDecoder> old_decoders = allocated_decoders_;
2302 allocated_decoders_.clear();
2303 config_.decoders.clear();
2304 for (size_t i = 0; i < recv_codecs.size(); ++i) {
2305 AllocatedDecoder allocated_decoder =
2306 CreateOrReuseVideoDecoder(&old_decoders, recv_codecs[i].codec);
2307 allocated_decoders_.push_back(allocated_decoder);
2308
2309 webrtc::VideoReceiveStream::Decoder decoder;
2310 decoder.decoder = allocated_decoder.decoder;
2311 decoder.payload_type = recv_codecs[i].codec.id;
2312 decoder.payload_name = recv_codecs[i].codec.name;
2313 config_.decoders.push_back(decoder);
2314 }
2315
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002316 // TODO(pbos): Reconfigure RTX based on incoming recv_codecs.
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002317 config_.rtp.fec = recv_codecs.front().fec;
pbos@webrtc.org257e1302014-07-25 19:01:32 +00002318 config_.rtp.nack.rtp_history_ms =
Shao Changbine62202f2015-04-21 20:24:50 +08002319 HasNack(recv_codecs.begin()->codec) ? kNackHistoryMs : 0;
pbos@webrtc.org257e1302014-07-25 19:01:32 +00002320
deadbeef874ca3a2015-08-20 17:19:20 -07002321 LOG(LS_INFO) << "RecreateWebRtcStream (recv) because of SetRecvCodecs: "
2322 << CodecSettingsVectorToString(recv_codecs);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002323 RecreateWebRtcStream();
Peter Boström9e1b9922015-12-04 16:34:11 +01002324 ClearDecoders(&old_decoders);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002325}
2326
Peter Boström3548dd22015-05-22 18:48:36 +02002327void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetLocalSsrc(
2328 uint32_t local_ssrc) {
henrikg91d6ede2015-09-17 00:24:34 -07002329 // TODO(pbos): Consider turning this sanity check into a RTC_DCHECK. You
2330 // should not be able to create a sender with the same SSRC as a receiver, but
2331 // right now this can't be done due to unittests depending on receiving what
2332 // they are sending from the same MediaChannel.
deadbeef874ca3a2015-08-20 17:19:20 -07002333 if (local_ssrc == config_.rtp.remote_ssrc) {
2334 LOG(LS_INFO) << "Ignoring call to SetLocalSsrc because parameters are "
2335 "unchanged; local_ssrc=" << local_ssrc;
Peter Boström3548dd22015-05-22 18:48:36 +02002336 return;
deadbeef874ca3a2015-08-20 17:19:20 -07002337 }
Peter Boström3548dd22015-05-22 18:48:36 +02002338
2339 config_.rtp.local_ssrc = local_ssrc;
deadbeef874ca3a2015-08-20 17:19:20 -07002340 LOG(LS_INFO)
2341 << "RecreateWebRtcStream (recv) because of SetLocalSsrc; local_ssrc="
2342 << local_ssrc;
Peter Boström3548dd22015-05-22 18:48:36 +02002343 RecreateWebRtcStream();
2344}
2345
stefan43edf0f2015-11-20 18:05:48 -08002346void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetFeedbackParameters(
2347 bool nack_enabled,
2348 bool remb_enabled,
2349 bool transport_cc_enabled) {
Peter Boström67c9df72015-05-11 14:34:58 +02002350 int nack_history_ms = nack_enabled ? kNackHistoryMs : 0;
2351 if (config_.rtp.nack.rtp_history_ms == nack_history_ms &&
stefan43edf0f2015-11-20 18:05:48 -08002352 config_.rtp.remb == remb_enabled &&
2353 config_.rtp.transport_cc == transport_cc_enabled) {
2354 LOG(LS_INFO)
2355 << "Ignoring call to SetFeedbackParameters because parameters are "
2356 "unchanged; nack="
2357 << nack_enabled << ", remb=" << remb_enabled
2358 << ", transport_cc=" << transport_cc_enabled;
Peter Boström126c03e2015-05-11 12:48:12 +02002359 return;
Peter Boström67c9df72015-05-11 14:34:58 +02002360 }
2361 config_.rtp.remb = remb_enabled;
2362 config_.rtp.nack.rtp_history_ms = nack_history_ms;
stefan43edf0f2015-11-20 18:05:48 -08002363 config_.rtp.transport_cc = transport_cc_enabled;
2364 LOG(LS_INFO)
2365 << "RecreateWebRtcStream (recv) because of SetFeedbackParameters; nack="
2366 << nack_enabled << ", remb=" << remb_enabled
2367 << ", transport_cc=" << transport_cc_enabled;
Peter Boström126c03e2015-05-11 12:48:12 +02002368 RecreateWebRtcStream();
2369}
2370
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002371void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRtpExtensions(
2372 const std::vector<webrtc::RtpExtension>& extensions) {
2373 config_.rtp.extensions = extensions;
deadbeef874ca3a2015-08-20 17:19:20 -07002374 LOG(LS_INFO) << "RecreateWebRtcStream (recv) because of SetRtpExtensions";
Peter Boström3548dd22015-05-22 18:48:36 +02002375 RecreateWebRtcStream();
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002376}
2377
deadbeef13871492015-12-09 12:37:51 -08002378void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRecvParameters(
2379 const VideoRecvParameters& recv_params) {
2380 config_.rtp.rtcp_mode = recv_params.rtcp.reduced_size
2381 ? webrtc::RtcpMode::kReducedSize
2382 : webrtc::RtcpMode::kCompound;
2383 LOG(LS_INFO) << "RecreateWebRtcStream (recv) because of SetRecvParameters";
2384 RecreateWebRtcStream();
2385}
2386
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002387void WebRtcVideoChannel2::WebRtcVideoReceiveStream::RecreateWebRtcStream() {
2388 if (stream_ != NULL) {
2389 call_->DestroyVideoReceiveStream(stream_);
2390 }
2391 stream_ = call_->CreateVideoReceiveStream(config_);
2392 stream_->Start();
2393}
2394
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002395void WebRtcVideoChannel2::WebRtcVideoReceiveStream::ClearDecoders(
2396 std::vector<AllocatedDecoder>* allocated_decoders) {
2397 for (size_t i = 0; i < allocated_decoders->size(); ++i) {
2398 if ((*allocated_decoders)[i].external) {
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002399 external_decoder_factory_->DestroyVideoDecoder(
Peter Boström7252a2b2015-05-18 19:42:03 +02002400 (*allocated_decoders)[i].external_decoder);
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002401 }
Peter Boström7252a2b2015-05-18 19:42:03 +02002402 delete (*allocated_decoders)[i].decoder;
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002403 }
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002404 allocated_decoders->clear();
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002405}
2406
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002407void WebRtcVideoChannel2::WebRtcVideoReceiveStream::RenderFrame(
Miguel Casas-Sanchez47650702015-05-29 17:21:40 -07002408 const webrtc::VideoFrame& frame,
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002409 int time_to_render_ms) {
nissee73afba2016-01-28 04:47:08 -08002410 rtc::CritScope crit(&sink_lock_);
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002411
2412 if (first_frame_timestamp_ < 0)
2413 first_frame_timestamp_ = frame.timestamp();
2414 int64_t rtp_time_elapsed_since_first_frame =
2415 (timestamp_wraparound_handler_.Unwrap(frame.timestamp()) -
2416 first_frame_timestamp_);
2417 int64_t elapsed_time_ms = rtp_time_elapsed_since_first_frame /
2418 (cricket::kVideoCodecClockrate / 1000);
2419 if (frame.ntp_time_ms() > 0)
2420 estimated_remote_start_ntp_time_ms_ = frame.ntp_time_ms() - elapsed_time_ms;
2421
nissee73afba2016-01-28 04:47:08 -08002422 if (sink_ == NULL) {
2423 LOG(LS_WARNING) << "VideoReceiveStream not connected to a VideoSink.";
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002424 return;
2425 }
2426
nissec4c84852016-01-19 00:52:47 -08002427 last_width_ = frame.width();
2428 last_height_ = frame.height();
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002429
magjed@webrtc.org2386d6d2015-03-05 14:03:08 +00002430 const WebRtcVideoFrame render_frame(
2431 frame.video_frame_buffer(),
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07002432 frame.render_time_ms() * rtc::kNumNanosecsPerMillisec, frame.rotation());
nissee73afba2016-01-28 04:47:08 -08002433 sink_->OnFrame(render_frame);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002434}
2435
pbos@webrtc.org0d852d52015-02-09 15:14:36 +00002436bool WebRtcVideoChannel2::WebRtcVideoReceiveStream::IsTextureSupported() const {
2437 return true;
2438}
2439
qiangchen444682a2015-11-24 18:07:56 -08002440bool WebRtcVideoChannel2::WebRtcVideoReceiveStream::SmoothsRenderedFrames()
2441 const {
2442 return disable_prerenderer_smoothing_;
2443}
2444
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00002445bool WebRtcVideoChannel2::WebRtcVideoReceiveStream::IsDefaultStream() const {
2446 return default_stream_;
2447}
2448
nissee73afba2016-01-28 04:47:08 -08002449void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetSink(
2450 rtc::VideoSinkInterface<cricket::VideoFrame>* sink) {
2451 rtc::CritScope crit(&sink_lock_);
2452 sink_ = sink;
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002453}
2454
pbosf42376c2015-08-28 07:35:32 -07002455std::string
2456WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetCodecNameFromPayloadType(
2457 int payload_type) {
2458 for (const webrtc::VideoReceiveStream::Decoder& decoder : config_.decoders) {
2459 if (decoder.payload_type == payload_type) {
2460 return decoder.payload_name;
2461 }
2462 }
2463 return "";
2464}
2465
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002466VideoReceiverInfo
2467WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetVideoReceiverInfo() {
2468 VideoReceiverInfo info;
Peter Boström259bd202015-05-28 13:39:50 +02002469 info.ssrc_groups = ssrc_groups_;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002470 info.add_ssrc(config_.rtp.remote_ssrc);
2471 webrtc::VideoReceiveStream::Stats stats = stream_->GetStats();
Peter Boströmb7d9a972015-12-18 16:01:11 +01002472 info.decoder_implementation_name = stats.decoder_implementation_name;
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59 +00002473 info.bytes_rcvd = stats.rtp_stats.transmitted.payload_bytes +
2474 stats.rtp_stats.transmitted.header_bytes +
2475 stats.rtp_stats.transmitted.padding_bytes;
2476 info.packets_rcvd = stats.rtp_stats.transmitted.packets;
Peter Boström393347f2015-04-22 14:52:45 +02002477 info.packets_lost = stats.rtcp_stats.cumulative_lost;
2478 info.fraction_lost =
2479 static_cast<float>(stats.rtcp_stats.fraction_lost) / (1 << 8);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002480
2481 info.framerate_rcvd = stats.network_frame_rate;
2482 info.framerate_decoded = stats.decode_frame_rate;
2483 info.framerate_output = stats.render_frame_rate;
2484
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002485 {
nissee73afba2016-01-28 04:47:08 -08002486 rtc::CritScope frame_cs(&sink_lock_);
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002487 info.frame_width = last_width_;
2488 info.frame_height = last_height_;
2489 info.capture_start_ntp_time_ms = estimated_remote_start_ntp_time_ms_;
2490 }
2491
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002492 info.decode_ms = stats.decode_ms;
2493 info.max_decode_ms = stats.max_decode_ms;
2494 info.current_delay_ms = stats.current_delay_ms;
2495 info.target_delay_ms = stats.target_delay_ms;
2496 info.jitter_buffer_ms = stats.jitter_buffer_ms;
2497 info.min_playout_delay_ms = stats.min_playout_delay_ms;
2498 info.render_delay_ms = stats.render_delay_ms;
2499
pbosf42376c2015-08-28 07:35:32 -07002500 info.codec_name = GetCodecNameFromPayloadType(stats.current_payload_type);
2501
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002502 info.firs_sent = stats.rtcp_packet_type_counts.fir_packets;
2503 info.plis_sent = stats.rtcp_packet_type_counts.pli_packets;
2504 info.nacks_sent = stats.rtcp_packet_type_counts.nack_packets;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002505
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002506 return info;
2507}
2508
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002509WebRtcVideoChannel2::VideoCodecSettings::VideoCodecSettings()
2510 : rtx_payload_type(-1) {}
2511
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002512bool WebRtcVideoChannel2::VideoCodecSettings::operator==(
2513 const WebRtcVideoChannel2::VideoCodecSettings& other) const {
2514 return codec == other.codec &&
2515 fec.ulpfec_payload_type == other.fec.ulpfec_payload_type &&
2516 fec.red_payload_type == other.fec.red_payload_type &&
Shao Changbine62202f2015-04-21 20:24:50 +08002517 fec.red_rtx_payload_type == other.fec.red_rtx_payload_type &&
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002518 rtx_payload_type == other.rtx_payload_type;
2519}
2520
Peter Boströmee0b00e2015-04-22 18:41:14 +02002521bool WebRtcVideoChannel2::VideoCodecSettings::operator!=(
2522 const WebRtcVideoChannel2::VideoCodecSettings& other) const {
2523 return !(*this == other);
2524}
2525
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002526std::vector<WebRtcVideoChannel2::VideoCodecSettings>
2527WebRtcVideoChannel2::MapCodecs(const std::vector<VideoCodec>& codecs) {
henrikg91d6ede2015-09-17 00:24:34 -07002528 RTC_DCHECK(!codecs.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002529
2530 std::vector<VideoCodecSettings> video_codecs;
2531 std::map<int, bool> payload_used;
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002532 std::map<int, VideoCodec::CodecType> payload_codec_type;
pkasting@chromium.orgd3245462015-02-23 21:28:22 +00002533 // |rtx_mapping| maps video payload type to rtx payload type.
2534 std::map<int, int> rtx_mapping;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002535
2536 webrtc::FecConfig fec_settings;
2537
2538 for (size_t i = 0; i < codecs.size(); ++i) {
2539 const VideoCodec& in_codec = codecs[i];
2540 int payload_type = in_codec.id;
2541
2542 if (payload_used[payload_type]) {
2543 LOG(LS_ERROR) << "Payload type already registered: "
2544 << in_codec.ToString();
2545 return std::vector<VideoCodecSettings>();
2546 }
2547 payload_used[payload_type] = true;
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002548 payload_codec_type[payload_type] = in_codec.GetCodecType();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002549
2550 switch (in_codec.GetCodecType()) {
2551 case VideoCodec::CODEC_RED: {
2552 // RED payload type, should not have duplicates.
henrikg91d6ede2015-09-17 00:24:34 -07002553 RTC_DCHECK(fec_settings.red_payload_type == -1);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002554 fec_settings.red_payload_type = in_codec.id;
2555 continue;
2556 }
2557
2558 case VideoCodec::CODEC_ULPFEC: {
2559 // ULPFEC payload type, should not have duplicates.
henrikg91d6ede2015-09-17 00:24:34 -07002560 RTC_DCHECK(fec_settings.ulpfec_payload_type == -1);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002561 fec_settings.ulpfec_payload_type = in_codec.id;
2562 continue;
2563 }
2564
2565 case VideoCodec::CODEC_RTX: {
2566 int associated_payload_type;
2567 if (!in_codec.GetParam(kCodecParamAssociatedPayloadType,
pkasting@chromium.orge9facf82015-02-17 20:36:28 +00002568 &associated_payload_type) ||
2569 !IsValidRtpPayloadType(associated_payload_type)) {
2570 LOG(LS_ERROR)
2571 << "RTX codec with invalid or no associated payload type: "
2572 << in_codec.ToString();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002573 return std::vector<VideoCodecSettings>();
2574 }
2575 rtx_mapping[associated_payload_type] = in_codec.id;
2576 continue;
2577 }
2578
2579 case VideoCodec::CODEC_VIDEO:
2580 break;
2581 }
2582
2583 video_codecs.push_back(VideoCodecSettings());
2584 video_codecs.back().codec = in_codec;
2585 }
2586
2587 // One of these codecs should have been a video codec. Only having FEC
2588 // parameters into this code is a logic error.
henrikg91d6ede2015-09-17 00:24:34 -07002589 RTC_DCHECK(!video_codecs.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002590
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002591 for (std::map<int, int>::const_iterator it = rtx_mapping.begin();
2592 it != rtx_mapping.end();
2593 ++it) {
2594 if (!payload_used[it->first]) {
2595 LOG(LS_ERROR) << "RTX mapped to payload not in codec list.";
2596 return std::vector<VideoCodecSettings>();
2597 }
Shao Changbine62202f2015-04-21 20:24:50 +08002598 if (payload_codec_type[it->first] != VideoCodec::CODEC_VIDEO &&
2599 payload_codec_type[it->first] != VideoCodec::CODEC_RED) {
2600 LOG(LS_ERROR) << "RTX not mapped to regular video codec or RED codec.";
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002601 return std::vector<VideoCodecSettings>();
2602 }
Shao Changbine62202f2015-04-21 20:24:50 +08002603
2604 if (it->first == fec_settings.red_payload_type) {
2605 fec_settings.red_rtx_payload_type = it->second;
2606 }
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002607 }
2608
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002609 for (size_t i = 0; i < video_codecs.size(); ++i) {
2610 video_codecs[i].fec = fec_settings;
Shao Changbine62202f2015-04-21 20:24:50 +08002611 if (rtx_mapping[video_codecs[i].codec.id] != 0 &&
2612 rtx_mapping[video_codecs[i].codec.id] !=
2613 fec_settings.red_payload_type) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002614 video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
2615 }
2616 }
2617
2618 return video_codecs;
2619}
2620
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002621} // namespace cricket
2622
2623#endif // HAVE_WEBRTC_VIDEO