blob: 3fd5690125ad8d2cb3fd954fdc00e8c2c742742e [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"
Peter Boström81ea54e2015-05-07 11:41:09 +020039#include "talk/media/webrtc/webrtcvideoencoderfactory.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000040#include "talk/media/webrtc/webrtcvideoframe.h"
41#include "talk/media/webrtc/webrtcvoiceengine.h"
buildbot@webrtc.orga09a9992014-08-13 17:26:08 +000042#include "webrtc/base/buffer.h"
43#include "webrtc/base/logging.h"
44#include "webrtc/base/stringutils.h"
qiangchenc27d89f2015-07-16 10:27:16 -070045#include "webrtc/base/timeutils.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000046#include "webrtc/call.h"
Zeke Chin71f6f442015-06-29 14:34:58 -070047#include "webrtc/modules/video_coding/codecs/h264/include/h264.h"
Peter Boström81ea54e2015-05-07 11:41:09 +020048#include "webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h"
49#include "webrtc/system_wrappers/interface/field_trial.h"
pbos@webrtc.org50fe3592015-01-29 12:33:07 +000050#include "webrtc/system_wrappers/interface/trace_event.h"
pbos@webrtc.org776e6f22014-10-29 15:28:39 +000051#include "webrtc/video_decoder.h"
pbos@webrtc.orgab990ae2014-09-17 09:02:25 +000052#include "webrtc/video_encoder.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000053
54#define UNIMPLEMENTED \
55 LOG(LS_ERROR) << "Call to unimplemented function " << __FUNCTION__; \
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +020056 RTC_NOTREACHED()
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000057
58namespace cricket {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +000059namespace {
Peter Boström81ea54e2015-05-07 11:41:09 +020060
61// Wrap cricket::WebRtcVideoEncoderFactory as a webrtc::VideoEncoderFactory.
62class EncoderFactoryAdapter : public webrtc::VideoEncoderFactory {
63 public:
64 // EncoderFactoryAdapter doesn't take ownership of |factory|, which is owned
65 // by e.g. PeerConnectionFactory.
66 explicit EncoderFactoryAdapter(cricket::WebRtcVideoEncoderFactory* factory)
67 : factory_(factory) {}
68 virtual ~EncoderFactoryAdapter() {}
69
70 // Implement webrtc::VideoEncoderFactory.
71 webrtc::VideoEncoder* Create() override {
72 return factory_->CreateVideoEncoder(webrtc::kVideoCodecVP8);
73 }
74
75 void Destroy(webrtc::VideoEncoder* encoder) override {
76 return factory_->DestroyVideoEncoder(encoder);
77 }
78
79 private:
80 cricket::WebRtcVideoEncoderFactory* const factory_;
81};
82
83// An encoder factory that wraps Create requests for simulcastable codec types
84// with a webrtc::SimulcastEncoderAdapter. Non simulcastable codec type
85// requests are just passed through to the contained encoder factory.
86class WebRtcSimulcastEncoderFactory
87 : public cricket::WebRtcVideoEncoderFactory {
88 public:
89 // WebRtcSimulcastEncoderFactory doesn't take ownership of |factory|, which is
90 // owned by e.g. PeerConnectionFactory.
91 explicit WebRtcSimulcastEncoderFactory(
92 cricket::WebRtcVideoEncoderFactory* factory)
93 : factory_(factory) {}
94
95 static bool UseSimulcastEncoderFactory(
96 const std::vector<VideoCodec>& codecs) {
97 // If any codec is VP8, use the simulcast factory. If asked to create a
98 // non-VP8 codec, we'll just return a contained factory encoder directly.
99 for (const auto& codec : codecs) {
100 if (codec.type == webrtc::kVideoCodecVP8) {
101 return true;
102 }
103 }
104 return false;
105 }
106
107 webrtc::VideoEncoder* CreateVideoEncoder(
108 webrtc::VideoCodecType type) override {
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +0200109 DCHECK(factory_ != NULL);
Peter Boström81ea54e2015-05-07 11:41:09 +0200110 // If it's a codec type we can simulcast, create a wrapped encoder.
111 if (type == webrtc::kVideoCodecVP8) {
112 return new webrtc::SimulcastEncoderAdapter(
113 new EncoderFactoryAdapter(factory_));
114 }
115 webrtc::VideoEncoder* encoder = factory_->CreateVideoEncoder(type);
116 if (encoder) {
117 non_simulcast_encoders_.push_back(encoder);
118 }
119 return encoder;
120 }
121
122 const std::vector<VideoCodec>& codecs() const override {
123 return factory_->codecs();
124 }
125
126 bool EncoderTypeHasInternalSource(
127 webrtc::VideoCodecType type) const override {
128 return factory_->EncoderTypeHasInternalSource(type);
129 }
130
131 void DestroyVideoEncoder(webrtc::VideoEncoder* encoder) override {
132 // Check first to see if the encoder wasn't wrapped in a
133 // SimulcastEncoderAdapter. In that case, ask the factory to destroy it.
134 if (std::remove(non_simulcast_encoders_.begin(),
135 non_simulcast_encoders_.end(),
136 encoder) != non_simulcast_encoders_.end()) {
137 factory_->DestroyVideoEncoder(encoder);
138 return;
139 }
140
141 // Otherwise, SimulcastEncoderAdapter can be deleted directly, and will call
142 // DestroyVideoEncoder on the factory for individual encoder instances.
143 delete encoder;
144 }
145
146 private:
147 cricket::WebRtcVideoEncoderFactory* factory_;
148 // A list of encoders that were created without being wrapped in a
149 // SimulcastEncoderAdapter.
150 std::vector<webrtc::VideoEncoder*> non_simulcast_encoders_;
151};
152
153bool CodecIsInternallySupported(const std::string& codec_name) {
154 if (CodecNamesEq(codec_name, kVp8CodecName)) {
155 return true;
156 }
157 if (CodecNamesEq(codec_name, kVp9CodecName)) {
jbauchbd384282015-07-16 04:05:52 -0700158 const std::string group_name =
Peter Boström81ea54e2015-05-07 11:41:09 +0200159 webrtc::field_trial::FindFullName("WebRTC-SupportVP9");
160 return group_name == "Enabled" || group_name == "EnabledByFlag";
161 }
Zeke Chin71f6f442015-06-29 14:34:58 -0700162 if (CodecNamesEq(codec_name, kH264CodecName)) {
163 return webrtc::H264Encoder::IsSupported() &&
164 webrtc::H264Decoder::IsSupported();
165 }
Peter Boström81ea54e2015-05-07 11:41:09 +0200166 return false;
167}
168
169void AddDefaultFeedbackParams(VideoCodec* codec) {
170 codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamCcm, kRtcpFbCcmParamFir));
171 codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamNack, kParamValueEmpty));
172 codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamNack, kRtcpFbNackParamPli));
173 codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamRemb, kParamValueEmpty));
174}
175
176static VideoCodec MakeVideoCodecWithDefaultFeedbackParams(int payload_type,
177 const char* name) {
178 VideoCodec codec(payload_type, name, kDefaultVideoMaxWidth,
179 kDefaultVideoMaxHeight, kDefaultVideoMaxFramerate, 0);
180 AddDefaultFeedbackParams(&codec);
181 return codec;
182}
183
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000184static std::string CodecVectorToString(const std::vector<VideoCodec>& codecs) {
185 std::stringstream out;
186 out << '{';
187 for (size_t i = 0; i < codecs.size(); ++i) {
188 out << codecs[i].ToString();
189 if (i != codecs.size() - 1) {
190 out << ", ";
191 }
192 }
193 out << '}';
194 return out.str();
195}
196
197static bool ValidateCodecFormats(const std::vector<VideoCodec>& codecs) {
198 bool has_video = false;
199 for (size_t i = 0; i < codecs.size(); ++i) {
200 if (!codecs[i].ValidateCodecFormat()) {
201 return false;
202 }
203 if (codecs[i].GetCodecType() == VideoCodec::CODEC_VIDEO) {
204 has_video = true;
205 }
206 }
207 if (!has_video) {
208 LOG(LS_ERROR) << "Setting codecs without a video codec is invalid: "
209 << CodecVectorToString(codecs);
210 return false;
211 }
212 return true;
213}
214
Peter Boströmd4362cd2015-03-25 14:17:23 +0100215static bool ValidateStreamParams(const StreamParams& sp) {
216 if (sp.ssrcs.empty()) {
217 LOG(LS_ERROR) << "No SSRCs in stream parameters: " << sp.ToString();
218 return false;
219 }
220
221 std::vector<uint32> primary_ssrcs;
222 sp.GetPrimarySsrcs(&primary_ssrcs);
223 std::vector<uint32> rtx_ssrcs;
224 sp.GetFidSsrcs(primary_ssrcs, &rtx_ssrcs);
225 for (uint32_t rtx_ssrc : rtx_ssrcs) {
226 bool rtx_ssrc_present = false;
227 for (uint32_t sp_ssrc : sp.ssrcs) {
228 if (sp_ssrc == rtx_ssrc) {
229 rtx_ssrc_present = true;
230 break;
231 }
232 }
233 if (!rtx_ssrc_present) {
234 LOG(LS_ERROR) << "RTX SSRC '" << rtx_ssrc
235 << "' missing from StreamParams ssrcs: " << sp.ToString();
236 return false;
237 }
238 }
239 if (!rtx_ssrcs.empty() && primary_ssrcs.size() != rtx_ssrcs.size()) {
240 LOG(LS_ERROR)
241 << "RTX SSRCs exist, but don't cover all SSRCs (unsupported): "
242 << sp.ToString();
243 return false;
244 }
245
246 return true;
247}
248
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000249static std::string RtpExtensionsToString(
250 const std::vector<RtpHeaderExtension>& extensions) {
251 std::stringstream out;
252 out << '{';
253 for (size_t i = 0; i < extensions.size(); ++i) {
254 out << "{" << extensions[i].uri << ": " << extensions[i].id << "}";
255 if (i != extensions.size() - 1) {
256 out << ", ";
257 }
258 }
259 out << '}';
260 return out.str();
261}
262
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700263inline const webrtc::RtpExtension* FindHeaderExtension(
264 const std::vector<webrtc::RtpExtension>& extensions,
265 const std::string& name) {
266 for (const auto& kv : extensions) {
267 if (kv.name == name) {
268 return &kv;
269 }
270 }
271 return NULL;
272}
273
andresp@webrtc.org82775b12014-11-07 09:37:54 +0000274// Merges two fec configs and logs an error if a conflict arises
Shao Changbine62202f2015-04-21 20:24:50 +0800275// such that merging in different order would trigger a different output.
andresp@webrtc.org82775b12014-11-07 09:37:54 +0000276static void MergeFecConfig(const webrtc::FecConfig& other,
277 webrtc::FecConfig* output) {
278 if (other.ulpfec_payload_type != -1) {
279 if (output->ulpfec_payload_type != -1 &&
280 output->ulpfec_payload_type != other.ulpfec_payload_type) {
281 LOG(LS_WARNING) << "Conflict merging ulpfec_payload_type configs: "
282 << output->ulpfec_payload_type << " and "
283 << other.ulpfec_payload_type;
284 }
285 output->ulpfec_payload_type = other.ulpfec_payload_type;
286 }
287 if (other.red_payload_type != -1) {
288 if (output->red_payload_type != -1 &&
289 output->red_payload_type != other.red_payload_type) {
290 LOG(LS_WARNING) << "Conflict merging red_payload_type configs: "
291 << output->red_payload_type << " and "
292 << other.red_payload_type;
293 }
294 output->red_payload_type = other.red_payload_type;
295 }
Shao Changbine62202f2015-04-21 20:24:50 +0800296 if (other.red_rtx_payload_type != -1) {
297 if (output->red_rtx_payload_type != -1 &&
298 output->red_rtx_payload_type != other.red_rtx_payload_type) {
299 LOG(LS_WARNING) << "Conflict merging red_rtx_payload_type configs: "
300 << output->red_rtx_payload_type << " and "
301 << other.red_rtx_payload_type;
302 }
303 output->red_rtx_payload_type = other.red_rtx_payload_type;
304 }
andresp@webrtc.org82775b12014-11-07 09:37:54 +0000305}
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000306} // namespace
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000307
Peter Boström81ea54e2015-05-07 11:41:09 +0200308// Constants defined in talk/media/webrtc/constants.h
309// TODO(pbos): Move these to a separate constants.cc file.
310const int kMinVideoBitrate = 30;
311const int kStartVideoBitrate = 300;
312const int kMaxVideoBitrate = 2000;
313
314const int kVideoMtu = 1200;
315const int kVideoRtpBufferSize = 65536;
316
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000317// This constant is really an on/off, lower-level configurable NACK history
318// duration hasn't been implemented.
319static const int kNackHistoryMs = 1000;
320
buildbot@webrtc.org933d88a2014-09-18 20:23:05 +0000321static const int kDefaultQpMax = 56;
322
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000323static const int kDefaultRtcpReceiverReportSsrc = 1;
324
Stefan Holmere5904162015-03-26 11:11:06 +0100325const int kMinBandwidthBps = 30000;
326const int kStartBandwidthBps = 300000;
327const int kMaxBandwidthBps = 2000000;
328
Peter Boström81ea54e2015-05-07 11:41:09 +0200329std::vector<VideoCodec> DefaultVideoCodecList() {
330 std::vector<VideoCodec> codecs;
331 if (CodecIsInternallySupported(kVp9CodecName)) {
332 codecs.push_back(MakeVideoCodecWithDefaultFeedbackParams(kDefaultVp9PlType,
333 kVp9CodecName));
334 // TODO(andresp): Add rtx codec for vp9 and verify it works.
335 }
336 codecs.push_back(MakeVideoCodecWithDefaultFeedbackParams(kDefaultVp8PlType,
337 kVp8CodecName));
Zeke Chin71f6f442015-06-29 14:34:58 -0700338 if (CodecIsInternallySupported(kH264CodecName)) {
339 codecs.push_back(MakeVideoCodecWithDefaultFeedbackParams(kDefaultH264PlType,
340 kH264CodecName));
341 }
Peter Boström81ea54e2015-05-07 11:41:09 +0200342 codecs.push_back(
343 VideoCodec::CreateRtxCodec(kDefaultRtxVp8PlType, kDefaultVp8PlType));
344 codecs.push_back(VideoCodec(kDefaultRedPlType, kRedCodecName));
345 codecs.push_back(VideoCodec(kDefaultUlpfecType, kUlpfecCodecName));
346 return codecs;
347}
348
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000349static bool FindFirstMatchingCodec(const std::vector<VideoCodec>& codecs,
350 const VideoCodec& requested_codec,
351 VideoCodec* matching_codec) {
352 for (size_t i = 0; i < codecs.size(); ++i) {
353 if (requested_codec.Matches(codecs[i])) {
354 *matching_codec = codecs[i];
355 return true;
356 }
357 }
358 return false;
359}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000360
pbos@webrtc.org3c107582014-07-20 15:27:35 +0000361static bool ValidateRtpHeaderExtensionIds(
362 const std::vector<RtpHeaderExtension>& extensions) {
363 std::set<int> extensions_used;
364 for (size_t i = 0; i < extensions.size(); ++i) {
Peter Boström23914fe2015-03-31 15:08:04 +0200365 if (extensions[i].id <= 0 || extensions[i].id >= 15 ||
pbos@webrtc.org3c107582014-07-20 15:27:35 +0000366 !extensions_used.insert(extensions[i].id).second) {
367 LOG(LS_ERROR) << "RTP extensions are with incorrect or duplicate ids.";
368 return false;
369 }
370 }
371 return true;
372}
373
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +0000374static bool CompareRtpHeaderExtensionIds(
375 const webrtc::RtpExtension& extension1,
376 const webrtc::RtpExtension& extension2) {
377 // Sorting on ID is sufficient, more than one extension per ID is unsupported.
378 return extension1.id > extension2.id;
379}
380
pbos@webrtc.org3c107582014-07-20 15:27:35 +0000381static std::vector<webrtc::RtpExtension> FilterRtpExtensions(
382 const std::vector<RtpHeaderExtension>& extensions) {
383 std::vector<webrtc::RtpExtension> webrtc_extensions;
384 for (size_t i = 0; i < extensions.size(); ++i) {
385 // Unsupported extensions will be ignored.
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200386 if (webrtc::RtpExtension::IsSupportedForVideo(extensions[i].uri)) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +0000387 webrtc_extensions.push_back(webrtc::RtpExtension(
388 extensions[i].uri, extensions[i].id));
389 } else {
390 LOG(LS_WARNING) << "Unsupported RTP extension: " << extensions[i].uri;
391 }
392 }
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +0000393
394 // Sort filtered headers to make sure that they can later be compared
395 // regardless of in which order they were entered.
396 std::sort(webrtc_extensions.begin(), webrtc_extensions.end(),
397 CompareRtpHeaderExtensionIds);
pbos@webrtc.org3c107582014-07-20 15:27:35 +0000398 return webrtc_extensions;
399}
400
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +0000401static bool RtpExtensionsHaveChanged(
402 const std::vector<webrtc::RtpExtension>& before,
403 const std::vector<webrtc::RtpExtension>& after) {
404 if (before.size() != after.size())
405 return true;
406 for (size_t i = 0; i < before.size(); ++i) {
407 if (before[i].id != after[i].id)
408 return true;
409 if (before[i].name != after[i].name)
410 return true;
411 }
412 return false;
413}
414
buildbot@webrtc.orga8530772014-12-10 09:01:18 +0000415std::vector<webrtc::VideoStream>
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000416WebRtcVideoChannel2::WebRtcVideoSendStream::CreateSimulcastVideoStreams(
buildbot@webrtc.orga8530772014-12-10 09:01:18 +0000417 const VideoCodec& codec,
418 const VideoOptions& options,
Peter Boströmdfd53fe2015-03-27 15:58:11 +0100419 int max_bitrate_bps,
buildbot@webrtc.orga8530772014-12-10 09:01:18 +0000420 size_t num_streams) {
buildbot@webrtc.orga8530772014-12-10 09:01:18 +0000421 int max_qp = kDefaultQpMax;
422 codec.GetParam(kCodecParamMaxQuantization, &max_qp);
423
buildbot@webrtc.orga8530772014-12-10 09:01:18 +0000424 return GetSimulcastConfig(
Peter Boströmdfd53fe2015-03-27 15:58:11 +0100425 num_streams, GetSimulcastBitrateMode(options), codec.width, codec.height,
426 max_bitrate_bps, max_qp,
buildbot@webrtc.orga8530772014-12-10 09:01:18 +0000427 codec.framerate != 0 ? codec.framerate : kDefaultVideoMaxFramerate);
428}
429
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000430std::vector<webrtc::VideoStream>
431WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoStreams(
buildbot@webrtc.orgd41eaeb2014-06-12 07:13:26 +0000432 const VideoCodec& codec,
433 const VideoOptions& options,
Peter Boströmdfd53fe2015-03-27 15:58:11 +0100434 int max_bitrate_bps,
buildbot@webrtc.orgd41eaeb2014-06-12 07:13:26 +0000435 size_t num_streams) {
Peter Boströmdfd53fe2015-03-27 15:58:11 +0100436 int codec_max_bitrate_kbps;
437 if (codec.GetParam(kCodecParamMaxBitrate, &codec_max_bitrate_kbps)) {
438 max_bitrate_bps = codec_max_bitrate_kbps * 1000;
439 }
440 if (num_streams != 1) {
441 return CreateSimulcastVideoStreams(codec, options, max_bitrate_bps,
442 num_streams);
443 }
444
445 // For unset max bitrates set default bitrate for non-simulcast.
446 if (max_bitrate_bps <= 0)
447 max_bitrate_bps = kMaxVideoBitrate * 1000;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000448
buildbot@webrtc.orgd41eaeb2014-06-12 07:13:26 +0000449 webrtc::VideoStream stream;
450 stream.width = codec.width;
451 stream.height = codec.height;
452 stream.max_framerate =
andresp@webrtc.org82775b12014-11-07 09:37:54 +0000453 codec.framerate != 0 ? codec.framerate : kDefaultVideoMaxFramerate;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000454
pbos@webrtc.org00873182014-11-25 14:03:34 +0000455 stream.min_bitrate_bps = kMinVideoBitrate * 1000;
Peter Boströmdfd53fe2015-03-27 15:58:11 +0100456 stream.target_bitrate_bps = stream.max_bitrate_bps = max_bitrate_bps;
buildbot@webrtc.orgd41eaeb2014-06-12 07:13:26 +0000457
buildbot@webrtc.org933d88a2014-09-18 20:23:05 +0000458 int max_qp = kDefaultQpMax;
buildbot@webrtc.orgd41eaeb2014-06-12 07:13:26 +0000459 codec.GetParam(kCodecParamMaxQuantization, &max_qp);
460 stream.max_qp = max_qp;
461 std::vector<webrtc::VideoStream> streams;
462 streams.push_back(stream);
463 return streams;
464}
465
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000466void* WebRtcVideoChannel2::WebRtcVideoSendStream::ConfigureVideoEncoderSettings(
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000467 const VideoCodec& codec,
Erik Språng143cec12015-04-28 10:01:41 +0200468 const VideoOptions& options,
469 bool is_screencast) {
470 // No automatic resizing when using simulcast.
471 bool automatic_resize = !is_screencast && ssrcs_.size() == 1;
472 bool frame_dropping = !is_screencast;
473 bool denoising;
474 if (is_screencast) {
475 denoising = false;
476 } else {
477 options.video_noise_reduction.Get(&denoising);
478 }
479
Shao Changbine62202f2015-04-21 20:24:50 +0800480 if (CodecNamesEq(codec.name, kVp8CodecName)) {
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000481 encoder_settings_.vp8 = webrtc::VideoEncoder::GetDefaultVp8Settings();
Erik Språng143cec12015-04-28 10:01:41 +0200482 encoder_settings_.vp8.automaticResizeOn = automatic_resize;
483 encoder_settings_.vp8.denoisingOn = denoising;
484 encoder_settings_.vp8.frameDroppingOn = frame_dropping;
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000485 return &encoder_settings_.vp8;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000486 }
Shao Changbine62202f2015-04-21 20:24:50 +0800487 if (CodecNamesEq(codec.name, kVp9CodecName)) {
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000488 encoder_settings_.vp9 = webrtc::VideoEncoder::GetDefaultVp9Settings();
Erik Språng143cec12015-04-28 10:01:41 +0200489 encoder_settings_.vp9.denoisingOn = denoising;
490 encoder_settings_.vp9.frameDroppingOn = frame_dropping;
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000491 return &encoder_settings_.vp9;
andresp@webrtc.org188d3b22014-11-07 13:21:04 +0000492 }
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000493 return NULL;
494}
495
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000496DefaultUnsignalledSsrcHandler::DefaultUnsignalledSsrcHandler()
497 : default_recv_ssrc_(0), default_renderer_(NULL) {}
498
499UnsignalledSsrcHandler::Action DefaultUnsignalledSsrcHandler::OnUnsignalledSsrc(
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +0000500 WebRtcVideoChannel2* channel,
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000501 uint32_t ssrc) {
502 if (default_recv_ssrc_ != 0) { // Already one default stream.
503 LOG(LS_WARNING) << "Unknown SSRC, but default receive stream already set.";
504 return kDropPacket;
505 }
506
507 StreamParams sp;
508 sp.ssrcs.push_back(ssrc);
509 LOG(LS_INFO) << "Creating default receive stream for SSRC=" << ssrc << ".";
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +0000510 if (!channel->AddRecvStream(sp, true)) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000511 LOG(LS_WARNING) << "Could not create default receive stream.";
512 }
513
514 channel->SetRenderer(ssrc, default_renderer_);
515 default_recv_ssrc_ = ssrc;
516 return kDeliverPacket;
517}
518
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000519WebRtcCallFactory::~WebRtcCallFactory() {
520}
521webrtc::Call* WebRtcCallFactory::CreateCall(
522 const webrtc::Call::Config& config) {
523 return webrtc::Call::Create(config);
524}
525
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000526VideoRenderer* DefaultUnsignalledSsrcHandler::GetDefaultRenderer() const {
527 return default_renderer_;
528}
529
530void DefaultUnsignalledSsrcHandler::SetDefaultRenderer(
531 VideoMediaChannel* channel,
532 VideoRenderer* renderer) {
533 default_renderer_ = renderer;
534 if (default_recv_ssrc_ != 0) {
535 channel->SetRenderer(default_recv_ssrc_, default_renderer_);
536 }
537}
538
pbos@webrtc.orgf1f0d9a2015-03-02 13:30:15 +0000539WebRtcVideoEngine2::WebRtcVideoEngine2(WebRtcVoiceEngine* voice_engine)
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200540 : voice_engine_(voice_engine),
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +0000541 initialized_(false),
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000542 call_factory_(&default_call_factory_),
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000543 external_decoder_factory_(NULL),
544 external_encoder_factory_(NULL) {
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +0000545 LOG(LS_INFO) << "WebRtcVideoEngine2::WebRtcVideoEngine2()";
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000546 video_codecs_ = GetSupportedCodecs();
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000547 rtp_header_extensions_.push_back(
548 RtpHeaderExtension(kRtpTimestampOffsetHeaderExtension,
549 kRtpTimestampOffsetHeaderExtensionDefaultId));
550 rtp_header_extensions_.push_back(
551 RtpHeaderExtension(kRtpAbsoluteSenderTimeHeaderExtension,
552 kRtpAbsoluteSenderTimeHeaderExtensionDefaultId));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700553 rtp_header_extensions_.push_back(
554 RtpHeaderExtension(kRtpVideoRotationHeaderExtension,
555 kRtpVideoRotationHeaderExtensionDefaultId));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000556}
557
558WebRtcVideoEngine2::~WebRtcVideoEngine2() {
559 LOG(LS_INFO) << "WebRtcVideoEngine2::~WebRtcVideoEngine2";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000560}
561
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000562void WebRtcVideoEngine2::SetCallFactory(WebRtcCallFactory* call_factory) {
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +0200563 DCHECK(!initialized_);
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000564 call_factory_ = call_factory;
565}
566
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200567void WebRtcVideoEngine2::Init() {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000568 LOG(LS_INFO) << "WebRtcVideoEngine2::Init";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000569 initialized_ = true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000570}
571
572int WebRtcVideoEngine2::GetCapabilities() { return VIDEO_RECV | VIDEO_SEND; }
573
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000574bool WebRtcVideoEngine2::SetDefaultEncoderConfig(
575 const VideoEncoderConfig& config) {
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000576 const VideoCodec& codec = config.max_codec;
pbos@webrtc.org957e8022014-11-10 12:36:11 +0000577 bool supports_codec = false;
578 for (size_t i = 0; i < video_codecs_.size(); ++i) {
Shao Changbine62202f2015-04-21 20:24:50 +0800579 if (CodecNamesEq(video_codecs_[i].name, codec.name)) {
pbos@webrtc.org2a72c652015-02-26 16:01:24 +0000580 video_codecs_[i].width = codec.width;
581 video_codecs_[i].height = codec.height;
582 video_codecs_[i].framerate = codec.framerate;
pbos@webrtc.org957e8022014-11-10 12:36:11 +0000583 supports_codec = true;
584 break;
585 }
586 }
587
588 if (!supports_codec) {
589 LOG(LS_ERROR) << "SetDefaultEncoderConfig, codec not supported: "
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000590 << codec.ToString();
591 return false;
592 }
593
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000594 return true;
595}
596
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000597WebRtcVideoChannel2* WebRtcVideoEngine2::CreateChannel(
buildbot@webrtc.org1ecbe452014-10-14 20:29:28 +0000598 const VideoOptions& options,
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000599 VoiceMediaChannel* voice_channel) {
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +0200600 DCHECK(initialized_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000601 LOG(LS_INFO) << "CreateChannel: "
602 << (voice_channel != NULL ? "With" : "Without")
pbos@webrtc.orgfa553ef2014-10-20 11:07:07 +0000603 << " voice channel. Options: " << options.ToString();
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000604 WebRtcVideoChannel2* channel =
Fredrik Solenberg4b60c732015-05-07 14:07:48 +0200605 new WebRtcVideoChannel2(call_factory_, voice_engine_,
606 static_cast<WebRtcVoiceMediaChannel*>(voice_channel), options,
607 external_encoder_factory_, external_decoder_factory_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000608 if (!channel->Init()) {
609 delete channel;
610 return NULL;
611 }
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000612 channel->SetRecvCodecs(video_codecs_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000613 return channel;
614}
615
616const std::vector<VideoCodec>& WebRtcVideoEngine2::codecs() const {
617 return video_codecs_;
618}
619
620const std::vector<RtpHeaderExtension>&
621WebRtcVideoEngine2::rtp_header_extensions() const {
622 return rtp_header_extensions_;
623}
624
625void WebRtcVideoEngine2::SetLogging(int min_sev, const char* filter) {
626 // TODO(pbos): Set up logging.
627 LOG(LS_VERBOSE) << "SetLogging: " << min_sev << '"' << filter << '"';
628 // if min_sev == -1, we keep the current log level.
629 if (min_sev < 0) {
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +0200630 DCHECK(min_sev == -1);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000631 return;
632 }
633}
634
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000635void WebRtcVideoEngine2::SetExternalDecoderFactory(
636 WebRtcVideoDecoderFactory* decoder_factory) {
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +0200637 DCHECK(!initialized_);
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000638 external_decoder_factory_ = decoder_factory;
639}
640
641void WebRtcVideoEngine2::SetExternalEncoderFactory(
642 WebRtcVideoEncoderFactory* encoder_factory) {
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +0200643 DCHECK(!initialized_);
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000644 if (external_encoder_factory_ == encoder_factory)
645 return;
646
647 // No matter what happens we shouldn't hold on to a stale
648 // WebRtcSimulcastEncoderFactory.
649 simulcast_encoder_factory_.reset();
650
651 if (encoder_factory &&
652 WebRtcSimulcastEncoderFactory::UseSimulcastEncoderFactory(
653 encoder_factory->codecs())) {
654 simulcast_encoder_factory_.reset(
655 new WebRtcSimulcastEncoderFactory(encoder_factory));
656 encoder_factory = simulcast_encoder_factory_.get();
657 }
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000658 external_encoder_factory_ = encoder_factory;
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000659
660 video_codecs_ = GetSupportedCodecs();
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000661}
662
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000663bool WebRtcVideoEngine2::EnableTimedRender() {
664 // TODO(pbos): Figure out whether this can be removed.
665 return true;
666}
667
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000668// Checks to see whether we comprehend and could receive a particular codec
669bool WebRtcVideoEngine2::FindCodec(const VideoCodec& in) {
670 // TODO(pbos): Probe encoder factory to figure out that the codec is supported
671 // if supported by the encoder factory. Add a corresponding test that fails
672 // with this code (that doesn't ask the factory).
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000673 for (size_t j = 0; j < video_codecs_.size(); ++j) {
674 VideoCodec codec(video_codecs_[j].id, video_codecs_[j].name, 0, 0, 0, 0);
675 if (codec.Matches(in)) {
676 return true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000677 }
678 }
679 return false;
680}
681
682// Tells whether the |requested| codec can be transmitted or not. If it can be
683// transmitted |out| is set with the best settings supported. Aspect ratio will
684// be set as close to |current|'s as possible. If not set |requested|'s
685// dimensions will be used for aspect ratio matching.
686bool WebRtcVideoEngine2::CanSendCodec(const VideoCodec& requested,
687 const VideoCodec& current,
688 VideoCodec* out) {
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +0200689 DCHECK(out != NULL);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000690
691 if (requested.width != requested.height &&
692 (requested.height == 0 || requested.width == 0)) {
693 // 0xn and nx0 are invalid resolutions.
694 return false;
695 }
696
697 VideoCodec matching_codec;
698 if (!FindFirstMatchingCodec(video_codecs_, requested, &matching_codec)) {
699 // Codec not supported.
700 return false;
701 }
702
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000703 out->id = requested.id;
704 out->name = requested.name;
705 out->preference = requested.preference;
706 out->params = requested.params;
andresp@webrtc.orgff689be2015-02-12 11:54:26 +0000707 out->framerate = std::min(requested.framerate, matching_codec.framerate);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000708 out->params = requested.params;
709 out->feedback_params = requested.feedback_params;
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000710 out->width = requested.width;
711 out->height = requested.height;
712 if (requested.width == 0 && requested.height == 0) {
713 return true;
714 }
715
716 while (out->width > matching_codec.width) {
717 out->width /= 2;
718 out->height /= 2;
719 }
720
721 return out->width > 0 && out->height > 0;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000722}
723
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000724// Ignore spammy trace messages, mostly from the stats API when we haven't
725// gotten RTCP info yet from the remote side.
726bool WebRtcVideoEngine2::ShouldIgnoreTrace(const std::string& trace) {
727 static const char* const kTracesToIgnore[] = {NULL};
728 for (const char* const* p = kTracesToIgnore; *p; ++p) {
729 if (trace.find(*p) == 0) {
730 return true;
731 }
732 }
733 return false;
734}
735
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000736std::vector<VideoCodec> WebRtcVideoEngine2::GetSupportedCodecs() const {
andresp@webrtc.org82775b12014-11-07 09:37:54 +0000737 std::vector<VideoCodec> supported_codecs = DefaultVideoCodecList();
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000738
739 if (external_encoder_factory_ == NULL) {
740 return supported_codecs;
741 }
742
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000743 const std::vector<WebRtcVideoEncoderFactory::VideoCodec>& codecs =
744 external_encoder_factory_->codecs();
745 for (size_t i = 0; i < codecs.size(); ++i) {
746 // Don't add internally-supported codecs twice.
747 if (CodecIsInternallySupported(codecs[i].name)) {
748 continue;
749 }
750
pkasting@chromium.orgd3245462015-02-23 21:28:22 +0000751 // External video encoders are given payloads 120-127. This also means that
752 // we only support up to 8 external payload types.
753 const int kExternalVideoPayloadTypeBase = 120;
754 size_t payload_type = kExternalVideoPayloadTypeBase + i;
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +0200755 DCHECK(payload_type < 128);
pkasting@chromium.orgd3245462015-02-23 21:28:22 +0000756 VideoCodec codec(static_cast<int>(payload_type),
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000757 codecs[i].name,
758 codecs[i].max_width,
759 codecs[i].max_height,
760 codecs[i].max_fps,
761 0);
762
763 AddDefaultFeedbackParams(&codec);
764 supported_codecs.push_back(codec);
765 }
766 return supported_codecs;
767}
768
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000769WebRtcVideoChannel2::WebRtcVideoChannel2(
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000770 WebRtcCallFactory* call_factory,
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +0000771 WebRtcVoiceEngine* voice_engine,
Fredrik Solenberg4b60c732015-05-07 14:07:48 +0200772 WebRtcVoiceMediaChannel* voice_channel,
pbos@webrtc.orgfa553ef2014-10-20 11:07:07 +0000773 const VideoOptions& options,
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000774 WebRtcVideoEncoderFactory* external_encoder_factory,
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000775 WebRtcVideoDecoderFactory* external_decoder_factory)
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +0000776 : unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
Fredrik Solenberg4b60c732015-05-07 14:07:48 +0200777 voice_channel_(voice_channel),
778 voice_channel_id_(voice_channel ? voice_channel->voe_channel() : -1),
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000779 external_encoder_factory_(external_encoder_factory),
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000780 external_decoder_factory_(external_decoder_factory) {
Fredrik Solenberg4b60c732015-05-07 14:07:48 +0200781 DCHECK(thread_checker_.CalledOnValidThread());
pbos@webrtc.orgfa553ef2014-10-20 11:07:07 +0000782 SetDefaultOptions();
783 options_.SetAll(options);
Peter Boströme7b221f2015-04-13 15:34:32 +0200784 options_.cpu_overuse_detection.Get(&signal_cpu_adaptation_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000785 webrtc::Call::Config config(this);
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000786 config.overuse_callback = this;
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +0000787 if (voice_engine != NULL) {
788 config.voice_engine = voice_engine->voe()->engine();
789 }
Stefan Holmere5904162015-03-26 11:11:06 +0100790 config.bitrate_config.min_bitrate_bps = kMinBandwidthBps;
791 config.bitrate_config.start_bitrate_bps = kStartBandwidthBps;
792 config.bitrate_config.max_bitrate_bps = kMaxBandwidthBps;
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000793 call_.reset(call_factory->CreateCall(config));
Fredrik Solenberg4b60c732015-05-07 14:07:48 +0200794 if (voice_channel_) {
795 voice_channel_->SetCall(call_.get());
796 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000797 rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc;
798 sending_ = false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000799 default_send_ssrc_ = 0;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000800}
801
802void WebRtcVideoChannel2::SetDefaultOptions() {
Peter Boströme4328002015-04-14 22:45:29 +0200803 options_.cpu_overuse_detection.Set(true);
pbos@webrtc.orgd8198032014-11-10 14:41:43 +0000804 options_.dscp.Set(false);
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +0000805 options_.suspend_below_min_bitrate.Set(false);
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000806 options_.video_noise_reduction.Set(true);
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +0000807 options_.screencast_min_bitrate.Set(0);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000808}
809
810WebRtcVideoChannel2::~WebRtcVideoChannel2() {
Fredrik Solenberg4b60c732015-05-07 14:07:48 +0200811 DetachVoiceChannel();
Peter Boströmdfd53fe2015-03-27 15:58:11 +0100812 for (auto& kv : send_streams_)
813 delete kv.second;
814 for (auto& kv : receive_streams_)
815 delete kv.second;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000816}
817
818bool WebRtcVideoChannel2::Init() { return true; }
819
Fredrik Solenberg4b60c732015-05-07 14:07:48 +0200820void WebRtcVideoChannel2::DetachVoiceChannel() {
821 DCHECK(thread_checker_.CalledOnValidThread());
822 if (voice_channel_) {
823 voice_channel_->SetCall(nullptr);
824 voice_channel_ = nullptr;
825 }
826}
827
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000828bool WebRtcVideoChannel2::CodecIsExternallySupported(
829 const std::string& name) const {
830 if (external_encoder_factory_ == NULL) {
831 return false;
832 }
833
834 const std::vector<WebRtcVideoEncoderFactory::VideoCodec> external_codecs =
835 external_encoder_factory_->codecs();
836 for (size_t c = 0; c < external_codecs.size(); ++c) {
Shao Changbine62202f2015-04-21 20:24:50 +0800837 if (CodecNamesEq(name, external_codecs[c].name)) {
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000838 return true;
839 }
840 }
841 return false;
842}
843
844std::vector<WebRtcVideoChannel2::VideoCodecSettings>
845WebRtcVideoChannel2::FilterSupportedCodecs(
846 const std::vector<WebRtcVideoChannel2::VideoCodecSettings>& mapped_codecs)
847 const {
848 std::vector<VideoCodecSettings> supported_codecs;
849 for (size_t i = 0; i < mapped_codecs.size(); ++i) {
850 const VideoCodecSettings& codec = mapped_codecs[i];
851 if (CodecIsInternallySupported(codec.codec.name) ||
852 CodecIsExternallySupported(codec.codec.name)) {
853 supported_codecs.push_back(codec);
854 }
855 }
856 return supported_codecs;
857}
858
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000859bool WebRtcVideoChannel2::SetRecvCodecs(const std::vector<VideoCodec>& codecs) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +0000860 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRecvCodecs");
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000861 LOG(LS_INFO) << "SetRecvCodecs: " << CodecVectorToString(codecs);
862 if (!ValidateCodecFormats(codecs)) {
863 return false;
864 }
865
866 const std::vector<VideoCodecSettings> mapped_codecs = MapCodecs(codecs);
867 if (mapped_codecs.empty()) {
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000868 LOG(LS_ERROR) << "SetRecvCodecs called without any video codecs.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000869 return false;
870 }
871
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000872 const std::vector<VideoCodecSettings> supported_codecs =
873 FilterSupportedCodecs(mapped_codecs);
874
875 if (mapped_codecs.size() != supported_codecs.size()) {
876 LOG(LS_ERROR) << "SetRecvCodecs called with unsupported video codecs.";
877 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000878 }
879
Peter Boströmee0b00e2015-04-22 18:41:14 +0200880 // Prevent reconfiguration when setting identical receive codecs.
881 if (recv_codecs_.size() == supported_codecs.size()) {
882 bool reconfigured = false;
883 for (size_t i = 0; i < supported_codecs.size(); ++i) {
884 if (recv_codecs_[i] != supported_codecs[i]) {
885 reconfigured = true;
886 break;
887 }
888 }
889 if (!reconfigured)
890 return true;
891 }
892
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000893 recv_codecs_ = supported_codecs;
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000894
pbos@webrtc.org575d1262014-10-08 14:48:08 +0000895 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000896 for (std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
897 receive_streams_.begin();
898 it != receive_streams_.end();
899 ++it) {
900 it->second->SetRecvCodecs(recv_codecs_);
901 }
902
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000903 return true;
904}
905
906bool WebRtcVideoChannel2::SetSendCodecs(const std::vector<VideoCodec>& codecs) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +0000907 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetSendCodecs");
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000908 LOG(LS_INFO) << "SetSendCodecs: " << CodecVectorToString(codecs);
909 if (!ValidateCodecFormats(codecs)) {
910 return false;
911 }
912
913 const std::vector<VideoCodecSettings> supported_codecs =
914 FilterSupportedCodecs(MapCodecs(codecs));
915
916 if (supported_codecs.empty()) {
Peter Boström3c3f6462015-04-15 16:27:49 +0200917 LOG(LS_ERROR) << "No video codecs supported.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000918 return false;
919 }
920
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000921 LOG(LS_INFO) << "Using codec: " << supported_codecs.front().codec.ToString();
922
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +0000923 VideoCodecSettings old_codec;
924 if (send_codec_.Get(&old_codec) && supported_codecs.front() == old_codec) {
925 // Using same codec, avoid reconfiguring.
926 return true;
927 }
928
929 send_codec_.Set(supported_codecs.front());
930
pbos@webrtc.org575d1262014-10-08 14:48:08 +0000931 rtc::CritScope stream_lock(&stream_crit_);
Peter Boström126c03e2015-05-11 12:48:12 +0200932 for (auto& kv : send_streams_) {
933 DCHECK(kv.second != nullptr);
934 kv.second->SetCodec(supported_codecs.front());
935 }
936 for (auto& kv : receive_streams_) {
937 DCHECK(kv.second != nullptr);
Peter Boström67c9df72015-05-11 14:34:58 +0200938 kv.second->SetNackAndRemb(HasNack(supported_codecs.front().codec),
939 HasRemb(supported_codecs.front().codec));
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000940 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000941
Stefan Holmere5904162015-03-26 11:11:06 +0100942 // TODO(holmer): Changing the codec parameters shouldn't necessarily mean that
943 // we change the min/max of bandwidth estimation. Reevaluate this.
pbos@webrtc.org00873182014-11-25 14:03:34 +0000944 VideoCodec codec = supported_codecs.front().codec;
945 int bitrate_kbps;
946 if (codec.GetParam(kCodecParamMinBitrate, &bitrate_kbps) &&
947 bitrate_kbps > 0) {
948 bitrate_config_.min_bitrate_bps = bitrate_kbps * 1000;
949 } else {
950 bitrate_config_.min_bitrate_bps = 0;
951 }
952 if (codec.GetParam(kCodecParamStartBitrate, &bitrate_kbps) &&
953 bitrate_kbps > 0) {
954 bitrate_config_.start_bitrate_bps = bitrate_kbps * 1000;
955 } else {
956 // Do not reconfigure start bitrate unless it's specified and positive.
957 bitrate_config_.start_bitrate_bps = -1;
958 }
959 if (codec.GetParam(kCodecParamMaxBitrate, &bitrate_kbps) &&
960 bitrate_kbps > 0) {
961 bitrate_config_.max_bitrate_bps = bitrate_kbps * 1000;
962 } else {
963 bitrate_config_.max_bitrate_bps = -1;
964 }
965 call_->SetBitrateConfig(bitrate_config_);
966
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000967 return true;
968}
969
970bool WebRtcVideoChannel2::GetSendCodec(VideoCodec* codec) {
971 VideoCodecSettings codec_settings;
972 if (!send_codec_.Get(&codec_settings)) {
973 LOG(LS_VERBOSE) << "GetSendCodec: No send codec set.";
974 return false;
975 }
976 *codec = codec_settings.codec;
977 return true;
978}
979
980bool WebRtcVideoChannel2::SetSendStreamFormat(uint32 ssrc,
981 const VideoFormat& format) {
982 LOG(LS_VERBOSE) << "SetSendStreamFormat:" << ssrc << " -> "
983 << format.ToString();
pbos@webrtc.org575d1262014-10-08 14:48:08 +0000984 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000985 if (send_streams_.find(ssrc) == send_streams_.end()) {
986 return false;
987 }
988 return send_streams_[ssrc]->SetVideoFormat(format);
989}
990
991bool WebRtcVideoChannel2::SetRender(bool render) {
992 // TODO(pbos): Implement. Or refactor away as it shouldn't be needed.
993 LOG(LS_VERBOSE) << "SetRender: " << (render ? "true" : "false");
994 return true;
995}
996
997bool WebRtcVideoChannel2::SetSend(bool send) {
998 LOG(LS_VERBOSE) << "SetSend: " << (send ? "true" : "false");
999 if (send && !send_codec_.IsSet()) {
1000 LOG(LS_ERROR) << "SetSend(true) called before setting codec.";
1001 return false;
1002 }
1003 if (send) {
1004 StartAllSendStreams();
1005 } else {
1006 StopAllSendStreams();
1007 }
1008 sending_ = send;
1009 return true;
1010}
1011
Peter Boströmd6f4c252015-03-26 16:23:04 +01001012bool WebRtcVideoChannel2::ValidateSendSsrcAvailability(
1013 const StreamParams& sp) const {
1014 for (uint32_t ssrc: sp.ssrcs) {
1015 if (send_ssrcs_.find(ssrc) != send_ssrcs_.end()) {
1016 LOG(LS_ERROR) << "Send stream with SSRC '" << ssrc << "' already exists.";
1017 return false;
1018 }
1019 }
1020 return true;
1021}
1022
1023bool WebRtcVideoChannel2::ValidateReceiveSsrcAvailability(
1024 const StreamParams& sp) const {
1025 for (uint32_t ssrc: sp.ssrcs) {
1026 if (receive_ssrcs_.find(ssrc) != receive_ssrcs_.end()) {
1027 LOG(LS_ERROR) << "Receive stream with SSRC '" << ssrc
1028 << "' already exists.";
1029 return false;
1030 }
1031 }
1032 return true;
1033}
1034
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001035bool WebRtcVideoChannel2::AddSendStream(const StreamParams& sp) {
1036 LOG(LS_INFO) << "AddSendStream: " << sp.ToString();
Peter Boströmd4362cd2015-03-25 14:17:23 +01001037 if (!ValidateStreamParams(sp))
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001038 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001039
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001040 rtc::CritScope stream_lock(&stream_crit_);
Peter Boströmd6f4c252015-03-26 16:23:04 +01001041
1042 if (!ValidateSendSsrcAvailability(sp))
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001043 return false;
Peter Boströmd6f4c252015-03-26 16:23:04 +01001044
1045 for (uint32 used_ssrc : sp.ssrcs)
1046 send_ssrcs_.insert(used_ssrc);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001047
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001048 WebRtcVideoSendStream* stream =
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001049 new WebRtcVideoSendStream(call_.get(),
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001050 external_encoder_factory_,
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001051 options_,
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001052 bitrate_config_.max_bitrate_bps,
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001053 send_codec_,
1054 sp,
1055 send_rtp_extensions_);
1056
Peter Boströmd6f4c252015-03-26 16:23:04 +01001057 uint32 ssrc = sp.first_ssrc();
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +02001058 DCHECK(ssrc != 0);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001059 send_streams_[ssrc] = stream;
1060
1061 if (rtcp_receiver_report_ssrc_ == kDefaultRtcpReceiverReportSsrc) {
1062 rtcp_receiver_report_ssrc_ = ssrc;
Peter Boström3548dd22015-05-22 18:48:36 +02001063 for (auto& kv : receive_streams_)
1064 kv.second->SetLocalSsrc(ssrc);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001065 }
1066 if (default_send_ssrc_ == 0) {
1067 default_send_ssrc_ = ssrc;
1068 }
1069 if (sending_) {
1070 stream->Start();
1071 }
1072
1073 return true;
1074}
1075
1076bool WebRtcVideoChannel2::RemoveSendStream(uint32 ssrc) {
1077 LOG(LS_INFO) << "RemoveSendStream: " << ssrc;
1078
1079 if (ssrc == 0) {
1080 if (default_send_ssrc_ == 0) {
1081 LOG(LS_ERROR) << "No default send stream active.";
1082 return false;
1083 }
1084
1085 LOG(LS_VERBOSE) << "Removing default stream: " << default_send_ssrc_;
1086 ssrc = default_send_ssrc_;
1087 }
1088
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001089 WebRtcVideoSendStream* removed_stream;
1090 {
1091 rtc::CritScope stream_lock(&stream_crit_);
1092 std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1093 send_streams_.find(ssrc);
1094 if (it == send_streams_.end()) {
1095 return false;
1096 }
1097
Peter Boströmd6f4c252015-03-26 16:23:04 +01001098 for (uint32 old_ssrc : it->second->GetSsrcs())
1099 send_ssrcs_.erase(old_ssrc);
1100
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001101 removed_stream = it->second;
1102 send_streams_.erase(it);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001103 }
1104
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001105 delete removed_stream;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001106
1107 if (ssrc == default_send_ssrc_) {
1108 default_send_ssrc_ = 0;
1109 }
1110
1111 return true;
1112}
1113
Peter Boströmd6f4c252015-03-26 16:23:04 +01001114void WebRtcVideoChannel2::DeleteReceiveStream(
1115 WebRtcVideoChannel2::WebRtcVideoReceiveStream* stream) {
1116 for (uint32 old_ssrc : stream->GetSsrcs())
1117 receive_ssrcs_.erase(old_ssrc);
1118 delete stream;
1119}
1120
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001121bool WebRtcVideoChannel2::AddRecvStream(const StreamParams& sp) {
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00001122 return AddRecvStream(sp, false);
1123}
1124
1125bool WebRtcVideoChannel2::AddRecvStream(const StreamParams& sp,
1126 bool default_stream) {
Fredrik Solenberg4b60c732015-05-07 14:07:48 +02001127 DCHECK(thread_checker_.CalledOnValidThread());
1128
Peter Boströmd4362cd2015-03-25 14:17:23 +01001129 LOG(LS_INFO) << "AddRecvStream" << (default_stream ? " (default stream)" : "")
1130 << ": " << sp.ToString();
1131 if (!ValidateStreamParams(sp))
1132 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001133
1134 uint32 ssrc = sp.first_ssrc();
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +02001135 DCHECK(ssrc != 0); // TODO(pbos): Is this ever valid?
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001136
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001137 rtc::CritScope stream_lock(&stream_crit_);
Peter Boströmd6f4c252015-03-26 16:23:04 +01001138 // Remove running stream if this was a default stream.
1139 auto prev_stream = receive_streams_.find(ssrc);
1140 if (prev_stream != receive_streams_.end()) {
1141 if (default_stream || !prev_stream->second->IsDefaultStream()) {
1142 LOG(LS_ERROR) << "Receive stream for SSRC '" << ssrc
1143 << "' already exists.";
1144 return false;
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00001145 }
Peter Boströmd6f4c252015-03-26 16:23:04 +01001146 DeleteReceiveStream(prev_stream->second);
1147 receive_streams_.erase(prev_stream);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001148 }
1149
Peter Boströmd6f4c252015-03-26 16:23:04 +01001150 if (!ValidateReceiveSsrcAvailability(sp))
1151 return false;
1152
1153 for (uint32 used_ssrc : sp.ssrcs)
1154 receive_ssrcs_.insert(used_ssrc);
1155
pbos@webrtc.orgbd249bc2014-07-07 04:45:15 +00001156 webrtc::VideoReceiveStream::Config config;
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001157 ConfigureReceiverRtp(&config, sp);
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +00001158
pbos8fc7fa72015-07-15 08:02:58 -07001159 // Set up A/V sync group based on sync label.
1160 config.sync_group = sp.sync_label;
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +00001161
Peter Boström126c03e2015-05-11 12:48:12 +02001162 config.rtp.remb = false;
1163 VideoCodecSettings send_codec;
1164 if (send_codec_.Get(&send_codec)) {
1165 config.rtp.remb = HasRemb(send_codec.codec);
1166 }
1167
Peter Boströmd6f4c252015-03-26 16:23:04 +01001168 receive_streams_[ssrc] = new WebRtcVideoReceiveStream(
Peter Boström259bd202015-05-28 13:39:50 +02001169 call_.get(), sp, external_decoder_factory_, default_stream, config,
Peter Boströmd6f4c252015-03-26 16:23:04 +01001170 recv_codecs_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001171
1172 return true;
1173}
1174
1175void WebRtcVideoChannel2::ConfigureReceiverRtp(
1176 webrtc::VideoReceiveStream::Config* config,
1177 const StreamParams& sp) const {
1178 uint32 ssrc = sp.first_ssrc();
1179
1180 config->rtp.remote_ssrc = ssrc;
1181 config->rtp.local_ssrc = rtcp_receiver_report_ssrc_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001182
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001183 config->rtp.extensions = recv_rtp_extensions_;
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001184
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001185 // TODO(pbos): This protection is against setting the same local ssrc as
1186 // remote which is not permitted by the lower-level API. RTCP requires a
1187 // corresponding sender SSRC. Figure out what to do when we don't have
1188 // (receive-only) or know a good local SSRC.
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001189 if (config->rtp.remote_ssrc == config->rtp.local_ssrc) {
1190 if (config->rtp.local_ssrc != kDefaultRtcpReceiverReportSsrc) {
1191 config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001192 } else {
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001193 config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc + 1;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001194 }
1195 }
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001196
1197 for (size_t i = 0; i < recv_codecs_.size(); ++i) {
andresp@webrtc.org82775b12014-11-07 09:37:54 +00001198 MergeFecConfig(recv_codecs_[i].fec, &config->rtp.fec);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001199 }
1200
andresp@webrtc.org82775b12014-11-07 09:37:54 +00001201 for (size_t i = 0; i < recv_codecs_.size(); ++i) {
1202 uint32 rtx_ssrc;
1203 if (recv_codecs_[i].rtx_payload_type != -1 &&
1204 sp.GetFidSsrc(ssrc, &rtx_ssrc)) {
1205 webrtc::VideoReceiveStream::Config::Rtp::Rtx& rtx =
1206 config->rtp.rtx[recv_codecs_[i].codec.id];
1207 rtx.ssrc = rtx_ssrc;
1208 rtx.payload_type = recv_codecs_[i].rtx_payload_type;
1209 }
1210 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001211}
1212
1213bool WebRtcVideoChannel2::RemoveRecvStream(uint32 ssrc) {
1214 LOG(LS_INFO) << "RemoveRecvStream: " << ssrc;
1215 if (ssrc == 0) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001216 LOG(LS_ERROR) << "RemoveRecvStream with 0 ssrc is not supported.";
1217 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001218 }
1219
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001220 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001221 std::map<uint32, WebRtcVideoReceiveStream*>::iterator stream =
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001222 receive_streams_.find(ssrc);
1223 if (stream == receive_streams_.end()) {
1224 LOG(LS_ERROR) << "Stream not found for ssrc: " << ssrc;
1225 return false;
1226 }
Peter Boströmd6f4c252015-03-26 16:23:04 +01001227 DeleteReceiveStream(stream->second);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001228 receive_streams_.erase(stream);
1229
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001230 return true;
1231}
1232
1233bool WebRtcVideoChannel2::SetRenderer(uint32 ssrc, VideoRenderer* renderer) {
1234 LOG(LS_INFO) << "SetRenderer: ssrc:" << ssrc << " "
1235 << (renderer ? "(ptr)" : "NULL");
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001236 if (ssrc == 0) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001237 default_unsignalled_ssrc_handler_.SetDefaultRenderer(this, renderer);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001238 return true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001239 }
1240
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001241 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001242 std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
1243 receive_streams_.find(ssrc);
1244 if (it == receive_streams_.end()) {
1245 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001246 }
1247
1248 it->second->SetRenderer(renderer);
1249 return true;
1250}
1251
1252bool WebRtcVideoChannel2::GetRenderer(uint32 ssrc, VideoRenderer** renderer) {
1253 if (ssrc == 0) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001254 *renderer = default_unsignalled_ssrc_handler_.GetDefaultRenderer();
1255 return *renderer != NULL;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001256 }
1257
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001258 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001259 std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
1260 receive_streams_.find(ssrc);
1261 if (it == receive_streams_.end()) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001262 return false;
1263 }
1264 *renderer = it->second->GetRenderer();
1265 return true;
1266}
1267
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00001268bool WebRtcVideoChannel2::GetStats(VideoMediaInfo* info) {
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001269 info->Clear();
1270 FillSenderStats(info);
1271 FillReceiverStats(info);
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00001272 webrtc::Call::Stats stats = call_->GetStats();
1273 FillBandwidthEstimationStats(stats, info);
1274 if (stats.rtt_ms != -1) {
1275 for (size_t i = 0; i < info->senders.size(); ++i) {
1276 info->senders[i].rtt_ms = stats.rtt_ms;
1277 }
1278 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001279 return true;
1280}
1281
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001282void WebRtcVideoChannel2::FillSenderStats(VideoMediaInfo* video_media_info) {
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001283 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001284 for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1285 send_streams_.begin();
1286 it != send_streams_.end();
1287 ++it) {
1288 video_media_info->senders.push_back(it->second->GetVideoSenderInfo());
1289 }
1290}
1291
1292void WebRtcVideoChannel2::FillReceiverStats(VideoMediaInfo* video_media_info) {
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001293 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001294 for (std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
1295 receive_streams_.begin();
1296 it != receive_streams_.end();
1297 ++it) {
1298 video_media_info->receivers.push_back(it->second->GetVideoReceiverInfo());
1299 }
1300}
1301
1302void WebRtcVideoChannel2::FillBandwidthEstimationStats(
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00001303 const webrtc::Call::Stats& stats,
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001304 VideoMediaInfo* video_media_info) {
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001305 BandwidthEstimationInfo bwe_info;
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001306 bwe_info.available_send_bandwidth = stats.send_bandwidth_bps;
1307 bwe_info.available_recv_bandwidth = stats.recv_bandwidth_bps;
1308 bwe_info.bucket_delay = stats.pacer_delay_ms;
1309
1310 // Get send stream bitrate stats.
1311 rtc::CritScope stream_lock(&stream_crit_);
1312 for (std::map<uint32, WebRtcVideoSendStream*>::iterator stream =
1313 send_streams_.begin();
1314 stream != send_streams_.end();
1315 ++stream) {
1316 stream->second->FillBandwidthEstimationInfo(&bwe_info);
1317 }
1318 video_media_info->bw_estimations.push_back(bwe_info);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001319}
1320
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001321bool WebRtcVideoChannel2::SetCapturer(uint32 ssrc, VideoCapturer* capturer) {
1322 LOG(LS_INFO) << "SetCapturer: " << ssrc << " -> "
1323 << (capturer != NULL ? "(capturer)" : "NULL");
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +02001324 DCHECK(ssrc != 0);
Peter Boströme7b221f2015-04-13 15:34:32 +02001325 {
1326 rtc::CritScope stream_lock(&stream_crit_);
1327 if (send_streams_.find(ssrc) == send_streams_.end()) {
1328 LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc;
1329 return false;
1330 }
1331 if (!send_streams_[ssrc]->SetCapturer(capturer)) {
1332 return false;
1333 }
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001334 }
1335
1336 if (capturer) {
1337 capturer->SetApplyRotation(
1338 !FindHeaderExtension(send_rtp_extensions_,
1339 kRtpVideoRotationHeaderExtension));
1340 }
Peter Boströme7b221f2015-04-13 15:34:32 +02001341 {
1342 rtc::CritScope lock(&capturer_crit_);
1343 capturers_[ssrc] = capturer;
1344 }
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001345 return true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001346}
1347
1348bool WebRtcVideoChannel2::SendIntraFrame() {
1349 // TODO(pbos): Implement.
1350 LOG(LS_VERBOSE) << "SendIntraFrame().";
1351 return true;
1352}
1353
1354bool WebRtcVideoChannel2::RequestIntraFrame() {
1355 // TODO(pbos): Implement.
1356 LOG(LS_VERBOSE) << "SendIntraFrame().";
1357 return true;
1358}
1359
1360void WebRtcVideoChannel2::OnPacketReceived(
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001361 rtc::Buffer* packet,
1362 const rtc::PacketTime& packet_time) {
pbos@webrtc.org4e545cc2014-05-14 13:58:13 +00001363 const webrtc::PacketReceiver::DeliveryStatus delivery_result =
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +02001364 call_->Receiver()->DeliverPacket(webrtc::MediaType::VIDEO,
kwiberg@webrtc.orgeebcab52015-03-24 09:19:06 +00001365 reinterpret_cast<const uint8_t*>(packet->data()), packet->size());
pbos@webrtc.org4e545cc2014-05-14 13:58:13 +00001366 switch (delivery_result) {
1367 case webrtc::PacketReceiver::DELIVERY_OK:
1368 return;
1369 case webrtc::PacketReceiver::DELIVERY_PACKET_ERROR:
1370 return;
1371 case webrtc::PacketReceiver::DELIVERY_UNKNOWN_SSRC:
1372 break;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001373 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001374
1375 uint32 ssrc = 0;
kwiberg@webrtc.orgeebcab52015-03-24 09:19:06 +00001376 if (!GetRtpSsrc(packet->data(), packet->size(), &ssrc)) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001377 return;
1378 }
1379
noahricd10a68e2015-07-10 11:27:55 -07001380 int payload_type = 0;
1381 if (!GetRtpPayloadType(packet->data(), packet->size(), &payload_type)) {
1382 return;
1383 }
1384
1385 // See if this payload_type is registered as one that usually gets its own
1386 // SSRC (RTX) or at least is safe to drop either way (ULPFEC). If it is, and
1387 // it wasn't handled above by DeliverPacket, that means we don't know what
1388 // stream it associates with, and we shouldn't ever create an implicit channel
1389 // for these.
1390 for (auto& codec : recv_codecs_) {
1391 if (payload_type == codec.rtx_payload_type ||
1392 payload_type == codec.fec.red_rtx_payload_type ||
1393 payload_type == codec.fec.ulpfec_payload_type) {
1394 return;
1395 }
1396 }
1397
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001398 switch (unsignalled_ssrc_handler_->OnUnsignalledSsrc(this, ssrc)) {
1399 case UnsignalledSsrcHandler::kDropPacket:
1400 return;
1401 case UnsignalledSsrcHandler::kDeliverPacket:
1402 break;
1403 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001404
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +02001405 if (call_->Receiver()->DeliverPacket(webrtc::MediaType::VIDEO,
kwiberg@webrtc.orgeebcab52015-03-24 09:19:06 +00001406 reinterpret_cast<const uint8_t*>(packet->data()), packet->size()) !=
pbos@webrtc.org1e019d12014-05-16 11:38:45 +00001407 webrtc::PacketReceiver::DELIVERY_OK) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001408 LOG(LS_WARNING) << "Failed to deliver RTP packet on re-delivery.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001409 return;
1410 }
1411}
1412
1413void WebRtcVideoChannel2::OnRtcpReceived(
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001414 rtc::Buffer* packet,
1415 const rtc::PacketTime& packet_time) {
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +02001416 if (call_->Receiver()->DeliverPacket(webrtc::MediaType::VIDEO,
kwiberg@webrtc.orgeebcab52015-03-24 09:19:06 +00001417 reinterpret_cast<const uint8_t*>(packet->data()), packet->size()) !=
pbos@webrtc.org1e019d12014-05-16 11:38:45 +00001418 webrtc::PacketReceiver::DELIVERY_OK) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001419 LOG(LS_WARNING) << "Failed to deliver RTCP packet.";
1420 }
1421}
1422
1423void WebRtcVideoChannel2::OnReadyToSend(bool ready) {
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00001424 LOG(LS_VERBOSE) << "OnReadyToSend: " << (ready ? "Ready." : "Not ready.");
Jelena Marusiccd670222015-07-16 09:30:09 +02001425 call_->SignalNetworkState(ready ? webrtc::kNetworkUp : webrtc::kNetworkDown);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001426}
1427
1428bool WebRtcVideoChannel2::MuteStream(uint32 ssrc, bool mute) {
1429 LOG(LS_VERBOSE) << "MuteStream: " << ssrc << " -> "
1430 << (mute ? "mute" : "unmute");
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +02001431 DCHECK(ssrc != 0);
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001432 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001433 if (send_streams_.find(ssrc) == send_streams_.end()) {
1434 LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc;
1435 return false;
1436 }
pbos@webrtc.orgef8bb8d2014-08-13 21:36:18 +00001437
1438 send_streams_[ssrc]->MuteStream(mute);
1439 return true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001440}
1441
1442bool WebRtcVideoChannel2::SetRecvRtpHeaderExtensions(
1443 const std::vector<RtpHeaderExtension>& extensions) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +00001444 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRecvRtpHeaderExtensions");
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001445 LOG(LS_INFO) << "SetRecvRtpHeaderExtensions: "
1446 << RtpExtensionsToString(extensions);
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001447 if (!ValidateRtpHeaderExtensionIds(extensions))
1448 return false;
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001449
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001450 std::vector<webrtc::RtpExtension> filtered_extensions =
1451 FilterRtpExtensions(extensions);
1452 if (!RtpExtensionsHaveChanged(recv_rtp_extensions_, filtered_extensions))
1453 return true;
1454
1455 recv_rtp_extensions_ = filtered_extensions;
1456
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001457 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001458 for (std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
1459 receive_streams_.begin();
1460 it != receive_streams_.end();
1461 ++it) {
1462 it->second->SetRtpExtensions(recv_rtp_extensions_);
1463 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001464 return true;
1465}
1466
1467bool WebRtcVideoChannel2::SetSendRtpHeaderExtensions(
1468 const std::vector<RtpHeaderExtension>& extensions) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +00001469 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetSendRtpHeaderExtensions");
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001470 LOG(LS_INFO) << "SetSendRtpHeaderExtensions: "
1471 << RtpExtensionsToString(extensions);
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001472 if (!ValidateRtpHeaderExtensionIds(extensions))
1473 return false;
1474
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001475 std::vector<webrtc::RtpExtension> filtered_extensions =
1476 FilterRtpExtensions(extensions);
1477 if (!RtpExtensionsHaveChanged(send_rtp_extensions_, filtered_extensions))
1478 return true;
1479
1480 send_rtp_extensions_ = filtered_extensions;
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001481
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001482 const webrtc::RtpExtension* cvo_extension = FindHeaderExtension(
1483 send_rtp_extensions_, kRtpVideoRotationHeaderExtension);
1484
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001485 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001486 for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1487 send_streams_.begin();
1488 it != send_streams_.end();
1489 ++it) {
1490 it->second->SetRtpExtensions(send_rtp_extensions_);
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001491 it->second->SetApplyRotation(!cvo_extension);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001492 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001493 return true;
1494}
1495
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001496// Counter-intuitively this method doesn't only set global bitrate caps but also
1497// per-stream codec max bitrates. This is to permit SetMaxSendBitrate (b=AS) to
1498// raise bitrates above the 2000k default bitrate cap.
pbos@webrtc.org00873182014-11-25 14:03:34 +00001499bool WebRtcVideoChannel2::SetMaxSendBandwidth(int max_bitrate_bps) {
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001500 // TODO(pbos): Figure out whether b=AS means max bitrate for this
1501 // WebRtcVideoChannel2 (in which case we're good), or per sender (SSRC), in
1502 // which case this should not set a Call::BitrateConfig but rather reconfigure
1503 // all senders.
pbos@webrtc.org00873182014-11-25 14:03:34 +00001504 LOG(LS_INFO) << "SetMaxSendBandwidth: " << max_bitrate_bps << "bps.";
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001505 if (max_bitrate_bps == bitrate_config_.max_bitrate_bps)
1506 return true;
1507
pbos@webrtc.org00873182014-11-25 14:03:34 +00001508 if (max_bitrate_bps <= 0) {
1509 // Unsetting max bitrate.
1510 max_bitrate_bps = -1;
1511 }
1512 bitrate_config_.start_bitrate_bps = -1;
1513 bitrate_config_.max_bitrate_bps = max_bitrate_bps;
1514 if (max_bitrate_bps > 0 &&
1515 bitrate_config_.min_bitrate_bps > max_bitrate_bps) {
1516 bitrate_config_.min_bitrate_bps = max_bitrate_bps;
1517 }
1518 call_->SetBitrateConfig(bitrate_config_);
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001519 rtc::CritScope stream_lock(&stream_crit_);
1520 for (auto& kv : send_streams_)
1521 kv.second->SetMaxBitrateBps(max_bitrate_bps);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001522 return true;
1523}
1524
1525bool WebRtcVideoChannel2::SetOptions(const VideoOptions& options) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +00001526 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetOptions");
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001527 LOG(LS_INFO) << "SetOptions: " << options.ToString();
1528 VideoOptions old_options = options_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001529 options_.SetAll(options);
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001530 if (options_ == old_options) {
1531 // No new options to set.
1532 return true;
1533 }
Peter Boströme7b221f2015-04-13 15:34:32 +02001534 {
1535 rtc::CritScope lock(&capturer_crit_);
1536 options_.cpu_overuse_detection.Get(&signal_cpu_adaptation_);
1537 }
pbos@webrtc.orgd8198032014-11-10 14:41:43 +00001538 rtc::DiffServCodePoint dscp = options_.dscp.GetWithDefaultIfUnset(false)
1539 ? rtc::DSCP_AF41
1540 : rtc::DSCP_DEFAULT;
1541 MediaChannel::SetDscp(dscp);
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001542 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001543 for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1544 send_streams_.begin();
1545 it != send_streams_.end();
1546 ++it) {
1547 it->second->SetOptions(options_);
1548 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001549 return true;
1550}
1551
1552void WebRtcVideoChannel2::SetInterface(NetworkInterface* iface) {
1553 MediaChannel::SetInterface(iface);
1554 // Set the RTP recv/send buffer to a bigger size
1555 MediaChannel::SetOption(NetworkInterface::ST_RTP,
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001556 rtc::Socket::OPT_RCVBUF,
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001557 kVideoRtpBufferSize);
1558
buildbot@webrtc.orgae694ef2014-10-28 17:37:17 +00001559 // Speculative change to increase the outbound socket buffer size.
1560 // In b/15152257, we are seeing a significant number of packets discarded
1561 // due to lack of socket buffer space, although it's not yet clear what the
1562 // ideal value should be.
1563 MediaChannel::SetOption(NetworkInterface::ST_RTP,
1564 rtc::Socket::OPT_SNDBUF,
1565 kVideoRtpBufferSize);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001566}
1567
1568void WebRtcVideoChannel2::UpdateAspectRatio(int ratio_w, int ratio_h) {
1569 // TODO(pbos): Implement.
1570}
1571
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001572void WebRtcVideoChannel2::OnMessage(rtc::Message* msg) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001573 // Ignored.
1574}
1575
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001576void WebRtcVideoChannel2::OnLoadUpdate(Load load) {
Peter Boströme7b221f2015-04-13 15:34:32 +02001577 // OnLoadUpdate can not take any locks that are held while creating streams
1578 // etc. Doing so establishes lock-order inversions between the webrtc process
1579 // thread on stream creation and locks such as stream_crit_ while calling out.
1580 rtc::CritScope stream_lock(&capturer_crit_);
1581 if (!signal_cpu_adaptation_)
1582 return;
Erik Språngefbde372015-04-29 16:21:28 +02001583 // Do not adapt resolution for screen content as this will likely result in
1584 // blurry and unreadable text.
Peter Boströme7b221f2015-04-13 15:34:32 +02001585 for (auto& kv : capturers_) {
Erik Språngefbde372015-04-29 16:21:28 +02001586 if (kv.second != nullptr
1587 && !kv.second->IsScreencast()
1588 && kv.second->video_adapter() != nullptr) {
Peter Boströme7b221f2015-04-13 15:34:32 +02001589 kv.second->video_adapter()->OnCpuResolutionRequest(
1590 load == kOveruse ? CoordinatedVideoAdapter::DOWNGRADE
1591 : CoordinatedVideoAdapter::UPGRADE);
1592 }
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001593 }
1594}
1595
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001596bool WebRtcVideoChannel2::SendRtp(const uint8_t* data, size_t len) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001597 rtc::Buffer packet(data, len, kMaxRtpPacketLen);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001598 return MediaChannel::SendPacket(&packet);
1599}
1600
1601bool WebRtcVideoChannel2::SendRtcp(const uint8_t* data, size_t len) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001602 rtc::Buffer packet(data, len, kMaxRtpPacketLen);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001603 return MediaChannel::SendRtcp(&packet);
1604}
1605
1606void WebRtcVideoChannel2::StartAllSendStreams() {
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001607 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001608 for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1609 send_streams_.begin();
1610 it != send_streams_.end();
1611 ++it) {
1612 it->second->Start();
1613 }
1614}
1615
1616void WebRtcVideoChannel2::StopAllSendStreams() {
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001617 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001618 for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1619 send_streams_.begin();
1620 it != send_streams_.end();
1621 ++it) {
1622 it->second->Stop();
1623 }
1624}
1625
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001626WebRtcVideoChannel2::WebRtcVideoSendStream::VideoSendStreamParameters::
1627 VideoSendStreamParameters(
1628 const webrtc::VideoSendStream::Config& config,
1629 const VideoOptions& options,
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001630 int max_bitrate_bps,
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001631 const Settable<VideoCodecSettings>& codec_settings)
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001632 : config(config),
1633 options(options),
1634 max_bitrate_bps(max_bitrate_bps),
1635 codec_settings(codec_settings) {
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001636}
1637
Peter Boström4d71ede2015-05-19 23:09:35 +02001638WebRtcVideoChannel2::WebRtcVideoSendStream::AllocatedEncoder::AllocatedEncoder(
1639 webrtc::VideoEncoder* encoder,
1640 webrtc::VideoCodecType type,
1641 bool external)
1642 : encoder(encoder),
1643 external_encoder(nullptr),
1644 type(type),
1645 external(external) {
1646 if (external) {
1647 external_encoder = encoder;
1648 this->encoder =
1649 new webrtc::VideoEncoderSoftwareFallbackWrapper(type, encoder);
1650 }
1651}
1652
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001653WebRtcVideoChannel2::WebRtcVideoSendStream::WebRtcVideoSendStream(
1654 webrtc::Call* call,
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001655 WebRtcVideoEncoderFactory* external_encoder_factory,
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001656 const VideoOptions& options,
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001657 int max_bitrate_bps,
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001658 const Settable<VideoCodecSettings>& codec_settings,
1659 const StreamParams& sp,
1660 const std::vector<webrtc::RtpExtension>& rtp_extensions)
Henrik Kjellander7c027b62015-04-22 13:21:30 +02001661 : ssrcs_(sp.ssrcs),
Peter Boström259bd202015-05-28 13:39:50 +02001662 ssrc_groups_(sp.ssrc_groups),
Henrik Kjellander7c027b62015-04-22 13:21:30 +02001663 call_(call),
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001664 external_encoder_factory_(external_encoder_factory),
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001665 stream_(NULL),
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001666 parameters_(webrtc::VideoSendStream::Config(),
1667 options,
1668 max_bitrate_bps,
1669 codec_settings),
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001670 allocated_encoder_(NULL, webrtc::kVideoCodecUnknown, false),
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +00001671 capturer_(NULL),
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001672 sending_(false),
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00001673 muted_(false),
qiangchenc27d89f2015-07-16 10:27:16 -07001674 old_adapt_changes_(0),
1675 first_frame_timestamp_ms_(0),
1676 last_frame_timestamp_ms_(0) {
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001677 parameters_.config.rtp.max_packet_size = kVideoMtu;
1678
1679 sp.GetPrimarySsrcs(&parameters_.config.rtp.ssrcs);
1680 sp.GetFidSsrcs(parameters_.config.rtp.ssrcs,
1681 &parameters_.config.rtp.rtx.ssrcs);
1682 parameters_.config.rtp.c_name = sp.cname;
1683 parameters_.config.rtp.extensions = rtp_extensions;
1684
1685 VideoCodecSettings params;
1686 if (codec_settings.Get(&params)) {
1687 SetCodec(params);
1688 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001689}
1690
1691WebRtcVideoChannel2::WebRtcVideoSendStream::~WebRtcVideoSendStream() {
1692 DisconnectCapturer();
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001693 if (stream_ != NULL) {
1694 call_->DestroyVideoSendStream(stream_);
1695 }
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001696 DestroyVideoEncoder(&allocated_encoder_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001697}
1698
Miguel Casas-Sanchez47650702015-05-29 17:21:40 -07001699static void CreateBlackFrame(webrtc::VideoFrame* video_frame,
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001700 int width,
1701 int height) {
pbos@webrtc.orgb4987bf2015-02-18 10:13:09 +00001702 video_frame->CreateEmptyFrame(width, height, width, (width + 1) / 2,
1703 (width + 1) / 2);
1704 memset(video_frame->buffer(webrtc::kYPlane), 16,
1705 video_frame->allocated_size(webrtc::kYPlane));
1706 memset(video_frame->buffer(webrtc::kUPlane), 128,
1707 video_frame->allocated_size(webrtc::kUPlane));
1708 memset(video_frame->buffer(webrtc::kVPlane), 128,
1709 video_frame->allocated_size(webrtc::kVPlane));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001710}
1711
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001712void WebRtcVideoChannel2::WebRtcVideoSendStream::InputFrame(
1713 VideoCapturer* capturer,
1714 const VideoFrame* frame) {
pbos@webrtc.org86196c42015-02-16 21:02:00 +00001715 TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::InputFrame");
Miguel Casas-Sanchez47650702015-05-29 17:21:40 -07001716 webrtc::VideoFrame video_frame(frame->GetVideoFrameBuffer(), 0, 0,
1717 frame->GetVideoRotation());
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001718 rtc::CritScope cs(&lock_);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001719 if (stream_ == NULL) {
Peter Boströmad1f9b62015-04-08 14:04:01 +02001720 // Frame input before send codecs are configured, dropping frame.
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001721 return;
1722 }
pbos@webrtc.org86196c42015-02-16 21:02:00 +00001723
1724 // Not sending, abort early to prevent expensive reconfigurations while
1725 // setting up codecs etc.
1726 if (!sending_)
1727 return;
1728
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001729 if (format_.width == 0) { // Dropping frames.
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +02001730 DCHECK(format_.height == 0);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001731 LOG(LS_VERBOSE) << "VideoFormat 0x0 set, Dropping frame.";
1732 return;
1733 }
pbos@webrtc.orgd60d79a2014-09-24 07:10:57 +00001734 if (muted_) {
1735 // Create a black frame to transmit instead.
magjed@webrtc.orgafdd5dd2015-03-12 13:11:25 +00001736 CreateBlackFrame(&video_frame,
pbos@webrtc.orgd60d79a2014-09-24 07:10:57 +00001737 static_cast<int>(frame->GetWidth()),
1738 static_cast<int>(frame->GetHeight()));
1739 }
qiangchenc27d89f2015-07-16 10:27:16 -07001740
1741 int64_t frame_delta_ms = frame->GetTimeStamp() / rtc::kNumNanosecsPerMillisec;
1742 // frame->GetTimeStamp() is essentially a delta, align to webrtc time
1743 if (first_frame_timestamp_ms_ == 0) {
1744 first_frame_timestamp_ms_ = rtc::Time() - frame_delta_ms;
1745 }
1746
1747 last_frame_timestamp_ms_ = first_frame_timestamp_ms_ + frame_delta_ms;
1748 video_frame.set_render_time_ms(last_frame_timestamp_ms_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001749 // Reconfigure codec if necessary.
pbos@webrtc.orgc4175b92014-09-03 15:25:49 +00001750 SetDimensions(
magjed@webrtc.orgafdd5dd2015-03-12 13:11:25 +00001751 video_frame.width(), video_frame.height(), capturer->IsScreencast());
pbos@webrtc.orgc4175b92014-09-03 15:25:49 +00001752
Alex Glazneve433c0e2015-05-01 13:54:19 -07001753 LOG(LS_VERBOSE) << "IncomingCapturedFrame: " << video_frame.width() << "x"
1754 << video_frame.height() << " -> (codec) "
1755 << parameters_.encoder_config.streams.back().width << "x"
1756 << parameters_.encoder_config.streams.back().height;
perkj@webrtc.orgaf612d52015-03-18 09:51:05 +00001757 stream_->Input()->IncomingCapturedFrame(video_frame);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001758}
1759
1760bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetCapturer(
1761 VideoCapturer* capturer) {
pbos@webrtc.orgb4987bf2015-02-18 10:13:09 +00001762 TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::SetCapturer");
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001763 if (!DisconnectCapturer() && capturer == NULL) {
1764 return false;
1765 }
1766
1767 {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001768 rtc::CritScope cs(&lock_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001769
pbos@webrtc.org9359cb32014-07-23 15:44:48 +00001770 if (capturer == NULL) {
1771 if (stream_ != NULL) {
1772 LOG(LS_VERBOSE) << "Disabling capturer, sending black frame.";
Miguel Casas-Sanchez47650702015-05-29 17:21:40 -07001773 webrtc::VideoFrame black_frame;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001774
pbos@webrtc.orgb4987bf2015-02-18 10:13:09 +00001775 CreateBlackFrame(&black_frame, last_dimensions_.width,
1776 last_dimensions_.height);
qiangchenc27d89f2015-07-16 10:27:16 -07001777
1778 // Force this black frame not to be dropped due to timestamp order
1779 // check. As IncomingCapturedFrame will drop the frame if this frame's
1780 // timestamp is less than or equal to last frame's timestamp, it is
1781 // necessary to give this black frame a larger timestamp than the
1782 // previous one.
1783 last_frame_timestamp_ms_ +=
1784 format_.interval / rtc::kNumNanosecsPerMillisec;
1785 black_frame.set_render_time_ms(last_frame_timestamp_ms_);
perkj@webrtc.orgaf612d52015-03-18 09:51:05 +00001786 stream_->Input()->IncomingCapturedFrame(black_frame);
pbos@webrtc.org9359cb32014-07-23 15:44:48 +00001787 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001788
1789 capturer_ = NULL;
1790 return true;
1791 }
1792
1793 capturer_ = capturer;
1794 }
1795 // Lock cannot be held while connecting the capturer to prevent lock-order
1796 // violations.
1797 capturer->SignalVideoFrame.connect(this, &WebRtcVideoSendStream::InputFrame);
1798 return true;
1799}
1800
1801bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetVideoFormat(
1802 const VideoFormat& format) {
1803 if ((format.width == 0 || format.height == 0) &&
1804 format.width != format.height) {
1805 LOG(LS_ERROR) << "Can't set VideoFormat, width or height is zero (but not "
1806 "both, 0x0 drops frames).";
1807 return false;
1808 }
1809
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001810 rtc::CritScope cs(&lock_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001811 if (format.width == 0 && format.height == 0) {
1812 LOG(LS_INFO)
1813 << "0x0 resolution selected. Captured frames will be dropped for ssrc: "
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001814 << parameters_.config.rtp.ssrcs[0] << ".";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001815 } else {
1816 // TODO(pbos): Fix me, this only affects the last stream!
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00001817 parameters_.encoder_config.streams.back().max_framerate =
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001818 VideoFormat::IntervalToFps(format.interval);
pbos@webrtc.orgc4175b92014-09-03 15:25:49 +00001819 SetDimensions(format.width, format.height, false);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001820 }
1821
1822 format_ = format;
1823 return true;
1824}
1825
pbos@webrtc.orgef8bb8d2014-08-13 21:36:18 +00001826void WebRtcVideoChannel2::WebRtcVideoSendStream::MuteStream(bool mute) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001827 rtc::CritScope cs(&lock_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001828 muted_ = mute;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001829}
1830
1831bool WebRtcVideoChannel2::WebRtcVideoSendStream::DisconnectCapturer() {
pbos@webrtc.org963b9792014-10-07 14:27:27 +00001832 cricket::VideoCapturer* capturer;
1833 {
1834 rtc::CritScope cs(&lock_);
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00001835 if (capturer_ == NULL)
pbos@webrtc.org963b9792014-10-07 14:27:27 +00001836 return false;
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00001837
1838 if (capturer_->video_adapter() != nullptr)
1839 old_adapt_changes_ += capturer_->video_adapter()->adaptation_changes();
1840
pbos@webrtc.org963b9792014-10-07 14:27:27 +00001841 capturer = capturer_;
1842 capturer_ = NULL;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001843 }
pbos@webrtc.org963b9792014-10-07 14:27:27 +00001844 capturer->SignalVideoFrame.disconnect(this);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001845 return true;
1846}
1847
Peter Boströmd6f4c252015-03-26 16:23:04 +01001848const std::vector<uint32>&
1849WebRtcVideoChannel2::WebRtcVideoSendStream::GetSsrcs() const {
1850 return ssrcs_;
1851}
1852
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001853void WebRtcVideoChannel2::WebRtcVideoSendStream::SetApplyRotation(
1854 bool apply_rotation) {
1855 rtc::CritScope cs(&lock_);
1856 if (capturer_ == NULL)
1857 return;
1858
1859 capturer_->SetApplyRotation(apply_rotation);
1860}
1861
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001862void WebRtcVideoChannel2::WebRtcVideoSendStream::SetOptions(
1863 const VideoOptions& options) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001864 rtc::CritScope cs(&lock_);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001865 VideoCodecSettings codec_settings;
1866 if (parameters_.codec_settings.Get(&codec_settings)) {
1867 SetCodecAndOptions(codec_settings, options);
1868 } else {
1869 parameters_.options = options;
1870 }
1871}
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001872
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001873void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodec(
1874 const VideoCodecSettings& codec_settings) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001875 rtc::CritScope cs(&lock_);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001876 SetCodecAndOptions(codec_settings, parameters_.options);
1877}
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001878
1879webrtc::VideoCodecType CodecTypeFromName(const std::string& name) {
Shao Changbine62202f2015-04-21 20:24:50 +08001880 if (CodecNamesEq(name, kVp8CodecName)) {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001881 return webrtc::kVideoCodecVP8;
Shao Changbine62202f2015-04-21 20:24:50 +08001882 } else if (CodecNamesEq(name, kVp9CodecName)) {
andresp@webrtc.org188d3b22014-11-07 13:21:04 +00001883 return webrtc::kVideoCodecVP9;
Shao Changbine62202f2015-04-21 20:24:50 +08001884 } else if (CodecNamesEq(name, kH264CodecName)) {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001885 return webrtc::kVideoCodecH264;
1886 }
1887 return webrtc::kVideoCodecUnknown;
1888}
1889
1890WebRtcVideoChannel2::WebRtcVideoSendStream::AllocatedEncoder
1891WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoder(
1892 const VideoCodec& codec) {
1893 webrtc::VideoCodecType type = CodecTypeFromName(codec.name);
1894
1895 // Do not re-create encoders of the same type.
1896 if (type == allocated_encoder_.type && allocated_encoder_.encoder != NULL) {
1897 return allocated_encoder_;
1898 }
1899
1900 if (external_encoder_factory_ != NULL) {
1901 webrtc::VideoEncoder* encoder =
1902 external_encoder_factory_->CreateVideoEncoder(type);
1903 if (encoder != NULL) {
1904 return AllocatedEncoder(encoder, type, true);
1905 }
1906 }
1907
1908 if (type == webrtc::kVideoCodecVP8) {
1909 return AllocatedEncoder(
1910 webrtc::VideoEncoder::Create(webrtc::VideoEncoder::kVp8), type, false);
andresp@webrtc.org188d3b22014-11-07 13:21:04 +00001911 } else if (type == webrtc::kVideoCodecVP9) {
1912 return AllocatedEncoder(
1913 webrtc::VideoEncoder::Create(webrtc::VideoEncoder::kVp9), type, false);
Zeke Chin71f6f442015-06-29 14:34:58 -07001914 } else if (type == webrtc::kVideoCodecH264) {
1915 return AllocatedEncoder(
1916 webrtc::VideoEncoder::Create(webrtc::VideoEncoder::kH264), type, false);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001917 }
1918
1919 // This shouldn't happen, we should not be trying to create something we don't
1920 // support.
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +02001921 DCHECK(false);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001922 return AllocatedEncoder(NULL, webrtc::kVideoCodecUnknown, false);
1923}
1924
1925void WebRtcVideoChannel2::WebRtcVideoSendStream::DestroyVideoEncoder(
1926 AllocatedEncoder* encoder) {
1927 if (encoder->external) {
Peter Boström4d71ede2015-05-19 23:09:35 +02001928 external_encoder_factory_->DestroyVideoEncoder(encoder->external_encoder);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001929 }
Peter Boström4d71ede2015-05-19 23:09:35 +02001930 delete encoder->encoder;
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001931}
1932
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001933void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodecAndOptions(
1934 const VideoCodecSettings& codec_settings,
1935 const VideoOptions& options) {
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001936 parameters_.encoder_config =
1937 CreateVideoEncoderConfig(last_dimensions_, codec_settings.codec);
pbos@webrtc.org86196c42015-02-16 21:02:00 +00001938 if (parameters_.encoder_config.streams.empty())
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001939 return;
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001940
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001941 format_ = VideoFormat(codec_settings.codec.width,
1942 codec_settings.codec.height,
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001943 VideoFormat::FpsToInterval(30),
1944 FOURCC_I420);
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001945
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001946 AllocatedEncoder new_encoder = CreateVideoEncoder(codec_settings.codec);
1947 parameters_.config.encoder_settings.encoder = new_encoder.encoder;
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001948 parameters_.config.encoder_settings.payload_name = codec_settings.codec.name;
1949 parameters_.config.encoder_settings.payload_type = codec_settings.codec.id;
1950 parameters_.config.rtp.fec = codec_settings.fec;
1951
1952 // Set RTX payload type if RTX is enabled.
1953 if (!parameters_.config.rtp.rtx.ssrcs.empty()) {
pbos@webrtc.orgb9557a92015-03-20 19:52:56 +00001954 if (codec_settings.rtx_payload_type == -1) {
1955 LOG(LS_WARNING) << "RTX SSRCs configured but there's no configured RTX "
1956 "payload type. Ignoring.";
1957 parameters_.config.rtp.rtx.ssrcs.clear();
1958 } else {
1959 parameters_.config.rtp.rtx.payload_type = codec_settings.rtx_payload_type;
1960 }
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001961 }
1962
Peter Boström67c9df72015-05-11 14:34:58 +02001963 parameters_.config.rtp.nack.rtp_history_ms =
1964 HasNack(codec_settings.codec) ? kNackHistoryMs : 0;
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001965
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00001966 options.suspend_below_min_bitrate.Get(
1967 &parameters_.config.suspend_below_min_bitrate);
1968
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001969 parameters_.codec_settings.Set(codec_settings);
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001970 parameters_.options = options;
pbos@webrtc.org543e5892014-07-23 07:01:31 +00001971
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001972 RecreateWebRtcStream();
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001973 if (allocated_encoder_.encoder != new_encoder.encoder) {
1974 DestroyVideoEncoder(&allocated_encoder_);
1975 allocated_encoder_ = new_encoder;
1976 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001977}
1978
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001979void WebRtcVideoChannel2::WebRtcVideoSendStream::SetRtpExtensions(
1980 const std::vector<webrtc::RtpExtension>& rtp_extensions) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001981 rtc::CritScope cs(&lock_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001982 parameters_.config.rtp.extensions = rtp_extensions;
Peter Boström3c3f6462015-04-15 16:27:49 +02001983 if (stream_ != nullptr)
1984 RecreateWebRtcStream();
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001985}
1986
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001987webrtc::VideoEncoderConfig
1988WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoderConfig(
1989 const Dimensions& dimensions,
1990 const VideoCodec& codec) const {
1991 webrtc::VideoEncoderConfig encoder_config;
1992 if (dimensions.is_screencast) {
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001993 int screencast_min_bitrate_kbps;
1994 parameters_.options.screencast_min_bitrate.Get(
1995 &screencast_min_bitrate_kbps);
1996 encoder_config.min_transmit_bitrate_bps =
1997 screencast_min_bitrate_kbps * 1000;
Erik Språng143cec12015-04-28 10:01:41 +02001998 encoder_config.content_type =
1999 webrtc::VideoEncoderConfig::ContentType::kScreen;
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00002000 } else {
2001 encoder_config.min_transmit_bitrate_bps = 0;
Erik Språng143cec12015-04-28 10:01:41 +02002002 encoder_config.content_type =
2003 webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo;
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00002004 }
2005
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002006 // Restrict dimensions according to codec max.
2007 int width = dimensions.width;
2008 int height = dimensions.height;
2009 if (!dimensions.is_screencast) {
2010 if (codec.width < width)
2011 width = codec.width;
2012 if (codec.height < height)
2013 height = codec.height;
2014 }
2015
2016 VideoCodec clamped_codec = codec;
2017 clamped_codec.width = width;
2018 clamped_codec.height = height;
pbos@webrtc.orgcddd17c2014-09-16 16:33:13 +00002019
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +00002020 encoder_config.streams = CreateVideoStreams(
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002021 clamped_codec, parameters_.options, parameters_.max_bitrate_bps,
Erik Språng143cec12015-04-28 10:01:41 +02002022 dimensions.is_screencast ? 1 : parameters_.config.rtp.ssrcs.size());
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002023
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00002024 // Conference mode screencast uses 2 temporal layers split at 100kbit.
2025 if (parameters_.options.conference_mode.GetWithDefaultIfUnset(false) &&
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002026 dimensions.is_screencast && encoder_config.streams.size() == 1) {
sprang@webrtc.org46d4d292014-12-23 15:19:35 +00002027 ScreenshareLayerConfig config = ScreenshareLayerConfig::GetDefault();
2028
2029 // For screenshare in conference mode, tl0 and tl1 bitrates are piggybacked
2030 // on the VideoCodec struct as target and max bitrates, respectively.
2031 // See eg. webrtc::VP8EncoderImpl::SetRates().
2032 encoder_config.streams[0].target_bitrate_bps =
2033 config.tl0_bitrate_kbps * 1000;
2034 encoder_config.streams[0].max_bitrate_bps = config.tl1_bitrate_kbps * 1000;
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00002035 encoder_config.streams[0].temporal_layer_thresholds_bps.clear();
2036 encoder_config.streams[0].temporal_layer_thresholds_bps.push_back(
sprang@webrtc.org46d4d292014-12-23 15:19:35 +00002037 config.tl0_bitrate_kbps * 1000);
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00002038 }
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002039 return encoder_config;
2040}
2041
2042void WebRtcVideoChannel2::WebRtcVideoSendStream::SetDimensions(
2043 int width,
2044 int height,
2045 bool is_screencast) {
2046 if (last_dimensions_.width == width && last_dimensions_.height == height &&
2047 last_dimensions_.is_screencast == is_screencast) {
2048 // Configured using the same parameters, do not reconfigure.
2049 return;
2050 }
2051 LOG(LS_INFO) << "SetDimensions: " << width << "x" << height
2052 << (is_screencast ? " (screencast)" : " (not screencast)");
2053
2054 last_dimensions_.width = width;
2055 last_dimensions_.height = height;
2056 last_dimensions_.is_screencast = is_screencast;
2057
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +02002058 DCHECK(!parameters_.encoder_config.streams.empty());
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002059
2060 VideoCodecSettings codec_settings;
2061 parameters_.codec_settings.Get(&codec_settings);
2062
2063 webrtc::VideoEncoderConfig encoder_config =
2064 CreateVideoEncoderConfig(last_dimensions_, codec_settings.codec);
2065
Erik Språng143cec12015-04-28 10:01:41 +02002066 encoder_config.encoder_specific_settings = ConfigureVideoEncoderSettings(
2067 codec_settings.codec, parameters_.options, is_screencast);
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00002068
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00002069 bool stream_reconfigured = stream_->ReconfigureVideoEncoder(encoder_config);
2070
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00002071 encoder_config.encoder_specific_settings = NULL;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002072
2073 if (!stream_reconfigured) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002074 LOG(LS_WARNING) << "Failed to reconfigure video encoder for dimensions: "
2075 << width << "x" << height;
2076 return;
2077 }
pbos@webrtc.orgcddd17c2014-09-16 16:33:13 +00002078
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00002079 parameters_.encoder_config = encoder_config;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002080}
2081
2082void WebRtcVideoChannel2::WebRtcVideoSendStream::Start() {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00002083 rtc::CritScope cs(&lock_);
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +02002084 DCHECK(stream_ != NULL);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002085 stream_->Start();
2086 sending_ = true;
2087}
2088
2089void WebRtcVideoChannel2::WebRtcVideoSendStream::Stop() {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00002090 rtc::CritScope cs(&lock_);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00002091 if (stream_ != NULL) {
2092 stream_->Stop();
2093 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002094 sending_ = false;
2095}
2096
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002097VideoSenderInfo
2098WebRtcVideoChannel2::WebRtcVideoSendStream::GetVideoSenderInfo() {
2099 VideoSenderInfo info;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002100 webrtc::VideoSendStream::Stats stats;
2101 {
2102 rtc::CritScope cs(&lock_);
2103 for (uint32_t ssrc : parameters_.config.rtp.ssrcs)
2104 info.add_ssrc(ssrc);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002105
Peter Boström74d9ed72015-03-26 16:28:31 +01002106 VideoCodecSettings codec_settings;
2107 if (parameters_.codec_settings.Get(&codec_settings))
2108 info.codec_name = codec_settings.codec.name;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002109 for (size_t i = 0; i < parameters_.encoder_config.streams.size(); ++i) {
2110 if (i == parameters_.encoder_config.streams.size() - 1) {
2111 info.preferred_bitrate +=
2112 parameters_.encoder_config.streams[i].max_bitrate_bps;
2113 } else {
2114 info.preferred_bitrate +=
2115 parameters_.encoder_config.streams[i].target_bitrate_bps;
2116 }
2117 }
pbos@webrtc.orgc3d2bd22014-08-12 20:55:10 +00002118
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002119 if (stream_ == NULL)
2120 return info;
2121
2122 stats = stream_->GetStats();
2123
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002124 info.adapt_changes = old_adapt_changes_;
2125 info.adapt_reason = CoordinatedVideoAdapter::ADAPTREASON_NONE;
2126
2127 if (capturer_ != NULL) {
2128 if (!capturer_->IsMuted()) {
2129 VideoFormat last_captured_frame_format;
2130 capturer_->GetStats(&info.adapt_frame_drops, &info.effects_frame_drops,
2131 &info.capturer_frame_time,
2132 &last_captured_frame_format);
2133 info.input_frame_width = last_captured_frame_format.width;
2134 info.input_frame_height = last_captured_frame_format.height;
2135 }
2136 if (capturer_->video_adapter() != nullptr) {
2137 info.adapt_changes += capturer_->video_adapter()->adaptation_changes();
2138 info.adapt_reason = capturer_->video_adapter()->adapt_reason();
2139 }
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002140 }
2141 }
Peter Boström259bd202015-05-28 13:39:50 +02002142 info.ssrc_groups = ssrc_groups_;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002143 info.framerate_input = stats.input_frame_rate;
2144 info.framerate_sent = stats.encode_frame_rate;
pbos@webrtc.org3e6e2712015-02-26 12:19:31 +00002145 info.avg_encode_ms = stats.avg_encode_time_ms;
2146 info.encode_usage_percent = stats.encode_usage_percent;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002147
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002148 info.nominal_bitrate = stats.media_bitrate_bps;
2149
pbos@webrtc.org273a4142014-12-01 15:23:21 +00002150 info.send_frame_width = 0;
2151 info.send_frame_height = 0;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002152 for (std::map<uint32_t, webrtc::VideoSendStream::StreamStats>::iterator it =
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002153 stats.substreams.begin();
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002154 it != stats.substreams.end(); ++it) {
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002155 // TODO(pbos): Wire up additional stats, such as padding bytes.
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002156 webrtc::VideoSendStream::StreamStats stream_stats = it->second;
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59 +00002157 info.bytes_sent += stream_stats.rtp_stats.transmitted.payload_bytes +
2158 stream_stats.rtp_stats.transmitted.header_bytes +
2159 stream_stats.rtp_stats.transmitted.padding_bytes;
2160 info.packets_sent += stream_stats.rtp_stats.transmitted.packets;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002161 info.packets_lost += stream_stats.rtcp_stats.cumulative_lost;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002162 if (stream_stats.width > info.send_frame_width)
2163 info.send_frame_width = stream_stats.width;
2164 if (stream_stats.height > info.send_frame_height)
2165 info.send_frame_height = stream_stats.height;
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002166 info.firs_rcvd += stream_stats.rtcp_packet_type_counts.fir_packets;
2167 info.nacks_rcvd += stream_stats.rtcp_packet_type_counts.nack_packets;
2168 info.plis_rcvd += stream_stats.rtcp_packet_type_counts.pli_packets;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002169 }
2170
2171 if (!stats.substreams.empty()) {
2172 // TODO(pbos): Report fraction lost per SSRC.
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002173 webrtc::VideoSendStream::StreamStats first_stream_stats =
2174 stats.substreams.begin()->second;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002175 info.fraction_lost =
2176 static_cast<float>(first_stream_stats.rtcp_stats.fraction_lost) /
2177 (1 << 8);
2178 }
2179
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002180 return info;
2181}
2182
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00002183void WebRtcVideoChannel2::WebRtcVideoSendStream::FillBandwidthEstimationInfo(
2184 BandwidthEstimationInfo* bwe_info) {
2185 rtc::CritScope cs(&lock_);
2186 if (stream_ == NULL) {
2187 return;
2188 }
2189 webrtc::VideoSendStream::Stats stats = stream_->GetStats();
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002190 for (std::map<uint32_t, webrtc::VideoSendStream::StreamStats>::iterator it =
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00002191 stats.substreams.begin();
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002192 it != stats.substreams.end(); ++it) {
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00002193 bwe_info->transmit_bitrate += it->second.total_bitrate_bps;
2194 bwe_info->retransmit_bitrate += it->second.retransmit_bitrate_bps;
2195 }
pbos@webrtc.org891d4832015-02-26 13:15:22 +00002196 bwe_info->target_enc_bitrate += stats.target_media_bitrate_bps;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002197 bwe_info->actual_enc_bitrate += stats.media_bitrate_bps;
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00002198}
2199
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002200void WebRtcVideoChannel2::WebRtcVideoSendStream::SetMaxBitrateBps(
2201 int max_bitrate_bps) {
2202 rtc::CritScope cs(&lock_);
2203 parameters_.max_bitrate_bps = max_bitrate_bps;
2204
2205 // No need to reconfigure if the stream hasn't been configured yet.
2206 if (parameters_.encoder_config.streams.empty())
2207 return;
2208
2209 // Force a stream reconfigure to set the new max bitrate.
2210 int width = last_dimensions_.width;
2211 last_dimensions_.width = 0;
2212 SetDimensions(width, last_dimensions_.height, last_dimensions_.is_screencast);
2213}
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002214
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002215void WebRtcVideoChannel2::WebRtcVideoSendStream::RecreateWebRtcStream() {
2216 if (stream_ != NULL) {
2217 call_->DestroyVideoSendStream(stream_);
2218 }
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00002219
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002220 VideoCodecSettings codec_settings;
2221 parameters_.codec_settings.Get(&codec_settings);
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00002222 parameters_.encoder_config.encoder_specific_settings =
Erik Språng143cec12015-04-28 10:01:41 +02002223 ConfigureVideoEncoderSettings(
2224 codec_settings.codec, parameters_.options,
2225 parameters_.encoder_config.content_type ==
2226 webrtc::VideoEncoderConfig::ContentType::kScreen);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002227
pbos@webrtc.orgb9557a92015-03-20 19:52:56 +00002228 webrtc::VideoSendStream::Config config = parameters_.config;
2229 if (!config.rtp.rtx.ssrcs.empty() && config.rtp.rtx.payload_type == -1) {
2230 LOG(LS_WARNING) << "RTX SSRCs configured but there's no configured RTX "
2231 "payload type the set codec. Ignoring RTX.";
2232 config.rtp.rtx.ssrcs.clear();
2233 }
2234 stream_ = call_->CreateVideoSendStream(config, parameters_.encoder_config);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002235
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00002236 parameters_.encoder_config.encoder_specific_settings = NULL;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002237
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002238 if (sending_) {
2239 stream_->Start();
2240 }
2241}
2242
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002243WebRtcVideoChannel2::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
2244 webrtc::Call* call,
Peter Boström259bd202015-05-28 13:39:50 +02002245 const StreamParams& sp,
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002246 WebRtcVideoDecoderFactory* external_decoder_factory,
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00002247 bool default_stream,
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002248 const webrtc::VideoReceiveStream::Config& config,
2249 const std::vector<VideoCodecSettings>& recv_codecs)
2250 : call_(call),
Peter Boström259bd202015-05-28 13:39:50 +02002251 ssrcs_(sp.ssrcs),
2252 ssrc_groups_(sp.ssrc_groups),
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002253 stream_(NULL),
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00002254 default_stream_(default_stream),
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +00002255 config_(config),
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002256 external_decoder_factory_(external_decoder_factory),
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +00002257 renderer_(NULL),
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002258 last_width_(-1),
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002259 last_height_(-1),
2260 first_frame_timestamp_(-1),
2261 estimated_remote_start_ntp_time_ms_(0) {
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002262 config_.renderer = this;
2263 // SetRecvCodecs will also reset (start) the VideoReceiveStream.
2264 SetRecvCodecs(recv_codecs);
2265}
2266
Peter Boström7252a2b2015-05-18 19:42:03 +02002267WebRtcVideoChannel2::WebRtcVideoReceiveStream::AllocatedDecoder::
2268 AllocatedDecoder(webrtc::VideoDecoder* decoder,
2269 webrtc::VideoCodecType type,
2270 bool external)
2271 : decoder(decoder),
2272 external_decoder(nullptr),
2273 type(type),
2274 external(external) {
2275 if (external) {
2276 external_decoder = decoder;
2277 this->decoder =
2278 new webrtc::VideoDecoderSoftwareFallbackWrapper(type, external_decoder);
2279 }
2280}
2281
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002282WebRtcVideoChannel2::WebRtcVideoReceiveStream::~WebRtcVideoReceiveStream() {
2283 call_->DestroyVideoReceiveStream(stream_);
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002284 ClearDecoders(&allocated_decoders_);
2285}
2286
Peter Boströmd6f4c252015-03-26 16:23:04 +01002287const std::vector<uint32>&
2288WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetSsrcs() const {
2289 return ssrcs_;
2290}
2291
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002292WebRtcVideoChannel2::WebRtcVideoReceiveStream::AllocatedDecoder
2293WebRtcVideoChannel2::WebRtcVideoReceiveStream::CreateOrReuseVideoDecoder(
2294 std::vector<AllocatedDecoder>* old_decoders,
2295 const VideoCodec& codec) {
2296 webrtc::VideoCodecType type = CodecTypeFromName(codec.name);
2297
2298 for (size_t i = 0; i < old_decoders->size(); ++i) {
2299 if ((*old_decoders)[i].type == type) {
2300 AllocatedDecoder decoder = (*old_decoders)[i];
2301 (*old_decoders)[i] = old_decoders->back();
2302 old_decoders->pop_back();
2303 return decoder;
2304 }
2305 }
2306
2307 if (external_decoder_factory_ != NULL) {
2308 webrtc::VideoDecoder* decoder =
2309 external_decoder_factory_->CreateVideoDecoder(type);
2310 if (decoder != NULL) {
2311 return AllocatedDecoder(decoder, type, true);
2312 }
2313 }
2314
2315 if (type == webrtc::kVideoCodecVP8) {
2316 return AllocatedDecoder(
2317 webrtc::VideoDecoder::Create(webrtc::VideoDecoder::kVp8), type, false);
2318 }
2319
pbos@webrtc.orgb9557a92015-03-20 19:52:56 +00002320 if (type == webrtc::kVideoCodecVP9) {
2321 return AllocatedDecoder(
2322 webrtc::VideoDecoder::Create(webrtc::VideoDecoder::kVp9), type, false);
2323 }
2324
Zeke Chin71f6f442015-06-29 14:34:58 -07002325 if (type == webrtc::kVideoCodecH264) {
2326 return AllocatedDecoder(
2327 webrtc::VideoDecoder::Create(webrtc::VideoDecoder::kH264), type, false);
2328 }
2329
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002330 // This shouldn't happen, we should not be trying to create something we don't
2331 // support.
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +02002332 DCHECK(false);
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002333 return AllocatedDecoder(NULL, webrtc::kVideoCodecUnknown, false);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002334}
2335
2336void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRecvCodecs(
2337 const std::vector<VideoCodecSettings>& recv_codecs) {
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002338 std::vector<AllocatedDecoder> old_decoders = allocated_decoders_;
2339 allocated_decoders_.clear();
2340 config_.decoders.clear();
2341 for (size_t i = 0; i < recv_codecs.size(); ++i) {
2342 AllocatedDecoder allocated_decoder =
2343 CreateOrReuseVideoDecoder(&old_decoders, recv_codecs[i].codec);
2344 allocated_decoders_.push_back(allocated_decoder);
2345
2346 webrtc::VideoReceiveStream::Decoder decoder;
2347 decoder.decoder = allocated_decoder.decoder;
2348 decoder.payload_type = recv_codecs[i].codec.id;
2349 decoder.payload_name = recv_codecs[i].codec.name;
2350 config_.decoders.push_back(decoder);
2351 }
2352
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002353 // TODO(pbos): Reconfigure RTX based on incoming recv_codecs.
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002354 config_.rtp.fec = recv_codecs.front().fec;
pbos@webrtc.org257e1302014-07-25 19:01:32 +00002355 config_.rtp.nack.rtp_history_ms =
Shao Changbine62202f2015-04-21 20:24:50 +08002356 HasNack(recv_codecs.begin()->codec) ? kNackHistoryMs : 0;
pbos@webrtc.org257e1302014-07-25 19:01:32 +00002357
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002358 ClearDecoders(&old_decoders);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002359 RecreateWebRtcStream();
2360}
2361
Peter Boström3548dd22015-05-22 18:48:36 +02002362void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetLocalSsrc(
2363 uint32_t local_ssrc) {
2364 // TODO(pbos): Consider turning this sanity check into a DCHECK. You should
2365 // not be able to create a sender with the same SSRC as a receiver, but right
2366 // now this can't be done due to unittests depending on receiving what they
2367 // are sending from the same MediaChannel.
2368 if (local_ssrc == config_.rtp.remote_ssrc)
2369 return;
2370
2371 config_.rtp.local_ssrc = local_ssrc;
2372 RecreateWebRtcStream();
2373}
2374
Peter Boström67c9df72015-05-11 14:34:58 +02002375void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetNackAndRemb(
2376 bool nack_enabled, bool remb_enabled) {
2377 int nack_history_ms = nack_enabled ? kNackHistoryMs : 0;
2378 if (config_.rtp.nack.rtp_history_ms == nack_history_ms &&
2379 config_.rtp.remb == remb_enabled) {
Peter Boström126c03e2015-05-11 12:48:12 +02002380 return;
Peter Boström67c9df72015-05-11 14:34:58 +02002381 }
2382 config_.rtp.remb = remb_enabled;
2383 config_.rtp.nack.rtp_history_ms = nack_history_ms;
Peter Boström126c03e2015-05-11 12:48:12 +02002384 RecreateWebRtcStream();
2385}
2386
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002387void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRtpExtensions(
2388 const std::vector<webrtc::RtpExtension>& extensions) {
2389 config_.rtp.extensions = extensions;
Peter Boström3548dd22015-05-22 18:48:36 +02002390 RecreateWebRtcStream();
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002391}
2392
2393void WebRtcVideoChannel2::WebRtcVideoReceiveStream::RecreateWebRtcStream() {
2394 if (stream_ != NULL) {
2395 call_->DestroyVideoReceiveStream(stream_);
2396 }
2397 stream_ = call_->CreateVideoReceiveStream(config_);
2398 stream_->Start();
2399}
2400
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002401void WebRtcVideoChannel2::WebRtcVideoReceiveStream::ClearDecoders(
2402 std::vector<AllocatedDecoder>* allocated_decoders) {
2403 for (size_t i = 0; i < allocated_decoders->size(); ++i) {
2404 if ((*allocated_decoders)[i].external) {
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002405 external_decoder_factory_->DestroyVideoDecoder(
Peter Boström7252a2b2015-05-18 19:42:03 +02002406 (*allocated_decoders)[i].external_decoder);
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002407 }
Peter Boström7252a2b2015-05-18 19:42:03 +02002408 delete (*allocated_decoders)[i].decoder;
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002409 }
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002410 allocated_decoders->clear();
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002411}
2412
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002413void WebRtcVideoChannel2::WebRtcVideoReceiveStream::RenderFrame(
Miguel Casas-Sanchez47650702015-05-29 17:21:40 -07002414 const webrtc::VideoFrame& frame,
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002415 int time_to_render_ms) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00002416 rtc::CritScope crit(&renderer_lock_);
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002417
2418 if (first_frame_timestamp_ < 0)
2419 first_frame_timestamp_ = frame.timestamp();
2420 int64_t rtp_time_elapsed_since_first_frame =
2421 (timestamp_wraparound_handler_.Unwrap(frame.timestamp()) -
2422 first_frame_timestamp_);
2423 int64_t elapsed_time_ms = rtp_time_elapsed_since_first_frame /
2424 (cricket::kVideoCodecClockrate / 1000);
2425 if (frame.ntp_time_ms() > 0)
2426 estimated_remote_start_ntp_time_ms_ = frame.ntp_time_ms() - elapsed_time_ms;
2427
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002428 if (renderer_ == NULL) {
2429 LOG(LS_WARNING) << "VideoReceiveStream not connected to a VideoRenderer.";
2430 return;
2431 }
2432
2433 if (frame.width() != last_width_ || frame.height() != last_height_) {
2434 SetSize(frame.width(), frame.height());
2435 }
2436
magjed@webrtc.org2386d6d2015-03-05 14:03:08 +00002437 const WebRtcVideoFrame render_frame(
2438 frame.video_frame_buffer(),
2439 elapsed_time_ms * rtc::kNumNanosecsPerMillisec,
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07002440 frame.render_time_ms() * rtc::kNumNanosecsPerMillisec, frame.rotation());
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002441 renderer_->RenderFrame(&render_frame);
2442}
2443
pbos@webrtc.org0d852d52015-02-09 15:14:36 +00002444bool WebRtcVideoChannel2::WebRtcVideoReceiveStream::IsTextureSupported() const {
2445 return true;
2446}
2447
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00002448bool WebRtcVideoChannel2::WebRtcVideoReceiveStream::IsDefaultStream() const {
2449 return default_stream_;
2450}
2451
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002452void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRenderer(
2453 cricket::VideoRenderer* renderer) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00002454 rtc::CritScope crit(&renderer_lock_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002455 renderer_ = renderer;
2456 if (renderer_ != NULL && last_width_ != -1) {
2457 SetSize(last_width_, last_height_);
2458 }
2459}
2460
2461VideoRenderer* WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetRenderer() {
2462 // TODO(pbos): Remove GetRenderer and all uses of it, it's thread-unsafe by
2463 // design.
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00002464 rtc::CritScope crit(&renderer_lock_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002465 return renderer_;
2466}
2467
2468void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetSize(int width,
2469 int height) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00002470 rtc::CritScope crit(&renderer_lock_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002471 if (!renderer_->SetSize(width, height, 0)) {
2472 LOG(LS_ERROR) << "Could not set renderer size.";
2473 }
2474 last_width_ = width;
2475 last_height_ = height;
2476}
2477
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002478VideoReceiverInfo
2479WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetVideoReceiverInfo() {
2480 VideoReceiverInfo info;
Peter Boström259bd202015-05-28 13:39:50 +02002481 info.ssrc_groups = ssrc_groups_;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002482 info.add_ssrc(config_.rtp.remote_ssrc);
2483 webrtc::VideoReceiveStream::Stats stats = stream_->GetStats();
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59 +00002484 info.bytes_rcvd = stats.rtp_stats.transmitted.payload_bytes +
2485 stats.rtp_stats.transmitted.header_bytes +
2486 stats.rtp_stats.transmitted.padding_bytes;
2487 info.packets_rcvd = stats.rtp_stats.transmitted.packets;
Peter Boström393347f2015-04-22 14:52:45 +02002488 info.packets_lost = stats.rtcp_stats.cumulative_lost;
2489 info.fraction_lost =
2490 static_cast<float>(stats.rtcp_stats.fraction_lost) / (1 << 8);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002491
2492 info.framerate_rcvd = stats.network_frame_rate;
2493 info.framerate_decoded = stats.decode_frame_rate;
2494 info.framerate_output = stats.render_frame_rate;
2495
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002496 {
2497 rtc::CritScope frame_cs(&renderer_lock_);
2498 info.frame_width = last_width_;
2499 info.frame_height = last_height_;
2500 info.capture_start_ntp_time_ms = estimated_remote_start_ntp_time_ms_;
2501 }
2502
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002503 info.decode_ms = stats.decode_ms;
2504 info.max_decode_ms = stats.max_decode_ms;
2505 info.current_delay_ms = stats.current_delay_ms;
2506 info.target_delay_ms = stats.target_delay_ms;
2507 info.jitter_buffer_ms = stats.jitter_buffer_ms;
2508 info.min_playout_delay_ms = stats.min_playout_delay_ms;
2509 info.render_delay_ms = stats.render_delay_ms;
2510
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002511 info.firs_sent = stats.rtcp_packet_type_counts.fir_packets;
2512 info.plis_sent = stats.rtcp_packet_type_counts.pli_packets;
2513 info.nacks_sent = stats.rtcp_packet_type_counts.nack_packets;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002514
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002515 return info;
2516}
2517
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002518WebRtcVideoChannel2::VideoCodecSettings::VideoCodecSettings()
2519 : rtx_payload_type(-1) {}
2520
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002521bool WebRtcVideoChannel2::VideoCodecSettings::operator==(
2522 const WebRtcVideoChannel2::VideoCodecSettings& other) const {
2523 return codec == other.codec &&
2524 fec.ulpfec_payload_type == other.fec.ulpfec_payload_type &&
2525 fec.red_payload_type == other.fec.red_payload_type &&
Shao Changbine62202f2015-04-21 20:24:50 +08002526 fec.red_rtx_payload_type == other.fec.red_rtx_payload_type &&
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002527 rtx_payload_type == other.rtx_payload_type;
2528}
2529
Peter Boströmee0b00e2015-04-22 18:41:14 +02002530bool WebRtcVideoChannel2::VideoCodecSettings::operator!=(
2531 const WebRtcVideoChannel2::VideoCodecSettings& other) const {
2532 return !(*this == other);
2533}
2534
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002535std::vector<WebRtcVideoChannel2::VideoCodecSettings>
2536WebRtcVideoChannel2::MapCodecs(const std::vector<VideoCodec>& codecs) {
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +02002537 DCHECK(!codecs.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002538
2539 std::vector<VideoCodecSettings> video_codecs;
2540 std::map<int, bool> payload_used;
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002541 std::map<int, VideoCodec::CodecType> payload_codec_type;
pkasting@chromium.orgd3245462015-02-23 21:28:22 +00002542 // |rtx_mapping| maps video payload type to rtx payload type.
2543 std::map<int, int> rtx_mapping;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002544
2545 webrtc::FecConfig fec_settings;
2546
2547 for (size_t i = 0; i < codecs.size(); ++i) {
2548 const VideoCodec& in_codec = codecs[i];
2549 int payload_type = in_codec.id;
2550
2551 if (payload_used[payload_type]) {
2552 LOG(LS_ERROR) << "Payload type already registered: "
2553 << in_codec.ToString();
2554 return std::vector<VideoCodecSettings>();
2555 }
2556 payload_used[payload_type] = true;
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002557 payload_codec_type[payload_type] = in_codec.GetCodecType();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002558
2559 switch (in_codec.GetCodecType()) {
2560 case VideoCodec::CODEC_RED: {
2561 // RED payload type, should not have duplicates.
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +02002562 DCHECK(fec_settings.red_payload_type == -1);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002563 fec_settings.red_payload_type = in_codec.id;
2564 continue;
2565 }
2566
2567 case VideoCodec::CODEC_ULPFEC: {
2568 // ULPFEC payload type, should not have duplicates.
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +02002569 DCHECK(fec_settings.ulpfec_payload_type == -1);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002570 fec_settings.ulpfec_payload_type = in_codec.id;
2571 continue;
2572 }
2573
2574 case VideoCodec::CODEC_RTX: {
2575 int associated_payload_type;
2576 if (!in_codec.GetParam(kCodecParamAssociatedPayloadType,
pkasting@chromium.orge9facf82015-02-17 20:36:28 +00002577 &associated_payload_type) ||
2578 !IsValidRtpPayloadType(associated_payload_type)) {
2579 LOG(LS_ERROR)
2580 << "RTX codec with invalid or no associated payload type: "
2581 << in_codec.ToString();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002582 return std::vector<VideoCodecSettings>();
2583 }
2584 rtx_mapping[associated_payload_type] = in_codec.id;
2585 continue;
2586 }
2587
2588 case VideoCodec::CODEC_VIDEO:
2589 break;
2590 }
2591
2592 video_codecs.push_back(VideoCodecSettings());
2593 video_codecs.back().codec = in_codec;
2594 }
2595
2596 // One of these codecs should have been a video codec. Only having FEC
2597 // parameters into this code is a logic error.
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +02002598 DCHECK(!video_codecs.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002599
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002600 for (std::map<int, int>::const_iterator it = rtx_mapping.begin();
2601 it != rtx_mapping.end();
2602 ++it) {
2603 if (!payload_used[it->first]) {
2604 LOG(LS_ERROR) << "RTX mapped to payload not in codec list.";
2605 return std::vector<VideoCodecSettings>();
2606 }
Shao Changbine62202f2015-04-21 20:24:50 +08002607 if (payload_codec_type[it->first] != VideoCodec::CODEC_VIDEO &&
2608 payload_codec_type[it->first] != VideoCodec::CODEC_RED) {
2609 LOG(LS_ERROR) << "RTX not mapped to regular video codec or RED codec.";
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002610 return std::vector<VideoCodecSettings>();
2611 }
Shao Changbine62202f2015-04-21 20:24:50 +08002612
2613 if (it->first == fec_settings.red_payload_type) {
2614 fec_settings.red_rtx_payload_type = it->second;
2615 }
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002616 }
2617
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002618 for (size_t i = 0; i < video_codecs.size(); ++i) {
2619 video_codecs[i].fec = fec_settings;
Shao Changbine62202f2015-04-21 20:24:50 +08002620 if (rtx_mapping[video_codecs[i].codec.id] != 0 &&
2621 rtx_mapping[video_codecs[i].codec.id] !=
2622 fec_settings.red_payload_type) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002623 video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
2624 }
2625 }
2626
2627 return video_codecs;
2628}
2629
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002630} // namespace cricket
2631
2632#endif // HAVE_WEBRTC_VIDEO