blob: 7d4181740e2cf1916a747d9e2fefd3a2fd499a5a [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}
noahricfdac5162015-08-27 01:59:29 -0700306
307// Returns true if the given codec is disallowed from doing simulcast.
308bool IsCodecBlacklistedForSimulcast(const std::string& codec_name) {
309 return CodecNamesEq(codec_name, kH264CodecName);
310}
311
Åsa Persson1c7d48d2015-09-08 09:21:43 +0200312// The selected thresholds for QVGA and VGA corresponded to a QP around 10.
313// The change in QP declined above the selected bitrates.
314static int GetMaxDefaultVideoBitrateKbps(int width, int height) {
315 if (width * height <= 320 * 240) {
316 return 600;
317 } else if (width * height <= 640 * 480) {
318 return 1700;
319 } else if (width * height <= 960 * 540) {
320 return 2000;
321 } else {
322 return 2500;
323 }
324}
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000325} // namespace
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000326
Peter Boström81ea54e2015-05-07 11:41:09 +0200327// Constants defined in talk/media/webrtc/constants.h
328// TODO(pbos): Move these to a separate constants.cc file.
329const int kMinVideoBitrate = 30;
330const int kStartVideoBitrate = 300;
Peter Boström81ea54e2015-05-07 11:41:09 +0200331
332const int kVideoMtu = 1200;
333const int kVideoRtpBufferSize = 65536;
334
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000335// This constant is really an on/off, lower-level configurable NACK history
336// duration hasn't been implemented.
337static const int kNackHistoryMs = 1000;
338
buildbot@webrtc.org933d88a2014-09-18 20:23:05 +0000339static const int kDefaultQpMax = 56;
340
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000341static const int kDefaultRtcpReceiverReportSsrc = 1;
342
Stefan Holmere5904162015-03-26 11:11:06 +0100343const int kMinBandwidthBps = 30000;
344const int kStartBandwidthBps = 300000;
345const int kMaxBandwidthBps = 2000000;
346
Peter Boström81ea54e2015-05-07 11:41:09 +0200347std::vector<VideoCodec> DefaultVideoCodecList() {
348 std::vector<VideoCodec> codecs;
349 if (CodecIsInternallySupported(kVp9CodecName)) {
350 codecs.push_back(MakeVideoCodecWithDefaultFeedbackParams(kDefaultVp9PlType,
351 kVp9CodecName));
352 // TODO(andresp): Add rtx codec for vp9 and verify it works.
353 }
354 codecs.push_back(MakeVideoCodecWithDefaultFeedbackParams(kDefaultVp8PlType,
355 kVp8CodecName));
Zeke Chin71f6f442015-06-29 14:34:58 -0700356 if (CodecIsInternallySupported(kH264CodecName)) {
357 codecs.push_back(MakeVideoCodecWithDefaultFeedbackParams(kDefaultH264PlType,
358 kH264CodecName));
359 }
Peter Boström81ea54e2015-05-07 11:41:09 +0200360 codecs.push_back(
361 VideoCodec::CreateRtxCodec(kDefaultRtxVp8PlType, kDefaultVp8PlType));
362 codecs.push_back(VideoCodec(kDefaultRedPlType, kRedCodecName));
363 codecs.push_back(VideoCodec(kDefaultUlpfecType, kUlpfecCodecName));
364 return codecs;
365}
366
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000367static bool FindFirstMatchingCodec(const std::vector<VideoCodec>& codecs,
368 const VideoCodec& requested_codec,
369 VideoCodec* matching_codec) {
370 for (size_t i = 0; i < codecs.size(); ++i) {
371 if (requested_codec.Matches(codecs[i])) {
372 *matching_codec = codecs[i];
373 return true;
374 }
375 }
376 return false;
377}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000378
pbos@webrtc.org3c107582014-07-20 15:27:35 +0000379static bool ValidateRtpHeaderExtensionIds(
380 const std::vector<RtpHeaderExtension>& extensions) {
381 std::set<int> extensions_used;
382 for (size_t i = 0; i < extensions.size(); ++i) {
Peter Boström23914fe2015-03-31 15:08:04 +0200383 if (extensions[i].id <= 0 || extensions[i].id >= 15 ||
pbos@webrtc.org3c107582014-07-20 15:27:35 +0000384 !extensions_used.insert(extensions[i].id).second) {
385 LOG(LS_ERROR) << "RTP extensions are with incorrect or duplicate ids.";
386 return false;
387 }
388 }
389 return true;
390}
391
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +0000392static bool CompareRtpHeaderExtensionIds(
393 const webrtc::RtpExtension& extension1,
394 const webrtc::RtpExtension& extension2) {
395 // Sorting on ID is sufficient, more than one extension per ID is unsupported.
396 return extension1.id > extension2.id;
397}
398
pbos@webrtc.org3c107582014-07-20 15:27:35 +0000399static std::vector<webrtc::RtpExtension> FilterRtpExtensions(
400 const std::vector<RtpHeaderExtension>& extensions) {
401 std::vector<webrtc::RtpExtension> webrtc_extensions;
402 for (size_t i = 0; i < extensions.size(); ++i) {
403 // Unsupported extensions will be ignored.
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200404 if (webrtc::RtpExtension::IsSupportedForVideo(extensions[i].uri)) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +0000405 webrtc_extensions.push_back(webrtc::RtpExtension(
406 extensions[i].uri, extensions[i].id));
407 } else {
408 LOG(LS_WARNING) << "Unsupported RTP extension: " << extensions[i].uri;
409 }
410 }
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +0000411
412 // Sort filtered headers to make sure that they can later be compared
413 // regardless of in which order they were entered.
414 std::sort(webrtc_extensions.begin(), webrtc_extensions.end(),
415 CompareRtpHeaderExtensionIds);
pbos@webrtc.org3c107582014-07-20 15:27:35 +0000416 return webrtc_extensions;
417}
418
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +0000419static bool RtpExtensionsHaveChanged(
420 const std::vector<webrtc::RtpExtension>& before,
421 const std::vector<webrtc::RtpExtension>& after) {
422 if (before.size() != after.size())
423 return true;
424 for (size_t i = 0; i < before.size(); ++i) {
425 if (before[i].id != after[i].id)
426 return true;
427 if (before[i].name != after[i].name)
428 return true;
429 }
430 return false;
431}
432
buildbot@webrtc.orga8530772014-12-10 09:01:18 +0000433std::vector<webrtc::VideoStream>
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000434WebRtcVideoChannel2::WebRtcVideoSendStream::CreateSimulcastVideoStreams(
buildbot@webrtc.orga8530772014-12-10 09:01:18 +0000435 const VideoCodec& codec,
436 const VideoOptions& options,
Peter Boströmdfd53fe2015-03-27 15:58:11 +0100437 int max_bitrate_bps,
buildbot@webrtc.orga8530772014-12-10 09:01:18 +0000438 size_t num_streams) {
buildbot@webrtc.orga8530772014-12-10 09:01:18 +0000439 int max_qp = kDefaultQpMax;
440 codec.GetParam(kCodecParamMaxQuantization, &max_qp);
441
buildbot@webrtc.orga8530772014-12-10 09:01:18 +0000442 return GetSimulcastConfig(
Peter Boströmdfd53fe2015-03-27 15:58:11 +0100443 num_streams, GetSimulcastBitrateMode(options), codec.width, codec.height,
444 max_bitrate_bps, max_qp,
buildbot@webrtc.orga8530772014-12-10 09:01:18 +0000445 codec.framerate != 0 ? codec.framerate : kDefaultVideoMaxFramerate);
446}
447
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000448std::vector<webrtc::VideoStream>
449WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoStreams(
buildbot@webrtc.orgd41eaeb2014-06-12 07:13:26 +0000450 const VideoCodec& codec,
451 const VideoOptions& options,
Peter Boströmdfd53fe2015-03-27 15:58:11 +0100452 int max_bitrate_bps,
buildbot@webrtc.orgd41eaeb2014-06-12 07:13:26 +0000453 size_t num_streams) {
Peter Boströmdfd53fe2015-03-27 15:58:11 +0100454 int codec_max_bitrate_kbps;
455 if (codec.GetParam(kCodecParamMaxBitrate, &codec_max_bitrate_kbps)) {
456 max_bitrate_bps = codec_max_bitrate_kbps * 1000;
457 }
458 if (num_streams != 1) {
459 return CreateSimulcastVideoStreams(codec, options, max_bitrate_bps,
460 num_streams);
461 }
462
463 // For unset max bitrates set default bitrate for non-simulcast.
Åsa Persson1c7d48d2015-09-08 09:21:43 +0200464 if (max_bitrate_bps <= 0) {
465 max_bitrate_bps =
466 GetMaxDefaultVideoBitrateKbps(codec.width, codec.height) * 1000;
467 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000468
buildbot@webrtc.orgd41eaeb2014-06-12 07:13:26 +0000469 webrtc::VideoStream stream;
470 stream.width = codec.width;
471 stream.height = codec.height;
472 stream.max_framerate =
andresp@webrtc.org82775b12014-11-07 09:37:54 +0000473 codec.framerate != 0 ? codec.framerate : kDefaultVideoMaxFramerate;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000474
pbos@webrtc.org00873182014-11-25 14:03:34 +0000475 stream.min_bitrate_bps = kMinVideoBitrate * 1000;
Peter Boströmdfd53fe2015-03-27 15:58:11 +0100476 stream.target_bitrate_bps = stream.max_bitrate_bps = max_bitrate_bps;
buildbot@webrtc.orgd41eaeb2014-06-12 07:13:26 +0000477
buildbot@webrtc.org933d88a2014-09-18 20:23:05 +0000478 int max_qp = kDefaultQpMax;
buildbot@webrtc.orgd41eaeb2014-06-12 07:13:26 +0000479 codec.GetParam(kCodecParamMaxQuantization, &max_qp);
480 stream.max_qp = max_qp;
481 std::vector<webrtc::VideoStream> streams;
482 streams.push_back(stream);
483 return streams;
484}
485
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000486void* WebRtcVideoChannel2::WebRtcVideoSendStream::ConfigureVideoEncoderSettings(
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000487 const VideoCodec& codec,
Erik Språng143cec12015-04-28 10:01:41 +0200488 const VideoOptions& options,
489 bool is_screencast) {
490 // No automatic resizing when using simulcast.
491 bool automatic_resize = !is_screencast && ssrcs_.size() == 1;
492 bool frame_dropping = !is_screencast;
493 bool denoising;
494 if (is_screencast) {
495 denoising = false;
496 } else {
497 options.video_noise_reduction.Get(&denoising);
498 }
499
Shao Changbine62202f2015-04-21 20:24:50 +0800500 if (CodecNamesEq(codec.name, kVp8CodecName)) {
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000501 encoder_settings_.vp8 = webrtc::VideoEncoder::GetDefaultVp8Settings();
Erik Språng143cec12015-04-28 10:01:41 +0200502 encoder_settings_.vp8.automaticResizeOn = automatic_resize;
503 encoder_settings_.vp8.denoisingOn = denoising;
504 encoder_settings_.vp8.frameDroppingOn = frame_dropping;
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000505 return &encoder_settings_.vp8;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000506 }
Shao Changbine62202f2015-04-21 20:24:50 +0800507 if (CodecNamesEq(codec.name, kVp9CodecName)) {
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000508 encoder_settings_.vp9 = webrtc::VideoEncoder::GetDefaultVp9Settings();
Erik Språng143cec12015-04-28 10:01:41 +0200509 encoder_settings_.vp9.denoisingOn = denoising;
510 encoder_settings_.vp9.frameDroppingOn = frame_dropping;
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000511 return &encoder_settings_.vp9;
andresp@webrtc.org188d3b22014-11-07 13:21:04 +0000512 }
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000513 return NULL;
514}
515
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000516DefaultUnsignalledSsrcHandler::DefaultUnsignalledSsrcHandler()
517 : default_recv_ssrc_(0), default_renderer_(NULL) {}
518
519UnsignalledSsrcHandler::Action DefaultUnsignalledSsrcHandler::OnUnsignalledSsrc(
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +0000520 WebRtcVideoChannel2* channel,
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000521 uint32_t ssrc) {
522 if (default_recv_ssrc_ != 0) { // Already one default stream.
523 LOG(LS_WARNING) << "Unknown SSRC, but default receive stream already set.";
524 return kDropPacket;
525 }
526
527 StreamParams sp;
528 sp.ssrcs.push_back(ssrc);
529 LOG(LS_INFO) << "Creating default receive stream for SSRC=" << ssrc << ".";
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +0000530 if (!channel->AddRecvStream(sp, true)) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000531 LOG(LS_WARNING) << "Could not create default receive stream.";
532 }
533
534 channel->SetRenderer(ssrc, default_renderer_);
535 default_recv_ssrc_ = ssrc;
536 return kDeliverPacket;
537}
538
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000539WebRtcCallFactory::~WebRtcCallFactory() {
540}
541webrtc::Call* WebRtcCallFactory::CreateCall(
542 const webrtc::Call::Config& config) {
543 return webrtc::Call::Create(config);
544}
545
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000546VideoRenderer* DefaultUnsignalledSsrcHandler::GetDefaultRenderer() const {
547 return default_renderer_;
548}
549
550void DefaultUnsignalledSsrcHandler::SetDefaultRenderer(
551 VideoMediaChannel* channel,
552 VideoRenderer* renderer) {
553 default_renderer_ = renderer;
554 if (default_recv_ssrc_ != 0) {
555 channel->SetRenderer(default_recv_ssrc_, default_renderer_);
556 }
557}
558
pbos@webrtc.orgf1f0d9a2015-03-02 13:30:15 +0000559WebRtcVideoEngine2::WebRtcVideoEngine2(WebRtcVoiceEngine* voice_engine)
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200560 : voice_engine_(voice_engine),
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +0000561 initialized_(false),
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000562 call_factory_(&default_call_factory_),
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000563 external_decoder_factory_(NULL),
564 external_encoder_factory_(NULL) {
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +0000565 LOG(LS_INFO) << "WebRtcVideoEngine2::WebRtcVideoEngine2()";
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000566 video_codecs_ = GetSupportedCodecs();
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000567 rtp_header_extensions_.push_back(
568 RtpHeaderExtension(kRtpTimestampOffsetHeaderExtension,
569 kRtpTimestampOffsetHeaderExtensionDefaultId));
570 rtp_header_extensions_.push_back(
571 RtpHeaderExtension(kRtpAbsoluteSenderTimeHeaderExtension,
572 kRtpAbsoluteSenderTimeHeaderExtensionDefaultId));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700573 rtp_header_extensions_.push_back(
574 RtpHeaderExtension(kRtpVideoRotationHeaderExtension,
575 kRtpVideoRotationHeaderExtensionDefaultId));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000576}
577
578WebRtcVideoEngine2::~WebRtcVideoEngine2() {
579 LOG(LS_INFO) << "WebRtcVideoEngine2::~WebRtcVideoEngine2";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000580}
581
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000582void WebRtcVideoEngine2::SetCallFactory(WebRtcCallFactory* call_factory) {
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +0200583 DCHECK(!initialized_);
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000584 call_factory_ = call_factory;
585}
586
Fredrik Solenberg9a416bd2015-05-22 09:04:09 +0200587void WebRtcVideoEngine2::Init() {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000588 LOG(LS_INFO) << "WebRtcVideoEngine2::Init";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000589 initialized_ = true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000590}
591
592int WebRtcVideoEngine2::GetCapabilities() { return VIDEO_RECV | VIDEO_SEND; }
593
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000594bool WebRtcVideoEngine2::SetDefaultEncoderConfig(
595 const VideoEncoderConfig& config) {
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000596 const VideoCodec& codec = config.max_codec;
pbos@webrtc.org957e8022014-11-10 12:36:11 +0000597 bool supports_codec = false;
598 for (size_t i = 0; i < video_codecs_.size(); ++i) {
Shao Changbine62202f2015-04-21 20:24:50 +0800599 if (CodecNamesEq(video_codecs_[i].name, codec.name)) {
pbos@webrtc.org2a72c652015-02-26 16:01:24 +0000600 video_codecs_[i].width = codec.width;
601 video_codecs_[i].height = codec.height;
602 video_codecs_[i].framerate = codec.framerate;
pbos@webrtc.org957e8022014-11-10 12:36:11 +0000603 supports_codec = true;
604 break;
605 }
606 }
607
608 if (!supports_codec) {
609 LOG(LS_ERROR) << "SetDefaultEncoderConfig, codec not supported: "
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000610 << codec.ToString();
611 return false;
612 }
613
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000614 return true;
615}
616
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000617WebRtcVideoChannel2* WebRtcVideoEngine2::CreateChannel(
buildbot@webrtc.org1ecbe452014-10-14 20:29:28 +0000618 const VideoOptions& options,
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000619 VoiceMediaChannel* voice_channel) {
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +0200620 DCHECK(initialized_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000621 LOG(LS_INFO) << "CreateChannel: "
622 << (voice_channel != NULL ? "With" : "Without")
pbos@webrtc.orgfa553ef2014-10-20 11:07:07 +0000623 << " voice channel. Options: " << options.ToString();
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000624 WebRtcVideoChannel2* channel =
Fredrik Solenberg4b60c732015-05-07 14:07:48 +0200625 new WebRtcVideoChannel2(call_factory_, voice_engine_,
626 static_cast<WebRtcVoiceMediaChannel*>(voice_channel), options,
627 external_encoder_factory_, external_decoder_factory_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000628 if (!channel->Init()) {
629 delete channel;
630 return NULL;
631 }
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000632 channel->SetRecvCodecs(video_codecs_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000633 return channel;
634}
635
636const std::vector<VideoCodec>& WebRtcVideoEngine2::codecs() const {
637 return video_codecs_;
638}
639
640const std::vector<RtpHeaderExtension>&
641WebRtcVideoEngine2::rtp_header_extensions() const {
642 return rtp_header_extensions_;
643}
644
645void WebRtcVideoEngine2::SetLogging(int min_sev, const char* filter) {
646 // TODO(pbos): Set up logging.
647 LOG(LS_VERBOSE) << "SetLogging: " << min_sev << '"' << filter << '"';
648 // if min_sev == -1, we keep the current log level.
649 if (min_sev < 0) {
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +0200650 DCHECK(min_sev == -1);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000651 return;
652 }
653}
654
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000655void WebRtcVideoEngine2::SetExternalDecoderFactory(
656 WebRtcVideoDecoderFactory* decoder_factory) {
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +0200657 DCHECK(!initialized_);
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000658 external_decoder_factory_ = decoder_factory;
659}
660
661void WebRtcVideoEngine2::SetExternalEncoderFactory(
662 WebRtcVideoEncoderFactory* encoder_factory) {
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +0200663 DCHECK(!initialized_);
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000664 if (external_encoder_factory_ == encoder_factory)
665 return;
666
667 // No matter what happens we shouldn't hold on to a stale
668 // WebRtcSimulcastEncoderFactory.
669 simulcast_encoder_factory_.reset();
670
671 if (encoder_factory &&
672 WebRtcSimulcastEncoderFactory::UseSimulcastEncoderFactory(
673 encoder_factory->codecs())) {
674 simulcast_encoder_factory_.reset(
675 new WebRtcSimulcastEncoderFactory(encoder_factory));
676 encoder_factory = simulcast_encoder_factory_.get();
677 }
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000678 external_encoder_factory_ = encoder_factory;
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000679
680 video_codecs_ = GetSupportedCodecs();
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000681}
682
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000683bool WebRtcVideoEngine2::EnableTimedRender() {
684 // TODO(pbos): Figure out whether this can be removed.
685 return true;
686}
687
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000688// Checks to see whether we comprehend and could receive a particular codec
689bool WebRtcVideoEngine2::FindCodec(const VideoCodec& in) {
690 // TODO(pbos): Probe encoder factory to figure out that the codec is supported
691 // if supported by the encoder factory. Add a corresponding test that fails
692 // with this code (that doesn't ask the factory).
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000693 for (size_t j = 0; j < video_codecs_.size(); ++j) {
694 VideoCodec codec(video_codecs_[j].id, video_codecs_[j].name, 0, 0, 0, 0);
695 if (codec.Matches(in)) {
696 return true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000697 }
698 }
699 return false;
700}
701
702// Tells whether the |requested| codec can be transmitted or not. If it can be
703// transmitted |out| is set with the best settings supported. Aspect ratio will
704// be set as close to |current|'s as possible. If not set |requested|'s
705// dimensions will be used for aspect ratio matching.
706bool WebRtcVideoEngine2::CanSendCodec(const VideoCodec& requested,
707 const VideoCodec& current,
708 VideoCodec* out) {
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +0200709 DCHECK(out != NULL);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000710
711 if (requested.width != requested.height &&
712 (requested.height == 0 || requested.width == 0)) {
713 // 0xn and nx0 are invalid resolutions.
714 return false;
715 }
716
717 VideoCodec matching_codec;
718 if (!FindFirstMatchingCodec(video_codecs_, requested, &matching_codec)) {
719 // Codec not supported.
720 return false;
721 }
722
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000723 out->id = requested.id;
724 out->name = requested.name;
725 out->preference = requested.preference;
726 out->params = requested.params;
andresp@webrtc.orgff689be2015-02-12 11:54:26 +0000727 out->framerate = std::min(requested.framerate, matching_codec.framerate);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000728 out->params = requested.params;
729 out->feedback_params = requested.feedback_params;
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000730 out->width = requested.width;
731 out->height = requested.height;
732 if (requested.width == 0 && requested.height == 0) {
733 return true;
734 }
735
736 while (out->width > matching_codec.width) {
737 out->width /= 2;
738 out->height /= 2;
739 }
740
741 return out->width > 0 && out->height > 0;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000742}
743
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000744// Ignore spammy trace messages, mostly from the stats API when we haven't
745// gotten RTCP info yet from the remote side.
746bool WebRtcVideoEngine2::ShouldIgnoreTrace(const std::string& trace) {
747 static const char* const kTracesToIgnore[] = {NULL};
748 for (const char* const* p = kTracesToIgnore; *p; ++p) {
749 if (trace.find(*p) == 0) {
750 return true;
751 }
752 }
753 return false;
754}
755
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000756std::vector<VideoCodec> WebRtcVideoEngine2::GetSupportedCodecs() const {
andresp@webrtc.org82775b12014-11-07 09:37:54 +0000757 std::vector<VideoCodec> supported_codecs = DefaultVideoCodecList();
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000758
759 if (external_encoder_factory_ == NULL) {
760 return supported_codecs;
761 }
762
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000763 const std::vector<WebRtcVideoEncoderFactory::VideoCodec>& codecs =
764 external_encoder_factory_->codecs();
765 for (size_t i = 0; i < codecs.size(); ++i) {
766 // Don't add internally-supported codecs twice.
767 if (CodecIsInternallySupported(codecs[i].name)) {
768 continue;
769 }
770
pkasting@chromium.orgd3245462015-02-23 21:28:22 +0000771 // External video encoders are given payloads 120-127. This also means that
772 // we only support up to 8 external payload types.
773 const int kExternalVideoPayloadTypeBase = 120;
774 size_t payload_type = kExternalVideoPayloadTypeBase + i;
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +0200775 DCHECK(payload_type < 128);
pkasting@chromium.orgd3245462015-02-23 21:28:22 +0000776 VideoCodec codec(static_cast<int>(payload_type),
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000777 codecs[i].name,
778 codecs[i].max_width,
779 codecs[i].max_height,
780 codecs[i].max_fps,
781 0);
782
783 AddDefaultFeedbackParams(&codec);
784 supported_codecs.push_back(codec);
785 }
786 return supported_codecs;
787}
788
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000789WebRtcVideoChannel2::WebRtcVideoChannel2(
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000790 WebRtcCallFactory* call_factory,
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +0000791 WebRtcVoiceEngine* voice_engine,
Fredrik Solenberg4b60c732015-05-07 14:07:48 +0200792 WebRtcVoiceMediaChannel* voice_channel,
pbos@webrtc.orgfa553ef2014-10-20 11:07:07 +0000793 const VideoOptions& options,
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000794 WebRtcVideoEncoderFactory* external_encoder_factory,
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000795 WebRtcVideoDecoderFactory* external_decoder_factory)
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +0000796 : unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
Fredrik Solenberg4b60c732015-05-07 14:07:48 +0200797 voice_channel_(voice_channel),
798 voice_channel_id_(voice_channel ? voice_channel->voe_channel() : -1),
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000799 external_encoder_factory_(external_encoder_factory),
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000800 external_decoder_factory_(external_decoder_factory) {
Fredrik Solenberg4b60c732015-05-07 14:07:48 +0200801 DCHECK(thread_checker_.CalledOnValidThread());
pbos@webrtc.orgfa553ef2014-10-20 11:07:07 +0000802 SetDefaultOptions();
803 options_.SetAll(options);
Peter Boströme7b221f2015-04-13 15:34:32 +0200804 options_.cpu_overuse_detection.Get(&signal_cpu_adaptation_);
solenberg4fbae2b2015-08-28 04:07:10 -0700805 webrtc::Call::Config config;
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +0000806 if (voice_engine != NULL) {
807 config.voice_engine = voice_engine->voe()->engine();
808 }
Stefan Holmere5904162015-03-26 11:11:06 +0100809 config.bitrate_config.min_bitrate_bps = kMinBandwidthBps;
810 config.bitrate_config.start_bitrate_bps = kStartBandwidthBps;
811 config.bitrate_config.max_bitrate_bps = kMaxBandwidthBps;
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000812 call_.reset(call_factory->CreateCall(config));
Fredrik Solenberg4b60c732015-05-07 14:07:48 +0200813 if (voice_channel_) {
814 voice_channel_->SetCall(call_.get());
815 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000816 rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc;
817 sending_ = false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000818 default_send_ssrc_ = 0;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000819}
820
821void WebRtcVideoChannel2::SetDefaultOptions() {
Peter Boströme4328002015-04-14 22:45:29 +0200822 options_.cpu_overuse_detection.Set(true);
pbos@webrtc.orgd8198032014-11-10 14:41:43 +0000823 options_.dscp.Set(false);
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +0000824 options_.suspend_below_min_bitrate.Set(false);
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000825 options_.video_noise_reduction.Set(true);
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +0000826 options_.screencast_min_bitrate.Set(0);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000827}
828
829WebRtcVideoChannel2::~WebRtcVideoChannel2() {
Fredrik Solenberg4b60c732015-05-07 14:07:48 +0200830 DetachVoiceChannel();
Peter Boströmdfd53fe2015-03-27 15:58:11 +0100831 for (auto& kv : send_streams_)
832 delete kv.second;
833 for (auto& kv : receive_streams_)
834 delete kv.second;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000835}
836
837bool WebRtcVideoChannel2::Init() { return true; }
838
Fredrik Solenberg4b60c732015-05-07 14:07:48 +0200839void WebRtcVideoChannel2::DetachVoiceChannel() {
840 DCHECK(thread_checker_.CalledOnValidThread());
841 if (voice_channel_) {
842 voice_channel_->SetCall(nullptr);
843 voice_channel_ = nullptr;
844 }
845}
846
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000847bool WebRtcVideoChannel2::CodecIsExternallySupported(
848 const std::string& name) const {
849 if (external_encoder_factory_ == NULL) {
850 return false;
851 }
852
853 const std::vector<WebRtcVideoEncoderFactory::VideoCodec> external_codecs =
854 external_encoder_factory_->codecs();
855 for (size_t c = 0; c < external_codecs.size(); ++c) {
Shao Changbine62202f2015-04-21 20:24:50 +0800856 if (CodecNamesEq(name, external_codecs[c].name)) {
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000857 return true;
858 }
859 }
860 return false;
861}
862
863std::vector<WebRtcVideoChannel2::VideoCodecSettings>
864WebRtcVideoChannel2::FilterSupportedCodecs(
865 const std::vector<WebRtcVideoChannel2::VideoCodecSettings>& mapped_codecs)
866 const {
867 std::vector<VideoCodecSettings> supported_codecs;
868 for (size_t i = 0; i < mapped_codecs.size(); ++i) {
869 const VideoCodecSettings& codec = mapped_codecs[i];
870 if (CodecIsInternallySupported(codec.codec.name) ||
871 CodecIsExternallySupported(codec.codec.name)) {
872 supported_codecs.push_back(codec);
873 }
874 }
875 return supported_codecs;
876}
877
deadbeef874ca3a2015-08-20 17:19:20 -0700878bool WebRtcVideoChannel2::ReceiveCodecsHaveChanged(
879 std::vector<VideoCodecSettings> before,
880 std::vector<VideoCodecSettings> after) {
881 if (before.size() != after.size()) {
882 return true;
883 }
884 // The receive codec order doesn't matter, so we sort the codecs before
885 // comparing. This is necessary because currently the
886 // only way to change the send codec is to munge SDP, which causes
887 // the receive codec list to change order, which causes the streams
888 // to be recreates which causes a "blink" of black video. In order
889 // to support munging the SDP in this way without recreating receive
890 // streams, we ignore the order of the received codecs so that
891 // changing the order doesn't cause this "blink".
892 auto comparison =
893 [](const VideoCodecSettings& codec1, const VideoCodecSettings& codec2) {
894 return codec1.codec.id > codec2.codec.id;
895 };
896 std::sort(before.begin(), before.end(), comparison);
897 std::sort(after.begin(), after.end(), comparison);
898 for (size_t i = 0; i < before.size(); ++i) {
899 // For the same reason that we sort the codecs, we also ignore the
900 // preference. We don't want a preference change on the receive
901 // side to cause recreation of the stream.
902 before[i].codec.preference = 0;
903 after[i].codec.preference = 0;
904 if (before[i] != after[i]) {
905 return true;
906 }
907 }
908 return false;
909}
910
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700911bool WebRtcVideoChannel2::SetSendParameters(const VideoSendParameters& params) {
912 // TODO(pbos): Refactor this to only recreate the send streams once
913 // instead of 4 times.
914 return (SetSendCodecs(params.codecs) &&
915 SetSendRtpHeaderExtensions(params.extensions) &&
916 SetMaxSendBandwidth(params.max_bandwidth_bps) &&
917 SetOptions(params.options));
918}
919
920bool WebRtcVideoChannel2::SetRecvParameters(const VideoRecvParameters& params) {
921 // TODO(pbos): Refactor this to only recreate the recv streams once
922 // instead of twice.
923 return (SetRecvCodecs(params.codecs) &&
924 SetRecvRtpHeaderExtensions(params.extensions));
925}
926
deadbeef874ca3a2015-08-20 17:19:20 -0700927std::string WebRtcVideoChannel2::CodecSettingsVectorToString(
928 const std::vector<VideoCodecSettings>& codecs) {
929 std::stringstream out;
930 out << '{';
931 for (size_t i = 0; i < codecs.size(); ++i) {
932 out << codecs[i].codec.ToString();
933 if (i != codecs.size() - 1) {
934 out << ", ";
935 }
936 }
937 out << '}';
938 return out.str();
939}
940
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000941bool WebRtcVideoChannel2::SetRecvCodecs(const std::vector<VideoCodec>& codecs) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +0000942 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRecvCodecs");
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000943 LOG(LS_INFO) << "SetRecvCodecs: " << CodecVectorToString(codecs);
944 if (!ValidateCodecFormats(codecs)) {
945 return false;
946 }
947
948 const std::vector<VideoCodecSettings> mapped_codecs = MapCodecs(codecs);
949 if (mapped_codecs.empty()) {
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000950 LOG(LS_ERROR) << "SetRecvCodecs called without any video codecs.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000951 return false;
952 }
953
deadbeef874ca3a2015-08-20 17:19:20 -0700954 std::vector<VideoCodecSettings> supported_codecs =
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000955 FilterSupportedCodecs(mapped_codecs);
956
957 if (mapped_codecs.size() != supported_codecs.size()) {
958 LOG(LS_ERROR) << "SetRecvCodecs called with unsupported video codecs.";
959 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000960 }
961
Peter Boströmee0b00e2015-04-22 18:41:14 +0200962 // Prevent reconfiguration when setting identical receive codecs.
deadbeef874ca3a2015-08-20 17:19:20 -0700963 if (!ReceiveCodecsHaveChanged(recv_codecs_, supported_codecs)) {
964 LOG(LS_INFO)
965 << "Ignoring call to SetRecvCodecs because codecs haven't changed.";
966 return true;
Peter Boströmee0b00e2015-04-22 18:41:14 +0200967 }
968
deadbeef874ca3a2015-08-20 17:19:20 -0700969 LOG(LS_INFO) << "Changing recv codecs from "
970 << CodecSettingsVectorToString(recv_codecs_) << " to "
971 << CodecSettingsVectorToString(supported_codecs);
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000972 recv_codecs_ = supported_codecs;
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000973
pbos@webrtc.org575d1262014-10-08 14:48:08 +0000974 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000975 for (std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
976 receive_streams_.begin();
977 it != receive_streams_.end();
978 ++it) {
979 it->second->SetRecvCodecs(recv_codecs_);
980 }
981
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000982 return true;
983}
984
985bool WebRtcVideoChannel2::SetSendCodecs(const std::vector<VideoCodec>& codecs) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +0000986 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetSendCodecs");
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000987 LOG(LS_INFO) << "SetSendCodecs: " << CodecVectorToString(codecs);
988 if (!ValidateCodecFormats(codecs)) {
989 return false;
990 }
991
992 const std::vector<VideoCodecSettings> supported_codecs =
993 FilterSupportedCodecs(MapCodecs(codecs));
994
995 if (supported_codecs.empty()) {
Peter Boström3c3f6462015-04-15 16:27:49 +0200996 LOG(LS_ERROR) << "No video codecs supported.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000997 return false;
998 }
999
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001000 LOG(LS_INFO) << "Using codec: " << supported_codecs.front().codec.ToString();
1001
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001002 VideoCodecSettings old_codec;
1003 if (send_codec_.Get(&old_codec) && supported_codecs.front() == old_codec) {
deadbeef874ca3a2015-08-20 17:19:20 -07001004 LOG(LS_INFO) << "Ignore call to SetSendCodecs because first supported "
1005 "codec hasn't changed.";
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001006 // Using same codec, avoid reconfiguring.
1007 return true;
1008 }
1009
1010 send_codec_.Set(supported_codecs.front());
1011
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001012 rtc::CritScope stream_lock(&stream_crit_);
deadbeef874ca3a2015-08-20 17:19:20 -07001013 LOG(LS_INFO) << "Change the send codec because SetSendCodecs has a different "
1014 "first supported codec.";
Peter Boström126c03e2015-05-11 12:48:12 +02001015 for (auto& kv : send_streams_) {
1016 DCHECK(kv.second != nullptr);
1017 kv.second->SetCodec(supported_codecs.front());
1018 }
deadbeef874ca3a2015-08-20 17:19:20 -07001019 LOG(LS_INFO) << "SetNackAndRemb on all the receive streams because the send "
1020 "codec has changed.";
Peter Boström126c03e2015-05-11 12:48:12 +02001021 for (auto& kv : receive_streams_) {
1022 DCHECK(kv.second != nullptr);
Peter Boström67c9df72015-05-11 14:34:58 +02001023 kv.second->SetNackAndRemb(HasNack(supported_codecs.front().codec),
1024 HasRemb(supported_codecs.front().codec));
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001025 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001026
Stefan Holmere5904162015-03-26 11:11:06 +01001027 // TODO(holmer): Changing the codec parameters shouldn't necessarily mean that
1028 // we change the min/max of bandwidth estimation. Reevaluate this.
pbos@webrtc.org00873182014-11-25 14:03:34 +00001029 VideoCodec codec = supported_codecs.front().codec;
1030 int bitrate_kbps;
1031 if (codec.GetParam(kCodecParamMinBitrate, &bitrate_kbps) &&
1032 bitrate_kbps > 0) {
1033 bitrate_config_.min_bitrate_bps = bitrate_kbps * 1000;
1034 } else {
1035 bitrate_config_.min_bitrate_bps = 0;
1036 }
1037 if (codec.GetParam(kCodecParamStartBitrate, &bitrate_kbps) &&
1038 bitrate_kbps > 0) {
1039 bitrate_config_.start_bitrate_bps = bitrate_kbps * 1000;
1040 } else {
1041 // Do not reconfigure start bitrate unless it's specified and positive.
1042 bitrate_config_.start_bitrate_bps = -1;
1043 }
1044 if (codec.GetParam(kCodecParamMaxBitrate, &bitrate_kbps) &&
1045 bitrate_kbps > 0) {
1046 bitrate_config_.max_bitrate_bps = bitrate_kbps * 1000;
1047 } else {
1048 bitrate_config_.max_bitrate_bps = -1;
1049 }
1050 call_->SetBitrateConfig(bitrate_config_);
1051
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001052 return true;
1053}
1054
1055bool WebRtcVideoChannel2::GetSendCodec(VideoCodec* codec) {
1056 VideoCodecSettings codec_settings;
1057 if (!send_codec_.Get(&codec_settings)) {
1058 LOG(LS_VERBOSE) << "GetSendCodec: No send codec set.";
1059 return false;
1060 }
1061 *codec = codec_settings.codec;
1062 return true;
1063}
1064
1065bool WebRtcVideoChannel2::SetSendStreamFormat(uint32 ssrc,
1066 const VideoFormat& format) {
1067 LOG(LS_VERBOSE) << "SetSendStreamFormat:" << ssrc << " -> "
1068 << format.ToString();
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001069 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001070 if (send_streams_.find(ssrc) == send_streams_.end()) {
1071 return false;
1072 }
1073 return send_streams_[ssrc]->SetVideoFormat(format);
1074}
1075
1076bool WebRtcVideoChannel2::SetRender(bool render) {
1077 // TODO(pbos): Implement. Or refactor away as it shouldn't be needed.
1078 LOG(LS_VERBOSE) << "SetRender: " << (render ? "true" : "false");
1079 return true;
1080}
1081
1082bool WebRtcVideoChannel2::SetSend(bool send) {
1083 LOG(LS_VERBOSE) << "SetSend: " << (send ? "true" : "false");
1084 if (send && !send_codec_.IsSet()) {
1085 LOG(LS_ERROR) << "SetSend(true) called before setting codec.";
1086 return false;
1087 }
1088 if (send) {
1089 StartAllSendStreams();
1090 } else {
1091 StopAllSendStreams();
1092 }
1093 sending_ = send;
1094 return true;
1095}
1096
Peter Boströmd6f4c252015-03-26 16:23:04 +01001097bool WebRtcVideoChannel2::ValidateSendSsrcAvailability(
1098 const StreamParams& sp) const {
1099 for (uint32_t ssrc: sp.ssrcs) {
1100 if (send_ssrcs_.find(ssrc) != send_ssrcs_.end()) {
1101 LOG(LS_ERROR) << "Send stream with SSRC '" << ssrc << "' already exists.";
1102 return false;
1103 }
1104 }
1105 return true;
1106}
1107
1108bool WebRtcVideoChannel2::ValidateReceiveSsrcAvailability(
1109 const StreamParams& sp) const {
1110 for (uint32_t ssrc: sp.ssrcs) {
1111 if (receive_ssrcs_.find(ssrc) != receive_ssrcs_.end()) {
1112 LOG(LS_ERROR) << "Receive stream with SSRC '" << ssrc
1113 << "' already exists.";
1114 return false;
1115 }
1116 }
1117 return true;
1118}
1119
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001120bool WebRtcVideoChannel2::AddSendStream(const StreamParams& sp) {
1121 LOG(LS_INFO) << "AddSendStream: " << sp.ToString();
Peter Boströmd4362cd2015-03-25 14:17:23 +01001122 if (!ValidateStreamParams(sp))
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001123 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001124
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001125 rtc::CritScope stream_lock(&stream_crit_);
Peter Boströmd6f4c252015-03-26 16:23:04 +01001126
1127 if (!ValidateSendSsrcAvailability(sp))
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001128 return false;
Peter Boströmd6f4c252015-03-26 16:23:04 +01001129
1130 for (uint32 used_ssrc : sp.ssrcs)
1131 send_ssrcs_.insert(used_ssrc);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001132
solenberge5269742015-09-08 05:13:22 -07001133 webrtc::VideoSendStream::Config config(this);
1134 config.overuse_callback = this;
1135
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001136 WebRtcVideoSendStream* stream =
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001137 new WebRtcVideoSendStream(call_.get(),
solenberg4fbae2b2015-08-28 04:07:10 -07001138 sp,
solenberge5269742015-09-08 05:13:22 -07001139 config,
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001140 external_encoder_factory_,
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001141 options_,
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001142 bitrate_config_.max_bitrate_bps,
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001143 send_codec_,
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001144 send_rtp_extensions_);
1145
Peter Boströmd6f4c252015-03-26 16:23:04 +01001146 uint32 ssrc = sp.first_ssrc();
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +02001147 DCHECK(ssrc != 0);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001148 send_streams_[ssrc] = stream;
1149
1150 if (rtcp_receiver_report_ssrc_ == kDefaultRtcpReceiverReportSsrc) {
1151 rtcp_receiver_report_ssrc_ = ssrc;
deadbeef874ca3a2015-08-20 17:19:20 -07001152 LOG(LS_INFO) << "SetLocalSsrc on all the receive streams because we added "
1153 "a send stream.";
Peter Boström3548dd22015-05-22 18:48:36 +02001154 for (auto& kv : receive_streams_)
1155 kv.second->SetLocalSsrc(ssrc);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001156 }
1157 if (default_send_ssrc_ == 0) {
1158 default_send_ssrc_ = ssrc;
1159 }
1160 if (sending_) {
1161 stream->Start();
1162 }
1163
1164 return true;
1165}
1166
1167bool WebRtcVideoChannel2::RemoveSendStream(uint32 ssrc) {
1168 LOG(LS_INFO) << "RemoveSendStream: " << ssrc;
1169
1170 if (ssrc == 0) {
1171 if (default_send_ssrc_ == 0) {
1172 LOG(LS_ERROR) << "No default send stream active.";
1173 return false;
1174 }
1175
1176 LOG(LS_VERBOSE) << "Removing default stream: " << default_send_ssrc_;
1177 ssrc = default_send_ssrc_;
1178 }
1179
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001180 WebRtcVideoSendStream* removed_stream;
1181 {
1182 rtc::CritScope stream_lock(&stream_crit_);
1183 std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1184 send_streams_.find(ssrc);
1185 if (it == send_streams_.end()) {
1186 return false;
1187 }
1188
Peter Boströmd6f4c252015-03-26 16:23:04 +01001189 for (uint32 old_ssrc : it->second->GetSsrcs())
1190 send_ssrcs_.erase(old_ssrc);
1191
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001192 removed_stream = it->second;
1193 send_streams_.erase(it);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001194 }
1195
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001196 delete removed_stream;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001197
1198 if (ssrc == default_send_ssrc_) {
1199 default_send_ssrc_ = 0;
1200 }
1201
1202 return true;
1203}
1204
Peter Boströmd6f4c252015-03-26 16:23:04 +01001205void WebRtcVideoChannel2::DeleteReceiveStream(
1206 WebRtcVideoChannel2::WebRtcVideoReceiveStream* stream) {
1207 for (uint32 old_ssrc : stream->GetSsrcs())
1208 receive_ssrcs_.erase(old_ssrc);
1209 delete stream;
1210}
1211
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001212bool WebRtcVideoChannel2::AddRecvStream(const StreamParams& sp) {
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00001213 return AddRecvStream(sp, false);
1214}
1215
1216bool WebRtcVideoChannel2::AddRecvStream(const StreamParams& sp,
1217 bool default_stream) {
Fredrik Solenberg4b60c732015-05-07 14:07:48 +02001218 DCHECK(thread_checker_.CalledOnValidThread());
1219
Peter Boströmd4362cd2015-03-25 14:17:23 +01001220 LOG(LS_INFO) << "AddRecvStream" << (default_stream ? " (default stream)" : "")
1221 << ": " << sp.ToString();
1222 if (!ValidateStreamParams(sp))
1223 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001224
1225 uint32 ssrc = sp.first_ssrc();
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +02001226 DCHECK(ssrc != 0); // TODO(pbos): Is this ever valid?
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001227
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001228 rtc::CritScope stream_lock(&stream_crit_);
Peter Boströmd6f4c252015-03-26 16:23:04 +01001229 // Remove running stream if this was a default stream.
1230 auto prev_stream = receive_streams_.find(ssrc);
1231 if (prev_stream != receive_streams_.end()) {
1232 if (default_stream || !prev_stream->second->IsDefaultStream()) {
1233 LOG(LS_ERROR) << "Receive stream for SSRC '" << ssrc
1234 << "' already exists.";
1235 return false;
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00001236 }
Peter Boströmd6f4c252015-03-26 16:23:04 +01001237 DeleteReceiveStream(prev_stream->second);
1238 receive_streams_.erase(prev_stream);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001239 }
1240
Peter Boströmd6f4c252015-03-26 16:23:04 +01001241 if (!ValidateReceiveSsrcAvailability(sp))
1242 return false;
1243
1244 for (uint32 used_ssrc : sp.ssrcs)
1245 receive_ssrcs_.insert(used_ssrc);
1246
solenberg4fbae2b2015-08-28 04:07:10 -07001247 webrtc::VideoReceiveStream::Config config(this);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001248 ConfigureReceiverRtp(&config, sp);
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +00001249
pbos8fc7fa72015-07-15 08:02:58 -07001250 // Set up A/V sync group based on sync label.
1251 config.sync_group = sp.sync_label;
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +00001252
Peter Boström126c03e2015-05-11 12:48:12 +02001253 config.rtp.remb = false;
1254 VideoCodecSettings send_codec;
1255 if (send_codec_.Get(&send_codec)) {
1256 config.rtp.remb = HasRemb(send_codec.codec);
1257 }
1258
Peter Boströmd6f4c252015-03-26 16:23:04 +01001259 receive_streams_[ssrc] = new WebRtcVideoReceiveStream(
solenberg4fbae2b2015-08-28 04:07:10 -07001260 call_.get(), sp, config, external_decoder_factory_, default_stream,
Peter Boströmd6f4c252015-03-26 16:23:04 +01001261 recv_codecs_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001262
1263 return true;
1264}
1265
1266void WebRtcVideoChannel2::ConfigureReceiverRtp(
1267 webrtc::VideoReceiveStream::Config* config,
1268 const StreamParams& sp) const {
1269 uint32 ssrc = sp.first_ssrc();
1270
1271 config->rtp.remote_ssrc = ssrc;
1272 config->rtp.local_ssrc = rtcp_receiver_report_ssrc_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001273
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001274 config->rtp.extensions = recv_rtp_extensions_;
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001275
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001276 // TODO(pbos): This protection is against setting the same local ssrc as
1277 // remote which is not permitted by the lower-level API. RTCP requires a
1278 // corresponding sender SSRC. Figure out what to do when we don't have
1279 // (receive-only) or know a good local SSRC.
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001280 if (config->rtp.remote_ssrc == config->rtp.local_ssrc) {
1281 if (config->rtp.local_ssrc != kDefaultRtcpReceiverReportSsrc) {
1282 config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001283 } else {
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001284 config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc + 1;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001285 }
1286 }
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001287
1288 for (size_t i = 0; i < recv_codecs_.size(); ++i) {
andresp@webrtc.org82775b12014-11-07 09:37:54 +00001289 MergeFecConfig(recv_codecs_[i].fec, &config->rtp.fec);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001290 }
1291
andresp@webrtc.org82775b12014-11-07 09:37:54 +00001292 for (size_t i = 0; i < recv_codecs_.size(); ++i) {
1293 uint32 rtx_ssrc;
1294 if (recv_codecs_[i].rtx_payload_type != -1 &&
1295 sp.GetFidSsrc(ssrc, &rtx_ssrc)) {
1296 webrtc::VideoReceiveStream::Config::Rtp::Rtx& rtx =
1297 config->rtp.rtx[recv_codecs_[i].codec.id];
1298 rtx.ssrc = rtx_ssrc;
1299 rtx.payload_type = recv_codecs_[i].rtx_payload_type;
1300 }
1301 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001302}
1303
1304bool WebRtcVideoChannel2::RemoveRecvStream(uint32 ssrc) {
1305 LOG(LS_INFO) << "RemoveRecvStream: " << ssrc;
1306 if (ssrc == 0) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001307 LOG(LS_ERROR) << "RemoveRecvStream with 0 ssrc is not supported.";
1308 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001309 }
1310
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001311 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001312 std::map<uint32, WebRtcVideoReceiveStream*>::iterator stream =
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001313 receive_streams_.find(ssrc);
1314 if (stream == receive_streams_.end()) {
1315 LOG(LS_ERROR) << "Stream not found for ssrc: " << ssrc;
1316 return false;
1317 }
Peter Boströmd6f4c252015-03-26 16:23:04 +01001318 DeleteReceiveStream(stream->second);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001319 receive_streams_.erase(stream);
1320
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001321 return true;
1322}
1323
1324bool WebRtcVideoChannel2::SetRenderer(uint32 ssrc, VideoRenderer* renderer) {
1325 LOG(LS_INFO) << "SetRenderer: ssrc:" << ssrc << " "
1326 << (renderer ? "(ptr)" : "NULL");
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001327 if (ssrc == 0) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001328 default_unsignalled_ssrc_handler_.SetDefaultRenderer(this, renderer);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001329 return true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001330 }
1331
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001332 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001333 std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
1334 receive_streams_.find(ssrc);
1335 if (it == receive_streams_.end()) {
1336 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001337 }
1338
1339 it->second->SetRenderer(renderer);
1340 return true;
1341}
1342
1343bool WebRtcVideoChannel2::GetRenderer(uint32 ssrc, VideoRenderer** renderer) {
1344 if (ssrc == 0) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001345 *renderer = default_unsignalled_ssrc_handler_.GetDefaultRenderer();
1346 return *renderer != NULL;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001347 }
1348
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001349 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001350 std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
1351 receive_streams_.find(ssrc);
1352 if (it == receive_streams_.end()) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001353 return false;
1354 }
1355 *renderer = it->second->GetRenderer();
1356 return true;
1357}
1358
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00001359bool WebRtcVideoChannel2::GetStats(VideoMediaInfo* info) {
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001360 info->Clear();
1361 FillSenderStats(info);
1362 FillReceiverStats(info);
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00001363 webrtc::Call::Stats stats = call_->GetStats();
1364 FillBandwidthEstimationStats(stats, info);
1365 if (stats.rtt_ms != -1) {
1366 for (size_t i = 0; i < info->senders.size(); ++i) {
1367 info->senders[i].rtt_ms = stats.rtt_ms;
1368 }
1369 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001370 return true;
1371}
1372
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001373void WebRtcVideoChannel2::FillSenderStats(VideoMediaInfo* video_media_info) {
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001374 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001375 for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1376 send_streams_.begin();
1377 it != send_streams_.end();
1378 ++it) {
1379 video_media_info->senders.push_back(it->second->GetVideoSenderInfo());
1380 }
1381}
1382
1383void WebRtcVideoChannel2::FillReceiverStats(VideoMediaInfo* video_media_info) {
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001384 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001385 for (std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
1386 receive_streams_.begin();
1387 it != receive_streams_.end();
1388 ++it) {
1389 video_media_info->receivers.push_back(it->second->GetVideoReceiverInfo());
1390 }
1391}
1392
1393void WebRtcVideoChannel2::FillBandwidthEstimationStats(
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00001394 const webrtc::Call::Stats& stats,
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001395 VideoMediaInfo* video_media_info) {
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001396 BandwidthEstimationInfo bwe_info;
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001397 bwe_info.available_send_bandwidth = stats.send_bandwidth_bps;
1398 bwe_info.available_recv_bandwidth = stats.recv_bandwidth_bps;
1399 bwe_info.bucket_delay = stats.pacer_delay_ms;
1400
1401 // Get send stream bitrate stats.
1402 rtc::CritScope stream_lock(&stream_crit_);
1403 for (std::map<uint32, WebRtcVideoSendStream*>::iterator stream =
1404 send_streams_.begin();
1405 stream != send_streams_.end();
1406 ++stream) {
1407 stream->second->FillBandwidthEstimationInfo(&bwe_info);
1408 }
1409 video_media_info->bw_estimations.push_back(bwe_info);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001410}
1411
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001412bool WebRtcVideoChannel2::SetCapturer(uint32 ssrc, VideoCapturer* capturer) {
1413 LOG(LS_INFO) << "SetCapturer: " << ssrc << " -> "
1414 << (capturer != NULL ? "(capturer)" : "NULL");
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +02001415 DCHECK(ssrc != 0);
Peter Boströme7b221f2015-04-13 15:34:32 +02001416 {
1417 rtc::CritScope stream_lock(&stream_crit_);
1418 if (send_streams_.find(ssrc) == send_streams_.end()) {
1419 LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc;
1420 return false;
1421 }
1422 if (!send_streams_[ssrc]->SetCapturer(capturer)) {
1423 return false;
1424 }
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001425 }
1426
1427 if (capturer) {
1428 capturer->SetApplyRotation(
1429 !FindHeaderExtension(send_rtp_extensions_,
1430 kRtpVideoRotationHeaderExtension));
1431 }
Peter Boströme7b221f2015-04-13 15:34:32 +02001432 {
1433 rtc::CritScope lock(&capturer_crit_);
1434 capturers_[ssrc] = capturer;
1435 }
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001436 return true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001437}
1438
1439bool WebRtcVideoChannel2::SendIntraFrame() {
1440 // TODO(pbos): Implement.
1441 LOG(LS_VERBOSE) << "SendIntraFrame().";
1442 return true;
1443}
1444
1445bool WebRtcVideoChannel2::RequestIntraFrame() {
1446 // TODO(pbos): Implement.
1447 LOG(LS_VERBOSE) << "SendIntraFrame().";
1448 return true;
1449}
1450
1451void WebRtcVideoChannel2::OnPacketReceived(
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001452 rtc::Buffer* packet,
1453 const rtc::PacketTime& packet_time) {
stefan68786d22015-09-08 05:36:15 -07001454 const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp,
1455 packet_time.not_before);
pbos@webrtc.org4e545cc2014-05-14 13:58:13 +00001456 const webrtc::PacketReceiver::DeliveryStatus delivery_result =
stefan68786d22015-09-08 05:36:15 -07001457 call_->Receiver()->DeliverPacket(
1458 webrtc::MediaType::VIDEO,
1459 reinterpret_cast<const uint8_t*>(packet->data()), packet->size(),
1460 webrtc_packet_time);
pbos@webrtc.org4e545cc2014-05-14 13:58:13 +00001461 switch (delivery_result) {
1462 case webrtc::PacketReceiver::DELIVERY_OK:
1463 return;
1464 case webrtc::PacketReceiver::DELIVERY_PACKET_ERROR:
1465 return;
1466 case webrtc::PacketReceiver::DELIVERY_UNKNOWN_SSRC:
1467 break;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001468 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001469
1470 uint32 ssrc = 0;
kwiberg@webrtc.orgeebcab52015-03-24 09:19:06 +00001471 if (!GetRtpSsrc(packet->data(), packet->size(), &ssrc)) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001472 return;
1473 }
1474
noahricd10a68e2015-07-10 11:27:55 -07001475 int payload_type = 0;
1476 if (!GetRtpPayloadType(packet->data(), packet->size(), &payload_type)) {
1477 return;
1478 }
1479
1480 // See if this payload_type is registered as one that usually gets its own
1481 // SSRC (RTX) or at least is safe to drop either way (ULPFEC). If it is, and
1482 // it wasn't handled above by DeliverPacket, that means we don't know what
1483 // stream it associates with, and we shouldn't ever create an implicit channel
1484 // for these.
1485 for (auto& codec : recv_codecs_) {
1486 if (payload_type == codec.rtx_payload_type ||
1487 payload_type == codec.fec.red_rtx_payload_type ||
1488 payload_type == codec.fec.ulpfec_payload_type) {
1489 return;
1490 }
1491 }
1492
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001493 switch (unsignalled_ssrc_handler_->OnUnsignalledSsrc(this, ssrc)) {
1494 case UnsignalledSsrcHandler::kDropPacket:
1495 return;
1496 case UnsignalledSsrcHandler::kDeliverPacket:
1497 break;
1498 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001499
stefan68786d22015-09-08 05:36:15 -07001500 if (call_->Receiver()->DeliverPacket(
1501 webrtc::MediaType::VIDEO,
1502 reinterpret_cast<const uint8_t*>(packet->data()), packet->size(),
1503 webrtc_packet_time) != webrtc::PacketReceiver::DELIVERY_OK) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001504 LOG(LS_WARNING) << "Failed to deliver RTP packet on re-delivery.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001505 return;
1506 }
1507}
1508
1509void WebRtcVideoChannel2::OnRtcpReceived(
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001510 rtc::Buffer* packet,
1511 const rtc::PacketTime& packet_time) {
stefan68786d22015-09-08 05:36:15 -07001512 const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp,
1513 packet_time.not_before);
1514 if (call_->Receiver()->DeliverPacket(
1515 webrtc::MediaType::VIDEO,
1516 reinterpret_cast<const uint8_t*>(packet->data()), packet->size(),
1517 webrtc_packet_time) != webrtc::PacketReceiver::DELIVERY_OK) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001518 LOG(LS_WARNING) << "Failed to deliver RTCP packet.";
1519 }
1520}
1521
1522void WebRtcVideoChannel2::OnReadyToSend(bool ready) {
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00001523 LOG(LS_VERBOSE) << "OnReadyToSend: " << (ready ? "Ready." : "Not ready.");
Jelena Marusiccd670222015-07-16 09:30:09 +02001524 call_->SignalNetworkState(ready ? webrtc::kNetworkUp : webrtc::kNetworkDown);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001525}
1526
1527bool WebRtcVideoChannel2::MuteStream(uint32 ssrc, bool mute) {
1528 LOG(LS_VERBOSE) << "MuteStream: " << ssrc << " -> "
1529 << (mute ? "mute" : "unmute");
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +02001530 DCHECK(ssrc != 0);
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001531 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001532 if (send_streams_.find(ssrc) == send_streams_.end()) {
1533 LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc;
1534 return false;
1535 }
pbos@webrtc.orgef8bb8d2014-08-13 21:36:18 +00001536
1537 send_streams_[ssrc]->MuteStream(mute);
1538 return true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001539}
1540
1541bool WebRtcVideoChannel2::SetRecvRtpHeaderExtensions(
1542 const std::vector<RtpHeaderExtension>& extensions) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +00001543 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRecvRtpHeaderExtensions");
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001544 LOG(LS_INFO) << "SetRecvRtpHeaderExtensions: "
1545 << RtpExtensionsToString(extensions);
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001546 if (!ValidateRtpHeaderExtensionIds(extensions))
1547 return false;
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001548
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001549 std::vector<webrtc::RtpExtension> filtered_extensions =
1550 FilterRtpExtensions(extensions);
deadbeef874ca3a2015-08-20 17:19:20 -07001551 if (!RtpExtensionsHaveChanged(recv_rtp_extensions_, filtered_extensions)) {
1552 LOG(LS_INFO) << "Ignoring call to SetRecvRtpHeaderExtensions because "
1553 "header extensions haven't changed.";
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001554 return true;
deadbeef874ca3a2015-08-20 17:19:20 -07001555 }
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001556
1557 recv_rtp_extensions_ = filtered_extensions;
1558
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001559 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001560 for (std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
1561 receive_streams_.begin();
1562 it != receive_streams_.end();
1563 ++it) {
1564 it->second->SetRtpExtensions(recv_rtp_extensions_);
1565 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001566 return true;
1567}
1568
1569bool WebRtcVideoChannel2::SetSendRtpHeaderExtensions(
1570 const std::vector<RtpHeaderExtension>& extensions) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +00001571 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetSendRtpHeaderExtensions");
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001572 LOG(LS_INFO) << "SetSendRtpHeaderExtensions: "
1573 << RtpExtensionsToString(extensions);
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001574 if (!ValidateRtpHeaderExtensionIds(extensions))
1575 return false;
1576
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001577 std::vector<webrtc::RtpExtension> filtered_extensions =
1578 FilterRtpExtensions(extensions);
deadbeef874ca3a2015-08-20 17:19:20 -07001579 if (!RtpExtensionsHaveChanged(send_rtp_extensions_, filtered_extensions)) {
1580 LOG(LS_INFO) << "Ignoring call to SetSendRtpHeaderExtensions because "
1581 "header extensions haven't changed.";
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001582 return true;
deadbeef874ca3a2015-08-20 17:19:20 -07001583 }
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001584
1585 send_rtp_extensions_ = filtered_extensions;
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001586
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001587 const webrtc::RtpExtension* cvo_extension = FindHeaderExtension(
1588 send_rtp_extensions_, kRtpVideoRotationHeaderExtension);
1589
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001590 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001591 for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1592 send_streams_.begin();
1593 it != send_streams_.end();
1594 ++it) {
1595 it->second->SetRtpExtensions(send_rtp_extensions_);
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001596 it->second->SetApplyRotation(!cvo_extension);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001597 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001598 return true;
1599}
1600
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001601// Counter-intuitively this method doesn't only set global bitrate caps but also
1602// per-stream codec max bitrates. This is to permit SetMaxSendBitrate (b=AS) to
1603// raise bitrates above the 2000k default bitrate cap.
pbos@webrtc.org00873182014-11-25 14:03:34 +00001604bool WebRtcVideoChannel2::SetMaxSendBandwidth(int max_bitrate_bps) {
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001605 // TODO(pbos): Figure out whether b=AS means max bitrate for this
1606 // WebRtcVideoChannel2 (in which case we're good), or per sender (SSRC), in
1607 // which case this should not set a Call::BitrateConfig but rather reconfigure
1608 // all senders.
pbos@webrtc.org00873182014-11-25 14:03:34 +00001609 LOG(LS_INFO) << "SetMaxSendBandwidth: " << max_bitrate_bps << "bps.";
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001610 if (max_bitrate_bps == bitrate_config_.max_bitrate_bps)
1611 return true;
1612
pbos@webrtc.org00873182014-11-25 14:03:34 +00001613 if (max_bitrate_bps <= 0) {
1614 // Unsetting max bitrate.
1615 max_bitrate_bps = -1;
1616 }
1617 bitrate_config_.start_bitrate_bps = -1;
1618 bitrate_config_.max_bitrate_bps = max_bitrate_bps;
1619 if (max_bitrate_bps > 0 &&
1620 bitrate_config_.min_bitrate_bps > max_bitrate_bps) {
1621 bitrate_config_.min_bitrate_bps = max_bitrate_bps;
1622 }
1623 call_->SetBitrateConfig(bitrate_config_);
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001624 rtc::CritScope stream_lock(&stream_crit_);
1625 for (auto& kv : send_streams_)
1626 kv.second->SetMaxBitrateBps(max_bitrate_bps);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001627 return true;
1628}
1629
1630bool WebRtcVideoChannel2::SetOptions(const VideoOptions& options) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +00001631 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetOptions");
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001632 LOG(LS_INFO) << "SetOptions: " << options.ToString();
1633 VideoOptions old_options = options_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001634 options_.SetAll(options);
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001635 if (options_ == old_options) {
1636 // No new options to set.
1637 return true;
1638 }
Peter Boströme7b221f2015-04-13 15:34:32 +02001639 {
1640 rtc::CritScope lock(&capturer_crit_);
1641 options_.cpu_overuse_detection.Get(&signal_cpu_adaptation_);
1642 }
pbos@webrtc.orgd8198032014-11-10 14:41:43 +00001643 rtc::DiffServCodePoint dscp = options_.dscp.GetWithDefaultIfUnset(false)
1644 ? rtc::DSCP_AF41
1645 : rtc::DSCP_DEFAULT;
1646 MediaChannel::SetDscp(dscp);
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001647 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001648 for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1649 send_streams_.begin();
1650 it != send_streams_.end();
1651 ++it) {
1652 it->second->SetOptions(options_);
1653 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001654 return true;
1655}
1656
1657void WebRtcVideoChannel2::SetInterface(NetworkInterface* iface) {
1658 MediaChannel::SetInterface(iface);
1659 // Set the RTP recv/send buffer to a bigger size
1660 MediaChannel::SetOption(NetworkInterface::ST_RTP,
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001661 rtc::Socket::OPT_RCVBUF,
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001662 kVideoRtpBufferSize);
1663
buildbot@webrtc.orgae694ef2014-10-28 17:37:17 +00001664 // Speculative change to increase the outbound socket buffer size.
1665 // In b/15152257, we are seeing a significant number of packets discarded
1666 // due to lack of socket buffer space, although it's not yet clear what the
1667 // ideal value should be.
1668 MediaChannel::SetOption(NetworkInterface::ST_RTP,
1669 rtc::Socket::OPT_SNDBUF,
1670 kVideoRtpBufferSize);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001671}
1672
1673void WebRtcVideoChannel2::UpdateAspectRatio(int ratio_w, int ratio_h) {
1674 // TODO(pbos): Implement.
1675}
1676
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001677void WebRtcVideoChannel2::OnMessage(rtc::Message* msg) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001678 // Ignored.
1679}
1680
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001681void WebRtcVideoChannel2::OnLoadUpdate(Load load) {
Peter Boströme7b221f2015-04-13 15:34:32 +02001682 // OnLoadUpdate can not take any locks that are held while creating streams
1683 // etc. Doing so establishes lock-order inversions between the webrtc process
1684 // thread on stream creation and locks such as stream_crit_ while calling out.
1685 rtc::CritScope stream_lock(&capturer_crit_);
1686 if (!signal_cpu_adaptation_)
1687 return;
Erik Språngefbde372015-04-29 16:21:28 +02001688 // Do not adapt resolution for screen content as this will likely result in
1689 // blurry and unreadable text.
Peter Boströme7b221f2015-04-13 15:34:32 +02001690 for (auto& kv : capturers_) {
Erik Språngefbde372015-04-29 16:21:28 +02001691 if (kv.second != nullptr
1692 && !kv.second->IsScreencast()
1693 && kv.second->video_adapter() != nullptr) {
Peter Boströme7b221f2015-04-13 15:34:32 +02001694 kv.second->video_adapter()->OnCpuResolutionRequest(
1695 load == kOveruse ? CoordinatedVideoAdapter::DOWNGRADE
1696 : CoordinatedVideoAdapter::UPGRADE);
1697 }
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001698 }
1699}
1700
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001701bool WebRtcVideoChannel2::SendRtp(const uint8_t* data, size_t len) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001702 rtc::Buffer packet(data, len, kMaxRtpPacketLen);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001703 return MediaChannel::SendPacket(&packet);
1704}
1705
1706bool WebRtcVideoChannel2::SendRtcp(const uint8_t* data, size_t len) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001707 rtc::Buffer packet(data, len, kMaxRtpPacketLen);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001708 return MediaChannel::SendRtcp(&packet);
1709}
1710
1711void WebRtcVideoChannel2::StartAllSendStreams() {
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001712 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001713 for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1714 send_streams_.begin();
1715 it != send_streams_.end();
1716 ++it) {
1717 it->second->Start();
1718 }
1719}
1720
1721void WebRtcVideoChannel2::StopAllSendStreams() {
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001722 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001723 for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1724 send_streams_.begin();
1725 it != send_streams_.end();
1726 ++it) {
1727 it->second->Stop();
1728 }
1729}
1730
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001731WebRtcVideoChannel2::WebRtcVideoSendStream::VideoSendStreamParameters::
1732 VideoSendStreamParameters(
1733 const webrtc::VideoSendStream::Config& config,
1734 const VideoOptions& options,
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001735 int max_bitrate_bps,
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001736 const Settable<VideoCodecSettings>& codec_settings)
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001737 : config(config),
1738 options(options),
1739 max_bitrate_bps(max_bitrate_bps),
1740 codec_settings(codec_settings) {
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001741}
1742
Peter Boström4d71ede2015-05-19 23:09:35 +02001743WebRtcVideoChannel2::WebRtcVideoSendStream::AllocatedEncoder::AllocatedEncoder(
1744 webrtc::VideoEncoder* encoder,
1745 webrtc::VideoCodecType type,
1746 bool external)
1747 : encoder(encoder),
1748 external_encoder(nullptr),
1749 type(type),
1750 external(external) {
1751 if (external) {
1752 external_encoder = encoder;
1753 this->encoder =
1754 new webrtc::VideoEncoderSoftwareFallbackWrapper(type, encoder);
1755 }
1756}
1757
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001758WebRtcVideoChannel2::WebRtcVideoSendStream::WebRtcVideoSendStream(
1759 webrtc::Call* call,
solenberg4fbae2b2015-08-28 04:07:10 -07001760 const StreamParams& sp,
1761 const webrtc::VideoSendStream::Config& config,
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001762 WebRtcVideoEncoderFactory* external_encoder_factory,
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001763 const VideoOptions& options,
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001764 int max_bitrate_bps,
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001765 const Settable<VideoCodecSettings>& codec_settings,
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001766 const std::vector<webrtc::RtpExtension>& rtp_extensions)
Henrik Kjellander7c027b62015-04-22 13:21:30 +02001767 : ssrcs_(sp.ssrcs),
Peter Boström259bd202015-05-28 13:39:50 +02001768 ssrc_groups_(sp.ssrc_groups),
Henrik Kjellander7c027b62015-04-22 13:21:30 +02001769 call_(call),
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001770 external_encoder_factory_(external_encoder_factory),
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001771 stream_(NULL),
solenberg4fbae2b2015-08-28 04:07:10 -07001772 parameters_(config, options, max_bitrate_bps, codec_settings),
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001773 allocated_encoder_(NULL, webrtc::kVideoCodecUnknown, false),
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +00001774 capturer_(NULL),
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001775 sending_(false),
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00001776 muted_(false),
qiangchenc27d89f2015-07-16 10:27:16 -07001777 old_adapt_changes_(0),
1778 first_frame_timestamp_ms_(0),
1779 last_frame_timestamp_ms_(0) {
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001780 parameters_.config.rtp.max_packet_size = kVideoMtu;
1781
1782 sp.GetPrimarySsrcs(&parameters_.config.rtp.ssrcs);
1783 sp.GetFidSsrcs(parameters_.config.rtp.ssrcs,
1784 &parameters_.config.rtp.rtx.ssrcs);
1785 parameters_.config.rtp.c_name = sp.cname;
1786 parameters_.config.rtp.extensions = rtp_extensions;
1787
1788 VideoCodecSettings params;
1789 if (codec_settings.Get(&params)) {
1790 SetCodec(params);
1791 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001792}
1793
1794WebRtcVideoChannel2::WebRtcVideoSendStream::~WebRtcVideoSendStream() {
1795 DisconnectCapturer();
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001796 if (stream_ != NULL) {
1797 call_->DestroyVideoSendStream(stream_);
1798 }
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001799 DestroyVideoEncoder(&allocated_encoder_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001800}
1801
Miguel Casas-Sanchez47650702015-05-29 17:21:40 -07001802static void CreateBlackFrame(webrtc::VideoFrame* video_frame,
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001803 int width,
1804 int height) {
pbos@webrtc.orgb4987bf2015-02-18 10:13:09 +00001805 video_frame->CreateEmptyFrame(width, height, width, (width + 1) / 2,
1806 (width + 1) / 2);
1807 memset(video_frame->buffer(webrtc::kYPlane), 16,
1808 video_frame->allocated_size(webrtc::kYPlane));
1809 memset(video_frame->buffer(webrtc::kUPlane), 128,
1810 video_frame->allocated_size(webrtc::kUPlane));
1811 memset(video_frame->buffer(webrtc::kVPlane), 128,
1812 video_frame->allocated_size(webrtc::kVPlane));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001813}
1814
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001815void WebRtcVideoChannel2::WebRtcVideoSendStream::InputFrame(
1816 VideoCapturer* capturer,
1817 const VideoFrame* frame) {
pbos@webrtc.org86196c42015-02-16 21:02:00 +00001818 TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::InputFrame");
Miguel Casas-Sanchez47650702015-05-29 17:21:40 -07001819 webrtc::VideoFrame video_frame(frame->GetVideoFrameBuffer(), 0, 0,
1820 frame->GetVideoRotation());
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001821 rtc::CritScope cs(&lock_);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001822 if (stream_ == NULL) {
Peter Boströmad1f9b62015-04-08 14:04:01 +02001823 // Frame input before send codecs are configured, dropping frame.
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001824 return;
1825 }
pbos@webrtc.org86196c42015-02-16 21:02:00 +00001826
1827 // Not sending, abort early to prevent expensive reconfigurations while
1828 // setting up codecs etc.
1829 if (!sending_)
1830 return;
1831
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001832 if (format_.width == 0) { // Dropping frames.
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +02001833 DCHECK(format_.height == 0);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001834 LOG(LS_VERBOSE) << "VideoFormat 0x0 set, Dropping frame.";
1835 return;
1836 }
pbos@webrtc.orgd60d79a2014-09-24 07:10:57 +00001837 if (muted_) {
1838 // Create a black frame to transmit instead.
magjed@webrtc.orgafdd5dd2015-03-12 13:11:25 +00001839 CreateBlackFrame(&video_frame,
pbos@webrtc.orgd60d79a2014-09-24 07:10:57 +00001840 static_cast<int>(frame->GetWidth()),
1841 static_cast<int>(frame->GetHeight()));
1842 }
qiangchenc27d89f2015-07-16 10:27:16 -07001843
1844 int64_t frame_delta_ms = frame->GetTimeStamp() / rtc::kNumNanosecsPerMillisec;
1845 // frame->GetTimeStamp() is essentially a delta, align to webrtc time
1846 if (first_frame_timestamp_ms_ == 0) {
1847 first_frame_timestamp_ms_ = rtc::Time() - frame_delta_ms;
1848 }
1849
1850 last_frame_timestamp_ms_ = first_frame_timestamp_ms_ + frame_delta_ms;
1851 video_frame.set_render_time_ms(last_frame_timestamp_ms_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001852 // Reconfigure codec if necessary.
pbos@webrtc.orgc4175b92014-09-03 15:25:49 +00001853 SetDimensions(
magjed@webrtc.orgafdd5dd2015-03-12 13:11:25 +00001854 video_frame.width(), video_frame.height(), capturer->IsScreencast());
pbos@webrtc.orgc4175b92014-09-03 15:25:49 +00001855
perkj@webrtc.orgaf612d52015-03-18 09:51:05 +00001856 stream_->Input()->IncomingCapturedFrame(video_frame);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001857}
1858
1859bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetCapturer(
1860 VideoCapturer* capturer) {
pbos@webrtc.orgb4987bf2015-02-18 10:13:09 +00001861 TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::SetCapturer");
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001862 if (!DisconnectCapturer() && capturer == NULL) {
1863 return false;
1864 }
1865
1866 {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001867 rtc::CritScope cs(&lock_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001868
pbos@webrtc.org9359cb32014-07-23 15:44:48 +00001869 if (capturer == NULL) {
1870 if (stream_ != NULL) {
1871 LOG(LS_VERBOSE) << "Disabling capturer, sending black frame.";
Miguel Casas-Sanchez47650702015-05-29 17:21:40 -07001872 webrtc::VideoFrame black_frame;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001873
pbos@webrtc.orgb4987bf2015-02-18 10:13:09 +00001874 CreateBlackFrame(&black_frame, last_dimensions_.width,
1875 last_dimensions_.height);
qiangchenc27d89f2015-07-16 10:27:16 -07001876
1877 // Force this black frame not to be dropped due to timestamp order
1878 // check. As IncomingCapturedFrame will drop the frame if this frame's
1879 // timestamp is less than or equal to last frame's timestamp, it is
1880 // necessary to give this black frame a larger timestamp than the
1881 // previous one.
1882 last_frame_timestamp_ms_ +=
1883 format_.interval / rtc::kNumNanosecsPerMillisec;
1884 black_frame.set_render_time_ms(last_frame_timestamp_ms_);
perkj@webrtc.orgaf612d52015-03-18 09:51:05 +00001885 stream_->Input()->IncomingCapturedFrame(black_frame);
pbos@webrtc.org9359cb32014-07-23 15:44:48 +00001886 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001887
1888 capturer_ = NULL;
1889 return true;
1890 }
1891
1892 capturer_ = capturer;
1893 }
1894 // Lock cannot be held while connecting the capturer to prevent lock-order
1895 // violations.
1896 capturer->SignalVideoFrame.connect(this, &WebRtcVideoSendStream::InputFrame);
1897 return true;
1898}
1899
1900bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetVideoFormat(
1901 const VideoFormat& format) {
1902 if ((format.width == 0 || format.height == 0) &&
1903 format.width != format.height) {
1904 LOG(LS_ERROR) << "Can't set VideoFormat, width or height is zero (but not "
1905 "both, 0x0 drops frames).";
1906 return false;
1907 }
1908
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001909 rtc::CritScope cs(&lock_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001910 if (format.width == 0 && format.height == 0) {
1911 LOG(LS_INFO)
1912 << "0x0 resolution selected. Captured frames will be dropped for ssrc: "
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001913 << parameters_.config.rtp.ssrcs[0] << ".";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001914 } else {
1915 // TODO(pbos): Fix me, this only affects the last stream!
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00001916 parameters_.encoder_config.streams.back().max_framerate =
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001917 VideoFormat::IntervalToFps(format.interval);
pbos@webrtc.orgc4175b92014-09-03 15:25:49 +00001918 SetDimensions(format.width, format.height, false);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001919 }
1920
1921 format_ = format;
1922 return true;
1923}
1924
pbos@webrtc.orgef8bb8d2014-08-13 21:36:18 +00001925void WebRtcVideoChannel2::WebRtcVideoSendStream::MuteStream(bool mute) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001926 rtc::CritScope cs(&lock_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001927 muted_ = mute;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001928}
1929
1930bool WebRtcVideoChannel2::WebRtcVideoSendStream::DisconnectCapturer() {
pbos@webrtc.org963b9792014-10-07 14:27:27 +00001931 cricket::VideoCapturer* capturer;
1932 {
1933 rtc::CritScope cs(&lock_);
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00001934 if (capturer_ == NULL)
pbos@webrtc.org963b9792014-10-07 14:27:27 +00001935 return false;
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00001936
1937 if (capturer_->video_adapter() != nullptr)
1938 old_adapt_changes_ += capturer_->video_adapter()->adaptation_changes();
1939
pbos@webrtc.org963b9792014-10-07 14:27:27 +00001940 capturer = capturer_;
1941 capturer_ = NULL;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001942 }
pbos@webrtc.org963b9792014-10-07 14:27:27 +00001943 capturer->SignalVideoFrame.disconnect(this);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001944 return true;
1945}
1946
Peter Boströmd6f4c252015-03-26 16:23:04 +01001947const std::vector<uint32>&
1948WebRtcVideoChannel2::WebRtcVideoSendStream::GetSsrcs() const {
1949 return ssrcs_;
1950}
1951
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001952void WebRtcVideoChannel2::WebRtcVideoSendStream::SetApplyRotation(
1953 bool apply_rotation) {
1954 rtc::CritScope cs(&lock_);
1955 if (capturer_ == NULL)
1956 return;
1957
1958 capturer_->SetApplyRotation(apply_rotation);
1959}
1960
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001961void WebRtcVideoChannel2::WebRtcVideoSendStream::SetOptions(
1962 const VideoOptions& options) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001963 rtc::CritScope cs(&lock_);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001964 VideoCodecSettings codec_settings;
1965 if (parameters_.codec_settings.Get(&codec_settings)) {
deadbeef874ca3a2015-08-20 17:19:20 -07001966 LOG(LS_INFO) << "SetCodecAndOptions because of SetOptions; options="
1967 << options.ToString();
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001968 SetCodecAndOptions(codec_settings, options);
1969 } else {
1970 parameters_.options = options;
1971 }
1972}
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001973
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001974void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodec(
1975 const VideoCodecSettings& codec_settings) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001976 rtc::CritScope cs(&lock_);
deadbeef874ca3a2015-08-20 17:19:20 -07001977 LOG(LS_INFO) << "SetCodecAndOptions because of SetCodec.";
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001978 SetCodecAndOptions(codec_settings, parameters_.options);
1979}
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001980
1981webrtc::VideoCodecType CodecTypeFromName(const std::string& name) {
Shao Changbine62202f2015-04-21 20:24:50 +08001982 if (CodecNamesEq(name, kVp8CodecName)) {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001983 return webrtc::kVideoCodecVP8;
Shao Changbine62202f2015-04-21 20:24:50 +08001984 } else if (CodecNamesEq(name, kVp9CodecName)) {
andresp@webrtc.org188d3b22014-11-07 13:21:04 +00001985 return webrtc::kVideoCodecVP9;
Shao Changbine62202f2015-04-21 20:24:50 +08001986 } else if (CodecNamesEq(name, kH264CodecName)) {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001987 return webrtc::kVideoCodecH264;
1988 }
1989 return webrtc::kVideoCodecUnknown;
1990}
1991
1992WebRtcVideoChannel2::WebRtcVideoSendStream::AllocatedEncoder
1993WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoder(
1994 const VideoCodec& codec) {
1995 webrtc::VideoCodecType type = CodecTypeFromName(codec.name);
1996
1997 // Do not re-create encoders of the same type.
1998 if (type == allocated_encoder_.type && allocated_encoder_.encoder != NULL) {
1999 return allocated_encoder_;
2000 }
2001
2002 if (external_encoder_factory_ != NULL) {
2003 webrtc::VideoEncoder* encoder =
2004 external_encoder_factory_->CreateVideoEncoder(type);
2005 if (encoder != NULL) {
2006 return AllocatedEncoder(encoder, type, true);
2007 }
2008 }
2009
2010 if (type == webrtc::kVideoCodecVP8) {
2011 return AllocatedEncoder(
2012 webrtc::VideoEncoder::Create(webrtc::VideoEncoder::kVp8), type, false);
andresp@webrtc.org188d3b22014-11-07 13:21:04 +00002013 } else if (type == webrtc::kVideoCodecVP9) {
2014 return AllocatedEncoder(
2015 webrtc::VideoEncoder::Create(webrtc::VideoEncoder::kVp9), type, false);
Zeke Chin71f6f442015-06-29 14:34:58 -07002016 } else if (type == webrtc::kVideoCodecH264) {
2017 return AllocatedEncoder(
2018 webrtc::VideoEncoder::Create(webrtc::VideoEncoder::kH264), type, false);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00002019 }
2020
2021 // This shouldn't happen, we should not be trying to create something we don't
2022 // support.
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +02002023 DCHECK(false);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00002024 return AllocatedEncoder(NULL, webrtc::kVideoCodecUnknown, false);
2025}
2026
2027void WebRtcVideoChannel2::WebRtcVideoSendStream::DestroyVideoEncoder(
2028 AllocatedEncoder* encoder) {
2029 if (encoder->external) {
Peter Boström4d71ede2015-05-19 23:09:35 +02002030 external_encoder_factory_->DestroyVideoEncoder(encoder->external_encoder);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00002031 }
Peter Boström4d71ede2015-05-19 23:09:35 +02002032 delete encoder->encoder;
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00002033}
2034
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00002035void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodecAndOptions(
2036 const VideoCodecSettings& codec_settings,
2037 const VideoOptions& options) {
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002038 parameters_.encoder_config =
2039 CreateVideoEncoderConfig(last_dimensions_, codec_settings.codec);
pbos@webrtc.org86196c42015-02-16 21:02:00 +00002040 if (parameters_.encoder_config.streams.empty())
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002041 return;
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002042
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00002043 format_ = VideoFormat(codec_settings.codec.width,
2044 codec_settings.codec.height,
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002045 VideoFormat::FpsToInterval(30),
2046 FOURCC_I420);
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00002047
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00002048 AllocatedEncoder new_encoder = CreateVideoEncoder(codec_settings.codec);
2049 parameters_.config.encoder_settings.encoder = new_encoder.encoder;
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00002050 parameters_.config.encoder_settings.payload_name = codec_settings.codec.name;
2051 parameters_.config.encoder_settings.payload_type = codec_settings.codec.id;
sophiechang47d78cc2015-09-03 18:24:44 -07002052 if (new_encoder.external) {
2053 webrtc::VideoCodecType type = CodecTypeFromName(codec_settings.codec.name);
2054 parameters_.config.encoder_settings.internal_source =
2055 external_encoder_factory_->EncoderTypeHasInternalSource(type);
2056 }
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00002057 parameters_.config.rtp.fec = codec_settings.fec;
2058
2059 // Set RTX payload type if RTX is enabled.
2060 if (!parameters_.config.rtp.rtx.ssrcs.empty()) {
pbos@webrtc.orgb9557a92015-03-20 19:52:56 +00002061 if (codec_settings.rtx_payload_type == -1) {
2062 LOG(LS_WARNING) << "RTX SSRCs configured but there's no configured RTX "
2063 "payload type. Ignoring.";
2064 parameters_.config.rtp.rtx.ssrcs.clear();
2065 } else {
2066 parameters_.config.rtp.rtx.payload_type = codec_settings.rtx_payload_type;
2067 }
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00002068 }
2069
Peter Boström67c9df72015-05-11 14:34:58 +02002070 parameters_.config.rtp.nack.rtp_history_ms =
2071 HasNack(codec_settings.codec) ? kNackHistoryMs : 0;
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00002072
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00002073 options.suspend_below_min_bitrate.Get(
2074 &parameters_.config.suspend_below_min_bitrate);
2075
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00002076 parameters_.codec_settings.Set(codec_settings);
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00002077 parameters_.options = options;
pbos@webrtc.org543e5892014-07-23 07:01:31 +00002078
deadbeef874ca3a2015-08-20 17:19:20 -07002079 LOG(LS_INFO)
2080 << "RecreateWebRtcStream (send) because of SetCodecAndOptions; options="
2081 << options.ToString();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002082 RecreateWebRtcStream();
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00002083 if (allocated_encoder_.encoder != new_encoder.encoder) {
2084 DestroyVideoEncoder(&allocated_encoder_);
2085 allocated_encoder_ = new_encoder;
2086 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002087}
2088
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002089void WebRtcVideoChannel2::WebRtcVideoSendStream::SetRtpExtensions(
2090 const std::vector<webrtc::RtpExtension>& rtp_extensions) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00002091 rtc::CritScope cs(&lock_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002092 parameters_.config.rtp.extensions = rtp_extensions;
deadbeef874ca3a2015-08-20 17:19:20 -07002093 if (stream_ != nullptr) {
2094 LOG(LS_INFO) << "RecreateWebRtcStream (send) because of SetRtpExtensions";
Peter Boström3c3f6462015-04-15 16:27:49 +02002095 RecreateWebRtcStream();
deadbeef874ca3a2015-08-20 17:19:20 -07002096 }
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002097}
2098
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002099webrtc::VideoEncoderConfig
2100WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoderConfig(
2101 const Dimensions& dimensions,
2102 const VideoCodec& codec) const {
2103 webrtc::VideoEncoderConfig encoder_config;
2104 if (dimensions.is_screencast) {
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00002105 int screencast_min_bitrate_kbps;
2106 parameters_.options.screencast_min_bitrate.Get(
2107 &screencast_min_bitrate_kbps);
2108 encoder_config.min_transmit_bitrate_bps =
2109 screencast_min_bitrate_kbps * 1000;
Erik Språng143cec12015-04-28 10:01:41 +02002110 encoder_config.content_type =
2111 webrtc::VideoEncoderConfig::ContentType::kScreen;
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00002112 } else {
2113 encoder_config.min_transmit_bitrate_bps = 0;
Erik Språng143cec12015-04-28 10:01:41 +02002114 encoder_config.content_type =
2115 webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo;
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00002116 }
2117
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002118 // Restrict dimensions according to codec max.
2119 int width = dimensions.width;
2120 int height = dimensions.height;
2121 if (!dimensions.is_screencast) {
2122 if (codec.width < width)
2123 width = codec.width;
2124 if (codec.height < height)
2125 height = codec.height;
2126 }
2127
2128 VideoCodec clamped_codec = codec;
2129 clamped_codec.width = width;
2130 clamped_codec.height = height;
pbos@webrtc.orgcddd17c2014-09-16 16:33:13 +00002131
noahricfdac5162015-08-27 01:59:29 -07002132 // By default, the stream count for the codec configuration should match the
2133 // number of negotiated ssrcs. But if the codec is blacklisted for simulcast
2134 // or a screencast, only configure a single stream.
2135 size_t stream_count = parameters_.config.rtp.ssrcs.size();
2136 if (IsCodecBlacklistedForSimulcast(codec.name) || dimensions.is_screencast) {
2137 stream_count = 1;
2138 }
2139
2140 encoder_config.streams =
2141 CreateVideoStreams(clamped_codec, parameters_.options,
2142 parameters_.max_bitrate_bps, stream_count);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002143
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00002144 // Conference mode screencast uses 2 temporal layers split at 100kbit.
2145 if (parameters_.options.conference_mode.GetWithDefaultIfUnset(false) &&
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002146 dimensions.is_screencast && encoder_config.streams.size() == 1) {
sprang@webrtc.org46d4d292014-12-23 15:19:35 +00002147 ScreenshareLayerConfig config = ScreenshareLayerConfig::GetDefault();
2148
2149 // For screenshare in conference mode, tl0 and tl1 bitrates are piggybacked
2150 // on the VideoCodec struct as target and max bitrates, respectively.
2151 // See eg. webrtc::VP8EncoderImpl::SetRates().
2152 encoder_config.streams[0].target_bitrate_bps =
2153 config.tl0_bitrate_kbps * 1000;
2154 encoder_config.streams[0].max_bitrate_bps = config.tl1_bitrate_kbps * 1000;
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00002155 encoder_config.streams[0].temporal_layer_thresholds_bps.clear();
2156 encoder_config.streams[0].temporal_layer_thresholds_bps.push_back(
sprang@webrtc.org46d4d292014-12-23 15:19:35 +00002157 config.tl0_bitrate_kbps * 1000);
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00002158 }
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002159 return encoder_config;
2160}
2161
2162void WebRtcVideoChannel2::WebRtcVideoSendStream::SetDimensions(
2163 int width,
2164 int height,
2165 bool is_screencast) {
2166 if (last_dimensions_.width == width && last_dimensions_.height == height &&
2167 last_dimensions_.is_screencast == is_screencast) {
2168 // Configured using the same parameters, do not reconfigure.
2169 return;
2170 }
2171 LOG(LS_INFO) << "SetDimensions: " << width << "x" << height
2172 << (is_screencast ? " (screencast)" : " (not screencast)");
2173
2174 last_dimensions_.width = width;
2175 last_dimensions_.height = height;
2176 last_dimensions_.is_screencast = is_screencast;
2177
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +02002178 DCHECK(!parameters_.encoder_config.streams.empty());
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002179
2180 VideoCodecSettings codec_settings;
2181 parameters_.codec_settings.Get(&codec_settings);
2182
2183 webrtc::VideoEncoderConfig encoder_config =
2184 CreateVideoEncoderConfig(last_dimensions_, codec_settings.codec);
2185
Erik Språng143cec12015-04-28 10:01:41 +02002186 encoder_config.encoder_specific_settings = ConfigureVideoEncoderSettings(
2187 codec_settings.codec, parameters_.options, is_screencast);
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00002188
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00002189 bool stream_reconfigured = stream_->ReconfigureVideoEncoder(encoder_config);
2190
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00002191 encoder_config.encoder_specific_settings = NULL;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002192
2193 if (!stream_reconfigured) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002194 LOG(LS_WARNING) << "Failed to reconfigure video encoder for dimensions: "
2195 << width << "x" << height;
2196 return;
2197 }
pbos@webrtc.orgcddd17c2014-09-16 16:33:13 +00002198
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00002199 parameters_.encoder_config = encoder_config;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002200}
2201
2202void WebRtcVideoChannel2::WebRtcVideoSendStream::Start() {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00002203 rtc::CritScope cs(&lock_);
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +02002204 DCHECK(stream_ != NULL);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002205 stream_->Start();
2206 sending_ = true;
2207}
2208
2209void WebRtcVideoChannel2::WebRtcVideoSendStream::Stop() {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00002210 rtc::CritScope cs(&lock_);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00002211 if (stream_ != NULL) {
2212 stream_->Stop();
2213 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002214 sending_ = false;
2215}
2216
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002217VideoSenderInfo
2218WebRtcVideoChannel2::WebRtcVideoSendStream::GetVideoSenderInfo() {
2219 VideoSenderInfo info;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002220 webrtc::VideoSendStream::Stats stats;
2221 {
2222 rtc::CritScope cs(&lock_);
2223 for (uint32_t ssrc : parameters_.config.rtp.ssrcs)
2224 info.add_ssrc(ssrc);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002225
Peter Boström74d9ed72015-03-26 16:28:31 +01002226 VideoCodecSettings codec_settings;
2227 if (parameters_.codec_settings.Get(&codec_settings))
2228 info.codec_name = codec_settings.codec.name;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002229 for (size_t i = 0; i < parameters_.encoder_config.streams.size(); ++i) {
2230 if (i == parameters_.encoder_config.streams.size() - 1) {
2231 info.preferred_bitrate +=
2232 parameters_.encoder_config.streams[i].max_bitrate_bps;
2233 } else {
2234 info.preferred_bitrate +=
2235 parameters_.encoder_config.streams[i].target_bitrate_bps;
2236 }
2237 }
pbos@webrtc.orgc3d2bd22014-08-12 20:55:10 +00002238
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002239 if (stream_ == NULL)
2240 return info;
2241
2242 stats = stream_->GetStats();
2243
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00002244 info.adapt_changes = old_adapt_changes_;
2245 info.adapt_reason = CoordinatedVideoAdapter::ADAPTREASON_NONE;
2246
2247 if (capturer_ != NULL) {
2248 if (!capturer_->IsMuted()) {
2249 VideoFormat last_captured_frame_format;
2250 capturer_->GetStats(&info.adapt_frame_drops, &info.effects_frame_drops,
2251 &info.capturer_frame_time,
2252 &last_captured_frame_format);
2253 info.input_frame_width = last_captured_frame_format.width;
2254 info.input_frame_height = last_captured_frame_format.height;
2255 }
2256 if (capturer_->video_adapter() != nullptr) {
2257 info.adapt_changes += capturer_->video_adapter()->adaptation_changes();
2258 info.adapt_reason = capturer_->video_adapter()->adapt_reason();
2259 }
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002260 }
2261 }
Peter Boström259bd202015-05-28 13:39:50 +02002262 info.ssrc_groups = ssrc_groups_;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002263 info.framerate_input = stats.input_frame_rate;
2264 info.framerate_sent = stats.encode_frame_rate;
pbos@webrtc.org3e6e2712015-02-26 12:19:31 +00002265 info.avg_encode_ms = stats.avg_encode_time_ms;
2266 info.encode_usage_percent = stats.encode_usage_percent;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002267
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002268 info.nominal_bitrate = stats.media_bitrate_bps;
2269
pbos@webrtc.org273a4142014-12-01 15:23:21 +00002270 info.send_frame_width = 0;
2271 info.send_frame_height = 0;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002272 for (std::map<uint32_t, webrtc::VideoSendStream::StreamStats>::iterator it =
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002273 stats.substreams.begin();
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002274 it != stats.substreams.end(); ++it) {
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002275 // TODO(pbos): Wire up additional stats, such as padding bytes.
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002276 webrtc::VideoSendStream::StreamStats stream_stats = it->second;
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59 +00002277 info.bytes_sent += stream_stats.rtp_stats.transmitted.payload_bytes +
2278 stream_stats.rtp_stats.transmitted.header_bytes +
2279 stream_stats.rtp_stats.transmitted.padding_bytes;
2280 info.packets_sent += stream_stats.rtp_stats.transmitted.packets;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002281 info.packets_lost += stream_stats.rtcp_stats.cumulative_lost;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002282 if (stream_stats.width > info.send_frame_width)
2283 info.send_frame_width = stream_stats.width;
2284 if (stream_stats.height > info.send_frame_height)
2285 info.send_frame_height = stream_stats.height;
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002286 info.firs_rcvd += stream_stats.rtcp_packet_type_counts.fir_packets;
2287 info.nacks_rcvd += stream_stats.rtcp_packet_type_counts.nack_packets;
2288 info.plis_rcvd += stream_stats.rtcp_packet_type_counts.pli_packets;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002289 }
2290
2291 if (!stats.substreams.empty()) {
2292 // TODO(pbos): Report fraction lost per SSRC.
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002293 webrtc::VideoSendStream::StreamStats first_stream_stats =
2294 stats.substreams.begin()->second;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002295 info.fraction_lost =
2296 static_cast<float>(first_stream_stats.rtcp_stats.fraction_lost) /
2297 (1 << 8);
2298 }
2299
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002300 return info;
2301}
2302
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00002303void WebRtcVideoChannel2::WebRtcVideoSendStream::FillBandwidthEstimationInfo(
2304 BandwidthEstimationInfo* bwe_info) {
2305 rtc::CritScope cs(&lock_);
2306 if (stream_ == NULL) {
2307 return;
2308 }
2309 webrtc::VideoSendStream::Stats stats = stream_->GetStats();
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002310 for (std::map<uint32_t, webrtc::VideoSendStream::StreamStats>::iterator it =
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00002311 stats.substreams.begin();
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002312 it != stats.substreams.end(); ++it) {
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00002313 bwe_info->transmit_bitrate += it->second.total_bitrate_bps;
2314 bwe_info->retransmit_bitrate += it->second.retransmit_bitrate_bps;
2315 }
pbos@webrtc.org891d4832015-02-26 13:15:22 +00002316 bwe_info->target_enc_bitrate += stats.target_media_bitrate_bps;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00002317 bwe_info->actual_enc_bitrate += stats.media_bitrate_bps;
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00002318}
2319
Peter Boströmdfd53fe2015-03-27 15:58:11 +01002320void WebRtcVideoChannel2::WebRtcVideoSendStream::SetMaxBitrateBps(
2321 int max_bitrate_bps) {
2322 rtc::CritScope cs(&lock_);
2323 parameters_.max_bitrate_bps = max_bitrate_bps;
2324
2325 // No need to reconfigure if the stream hasn't been configured yet.
2326 if (parameters_.encoder_config.streams.empty())
2327 return;
2328
2329 // Force a stream reconfigure to set the new max bitrate.
2330 int width = last_dimensions_.width;
2331 last_dimensions_.width = 0;
2332 SetDimensions(width, last_dimensions_.height, last_dimensions_.is_screencast);
2333}
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002334
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002335void WebRtcVideoChannel2::WebRtcVideoSendStream::RecreateWebRtcStream() {
2336 if (stream_ != NULL) {
2337 call_->DestroyVideoSendStream(stream_);
2338 }
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00002339
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002340 VideoCodecSettings codec_settings;
2341 parameters_.codec_settings.Get(&codec_settings);
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00002342 parameters_.encoder_config.encoder_specific_settings =
Erik Språng143cec12015-04-28 10:01:41 +02002343 ConfigureVideoEncoderSettings(
2344 codec_settings.codec, parameters_.options,
2345 parameters_.encoder_config.content_type ==
2346 webrtc::VideoEncoderConfig::ContentType::kScreen);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002347
pbos@webrtc.orgb9557a92015-03-20 19:52:56 +00002348 webrtc::VideoSendStream::Config config = parameters_.config;
2349 if (!config.rtp.rtx.ssrcs.empty() && config.rtp.rtx.payload_type == -1) {
2350 LOG(LS_WARNING) << "RTX SSRCs configured but there's no configured RTX "
2351 "payload type the set codec. Ignoring RTX.";
2352 config.rtp.rtx.ssrcs.clear();
2353 }
2354 stream_ = call_->CreateVideoSendStream(config, parameters_.encoder_config);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002355
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00002356 parameters_.encoder_config.encoder_specific_settings = NULL;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002357
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002358 if (sending_) {
2359 stream_->Start();
2360 }
2361}
2362
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002363WebRtcVideoChannel2::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
2364 webrtc::Call* call,
Peter Boström259bd202015-05-28 13:39:50 +02002365 const StreamParams& sp,
solenberg4fbae2b2015-08-28 04:07:10 -07002366 const webrtc::VideoReceiveStream::Config& config,
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002367 WebRtcVideoDecoderFactory* external_decoder_factory,
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00002368 bool default_stream,
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002369 const std::vector<VideoCodecSettings>& recv_codecs)
2370 : call_(call),
Peter Boström259bd202015-05-28 13:39:50 +02002371 ssrcs_(sp.ssrcs),
2372 ssrc_groups_(sp.ssrc_groups),
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002373 stream_(NULL),
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00002374 default_stream_(default_stream),
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +00002375 config_(config),
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002376 external_decoder_factory_(external_decoder_factory),
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +00002377 renderer_(NULL),
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002378 last_width_(-1),
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002379 last_height_(-1),
2380 first_frame_timestamp_(-1),
2381 estimated_remote_start_ntp_time_ms_(0) {
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002382 config_.renderer = this;
2383 // SetRecvCodecs will also reset (start) the VideoReceiveStream.
deadbeef874ca3a2015-08-20 17:19:20 -07002384 LOG(LS_INFO) << "SetRecvCodecs (recv) because we are creating the receive "
2385 "stream for the first time: "
2386 << CodecSettingsVectorToString(recv_codecs);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002387 SetRecvCodecs(recv_codecs);
2388}
2389
Peter Boström7252a2b2015-05-18 19:42:03 +02002390WebRtcVideoChannel2::WebRtcVideoReceiveStream::AllocatedDecoder::
2391 AllocatedDecoder(webrtc::VideoDecoder* decoder,
2392 webrtc::VideoCodecType type,
2393 bool external)
2394 : decoder(decoder),
2395 external_decoder(nullptr),
2396 type(type),
2397 external(external) {
2398 if (external) {
2399 external_decoder = decoder;
2400 this->decoder =
2401 new webrtc::VideoDecoderSoftwareFallbackWrapper(type, external_decoder);
2402 }
2403}
2404
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002405WebRtcVideoChannel2::WebRtcVideoReceiveStream::~WebRtcVideoReceiveStream() {
2406 call_->DestroyVideoReceiveStream(stream_);
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002407 ClearDecoders(&allocated_decoders_);
2408}
2409
Peter Boströmd6f4c252015-03-26 16:23:04 +01002410const std::vector<uint32>&
2411WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetSsrcs() const {
2412 return ssrcs_;
2413}
2414
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002415WebRtcVideoChannel2::WebRtcVideoReceiveStream::AllocatedDecoder
2416WebRtcVideoChannel2::WebRtcVideoReceiveStream::CreateOrReuseVideoDecoder(
2417 std::vector<AllocatedDecoder>* old_decoders,
2418 const VideoCodec& codec) {
2419 webrtc::VideoCodecType type = CodecTypeFromName(codec.name);
2420
2421 for (size_t i = 0; i < old_decoders->size(); ++i) {
2422 if ((*old_decoders)[i].type == type) {
2423 AllocatedDecoder decoder = (*old_decoders)[i];
2424 (*old_decoders)[i] = old_decoders->back();
2425 old_decoders->pop_back();
2426 return decoder;
2427 }
2428 }
2429
2430 if (external_decoder_factory_ != NULL) {
2431 webrtc::VideoDecoder* decoder =
2432 external_decoder_factory_->CreateVideoDecoder(type);
2433 if (decoder != NULL) {
2434 return AllocatedDecoder(decoder, type, true);
2435 }
2436 }
2437
2438 if (type == webrtc::kVideoCodecVP8) {
2439 return AllocatedDecoder(
2440 webrtc::VideoDecoder::Create(webrtc::VideoDecoder::kVp8), type, false);
2441 }
2442
pbos@webrtc.orgb9557a92015-03-20 19:52:56 +00002443 if (type == webrtc::kVideoCodecVP9) {
2444 return AllocatedDecoder(
2445 webrtc::VideoDecoder::Create(webrtc::VideoDecoder::kVp9), type, false);
2446 }
2447
Zeke Chin71f6f442015-06-29 14:34:58 -07002448 if (type == webrtc::kVideoCodecH264) {
2449 return AllocatedDecoder(
2450 webrtc::VideoDecoder::Create(webrtc::VideoDecoder::kH264), type, false);
2451 }
2452
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002453 // This shouldn't happen, we should not be trying to create something we don't
2454 // support.
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +02002455 DCHECK(false);
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002456 return AllocatedDecoder(NULL, webrtc::kVideoCodecUnknown, false);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002457}
2458
2459void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRecvCodecs(
2460 const std::vector<VideoCodecSettings>& recv_codecs) {
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002461 std::vector<AllocatedDecoder> old_decoders = allocated_decoders_;
2462 allocated_decoders_.clear();
2463 config_.decoders.clear();
2464 for (size_t i = 0; i < recv_codecs.size(); ++i) {
2465 AllocatedDecoder allocated_decoder =
2466 CreateOrReuseVideoDecoder(&old_decoders, recv_codecs[i].codec);
2467 allocated_decoders_.push_back(allocated_decoder);
2468
2469 webrtc::VideoReceiveStream::Decoder decoder;
2470 decoder.decoder = allocated_decoder.decoder;
2471 decoder.payload_type = recv_codecs[i].codec.id;
2472 decoder.payload_name = recv_codecs[i].codec.name;
2473 config_.decoders.push_back(decoder);
2474 }
2475
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002476 // TODO(pbos): Reconfigure RTX based on incoming recv_codecs.
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002477 config_.rtp.fec = recv_codecs.front().fec;
pbos@webrtc.org257e1302014-07-25 19:01:32 +00002478 config_.rtp.nack.rtp_history_ms =
Shao Changbine62202f2015-04-21 20:24:50 +08002479 HasNack(recv_codecs.begin()->codec) ? kNackHistoryMs : 0;
pbos@webrtc.org257e1302014-07-25 19:01:32 +00002480
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002481 ClearDecoders(&old_decoders);
deadbeef874ca3a2015-08-20 17:19:20 -07002482 LOG(LS_INFO) << "RecreateWebRtcStream (recv) because of SetRecvCodecs: "
2483 << CodecSettingsVectorToString(recv_codecs);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002484 RecreateWebRtcStream();
2485}
2486
Peter Boström3548dd22015-05-22 18:48:36 +02002487void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetLocalSsrc(
2488 uint32_t local_ssrc) {
2489 // TODO(pbos): Consider turning this sanity check into a DCHECK. You should
2490 // not be able to create a sender with the same SSRC as a receiver, but right
2491 // now this can't be done due to unittests depending on receiving what they
2492 // are sending from the same MediaChannel.
deadbeef874ca3a2015-08-20 17:19:20 -07002493 if (local_ssrc == config_.rtp.remote_ssrc) {
2494 LOG(LS_INFO) << "Ignoring call to SetLocalSsrc because parameters are "
2495 "unchanged; local_ssrc=" << local_ssrc;
Peter Boström3548dd22015-05-22 18:48:36 +02002496 return;
deadbeef874ca3a2015-08-20 17:19:20 -07002497 }
Peter Boström3548dd22015-05-22 18:48:36 +02002498
2499 config_.rtp.local_ssrc = local_ssrc;
deadbeef874ca3a2015-08-20 17:19:20 -07002500 LOG(LS_INFO)
2501 << "RecreateWebRtcStream (recv) because of SetLocalSsrc; local_ssrc="
2502 << local_ssrc;
Peter Boström3548dd22015-05-22 18:48:36 +02002503 RecreateWebRtcStream();
2504}
2505
Peter Boström67c9df72015-05-11 14:34:58 +02002506void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetNackAndRemb(
2507 bool nack_enabled, bool remb_enabled) {
2508 int nack_history_ms = nack_enabled ? kNackHistoryMs : 0;
2509 if (config_.rtp.nack.rtp_history_ms == nack_history_ms &&
2510 config_.rtp.remb == remb_enabled) {
deadbeef874ca3a2015-08-20 17:19:20 -07002511 LOG(LS_INFO) << "Ignoring call to SetNackAndRemb because parameters are "
2512 "unchanged; nack=" << nack_enabled
2513 << ", remb=" << remb_enabled;
Peter Boström126c03e2015-05-11 12:48:12 +02002514 return;
Peter Boström67c9df72015-05-11 14:34:58 +02002515 }
2516 config_.rtp.remb = remb_enabled;
2517 config_.rtp.nack.rtp_history_ms = nack_history_ms;
deadbeef874ca3a2015-08-20 17:19:20 -07002518 LOG(LS_INFO) << "RecreateWebRtcStream (recv) because of SetNackAndRemb; nack="
2519 << nack_enabled << ", remb=" << remb_enabled;
Peter Boström126c03e2015-05-11 12:48:12 +02002520 RecreateWebRtcStream();
2521}
2522
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002523void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRtpExtensions(
2524 const std::vector<webrtc::RtpExtension>& extensions) {
2525 config_.rtp.extensions = extensions;
deadbeef874ca3a2015-08-20 17:19:20 -07002526 LOG(LS_INFO) << "RecreateWebRtcStream (recv) because of SetRtpExtensions";
Peter Boström3548dd22015-05-22 18:48:36 +02002527 RecreateWebRtcStream();
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002528}
2529
2530void WebRtcVideoChannel2::WebRtcVideoReceiveStream::RecreateWebRtcStream() {
2531 if (stream_ != NULL) {
2532 call_->DestroyVideoReceiveStream(stream_);
2533 }
2534 stream_ = call_->CreateVideoReceiveStream(config_);
2535 stream_->Start();
2536}
2537
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002538void WebRtcVideoChannel2::WebRtcVideoReceiveStream::ClearDecoders(
2539 std::vector<AllocatedDecoder>* allocated_decoders) {
2540 for (size_t i = 0; i < allocated_decoders->size(); ++i) {
2541 if ((*allocated_decoders)[i].external) {
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002542 external_decoder_factory_->DestroyVideoDecoder(
Peter Boström7252a2b2015-05-18 19:42:03 +02002543 (*allocated_decoders)[i].external_decoder);
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002544 }
Peter Boström7252a2b2015-05-18 19:42:03 +02002545 delete (*allocated_decoders)[i].decoder;
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002546 }
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002547 allocated_decoders->clear();
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002548}
2549
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002550void WebRtcVideoChannel2::WebRtcVideoReceiveStream::RenderFrame(
Miguel Casas-Sanchez47650702015-05-29 17:21:40 -07002551 const webrtc::VideoFrame& frame,
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002552 int time_to_render_ms) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00002553 rtc::CritScope crit(&renderer_lock_);
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002554
2555 if (first_frame_timestamp_ < 0)
2556 first_frame_timestamp_ = frame.timestamp();
2557 int64_t rtp_time_elapsed_since_first_frame =
2558 (timestamp_wraparound_handler_.Unwrap(frame.timestamp()) -
2559 first_frame_timestamp_);
2560 int64_t elapsed_time_ms = rtp_time_elapsed_since_first_frame /
2561 (cricket::kVideoCodecClockrate / 1000);
2562 if (frame.ntp_time_ms() > 0)
2563 estimated_remote_start_ntp_time_ms_ = frame.ntp_time_ms() - elapsed_time_ms;
2564
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002565 if (renderer_ == NULL) {
2566 LOG(LS_WARNING) << "VideoReceiveStream not connected to a VideoRenderer.";
2567 return;
2568 }
2569
2570 if (frame.width() != last_width_ || frame.height() != last_height_) {
2571 SetSize(frame.width(), frame.height());
2572 }
2573
magjed@webrtc.org2386d6d2015-03-05 14:03:08 +00002574 const WebRtcVideoFrame render_frame(
2575 frame.video_frame_buffer(),
2576 elapsed_time_ms * rtc::kNumNanosecsPerMillisec,
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07002577 frame.render_time_ms() * rtc::kNumNanosecsPerMillisec, frame.rotation());
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002578 renderer_->RenderFrame(&render_frame);
2579}
2580
pbos@webrtc.org0d852d52015-02-09 15:14:36 +00002581bool WebRtcVideoChannel2::WebRtcVideoReceiveStream::IsTextureSupported() const {
2582 return true;
2583}
2584
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00002585bool WebRtcVideoChannel2::WebRtcVideoReceiveStream::IsDefaultStream() const {
2586 return default_stream_;
2587}
2588
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002589void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRenderer(
2590 cricket::VideoRenderer* renderer) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00002591 rtc::CritScope crit(&renderer_lock_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002592 renderer_ = renderer;
2593 if (renderer_ != NULL && last_width_ != -1) {
2594 SetSize(last_width_, last_height_);
2595 }
2596}
2597
2598VideoRenderer* WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetRenderer() {
2599 // TODO(pbos): Remove GetRenderer and all uses of it, it's thread-unsafe by
2600 // design.
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00002601 rtc::CritScope crit(&renderer_lock_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002602 return renderer_;
2603}
2604
2605void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetSize(int width,
2606 int height) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00002607 rtc::CritScope crit(&renderer_lock_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002608 if (!renderer_->SetSize(width, height, 0)) {
2609 LOG(LS_ERROR) << "Could not set renderer size.";
2610 }
2611 last_width_ = width;
2612 last_height_ = height;
2613}
2614
pbosf42376c2015-08-28 07:35:32 -07002615std::string
2616WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetCodecNameFromPayloadType(
2617 int payload_type) {
2618 for (const webrtc::VideoReceiveStream::Decoder& decoder : config_.decoders) {
2619 if (decoder.payload_type == payload_type) {
2620 return decoder.payload_name;
2621 }
2622 }
2623 return "";
2624}
2625
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002626VideoReceiverInfo
2627WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetVideoReceiverInfo() {
2628 VideoReceiverInfo info;
Peter Boström259bd202015-05-28 13:39:50 +02002629 info.ssrc_groups = ssrc_groups_;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002630 info.add_ssrc(config_.rtp.remote_ssrc);
2631 webrtc::VideoReceiveStream::Stats stats = stream_->GetStats();
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59 +00002632 info.bytes_rcvd = stats.rtp_stats.transmitted.payload_bytes +
2633 stats.rtp_stats.transmitted.header_bytes +
2634 stats.rtp_stats.transmitted.padding_bytes;
2635 info.packets_rcvd = stats.rtp_stats.transmitted.packets;
Peter Boström393347f2015-04-22 14:52:45 +02002636 info.packets_lost = stats.rtcp_stats.cumulative_lost;
2637 info.fraction_lost =
2638 static_cast<float>(stats.rtcp_stats.fraction_lost) / (1 << 8);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002639
2640 info.framerate_rcvd = stats.network_frame_rate;
2641 info.framerate_decoded = stats.decode_frame_rate;
2642 info.framerate_output = stats.render_frame_rate;
2643
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002644 {
2645 rtc::CritScope frame_cs(&renderer_lock_);
2646 info.frame_width = last_width_;
2647 info.frame_height = last_height_;
2648 info.capture_start_ntp_time_ms = estimated_remote_start_ntp_time_ms_;
2649 }
2650
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002651 info.decode_ms = stats.decode_ms;
2652 info.max_decode_ms = stats.max_decode_ms;
2653 info.current_delay_ms = stats.current_delay_ms;
2654 info.target_delay_ms = stats.target_delay_ms;
2655 info.jitter_buffer_ms = stats.jitter_buffer_ms;
2656 info.min_playout_delay_ms = stats.min_playout_delay_ms;
2657 info.render_delay_ms = stats.render_delay_ms;
2658
pbosf42376c2015-08-28 07:35:32 -07002659 info.codec_name = GetCodecNameFromPayloadType(stats.current_payload_type);
2660
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002661 info.firs_sent = stats.rtcp_packet_type_counts.fir_packets;
2662 info.plis_sent = stats.rtcp_packet_type_counts.pli_packets;
2663 info.nacks_sent = stats.rtcp_packet_type_counts.nack_packets;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002664
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002665 return info;
2666}
2667
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002668WebRtcVideoChannel2::VideoCodecSettings::VideoCodecSettings()
2669 : rtx_payload_type(-1) {}
2670
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002671bool WebRtcVideoChannel2::VideoCodecSettings::operator==(
2672 const WebRtcVideoChannel2::VideoCodecSettings& other) const {
2673 return codec == other.codec &&
2674 fec.ulpfec_payload_type == other.fec.ulpfec_payload_type &&
2675 fec.red_payload_type == other.fec.red_payload_type &&
Shao Changbine62202f2015-04-21 20:24:50 +08002676 fec.red_rtx_payload_type == other.fec.red_rtx_payload_type &&
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002677 rtx_payload_type == other.rtx_payload_type;
2678}
2679
Peter Boströmee0b00e2015-04-22 18:41:14 +02002680bool WebRtcVideoChannel2::VideoCodecSettings::operator!=(
2681 const WebRtcVideoChannel2::VideoCodecSettings& other) const {
2682 return !(*this == other);
2683}
2684
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002685std::vector<WebRtcVideoChannel2::VideoCodecSettings>
2686WebRtcVideoChannel2::MapCodecs(const std::vector<VideoCodec>& codecs) {
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +02002687 DCHECK(!codecs.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002688
2689 std::vector<VideoCodecSettings> video_codecs;
2690 std::map<int, bool> payload_used;
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002691 std::map<int, VideoCodec::CodecType> payload_codec_type;
pkasting@chromium.orgd3245462015-02-23 21:28:22 +00002692 // |rtx_mapping| maps video payload type to rtx payload type.
2693 std::map<int, int> rtx_mapping;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002694
2695 webrtc::FecConfig fec_settings;
2696
2697 for (size_t i = 0; i < codecs.size(); ++i) {
2698 const VideoCodec& in_codec = codecs[i];
2699 int payload_type = in_codec.id;
2700
2701 if (payload_used[payload_type]) {
2702 LOG(LS_ERROR) << "Payload type already registered: "
2703 << in_codec.ToString();
2704 return std::vector<VideoCodecSettings>();
2705 }
2706 payload_used[payload_type] = true;
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002707 payload_codec_type[payload_type] = in_codec.GetCodecType();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002708
2709 switch (in_codec.GetCodecType()) {
2710 case VideoCodec::CODEC_RED: {
2711 // RED payload type, should not have duplicates.
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +02002712 DCHECK(fec_settings.red_payload_type == -1);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002713 fec_settings.red_payload_type = in_codec.id;
2714 continue;
2715 }
2716
2717 case VideoCodec::CODEC_ULPFEC: {
2718 // ULPFEC payload type, should not have duplicates.
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +02002719 DCHECK(fec_settings.ulpfec_payload_type == -1);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002720 fec_settings.ulpfec_payload_type = in_codec.id;
2721 continue;
2722 }
2723
2724 case VideoCodec::CODEC_RTX: {
2725 int associated_payload_type;
2726 if (!in_codec.GetParam(kCodecParamAssociatedPayloadType,
pkasting@chromium.orge9facf82015-02-17 20:36:28 +00002727 &associated_payload_type) ||
2728 !IsValidRtpPayloadType(associated_payload_type)) {
2729 LOG(LS_ERROR)
2730 << "RTX codec with invalid or no associated payload type: "
2731 << in_codec.ToString();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002732 return std::vector<VideoCodecSettings>();
2733 }
2734 rtx_mapping[associated_payload_type] = in_codec.id;
2735 continue;
2736 }
2737
2738 case VideoCodec::CODEC_VIDEO:
2739 break;
2740 }
2741
2742 video_codecs.push_back(VideoCodecSettings());
2743 video_codecs.back().codec = in_codec;
2744 }
2745
2746 // One of these codecs should have been a video codec. Only having FEC
2747 // parameters into this code is a logic error.
Fredrik Solenbergd3ddc1b2015-05-07 17:07:34 +02002748 DCHECK(!video_codecs.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002749
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002750 for (std::map<int, int>::const_iterator it = rtx_mapping.begin();
2751 it != rtx_mapping.end();
2752 ++it) {
2753 if (!payload_used[it->first]) {
2754 LOG(LS_ERROR) << "RTX mapped to payload not in codec list.";
2755 return std::vector<VideoCodecSettings>();
2756 }
Shao Changbine62202f2015-04-21 20:24:50 +08002757 if (payload_codec_type[it->first] != VideoCodec::CODEC_VIDEO &&
2758 payload_codec_type[it->first] != VideoCodec::CODEC_RED) {
2759 LOG(LS_ERROR) << "RTX not mapped to regular video codec or RED codec.";
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002760 return std::vector<VideoCodecSettings>();
2761 }
Shao Changbine62202f2015-04-21 20:24:50 +08002762
2763 if (it->first == fec_settings.red_payload_type) {
2764 fec_settings.red_rtx_payload_type = it->second;
2765 }
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002766 }
2767
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002768 for (size_t i = 0; i < video_codecs.size(); ++i) {
2769 video_codecs[i].fec = fec_settings;
Shao Changbine62202f2015-04-21 20:24:50 +08002770 if (rtx_mapping[video_codecs[i].codec.id] != 0 &&
2771 rtx_mapping[video_codecs[i].codec.id] !=
2772 fec_settings.red_payload_type) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002773 video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
2774 }
2775 }
2776
2777 return video_codecs;
2778}
2779
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002780} // namespace cricket
2781
2782#endif // HAVE_WEBRTC_VIDEO