blob: dd8de11ba964bd2eae9c1f4320d061a37e89c07a [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
35#include "libyuv/convert_from.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000036#include "talk/media/base/videocapturer.h"
37#include "talk/media/base/videorenderer.h"
buildbot@webrtc.orgdf9bbbe2014-06-19 19:54:33 +000038#include "talk/media/webrtc/constants.h"
buildbot@webrtc.orga8530772014-12-10 09:01:18 +000039#include "talk/media/webrtc/simulcast.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000040#include "talk/media/webrtc/webrtcvideocapturer.h"
andresp@webrtc.org82775b12014-11-07 09:37:54 +000041#include "talk/media/webrtc/webrtcvideoengine.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000042#include "talk/media/webrtc/webrtcvideoframe.h"
43#include "talk/media/webrtc/webrtcvoiceengine.h"
buildbot@webrtc.orga09a9992014-08-13 17:26:08 +000044#include "webrtc/base/buffer.h"
45#include "webrtc/base/logging.h"
46#include "webrtc/base/stringutils.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000047#include "webrtc/call.h"
pbos@webrtc.org50fe3592015-01-29 12:33:07 +000048#include "webrtc/system_wrappers/interface/trace_event.h"
pbos@webrtc.org776e6f22014-10-29 15:28:39 +000049#include "webrtc/video_decoder.h"
pbos@webrtc.orgab990ae2014-09-17 09:02:25 +000050#include "webrtc/video_encoder.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000051
52#define UNIMPLEMENTED \
53 LOG(LS_ERROR) << "Call to unimplemented function " << __FUNCTION__; \
54 ASSERT(false)
55
56namespace cricket {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +000057namespace {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +000058static std::string CodecVectorToString(const std::vector<VideoCodec>& codecs) {
59 std::stringstream out;
60 out << '{';
61 for (size_t i = 0; i < codecs.size(); ++i) {
62 out << codecs[i].ToString();
63 if (i != codecs.size() - 1) {
64 out << ", ";
65 }
66 }
67 out << '}';
68 return out.str();
69}
70
71static bool ValidateCodecFormats(const std::vector<VideoCodec>& codecs) {
72 bool has_video = false;
73 for (size_t i = 0; i < codecs.size(); ++i) {
74 if (!codecs[i].ValidateCodecFormat()) {
75 return false;
76 }
77 if (codecs[i].GetCodecType() == VideoCodec::CODEC_VIDEO) {
78 has_video = true;
79 }
80 }
81 if (!has_video) {
82 LOG(LS_ERROR) << "Setting codecs without a video codec is invalid: "
83 << CodecVectorToString(codecs);
84 return false;
85 }
86 return true;
87}
88
Peter Boströmd4362cd2015-03-25 14:17:23 +010089static bool ValidateStreamParams(const StreamParams& sp) {
90 if (sp.ssrcs.empty()) {
91 LOG(LS_ERROR) << "No SSRCs in stream parameters: " << sp.ToString();
92 return false;
93 }
94
95 std::vector<uint32> primary_ssrcs;
96 sp.GetPrimarySsrcs(&primary_ssrcs);
97 std::vector<uint32> rtx_ssrcs;
98 sp.GetFidSsrcs(primary_ssrcs, &rtx_ssrcs);
99 for (uint32_t rtx_ssrc : rtx_ssrcs) {
100 bool rtx_ssrc_present = false;
101 for (uint32_t sp_ssrc : sp.ssrcs) {
102 if (sp_ssrc == rtx_ssrc) {
103 rtx_ssrc_present = true;
104 break;
105 }
106 }
107 if (!rtx_ssrc_present) {
108 LOG(LS_ERROR) << "RTX SSRC '" << rtx_ssrc
109 << "' missing from StreamParams ssrcs: " << sp.ToString();
110 return false;
111 }
112 }
113 if (!rtx_ssrcs.empty() && primary_ssrcs.size() != rtx_ssrcs.size()) {
114 LOG(LS_ERROR)
115 << "RTX SSRCs exist, but don't cover all SSRCs (unsupported): "
116 << sp.ToString();
117 return false;
118 }
119
120 return true;
121}
122
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000123static std::string RtpExtensionsToString(
124 const std::vector<RtpHeaderExtension>& extensions) {
125 std::stringstream out;
126 out << '{';
127 for (size_t i = 0; i < extensions.size(); ++i) {
128 out << "{" << extensions[i].uri << ": " << extensions[i].id << "}";
129 if (i != extensions.size() - 1) {
130 out << ", ";
131 }
132 }
133 out << '}';
134 return out.str();
135}
136
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700137inline const webrtc::RtpExtension* FindHeaderExtension(
138 const std::vector<webrtc::RtpExtension>& extensions,
139 const std::string& name) {
140 for (const auto& kv : extensions) {
141 if (kv.name == name) {
142 return &kv;
143 }
144 }
145 return NULL;
146}
147
andresp@webrtc.org82775b12014-11-07 09:37:54 +0000148// Merges two fec configs and logs an error if a conflict arises
Shao Changbine62202f2015-04-21 20:24:50 +0800149// such that merging in different order would trigger a different output.
andresp@webrtc.org82775b12014-11-07 09:37:54 +0000150static void MergeFecConfig(const webrtc::FecConfig& other,
151 webrtc::FecConfig* output) {
152 if (other.ulpfec_payload_type != -1) {
153 if (output->ulpfec_payload_type != -1 &&
154 output->ulpfec_payload_type != other.ulpfec_payload_type) {
155 LOG(LS_WARNING) << "Conflict merging ulpfec_payload_type configs: "
156 << output->ulpfec_payload_type << " and "
157 << other.ulpfec_payload_type;
158 }
159 output->ulpfec_payload_type = other.ulpfec_payload_type;
160 }
161 if (other.red_payload_type != -1) {
162 if (output->red_payload_type != -1 &&
163 output->red_payload_type != other.red_payload_type) {
164 LOG(LS_WARNING) << "Conflict merging red_payload_type configs: "
165 << output->red_payload_type << " and "
166 << other.red_payload_type;
167 }
168 output->red_payload_type = other.red_payload_type;
169 }
Shao Changbine62202f2015-04-21 20:24:50 +0800170 if (other.red_rtx_payload_type != -1) {
171 if (output->red_rtx_payload_type != -1 &&
172 output->red_rtx_payload_type != other.red_rtx_payload_type) {
173 LOG(LS_WARNING) << "Conflict merging red_rtx_payload_type configs: "
174 << output->red_rtx_payload_type << " and "
175 << other.red_rtx_payload_type;
176 }
177 output->red_rtx_payload_type = other.red_rtx_payload_type;
178 }
andresp@webrtc.org82775b12014-11-07 09:37:54 +0000179}
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000180} // namespace
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000181
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000182// This constant is really an on/off, lower-level configurable NACK history
183// duration hasn't been implemented.
184static const int kNackHistoryMs = 1000;
185
buildbot@webrtc.org933d88a2014-09-18 20:23:05 +0000186static const int kDefaultQpMax = 56;
187
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000188static const int kDefaultRtcpReceiverReportSsrc = 1;
189
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000190const char kH264CodecName[] = "H264";
191
Stefan Holmere5904162015-03-26 11:11:06 +0100192const int kMinBandwidthBps = 30000;
193const int kStartBandwidthBps = 300000;
194const int kMaxBandwidthBps = 2000000;
195
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000196static bool FindFirstMatchingCodec(const std::vector<VideoCodec>& codecs,
197 const VideoCodec& requested_codec,
198 VideoCodec* matching_codec) {
199 for (size_t i = 0; i < codecs.size(); ++i) {
200 if (requested_codec.Matches(codecs[i])) {
201 *matching_codec = codecs[i];
202 return true;
203 }
204 }
205 return false;
206}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000207
pbos@webrtc.org3c107582014-07-20 15:27:35 +0000208static bool ValidateRtpHeaderExtensionIds(
209 const std::vector<RtpHeaderExtension>& extensions) {
210 std::set<int> extensions_used;
211 for (size_t i = 0; i < extensions.size(); ++i) {
Peter Boström23914fe2015-03-31 15:08:04 +0200212 if (extensions[i].id <= 0 || extensions[i].id >= 15 ||
pbos@webrtc.org3c107582014-07-20 15:27:35 +0000213 !extensions_used.insert(extensions[i].id).second) {
214 LOG(LS_ERROR) << "RTP extensions are with incorrect or duplicate ids.";
215 return false;
216 }
217 }
218 return true;
219}
220
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +0000221static bool CompareRtpHeaderExtensionIds(
222 const webrtc::RtpExtension& extension1,
223 const webrtc::RtpExtension& extension2) {
224 // Sorting on ID is sufficient, more than one extension per ID is unsupported.
225 return extension1.id > extension2.id;
226}
227
pbos@webrtc.org3c107582014-07-20 15:27:35 +0000228static std::vector<webrtc::RtpExtension> FilterRtpExtensions(
229 const std::vector<RtpHeaderExtension>& extensions) {
230 std::vector<webrtc::RtpExtension> webrtc_extensions;
231 for (size_t i = 0; i < extensions.size(); ++i) {
232 // Unsupported extensions will be ignored.
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200233 if (webrtc::RtpExtension::IsSupportedForVideo(extensions[i].uri)) {
pbos@webrtc.org3c107582014-07-20 15:27:35 +0000234 webrtc_extensions.push_back(webrtc::RtpExtension(
235 extensions[i].uri, extensions[i].id));
236 } else {
237 LOG(LS_WARNING) << "Unsupported RTP extension: " << extensions[i].uri;
238 }
239 }
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +0000240
241 // Sort filtered headers to make sure that they can later be compared
242 // regardless of in which order they were entered.
243 std::sort(webrtc_extensions.begin(), webrtc_extensions.end(),
244 CompareRtpHeaderExtensionIds);
pbos@webrtc.org3c107582014-07-20 15:27:35 +0000245 return webrtc_extensions;
246}
247
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +0000248static bool RtpExtensionsHaveChanged(
249 const std::vector<webrtc::RtpExtension>& before,
250 const std::vector<webrtc::RtpExtension>& after) {
251 if (before.size() != after.size())
252 return true;
253 for (size_t i = 0; i < before.size(); ++i) {
254 if (before[i].id != after[i].id)
255 return true;
256 if (before[i].name != after[i].name)
257 return true;
258 }
259 return false;
260}
261
buildbot@webrtc.orga8530772014-12-10 09:01:18 +0000262std::vector<webrtc::VideoStream>
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000263WebRtcVideoChannel2::WebRtcVideoSendStream::CreateSimulcastVideoStreams(
buildbot@webrtc.orga8530772014-12-10 09:01:18 +0000264 const VideoCodec& codec,
265 const VideoOptions& options,
Peter Boströmdfd53fe2015-03-27 15:58:11 +0100266 int max_bitrate_bps,
buildbot@webrtc.orga8530772014-12-10 09:01:18 +0000267 size_t num_streams) {
buildbot@webrtc.orga8530772014-12-10 09:01:18 +0000268 int max_qp = kDefaultQpMax;
269 codec.GetParam(kCodecParamMaxQuantization, &max_qp);
270
buildbot@webrtc.orga8530772014-12-10 09:01:18 +0000271 return GetSimulcastConfig(
Peter Boströmdfd53fe2015-03-27 15:58:11 +0100272 num_streams, GetSimulcastBitrateMode(options), codec.width, codec.height,
273 max_bitrate_bps, max_qp,
buildbot@webrtc.orga8530772014-12-10 09:01:18 +0000274 codec.framerate != 0 ? codec.framerate : kDefaultVideoMaxFramerate);
275}
276
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000277std::vector<webrtc::VideoStream>
278WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoStreams(
buildbot@webrtc.orgd41eaeb2014-06-12 07:13:26 +0000279 const VideoCodec& codec,
280 const VideoOptions& options,
Peter Boströmdfd53fe2015-03-27 15:58:11 +0100281 int max_bitrate_bps,
buildbot@webrtc.orgd41eaeb2014-06-12 07:13:26 +0000282 size_t num_streams) {
Peter Boströmdfd53fe2015-03-27 15:58:11 +0100283 int codec_max_bitrate_kbps;
284 if (codec.GetParam(kCodecParamMaxBitrate, &codec_max_bitrate_kbps)) {
285 max_bitrate_bps = codec_max_bitrate_kbps * 1000;
286 }
287 if (num_streams != 1) {
288 return CreateSimulcastVideoStreams(codec, options, max_bitrate_bps,
289 num_streams);
290 }
291
292 // For unset max bitrates set default bitrate for non-simulcast.
293 if (max_bitrate_bps <= 0)
294 max_bitrate_bps = kMaxVideoBitrate * 1000;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000295
buildbot@webrtc.orgd41eaeb2014-06-12 07:13:26 +0000296 webrtc::VideoStream stream;
297 stream.width = codec.width;
298 stream.height = codec.height;
299 stream.max_framerate =
andresp@webrtc.org82775b12014-11-07 09:37:54 +0000300 codec.framerate != 0 ? codec.framerate : kDefaultVideoMaxFramerate;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000301
pbos@webrtc.org00873182014-11-25 14:03:34 +0000302 stream.min_bitrate_bps = kMinVideoBitrate * 1000;
Peter Boströmdfd53fe2015-03-27 15:58:11 +0100303 stream.target_bitrate_bps = stream.max_bitrate_bps = max_bitrate_bps;
buildbot@webrtc.orgd41eaeb2014-06-12 07:13:26 +0000304
buildbot@webrtc.org933d88a2014-09-18 20:23:05 +0000305 int max_qp = kDefaultQpMax;
buildbot@webrtc.orgd41eaeb2014-06-12 07:13:26 +0000306 codec.GetParam(kCodecParamMaxQuantization, &max_qp);
307 stream.max_qp = max_qp;
308 std::vector<webrtc::VideoStream> streams;
309 streams.push_back(stream);
310 return streams;
311}
312
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000313void* WebRtcVideoChannel2::WebRtcVideoSendStream::ConfigureVideoEncoderSettings(
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000314 const VideoCodec& codec,
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +0200315 const VideoOptions& options,
316 bool is_screencast) {
317 // No automatic resizing when using simulcast.
318 bool automatic_resize = !is_screencast && ssrcs_.size() == 1;
319 bool frame_dropping = !is_screencast;
320 bool denoising;
321 if (is_screencast) {
322 denoising = false;
323 } else {
324 options.video_noise_reduction.Get(&denoising);
325 }
326
Shao Changbine62202f2015-04-21 20:24:50 +0800327 if (CodecNamesEq(codec.name, kVp8CodecName)) {
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000328 encoder_settings_.vp8 = webrtc::VideoEncoder::GetDefaultVp8Settings();
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +0200329 encoder_settings_.vp8.automaticResizeOn = automatic_resize;
330 encoder_settings_.vp8.denoisingOn = denoising;
331 encoder_settings_.vp8.frameDroppingOn = frame_dropping;
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000332 return &encoder_settings_.vp8;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000333 }
Shao Changbine62202f2015-04-21 20:24:50 +0800334 if (CodecNamesEq(codec.name, kVp9CodecName)) {
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000335 encoder_settings_.vp9 = webrtc::VideoEncoder::GetDefaultVp9Settings();
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +0200336 encoder_settings_.vp9.denoisingOn = denoising;
337 encoder_settings_.vp9.frameDroppingOn = frame_dropping;
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000338 return &encoder_settings_.vp9;
andresp@webrtc.org188d3b22014-11-07 13:21:04 +0000339 }
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000340 return NULL;
341}
342
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000343DefaultUnsignalledSsrcHandler::DefaultUnsignalledSsrcHandler()
344 : default_recv_ssrc_(0), default_renderer_(NULL) {}
345
346UnsignalledSsrcHandler::Action DefaultUnsignalledSsrcHandler::OnUnsignalledSsrc(
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +0000347 WebRtcVideoChannel2* channel,
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000348 uint32_t ssrc) {
349 if (default_recv_ssrc_ != 0) { // Already one default stream.
350 LOG(LS_WARNING) << "Unknown SSRC, but default receive stream already set.";
351 return kDropPacket;
352 }
353
354 StreamParams sp;
355 sp.ssrcs.push_back(ssrc);
356 LOG(LS_INFO) << "Creating default receive stream for SSRC=" << ssrc << ".";
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +0000357 if (!channel->AddRecvStream(sp, true)) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000358 LOG(LS_WARNING) << "Could not create default receive stream.";
359 }
360
361 channel->SetRenderer(ssrc, default_renderer_);
362 default_recv_ssrc_ = ssrc;
363 return kDeliverPacket;
364}
365
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000366WebRtcCallFactory::~WebRtcCallFactory() {
367}
368webrtc::Call* WebRtcCallFactory::CreateCall(
369 const webrtc::Call::Config& config) {
370 return webrtc::Call::Create(config);
371}
372
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000373VideoRenderer* DefaultUnsignalledSsrcHandler::GetDefaultRenderer() const {
374 return default_renderer_;
375}
376
377void DefaultUnsignalledSsrcHandler::SetDefaultRenderer(
378 VideoMediaChannel* channel,
379 VideoRenderer* renderer) {
380 default_renderer_ = renderer;
381 if (default_recv_ssrc_ != 0) {
382 channel->SetRenderer(default_recv_ssrc_, default_renderer_);
383 }
384}
385
pbos@webrtc.orgf1f0d9a2015-03-02 13:30:15 +0000386WebRtcVideoEngine2::WebRtcVideoEngine2(WebRtcVoiceEngine* voice_engine)
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +0000387 : worker_thread_(NULL),
pbos@webrtc.orgf1f0d9a2015-03-02 13:30:15 +0000388 voice_engine_(voice_engine),
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +0000389 initialized_(false),
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000390 call_factory_(&default_call_factory_),
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000391 external_decoder_factory_(NULL),
392 external_encoder_factory_(NULL) {
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +0000393 LOG(LS_INFO) << "WebRtcVideoEngine2::WebRtcVideoEngine2()";
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000394 video_codecs_ = GetSupportedCodecs();
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000395 rtp_header_extensions_.push_back(
396 RtpHeaderExtension(kRtpTimestampOffsetHeaderExtension,
397 kRtpTimestampOffsetHeaderExtensionDefaultId));
398 rtp_header_extensions_.push_back(
399 RtpHeaderExtension(kRtpAbsoluteSenderTimeHeaderExtension,
400 kRtpAbsoluteSenderTimeHeaderExtensionDefaultId));
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700401 rtp_header_extensions_.push_back(
402 RtpHeaderExtension(kRtpVideoRotationHeaderExtension,
403 kRtpVideoRotationHeaderExtensionDefaultId));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000404}
405
406WebRtcVideoEngine2::~WebRtcVideoEngine2() {
407 LOG(LS_INFO) << "WebRtcVideoEngine2::~WebRtcVideoEngine2";
408
409 if (initialized_) {
410 Terminate();
411 }
412}
413
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000414void WebRtcVideoEngine2::SetCallFactory(WebRtcCallFactory* call_factory) {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000415 assert(!initialized_);
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000416 call_factory_ = call_factory;
417}
418
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000419bool WebRtcVideoEngine2::Init(rtc::Thread* worker_thread) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000420 LOG(LS_INFO) << "WebRtcVideoEngine2::Init";
421 worker_thread_ = worker_thread;
422 ASSERT(worker_thread_ != NULL);
423
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000424 initialized_ = true;
425 return true;
426}
427
428void WebRtcVideoEngine2::Terminate() {
429 LOG(LS_INFO) << "WebRtcVideoEngine2::Terminate";
430
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000431 initialized_ = false;
432}
433
434int WebRtcVideoEngine2::GetCapabilities() { return VIDEO_RECV | VIDEO_SEND; }
435
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000436bool WebRtcVideoEngine2::SetDefaultEncoderConfig(
437 const VideoEncoderConfig& config) {
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000438 const VideoCodec& codec = config.max_codec;
pbos@webrtc.org957e8022014-11-10 12:36:11 +0000439 bool supports_codec = false;
440 for (size_t i = 0; i < video_codecs_.size(); ++i) {
Shao Changbine62202f2015-04-21 20:24:50 +0800441 if (CodecNamesEq(video_codecs_[i].name, codec.name)) {
pbos@webrtc.org2a72c652015-02-26 16:01:24 +0000442 video_codecs_[i].width = codec.width;
443 video_codecs_[i].height = codec.height;
444 video_codecs_[i].framerate = codec.framerate;
pbos@webrtc.org957e8022014-11-10 12:36:11 +0000445 supports_codec = true;
446 break;
447 }
448 }
449
450 if (!supports_codec) {
451 LOG(LS_ERROR) << "SetDefaultEncoderConfig, codec not supported: "
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000452 << codec.ToString();
453 return false;
454 }
455
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000456 return true;
457}
458
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000459WebRtcVideoChannel2* WebRtcVideoEngine2::CreateChannel(
buildbot@webrtc.org1ecbe452014-10-14 20:29:28 +0000460 const VideoOptions& options,
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000461 VoiceMediaChannel* voice_channel) {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000462 assert(initialized_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000463 LOG(LS_INFO) << "CreateChannel: "
464 << (voice_channel != NULL ? "With" : "Without")
pbos@webrtc.orgfa553ef2014-10-20 11:07:07 +0000465 << " voice channel. Options: " << options.ToString();
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000466 WebRtcVideoChannel2* channel =
467 new WebRtcVideoChannel2(call_factory_,
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +0000468 voice_engine_,
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000469 voice_channel,
pbos@webrtc.orgfa553ef2014-10-20 11:07:07 +0000470 options,
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000471 external_encoder_factory_,
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000472 external_decoder_factory_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000473 if (!channel->Init()) {
474 delete channel;
475 return NULL;
476 }
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000477 channel->SetRecvCodecs(video_codecs_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000478 return channel;
479}
480
481const std::vector<VideoCodec>& WebRtcVideoEngine2::codecs() const {
482 return video_codecs_;
483}
484
485const std::vector<RtpHeaderExtension>&
486WebRtcVideoEngine2::rtp_header_extensions() const {
487 return rtp_header_extensions_;
488}
489
490void WebRtcVideoEngine2::SetLogging(int min_sev, const char* filter) {
491 // TODO(pbos): Set up logging.
492 LOG(LS_VERBOSE) << "SetLogging: " << min_sev << '"' << filter << '"';
493 // if min_sev == -1, we keep the current log level.
494 if (min_sev < 0) {
495 assert(min_sev == -1);
496 return;
497 }
498}
499
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000500void WebRtcVideoEngine2::SetExternalDecoderFactory(
501 WebRtcVideoDecoderFactory* decoder_factory) {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000502 assert(!initialized_);
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000503 external_decoder_factory_ = decoder_factory;
504}
505
506void WebRtcVideoEngine2::SetExternalEncoderFactory(
507 WebRtcVideoEncoderFactory* encoder_factory) {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000508 assert(!initialized_);
pbos@webrtc.orgf18fba22015-01-14 16:26:23 +0000509 if (external_encoder_factory_ == encoder_factory)
510 return;
511
512 // No matter what happens we shouldn't hold on to a stale
513 // WebRtcSimulcastEncoderFactory.
514 simulcast_encoder_factory_.reset();
515
516 if (encoder_factory &&
517 WebRtcSimulcastEncoderFactory::UseSimulcastEncoderFactory(
518 encoder_factory->codecs())) {
519 simulcast_encoder_factory_.reset(
520 new WebRtcSimulcastEncoderFactory(encoder_factory));
521 encoder_factory = simulcast_encoder_factory_.get();
522 }
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000523 external_encoder_factory_ = encoder_factory;
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000524
525 video_codecs_ = GetSupportedCodecs();
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000526}
527
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000528bool WebRtcVideoEngine2::EnableTimedRender() {
529 // TODO(pbos): Figure out whether this can be removed.
530 return true;
531}
532
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000533// Checks to see whether we comprehend and could receive a particular codec
534bool WebRtcVideoEngine2::FindCodec(const VideoCodec& in) {
535 // TODO(pbos): Probe encoder factory to figure out that the codec is supported
536 // if supported by the encoder factory. Add a corresponding test that fails
537 // with this code (that doesn't ask the factory).
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000538 for (size_t j = 0; j < video_codecs_.size(); ++j) {
539 VideoCodec codec(video_codecs_[j].id, video_codecs_[j].name, 0, 0, 0, 0);
540 if (codec.Matches(in)) {
541 return true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000542 }
543 }
544 return false;
545}
546
547// Tells whether the |requested| codec can be transmitted or not. If it can be
548// transmitted |out| is set with the best settings supported. Aspect ratio will
549// be set as close to |current|'s as possible. If not set |requested|'s
550// dimensions will be used for aspect ratio matching.
551bool WebRtcVideoEngine2::CanSendCodec(const VideoCodec& requested,
552 const VideoCodec& current,
553 VideoCodec* out) {
554 assert(out != NULL);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000555
556 if (requested.width != requested.height &&
557 (requested.height == 0 || requested.width == 0)) {
558 // 0xn and nx0 are invalid resolutions.
559 return false;
560 }
561
562 VideoCodec matching_codec;
563 if (!FindFirstMatchingCodec(video_codecs_, requested, &matching_codec)) {
564 // Codec not supported.
565 return false;
566 }
567
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000568 out->id = requested.id;
569 out->name = requested.name;
570 out->preference = requested.preference;
571 out->params = requested.params;
andresp@webrtc.orgff689be2015-02-12 11:54:26 +0000572 out->framerate = std::min(requested.framerate, matching_codec.framerate);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000573 out->params = requested.params;
574 out->feedback_params = requested.feedback_params;
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000575 out->width = requested.width;
576 out->height = requested.height;
577 if (requested.width == 0 && requested.height == 0) {
578 return true;
579 }
580
581 while (out->width > matching_codec.width) {
582 out->width /= 2;
583 out->height /= 2;
584 }
585
586 return out->width > 0 && out->height > 0;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000587}
588
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000589// Ignore spammy trace messages, mostly from the stats API when we haven't
590// gotten RTCP info yet from the remote side.
591bool WebRtcVideoEngine2::ShouldIgnoreTrace(const std::string& trace) {
592 static const char* const kTracesToIgnore[] = {NULL};
593 for (const char* const* p = kTracesToIgnore; *p; ++p) {
594 if (trace.find(*p) == 0) {
595 return true;
596 }
597 }
598 return false;
599}
600
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000601std::vector<VideoCodec> WebRtcVideoEngine2::GetSupportedCodecs() const {
andresp@webrtc.org82775b12014-11-07 09:37:54 +0000602 std::vector<VideoCodec> supported_codecs = DefaultVideoCodecList();
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000603
604 if (external_encoder_factory_ == NULL) {
605 return supported_codecs;
606 }
607
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000608 const std::vector<WebRtcVideoEncoderFactory::VideoCodec>& codecs =
609 external_encoder_factory_->codecs();
610 for (size_t i = 0; i < codecs.size(); ++i) {
611 // Don't add internally-supported codecs twice.
612 if (CodecIsInternallySupported(codecs[i].name)) {
613 continue;
614 }
615
pkasting@chromium.orgd3245462015-02-23 21:28:22 +0000616 // External video encoders are given payloads 120-127. This also means that
617 // we only support up to 8 external payload types.
618 const int kExternalVideoPayloadTypeBase = 120;
619 size_t payload_type = kExternalVideoPayloadTypeBase + i;
620 assert(payload_type < 128);
621 VideoCodec codec(static_cast<int>(payload_type),
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000622 codecs[i].name,
623 codecs[i].max_width,
624 codecs[i].max_height,
625 codecs[i].max_fps,
626 0);
627
628 AddDefaultFeedbackParams(&codec);
629 supported_codecs.push_back(codec);
630 }
631 return supported_codecs;
632}
633
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000634WebRtcVideoChannel2::WebRtcVideoChannel2(
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000635 WebRtcCallFactory* call_factory,
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +0000636 WebRtcVoiceEngine* voice_engine,
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000637 VoiceMediaChannel* voice_channel,
pbos@webrtc.orgfa553ef2014-10-20 11:07:07 +0000638 const VideoOptions& options,
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000639 WebRtcVideoEncoderFactory* external_encoder_factory,
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000640 WebRtcVideoDecoderFactory* external_decoder_factory)
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +0000641 : unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
pbos@webrtc.org8296ec52015-03-20 14:27:49 +0000642 voice_channel_id_(voice_channel != nullptr
643 ? static_cast<WebRtcVoiceMediaChannel*>(
644 voice_channel)->voe_channel()
645 : -1),
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000646 external_encoder_factory_(external_encoder_factory),
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +0000647 external_decoder_factory_(external_decoder_factory) {
pbos@webrtc.orgfa553ef2014-10-20 11:07:07 +0000648 SetDefaultOptions();
649 options_.SetAll(options);
Peter Boströme7b221f2015-04-13 15:34:32 +0200650 options_.cpu_overuse_detection.Get(&signal_cpu_adaptation_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000651 webrtc::Call::Config config(this);
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000652 config.overuse_callback = this;
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +0000653 if (voice_engine != NULL) {
654 config.voice_engine = voice_engine->voe()->engine();
655 }
Stefan Holmere5904162015-03-26 11:11:06 +0100656 config.bitrate_config.min_bitrate_bps = kMinBandwidthBps;
657 config.bitrate_config.start_bitrate_bps = kStartBandwidthBps;
658 config.bitrate_config.max_bitrate_bps = kMaxBandwidthBps;
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000659 call_.reset(call_factory->CreateCall(config));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000660
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000661 rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc;
662 sending_ = false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000663 default_send_ssrc_ = 0;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000664}
665
666void WebRtcVideoChannel2::SetDefaultOptions() {
Peter Boströme4328002015-04-14 22:45:29 +0200667 options_.cpu_overuse_detection.Set(true);
pbos@webrtc.orgd8198032014-11-10 14:41:43 +0000668 options_.dscp.Set(false);
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +0000669 options_.suspend_below_min_bitrate.Set(false);
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000670 options_.video_noise_reduction.Set(true);
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +0000671 options_.screencast_min_bitrate.Set(0);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000672}
673
674WebRtcVideoChannel2::~WebRtcVideoChannel2() {
Peter Boströmdfd53fe2015-03-27 15:58:11 +0100675 for (auto& kv : send_streams_)
676 delete kv.second;
677 for (auto& kv : receive_streams_)
678 delete kv.second;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000679}
680
681bool WebRtcVideoChannel2::Init() { return true; }
682
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000683bool WebRtcVideoChannel2::CodecIsExternallySupported(
684 const std::string& name) const {
685 if (external_encoder_factory_ == NULL) {
686 return false;
687 }
688
689 const std::vector<WebRtcVideoEncoderFactory::VideoCodec> external_codecs =
690 external_encoder_factory_->codecs();
691 for (size_t c = 0; c < external_codecs.size(); ++c) {
Shao Changbine62202f2015-04-21 20:24:50 +0800692 if (CodecNamesEq(name, external_codecs[c].name)) {
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000693 return true;
694 }
695 }
696 return false;
697}
698
699std::vector<WebRtcVideoChannel2::VideoCodecSettings>
700WebRtcVideoChannel2::FilterSupportedCodecs(
701 const std::vector<WebRtcVideoChannel2::VideoCodecSettings>& mapped_codecs)
702 const {
703 std::vector<VideoCodecSettings> supported_codecs;
704 for (size_t i = 0; i < mapped_codecs.size(); ++i) {
705 const VideoCodecSettings& codec = mapped_codecs[i];
706 if (CodecIsInternallySupported(codec.codec.name) ||
707 CodecIsExternallySupported(codec.codec.name)) {
708 supported_codecs.push_back(codec);
709 }
710 }
711 return supported_codecs;
712}
713
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000714bool WebRtcVideoChannel2::SetRecvCodecs(const std::vector<VideoCodec>& codecs) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +0000715 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRecvCodecs");
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000716 LOG(LS_INFO) << "SetRecvCodecs: " << CodecVectorToString(codecs);
717 if (!ValidateCodecFormats(codecs)) {
718 return false;
719 }
720
721 const std::vector<VideoCodecSettings> mapped_codecs = MapCodecs(codecs);
722 if (mapped_codecs.empty()) {
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000723 LOG(LS_ERROR) << "SetRecvCodecs called without any video codecs.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000724 return false;
725 }
726
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000727 const std::vector<VideoCodecSettings> supported_codecs =
728 FilterSupportedCodecs(mapped_codecs);
729
730 if (mapped_codecs.size() != supported_codecs.size()) {
731 LOG(LS_ERROR) << "SetRecvCodecs called with unsupported video codecs.";
732 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000733 }
734
Peter Boströmee0b00e2015-04-22 18:41:14 +0200735 // Prevent reconfiguration when setting identical receive codecs.
736 if (recv_codecs_.size() == supported_codecs.size()) {
737 bool reconfigured = false;
738 for (size_t i = 0; i < supported_codecs.size(); ++i) {
739 if (recv_codecs_[i] != supported_codecs[i]) {
740 reconfigured = true;
741 break;
742 }
743 }
744 if (!reconfigured)
745 return true;
746 }
747
pbos@webrtc.org96a93252014-11-03 14:46:44 +0000748 recv_codecs_ = supported_codecs;
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000749
pbos@webrtc.org575d1262014-10-08 14:48:08 +0000750 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000751 for (std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
752 receive_streams_.begin();
753 it != receive_streams_.end();
754 ++it) {
755 it->second->SetRecvCodecs(recv_codecs_);
756 }
757
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000758 return true;
759}
760
761bool WebRtcVideoChannel2::SetSendCodecs(const std::vector<VideoCodec>& codecs) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +0000762 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetSendCodecs");
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000763 LOG(LS_INFO) << "SetSendCodecs: " << CodecVectorToString(codecs);
764 if (!ValidateCodecFormats(codecs)) {
765 return false;
766 }
767
768 const std::vector<VideoCodecSettings> supported_codecs =
769 FilterSupportedCodecs(MapCodecs(codecs));
770
771 if (supported_codecs.empty()) {
Peter Boström3c3f6462015-04-15 16:27:49 +0200772 LOG(LS_ERROR) << "No video codecs supported.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000773 return false;
774 }
775
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000776 LOG(LS_INFO) << "Using codec: " << supported_codecs.front().codec.ToString();
777
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +0000778 VideoCodecSettings old_codec;
779 if (send_codec_.Get(&old_codec) && supported_codecs.front() == old_codec) {
780 // Using same codec, avoid reconfiguring.
781 return true;
782 }
783
784 send_codec_.Set(supported_codecs.front());
785
pbos@webrtc.org575d1262014-10-08 14:48:08 +0000786 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000787 for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
788 send_streams_.begin();
789 it != send_streams_.end();
790 ++it) {
791 assert(it->second != NULL);
792 it->second->SetCodec(supported_codecs.front());
793 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000794
Stefan Holmere5904162015-03-26 11:11:06 +0100795 // TODO(holmer): Changing the codec parameters shouldn't necessarily mean that
796 // we change the min/max of bandwidth estimation. Reevaluate this.
pbos@webrtc.org00873182014-11-25 14:03:34 +0000797 VideoCodec codec = supported_codecs.front().codec;
798 int bitrate_kbps;
799 if (codec.GetParam(kCodecParamMinBitrate, &bitrate_kbps) &&
800 bitrate_kbps > 0) {
801 bitrate_config_.min_bitrate_bps = bitrate_kbps * 1000;
802 } else {
803 bitrate_config_.min_bitrate_bps = 0;
804 }
805 if (codec.GetParam(kCodecParamStartBitrate, &bitrate_kbps) &&
806 bitrate_kbps > 0) {
807 bitrate_config_.start_bitrate_bps = bitrate_kbps * 1000;
808 } else {
809 // Do not reconfigure start bitrate unless it's specified and positive.
810 bitrate_config_.start_bitrate_bps = -1;
811 }
812 if (codec.GetParam(kCodecParamMaxBitrate, &bitrate_kbps) &&
813 bitrate_kbps > 0) {
814 bitrate_config_.max_bitrate_bps = bitrate_kbps * 1000;
815 } else {
816 bitrate_config_.max_bitrate_bps = -1;
817 }
818 call_->SetBitrateConfig(bitrate_config_);
819
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000820 return true;
821}
822
823bool WebRtcVideoChannel2::GetSendCodec(VideoCodec* codec) {
824 VideoCodecSettings codec_settings;
825 if (!send_codec_.Get(&codec_settings)) {
826 LOG(LS_VERBOSE) << "GetSendCodec: No send codec set.";
827 return false;
828 }
829 *codec = codec_settings.codec;
830 return true;
831}
832
833bool WebRtcVideoChannel2::SetSendStreamFormat(uint32 ssrc,
834 const VideoFormat& format) {
835 LOG(LS_VERBOSE) << "SetSendStreamFormat:" << ssrc << " -> "
836 << format.ToString();
pbos@webrtc.org575d1262014-10-08 14:48:08 +0000837 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000838 if (send_streams_.find(ssrc) == send_streams_.end()) {
839 return false;
840 }
841 return send_streams_[ssrc]->SetVideoFormat(format);
842}
843
844bool WebRtcVideoChannel2::SetRender(bool render) {
845 // TODO(pbos): Implement. Or refactor away as it shouldn't be needed.
846 LOG(LS_VERBOSE) << "SetRender: " << (render ? "true" : "false");
847 return true;
848}
849
850bool WebRtcVideoChannel2::SetSend(bool send) {
851 LOG(LS_VERBOSE) << "SetSend: " << (send ? "true" : "false");
852 if (send && !send_codec_.IsSet()) {
853 LOG(LS_ERROR) << "SetSend(true) called before setting codec.";
854 return false;
855 }
856 if (send) {
857 StartAllSendStreams();
858 } else {
859 StopAllSendStreams();
860 }
861 sending_ = send;
862 return true;
863}
864
Peter Boströmd6f4c252015-03-26 16:23:04 +0100865bool WebRtcVideoChannel2::ValidateSendSsrcAvailability(
866 const StreamParams& sp) const {
867 for (uint32_t ssrc: sp.ssrcs) {
868 if (send_ssrcs_.find(ssrc) != send_ssrcs_.end()) {
869 LOG(LS_ERROR) << "Send stream with SSRC '" << ssrc << "' already exists.";
870 return false;
871 }
872 }
873 return true;
874}
875
876bool WebRtcVideoChannel2::ValidateReceiveSsrcAvailability(
877 const StreamParams& sp) const {
878 for (uint32_t ssrc: sp.ssrcs) {
879 if (receive_ssrcs_.find(ssrc) != receive_ssrcs_.end()) {
880 LOG(LS_ERROR) << "Receive stream with SSRC '" << ssrc
881 << "' already exists.";
882 return false;
883 }
884 }
885 return true;
886}
887
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000888bool WebRtcVideoChannel2::AddSendStream(const StreamParams& sp) {
889 LOG(LS_INFO) << "AddSendStream: " << sp.ToString();
Peter Boströmd4362cd2015-03-25 14:17:23 +0100890 if (!ValidateStreamParams(sp))
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000891 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000892
pbos@webrtc.org575d1262014-10-08 14:48:08 +0000893 rtc::CritScope stream_lock(&stream_crit_);
Peter Boströmd6f4c252015-03-26 16:23:04 +0100894
895 if (!ValidateSendSsrcAvailability(sp))
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000896 return false;
Peter Boströmd6f4c252015-03-26 16:23:04 +0100897
898 for (uint32 used_ssrc : sp.ssrcs)
899 send_ssrcs_.insert(used_ssrc);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000900
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000901 WebRtcVideoSendStream* stream =
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +0000902 new WebRtcVideoSendStream(call_.get(),
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +0000903 external_encoder_factory_,
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +0000904 options_,
Peter Boströmdfd53fe2015-03-27 15:58:11 +0100905 bitrate_config_.max_bitrate_bps,
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +0000906 send_codec_,
907 sp,
908 send_rtp_extensions_);
909
Peter Boströmd6f4c252015-03-26 16:23:04 +0100910 uint32 ssrc = sp.first_ssrc();
911 assert(ssrc != 0);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000912 send_streams_[ssrc] = stream;
913
914 if (rtcp_receiver_report_ssrc_ == kDefaultRtcpReceiverReportSsrc) {
915 rtcp_receiver_report_ssrc_ = ssrc;
916 }
917 if (default_send_ssrc_ == 0) {
918 default_send_ssrc_ = ssrc;
919 }
920 if (sending_) {
921 stream->Start();
922 }
923
924 return true;
925}
926
927bool WebRtcVideoChannel2::RemoveSendStream(uint32 ssrc) {
928 LOG(LS_INFO) << "RemoveSendStream: " << ssrc;
929
930 if (ssrc == 0) {
931 if (default_send_ssrc_ == 0) {
932 LOG(LS_ERROR) << "No default send stream active.";
933 return false;
934 }
935
936 LOG(LS_VERBOSE) << "Removing default stream: " << default_send_ssrc_;
937 ssrc = default_send_ssrc_;
938 }
939
pbos@webrtc.org575d1262014-10-08 14:48:08 +0000940 WebRtcVideoSendStream* removed_stream;
941 {
942 rtc::CritScope stream_lock(&stream_crit_);
943 std::map<uint32, WebRtcVideoSendStream*>::iterator it =
944 send_streams_.find(ssrc);
945 if (it == send_streams_.end()) {
946 return false;
947 }
948
Peter Boströmd6f4c252015-03-26 16:23:04 +0100949 for (uint32 old_ssrc : it->second->GetSsrcs())
950 send_ssrcs_.erase(old_ssrc);
951
pbos@webrtc.org575d1262014-10-08 14:48:08 +0000952 removed_stream = it->second;
953 send_streams_.erase(it);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000954 }
955
pbos@webrtc.org575d1262014-10-08 14:48:08 +0000956 delete removed_stream;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000957
958 if (ssrc == default_send_ssrc_) {
959 default_send_ssrc_ = 0;
960 }
961
962 return true;
963}
964
Peter Boströmd6f4c252015-03-26 16:23:04 +0100965void WebRtcVideoChannel2::DeleteReceiveStream(
966 WebRtcVideoChannel2::WebRtcVideoReceiveStream* stream) {
967 for (uint32 old_ssrc : stream->GetSsrcs())
968 receive_ssrcs_.erase(old_ssrc);
969 delete stream;
970}
971
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000972bool WebRtcVideoChannel2::AddRecvStream(const StreamParams& sp) {
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +0000973 return AddRecvStream(sp, false);
974}
975
976bool WebRtcVideoChannel2::AddRecvStream(const StreamParams& sp,
977 bool default_stream) {
Peter Boströmd4362cd2015-03-25 14:17:23 +0100978 LOG(LS_INFO) << "AddRecvStream" << (default_stream ? " (default stream)" : "")
979 << ": " << sp.ToString();
980 if (!ValidateStreamParams(sp))
981 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000982
983 uint32 ssrc = sp.first_ssrc();
984 assert(ssrc != 0); // TODO(pbos): Is this ever valid?
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000985
pbos@webrtc.org575d1262014-10-08 14:48:08 +0000986 rtc::CritScope stream_lock(&stream_crit_);
Peter Boströmd6f4c252015-03-26 16:23:04 +0100987 // Remove running stream if this was a default stream.
988 auto prev_stream = receive_streams_.find(ssrc);
989 if (prev_stream != receive_streams_.end()) {
990 if (default_stream || !prev_stream->second->IsDefaultStream()) {
991 LOG(LS_ERROR) << "Receive stream for SSRC '" << ssrc
992 << "' already exists.";
993 return false;
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +0000994 }
Peter Boströmd6f4c252015-03-26 16:23:04 +0100995 DeleteReceiveStream(prev_stream->second);
996 receive_streams_.erase(prev_stream);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000997 }
998
Peter Boströmd6f4c252015-03-26 16:23:04 +0100999 if (!ValidateReceiveSsrcAvailability(sp))
1000 return false;
1001
1002 for (uint32 used_ssrc : sp.ssrcs)
1003 receive_ssrcs_.insert(used_ssrc);
1004
pbos@webrtc.orgbd249bc2014-07-07 04:45:15 +00001005 webrtc::VideoReceiveStream::Config config;
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001006 ConfigureReceiverRtp(&config, sp);
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +00001007
1008 // Set up A/V sync if there is a VoiceChannel.
1009 // TODO(pbos): The A/V is synched by the receiving channel. So we need to know
1010 // the SSRC of the remote audio channel in order to sync the correct webrtc
1011 // VoiceEngine channel. For now sync the first channel in non-conference to
1012 // match existing behavior in WebRtcVideoEngine.
pbos@webrtc.org8296ec52015-03-20 14:27:49 +00001013 if (voice_channel_id_ != -1 && receive_streams_.empty() &&
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +00001014 !options_.conference_mode.GetWithDefaultIfUnset(false)) {
pbos@webrtc.org8296ec52015-03-20 14:27:49 +00001015 config.audio_channel_id = voice_channel_id_;
pbos@webrtc.org3bf3d232014-10-31 12:59:34 +00001016 }
1017
Peter Boströmd6f4c252015-03-26 16:23:04 +01001018 receive_streams_[ssrc] = new WebRtcVideoReceiveStream(
1019 call_.get(), sp.ssrcs, external_decoder_factory_, default_stream, config,
1020 recv_codecs_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001021
1022 return true;
1023}
1024
1025void WebRtcVideoChannel2::ConfigureReceiverRtp(
1026 webrtc::VideoReceiveStream::Config* config,
1027 const StreamParams& sp) const {
1028 uint32 ssrc = sp.first_ssrc();
1029
1030 config->rtp.remote_ssrc = ssrc;
1031 config->rtp.local_ssrc = rtcp_receiver_report_ssrc_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001032
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001033 config->rtp.extensions = recv_rtp_extensions_;
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001034
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001035 // TODO(pbos): This protection is against setting the same local ssrc as
1036 // remote which is not permitted by the lower-level API. RTCP requires a
1037 // corresponding sender SSRC. Figure out what to do when we don't have
1038 // (receive-only) or know a good local SSRC.
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001039 if (config->rtp.remote_ssrc == config->rtp.local_ssrc) {
1040 if (config->rtp.local_ssrc != kDefaultRtcpReceiverReportSsrc) {
1041 config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001042 } else {
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001043 config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc + 1;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001044 }
1045 }
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001046
1047 for (size_t i = 0; i < recv_codecs_.size(); ++i) {
andresp@webrtc.org82775b12014-11-07 09:37:54 +00001048 MergeFecConfig(recv_codecs_[i].fec, &config->rtp.fec);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001049 }
1050
andresp@webrtc.org82775b12014-11-07 09:37:54 +00001051 for (size_t i = 0; i < recv_codecs_.size(); ++i) {
1052 uint32 rtx_ssrc;
1053 if (recv_codecs_[i].rtx_payload_type != -1 &&
1054 sp.GetFidSsrc(ssrc, &rtx_ssrc)) {
1055 webrtc::VideoReceiveStream::Config::Rtp::Rtx& rtx =
1056 config->rtp.rtx[recv_codecs_[i].codec.id];
1057 rtx.ssrc = rtx_ssrc;
1058 rtx.payload_type = recv_codecs_[i].rtx_payload_type;
1059 }
1060 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001061}
1062
1063bool WebRtcVideoChannel2::RemoveRecvStream(uint32 ssrc) {
1064 LOG(LS_INFO) << "RemoveRecvStream: " << ssrc;
1065 if (ssrc == 0) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001066 LOG(LS_ERROR) << "RemoveRecvStream with 0 ssrc is not supported.";
1067 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001068 }
1069
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001070 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001071 std::map<uint32, WebRtcVideoReceiveStream*>::iterator stream =
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001072 receive_streams_.find(ssrc);
1073 if (stream == receive_streams_.end()) {
1074 LOG(LS_ERROR) << "Stream not found for ssrc: " << ssrc;
1075 return false;
1076 }
Peter Boströmd6f4c252015-03-26 16:23:04 +01001077 DeleteReceiveStream(stream->second);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001078 receive_streams_.erase(stream);
1079
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001080 return true;
1081}
1082
1083bool WebRtcVideoChannel2::SetRenderer(uint32 ssrc, VideoRenderer* renderer) {
1084 LOG(LS_INFO) << "SetRenderer: ssrc:" << ssrc << " "
1085 << (renderer ? "(ptr)" : "NULL");
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001086 if (ssrc == 0) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001087 default_unsignalled_ssrc_handler_.SetDefaultRenderer(this, renderer);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001088 return true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001089 }
1090
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001091 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001092 std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
1093 receive_streams_.find(ssrc);
1094 if (it == receive_streams_.end()) {
1095 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001096 }
1097
1098 it->second->SetRenderer(renderer);
1099 return true;
1100}
1101
1102bool WebRtcVideoChannel2::GetRenderer(uint32 ssrc, VideoRenderer** renderer) {
1103 if (ssrc == 0) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001104 *renderer = default_unsignalled_ssrc_handler_.GetDefaultRenderer();
1105 return *renderer != NULL;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001106 }
1107
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001108 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001109 std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
1110 receive_streams_.find(ssrc);
1111 if (it == receive_streams_.end()) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001112 return false;
1113 }
1114 *renderer = it->second->GetRenderer();
1115 return true;
1116}
1117
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00001118bool WebRtcVideoChannel2::GetStats(VideoMediaInfo* info) {
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001119 info->Clear();
1120 FillSenderStats(info);
1121 FillReceiverStats(info);
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00001122 webrtc::Call::Stats stats = call_->GetStats();
1123 FillBandwidthEstimationStats(stats, info);
1124 if (stats.rtt_ms != -1) {
1125 for (size_t i = 0; i < info->senders.size(); ++i) {
1126 info->senders[i].rtt_ms = stats.rtt_ms;
1127 }
1128 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001129 return true;
1130}
1131
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001132void WebRtcVideoChannel2::FillSenderStats(VideoMediaInfo* video_media_info) {
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001133 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001134 for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1135 send_streams_.begin();
1136 it != send_streams_.end();
1137 ++it) {
1138 video_media_info->senders.push_back(it->second->GetVideoSenderInfo());
1139 }
1140}
1141
1142void WebRtcVideoChannel2::FillReceiverStats(VideoMediaInfo* video_media_info) {
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001143 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001144 for (std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
1145 receive_streams_.begin();
1146 it != receive_streams_.end();
1147 ++it) {
1148 video_media_info->receivers.push_back(it->second->GetVideoReceiverInfo());
1149 }
1150}
1151
1152void WebRtcVideoChannel2::FillBandwidthEstimationStats(
pbos@webrtc.org2b19f062014-12-11 13:26:09 +00001153 const webrtc::Call::Stats& stats,
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001154 VideoMediaInfo* video_media_info) {
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001155 BandwidthEstimationInfo bwe_info;
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001156 bwe_info.available_send_bandwidth = stats.send_bandwidth_bps;
1157 bwe_info.available_recv_bandwidth = stats.recv_bandwidth_bps;
1158 bwe_info.bucket_delay = stats.pacer_delay_ms;
1159
1160 // Get send stream bitrate stats.
1161 rtc::CritScope stream_lock(&stream_crit_);
1162 for (std::map<uint32, WebRtcVideoSendStream*>::iterator stream =
1163 send_streams_.begin();
1164 stream != send_streams_.end();
1165 ++stream) {
1166 stream->second->FillBandwidthEstimationInfo(&bwe_info);
1167 }
1168 video_media_info->bw_estimations.push_back(bwe_info);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001169}
1170
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001171bool WebRtcVideoChannel2::SetCapturer(uint32 ssrc, VideoCapturer* capturer) {
1172 LOG(LS_INFO) << "SetCapturer: " << ssrc << " -> "
1173 << (capturer != NULL ? "(capturer)" : "NULL");
1174 assert(ssrc != 0);
Peter Boströme7b221f2015-04-13 15:34:32 +02001175 {
1176 rtc::CritScope stream_lock(&stream_crit_);
1177 if (send_streams_.find(ssrc) == send_streams_.end()) {
1178 LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc;
1179 return false;
1180 }
1181 if (!send_streams_[ssrc]->SetCapturer(capturer)) {
1182 return false;
1183 }
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001184 }
1185
1186 if (capturer) {
1187 capturer->SetApplyRotation(
1188 !FindHeaderExtension(send_rtp_extensions_,
1189 kRtpVideoRotationHeaderExtension));
1190 }
Peter Boströme7b221f2015-04-13 15:34:32 +02001191 {
1192 rtc::CritScope lock(&capturer_crit_);
1193 capturers_[ssrc] = capturer;
1194 }
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001195 return true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001196}
1197
1198bool WebRtcVideoChannel2::SendIntraFrame() {
1199 // TODO(pbos): Implement.
1200 LOG(LS_VERBOSE) << "SendIntraFrame().";
1201 return true;
1202}
1203
1204bool WebRtcVideoChannel2::RequestIntraFrame() {
1205 // TODO(pbos): Implement.
1206 LOG(LS_VERBOSE) << "SendIntraFrame().";
1207 return true;
1208}
1209
1210void WebRtcVideoChannel2::OnPacketReceived(
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001211 rtc::Buffer* packet,
1212 const rtc::PacketTime& packet_time) {
pbos@webrtc.org4e545cc2014-05-14 13:58:13 +00001213 const webrtc::PacketReceiver::DeliveryStatus delivery_result =
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +02001214 call_->Receiver()->DeliverPacket(webrtc::MediaType::VIDEO,
kwiberg@webrtc.orgeebcab52015-03-24 09:19:06 +00001215 reinterpret_cast<const uint8_t*>(packet->data()), packet->size());
pbos@webrtc.org4e545cc2014-05-14 13:58:13 +00001216 switch (delivery_result) {
1217 case webrtc::PacketReceiver::DELIVERY_OK:
1218 return;
1219 case webrtc::PacketReceiver::DELIVERY_PACKET_ERROR:
1220 return;
1221 case webrtc::PacketReceiver::DELIVERY_UNKNOWN_SSRC:
1222 break;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001223 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001224
1225 uint32 ssrc = 0;
kwiberg@webrtc.orgeebcab52015-03-24 09:19:06 +00001226 if (!GetRtpSsrc(packet->data(), packet->size(), &ssrc)) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001227 return;
1228 }
1229
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00001230 // TODO(pbos): Ignore unsignalled packets that don't use the video payload
1231 // (prevent creating default receivers for RTX configured as if it would
1232 // receive media payloads on those SSRCs).
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001233 switch (unsignalled_ssrc_handler_->OnUnsignalledSsrc(this, ssrc)) {
1234 case UnsignalledSsrcHandler::kDropPacket:
1235 return;
1236 case UnsignalledSsrcHandler::kDeliverPacket:
1237 break;
1238 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001239
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +02001240 if (call_->Receiver()->DeliverPacket(webrtc::MediaType::VIDEO,
kwiberg@webrtc.orgeebcab52015-03-24 09:19:06 +00001241 reinterpret_cast<const uint8_t*>(packet->data()), packet->size()) !=
pbos@webrtc.org1e019d12014-05-16 11:38:45 +00001242 webrtc::PacketReceiver::DELIVERY_OK) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001243 LOG(LS_WARNING) << "Failed to deliver RTP packet on re-delivery.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001244 return;
1245 }
1246}
1247
1248void WebRtcVideoChannel2::OnRtcpReceived(
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001249 rtc::Buffer* packet,
1250 const rtc::PacketTime& packet_time) {
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +02001251 if (call_->Receiver()->DeliverPacket(webrtc::MediaType::VIDEO,
kwiberg@webrtc.orgeebcab52015-03-24 09:19:06 +00001252 reinterpret_cast<const uint8_t*>(packet->data()), packet->size()) !=
pbos@webrtc.org1e019d12014-05-16 11:38:45 +00001253 webrtc::PacketReceiver::DELIVERY_OK) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001254 LOG(LS_WARNING) << "Failed to deliver RTCP packet.";
1255 }
1256}
1257
1258void WebRtcVideoChannel2::OnReadyToSend(bool ready) {
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00001259 LOG(LS_VERBOSE) << "OnReadyToSend: " << (ready ? "Ready." : "Not ready.");
1260 call_->SignalNetworkState(ready ? webrtc::Call::kNetworkUp
1261 : webrtc::Call::kNetworkDown);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001262}
1263
1264bool WebRtcVideoChannel2::MuteStream(uint32 ssrc, bool mute) {
1265 LOG(LS_VERBOSE) << "MuteStream: " << ssrc << " -> "
1266 << (mute ? "mute" : "unmute");
1267 assert(ssrc != 0);
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001268 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001269 if (send_streams_.find(ssrc) == send_streams_.end()) {
1270 LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc;
1271 return false;
1272 }
pbos@webrtc.orgef8bb8d2014-08-13 21:36:18 +00001273
1274 send_streams_[ssrc]->MuteStream(mute);
1275 return true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001276}
1277
1278bool WebRtcVideoChannel2::SetRecvRtpHeaderExtensions(
1279 const std::vector<RtpHeaderExtension>& extensions) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +00001280 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRecvRtpHeaderExtensions");
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001281 LOG(LS_INFO) << "SetRecvRtpHeaderExtensions: "
1282 << RtpExtensionsToString(extensions);
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001283 if (!ValidateRtpHeaderExtensionIds(extensions))
1284 return false;
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001285
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001286 std::vector<webrtc::RtpExtension> filtered_extensions =
1287 FilterRtpExtensions(extensions);
1288 if (!RtpExtensionsHaveChanged(recv_rtp_extensions_, filtered_extensions))
1289 return true;
1290
1291 recv_rtp_extensions_ = filtered_extensions;
1292
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001293 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001294 for (std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
1295 receive_streams_.begin();
1296 it != receive_streams_.end();
1297 ++it) {
1298 it->second->SetRtpExtensions(recv_rtp_extensions_);
1299 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001300 return true;
1301}
1302
1303bool WebRtcVideoChannel2::SetSendRtpHeaderExtensions(
1304 const std::vector<RtpHeaderExtension>& extensions) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +00001305 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetSendRtpHeaderExtensions");
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001306 LOG(LS_INFO) << "SetSendRtpHeaderExtensions: "
1307 << RtpExtensionsToString(extensions);
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001308 if (!ValidateRtpHeaderExtensionIds(extensions))
1309 return false;
1310
pbos@webrtc.orgc37e72e2015-01-05 18:51:13 +00001311 std::vector<webrtc::RtpExtension> filtered_extensions =
1312 FilterRtpExtensions(extensions);
1313 if (!RtpExtensionsHaveChanged(send_rtp_extensions_, filtered_extensions))
1314 return true;
1315
1316 send_rtp_extensions_ = filtered_extensions;
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001317
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001318 const webrtc::RtpExtension* cvo_extension = FindHeaderExtension(
1319 send_rtp_extensions_, kRtpVideoRotationHeaderExtension);
1320
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001321 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001322 for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1323 send_streams_.begin();
1324 it != send_streams_.end();
1325 ++it) {
1326 it->second->SetRtpExtensions(send_rtp_extensions_);
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001327 it->second->SetApplyRotation(!cvo_extension);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001328 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001329 return true;
1330}
1331
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001332// Counter-intuitively this method doesn't only set global bitrate caps but also
1333// per-stream codec max bitrates. This is to permit SetMaxSendBitrate (b=AS) to
1334// raise bitrates above the 2000k default bitrate cap.
pbos@webrtc.org00873182014-11-25 14:03:34 +00001335bool WebRtcVideoChannel2::SetMaxSendBandwidth(int max_bitrate_bps) {
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001336 // TODO(pbos): Figure out whether b=AS means max bitrate for this
1337 // WebRtcVideoChannel2 (in which case we're good), or per sender (SSRC), in
1338 // which case this should not set a Call::BitrateConfig but rather reconfigure
1339 // all senders.
pbos@webrtc.org00873182014-11-25 14:03:34 +00001340 LOG(LS_INFO) << "SetMaxSendBandwidth: " << max_bitrate_bps << "bps.";
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001341 if (max_bitrate_bps == bitrate_config_.max_bitrate_bps)
1342 return true;
1343
pbos@webrtc.org00873182014-11-25 14:03:34 +00001344 if (max_bitrate_bps <= 0) {
1345 // Unsetting max bitrate.
1346 max_bitrate_bps = -1;
1347 }
1348 bitrate_config_.start_bitrate_bps = -1;
1349 bitrate_config_.max_bitrate_bps = max_bitrate_bps;
1350 if (max_bitrate_bps > 0 &&
1351 bitrate_config_.min_bitrate_bps > max_bitrate_bps) {
1352 bitrate_config_.min_bitrate_bps = max_bitrate_bps;
1353 }
1354 call_->SetBitrateConfig(bitrate_config_);
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001355 rtc::CritScope stream_lock(&stream_crit_);
1356 for (auto& kv : send_streams_)
1357 kv.second->SetMaxBitrateBps(max_bitrate_bps);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001358 return true;
1359}
1360
1361bool WebRtcVideoChannel2::SetOptions(const VideoOptions& options) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +00001362 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetOptions");
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001363 LOG(LS_INFO) << "SetOptions: " << options.ToString();
1364 VideoOptions old_options = options_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001365 options_.SetAll(options);
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001366 if (options_ == old_options) {
1367 // No new options to set.
1368 return true;
1369 }
Peter Boströme7b221f2015-04-13 15:34:32 +02001370 {
1371 rtc::CritScope lock(&capturer_crit_);
1372 options_.cpu_overuse_detection.Get(&signal_cpu_adaptation_);
1373 }
pbos@webrtc.orgd8198032014-11-10 14:41:43 +00001374 rtc::DiffServCodePoint dscp = options_.dscp.GetWithDefaultIfUnset(false)
1375 ? rtc::DSCP_AF41
1376 : rtc::DSCP_DEFAULT;
1377 MediaChannel::SetDscp(dscp);
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001378 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001379 for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1380 send_streams_.begin();
1381 it != send_streams_.end();
1382 ++it) {
1383 it->second->SetOptions(options_);
1384 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001385 return true;
1386}
1387
1388void WebRtcVideoChannel2::SetInterface(NetworkInterface* iface) {
1389 MediaChannel::SetInterface(iface);
1390 // Set the RTP recv/send buffer to a bigger size
1391 MediaChannel::SetOption(NetworkInterface::ST_RTP,
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001392 rtc::Socket::OPT_RCVBUF,
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001393 kVideoRtpBufferSize);
1394
buildbot@webrtc.orgae694ef2014-10-28 17:37:17 +00001395 // Speculative change to increase the outbound socket buffer size.
1396 // In b/15152257, we are seeing a significant number of packets discarded
1397 // due to lack of socket buffer space, although it's not yet clear what the
1398 // ideal value should be.
1399 MediaChannel::SetOption(NetworkInterface::ST_RTP,
1400 rtc::Socket::OPT_SNDBUF,
1401 kVideoRtpBufferSize);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001402}
1403
1404void WebRtcVideoChannel2::UpdateAspectRatio(int ratio_w, int ratio_h) {
1405 // TODO(pbos): Implement.
1406}
1407
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001408void WebRtcVideoChannel2::OnMessage(rtc::Message* msg) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001409 // Ignored.
1410}
1411
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001412void WebRtcVideoChannel2::OnLoadUpdate(Load load) {
Peter Boströme7b221f2015-04-13 15:34:32 +02001413 // OnLoadUpdate can not take any locks that are held while creating streams
1414 // etc. Doing so establishes lock-order inversions between the webrtc process
1415 // thread on stream creation and locks such as stream_crit_ while calling out.
1416 rtc::CritScope stream_lock(&capturer_crit_);
1417 if (!signal_cpu_adaptation_)
1418 return;
1419 for (auto& kv : capturers_) {
1420 if (kv.second != nullptr && kv.second->video_adapter() != nullptr) {
1421 kv.second->video_adapter()->OnCpuResolutionRequest(
1422 load == kOveruse ? CoordinatedVideoAdapter::DOWNGRADE
1423 : CoordinatedVideoAdapter::UPGRADE);
1424 }
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001425 }
1426}
1427
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001428bool WebRtcVideoChannel2::SendRtp(const uint8_t* data, size_t len) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001429 rtc::Buffer packet(data, len, kMaxRtpPacketLen);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001430 return MediaChannel::SendPacket(&packet);
1431}
1432
1433bool WebRtcVideoChannel2::SendRtcp(const uint8_t* data, size_t len) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001434 rtc::Buffer packet(data, len, kMaxRtpPacketLen);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001435 return MediaChannel::SendRtcp(&packet);
1436}
1437
1438void WebRtcVideoChannel2::StartAllSendStreams() {
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001439 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001440 for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1441 send_streams_.begin();
1442 it != send_streams_.end();
1443 ++it) {
1444 it->second->Start();
1445 }
1446}
1447
1448void WebRtcVideoChannel2::StopAllSendStreams() {
pbos@webrtc.org575d1262014-10-08 14:48:08 +00001449 rtc::CritScope stream_lock(&stream_crit_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001450 for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1451 send_streams_.begin();
1452 it != send_streams_.end();
1453 ++it) {
1454 it->second->Stop();
1455 }
1456}
1457
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001458WebRtcVideoChannel2::WebRtcVideoSendStream::VideoSendStreamParameters::
1459 VideoSendStreamParameters(
1460 const webrtc::VideoSendStream::Config& config,
1461 const VideoOptions& options,
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001462 int max_bitrate_bps,
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001463 const Settable<VideoCodecSettings>& codec_settings)
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001464 : config(config),
1465 options(options),
1466 max_bitrate_bps(max_bitrate_bps),
1467 codec_settings(codec_settings) {
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001468}
1469
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001470WebRtcVideoChannel2::WebRtcVideoSendStream::WebRtcVideoSendStream(
1471 webrtc::Call* call,
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001472 WebRtcVideoEncoderFactory* external_encoder_factory,
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001473 const VideoOptions& options,
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001474 int max_bitrate_bps,
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001475 const Settable<VideoCodecSettings>& codec_settings,
1476 const StreamParams& sp,
1477 const std::vector<webrtc::RtpExtension>& rtp_extensions)
Henrik Kjellander7c027b62015-04-22 13:21:30 +02001478 : ssrcs_(sp.ssrcs),
1479 call_(call),
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001480 external_encoder_factory_(external_encoder_factory),
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001481 stream_(NULL),
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001482 parameters_(webrtc::VideoSendStream::Config(),
1483 options,
1484 max_bitrate_bps,
1485 codec_settings),
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001486 allocated_encoder_(NULL, webrtc::kVideoCodecUnknown, false),
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +00001487 capturer_(NULL),
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001488 sending_(false),
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00001489 muted_(false),
1490 old_adapt_changes_(0) {
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001491 parameters_.config.rtp.max_packet_size = kVideoMtu;
1492
1493 sp.GetPrimarySsrcs(&parameters_.config.rtp.ssrcs);
1494 sp.GetFidSsrcs(parameters_.config.rtp.ssrcs,
1495 &parameters_.config.rtp.rtx.ssrcs);
1496 parameters_.config.rtp.c_name = sp.cname;
1497 parameters_.config.rtp.extensions = rtp_extensions;
1498
1499 VideoCodecSettings params;
1500 if (codec_settings.Get(&params)) {
1501 SetCodec(params);
1502 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001503}
1504
1505WebRtcVideoChannel2::WebRtcVideoSendStream::~WebRtcVideoSendStream() {
1506 DisconnectCapturer();
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001507 if (stream_ != NULL) {
1508 call_->DestroyVideoSendStream(stream_);
1509 }
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001510 DestroyVideoEncoder(&allocated_encoder_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001511}
1512
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001513static void CreateBlackFrame(webrtc::I420VideoFrame* video_frame,
1514 int width,
1515 int height) {
pbos@webrtc.orgb4987bf2015-02-18 10:13:09 +00001516 video_frame->CreateEmptyFrame(width, height, width, (width + 1) / 2,
1517 (width + 1) / 2);
1518 memset(video_frame->buffer(webrtc::kYPlane), 16,
1519 video_frame->allocated_size(webrtc::kYPlane));
1520 memset(video_frame->buffer(webrtc::kUPlane), 128,
1521 video_frame->allocated_size(webrtc::kUPlane));
1522 memset(video_frame->buffer(webrtc::kVPlane), 128,
1523 video_frame->allocated_size(webrtc::kVPlane));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001524}
1525
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001526void WebRtcVideoChannel2::WebRtcVideoSendStream::InputFrame(
1527 VideoCapturer* capturer,
1528 const VideoFrame* frame) {
pbos@webrtc.org86196c42015-02-16 21:02:00 +00001529 TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::InputFrame");
magjed@webrtc.orgafdd5dd2015-03-12 13:11:25 +00001530 webrtc::I420VideoFrame video_frame(frame->GetVideoFrameBuffer(), 0, 0,
1531 frame->GetVideoRotation());
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001532 rtc::CritScope cs(&lock_);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001533 if (stream_ == NULL) {
Peter Boströmad1f9b62015-04-08 14:04:01 +02001534 // Frame input before send codecs are configured, dropping frame.
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001535 return;
1536 }
pbos@webrtc.org86196c42015-02-16 21:02:00 +00001537
1538 // Not sending, abort early to prevent expensive reconfigurations while
1539 // setting up codecs etc.
1540 if (!sending_)
1541 return;
1542
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001543 if (format_.width == 0) { // Dropping frames.
1544 assert(format_.height == 0);
1545 LOG(LS_VERBOSE) << "VideoFormat 0x0 set, Dropping frame.";
1546 return;
1547 }
pbos@webrtc.orgd60d79a2014-09-24 07:10:57 +00001548 if (muted_) {
1549 // Create a black frame to transmit instead.
magjed@webrtc.orgafdd5dd2015-03-12 13:11:25 +00001550 CreateBlackFrame(&video_frame,
pbos@webrtc.orgd60d79a2014-09-24 07:10:57 +00001551 static_cast<int>(frame->GetWidth()),
1552 static_cast<int>(frame->GetHeight()));
1553 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001554 // Reconfigure codec if necessary.
pbos@webrtc.orgc4175b92014-09-03 15:25:49 +00001555 SetDimensions(
magjed@webrtc.orgafdd5dd2015-03-12 13:11:25 +00001556 video_frame.width(), video_frame.height(), capturer->IsScreencast());
pbos@webrtc.orgc4175b92014-09-03 15:25:49 +00001557
perkj@webrtc.orgaf612d52015-03-18 09:51:05 +00001558 stream_->Input()->IncomingCapturedFrame(video_frame);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001559}
1560
1561bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetCapturer(
1562 VideoCapturer* capturer) {
pbos@webrtc.orgb4987bf2015-02-18 10:13:09 +00001563 TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::SetCapturer");
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001564 if (!DisconnectCapturer() && capturer == NULL) {
1565 return false;
1566 }
1567
1568 {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001569 rtc::CritScope cs(&lock_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001570
pbos@webrtc.org9359cb32014-07-23 15:44:48 +00001571 if (capturer == NULL) {
1572 if (stream_ != NULL) {
1573 LOG(LS_VERBOSE) << "Disabling capturer, sending black frame.";
1574 webrtc::I420VideoFrame black_frame;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001575
pbos@webrtc.orgb4987bf2015-02-18 10:13:09 +00001576 CreateBlackFrame(&black_frame, last_dimensions_.width,
1577 last_dimensions_.height);
perkj@webrtc.orgaf612d52015-03-18 09:51:05 +00001578 stream_->Input()->IncomingCapturedFrame(black_frame);
pbos@webrtc.org9359cb32014-07-23 15:44:48 +00001579 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001580
1581 capturer_ = NULL;
1582 return true;
1583 }
1584
1585 capturer_ = capturer;
1586 }
1587 // Lock cannot be held while connecting the capturer to prevent lock-order
1588 // violations.
1589 capturer->SignalVideoFrame.connect(this, &WebRtcVideoSendStream::InputFrame);
1590 return true;
1591}
1592
1593bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetVideoFormat(
1594 const VideoFormat& format) {
1595 if ((format.width == 0 || format.height == 0) &&
1596 format.width != format.height) {
1597 LOG(LS_ERROR) << "Can't set VideoFormat, width or height is zero (but not "
1598 "both, 0x0 drops frames).";
1599 return false;
1600 }
1601
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001602 rtc::CritScope cs(&lock_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001603 if (format.width == 0 && format.height == 0) {
1604 LOG(LS_INFO)
1605 << "0x0 resolution selected. Captured frames will be dropped for ssrc: "
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001606 << parameters_.config.rtp.ssrcs[0] << ".";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001607 } else {
1608 // TODO(pbos): Fix me, this only affects the last stream!
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00001609 parameters_.encoder_config.streams.back().max_framerate =
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001610 VideoFormat::IntervalToFps(format.interval);
pbos@webrtc.orgc4175b92014-09-03 15:25:49 +00001611 SetDimensions(format.width, format.height, false);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001612 }
1613
1614 format_ = format;
1615 return true;
1616}
1617
pbos@webrtc.orgef8bb8d2014-08-13 21:36:18 +00001618void WebRtcVideoChannel2::WebRtcVideoSendStream::MuteStream(bool mute) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001619 rtc::CritScope cs(&lock_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001620 muted_ = mute;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001621}
1622
1623bool WebRtcVideoChannel2::WebRtcVideoSendStream::DisconnectCapturer() {
pbos@webrtc.org963b9792014-10-07 14:27:27 +00001624 cricket::VideoCapturer* capturer;
1625 {
1626 rtc::CritScope cs(&lock_);
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00001627 if (capturer_ == NULL)
pbos@webrtc.org963b9792014-10-07 14:27:27 +00001628 return false;
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00001629
1630 if (capturer_->video_adapter() != nullptr)
1631 old_adapt_changes_ += capturer_->video_adapter()->adaptation_changes();
1632
pbos@webrtc.org963b9792014-10-07 14:27:27 +00001633 capturer = capturer_;
1634 capturer_ = NULL;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001635 }
pbos@webrtc.org963b9792014-10-07 14:27:27 +00001636 capturer->SignalVideoFrame.disconnect(this);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001637 return true;
1638}
1639
Peter Boströmd6f4c252015-03-26 16:23:04 +01001640const std::vector<uint32>&
1641WebRtcVideoChannel2::WebRtcVideoSendStream::GetSsrcs() const {
1642 return ssrcs_;
1643}
1644
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001645void WebRtcVideoChannel2::WebRtcVideoSendStream::SetApplyRotation(
1646 bool apply_rotation) {
1647 rtc::CritScope cs(&lock_);
1648 if (capturer_ == NULL)
1649 return;
1650
1651 capturer_->SetApplyRotation(apply_rotation);
1652}
1653
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001654void WebRtcVideoChannel2::WebRtcVideoSendStream::SetOptions(
1655 const VideoOptions& options) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001656 rtc::CritScope cs(&lock_);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001657 VideoCodecSettings codec_settings;
1658 if (parameters_.codec_settings.Get(&codec_settings)) {
1659 SetCodecAndOptions(codec_settings, options);
1660 } else {
1661 parameters_.options = options;
1662 }
1663}
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001664
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001665void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodec(
1666 const VideoCodecSettings& codec_settings) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001667 rtc::CritScope cs(&lock_);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001668 SetCodecAndOptions(codec_settings, parameters_.options);
1669}
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001670
1671webrtc::VideoCodecType CodecTypeFromName(const std::string& name) {
Shao Changbine62202f2015-04-21 20:24:50 +08001672 if (CodecNamesEq(name, kVp8CodecName)) {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001673 return webrtc::kVideoCodecVP8;
Shao Changbine62202f2015-04-21 20:24:50 +08001674 } else if (CodecNamesEq(name, kVp9CodecName)) {
andresp@webrtc.org188d3b22014-11-07 13:21:04 +00001675 return webrtc::kVideoCodecVP9;
Shao Changbine62202f2015-04-21 20:24:50 +08001676 } else if (CodecNamesEq(name, kH264CodecName)) {
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001677 return webrtc::kVideoCodecH264;
1678 }
1679 return webrtc::kVideoCodecUnknown;
1680}
1681
1682WebRtcVideoChannel2::WebRtcVideoSendStream::AllocatedEncoder
1683WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoder(
1684 const VideoCodec& codec) {
1685 webrtc::VideoCodecType type = CodecTypeFromName(codec.name);
1686
1687 // Do not re-create encoders of the same type.
1688 if (type == allocated_encoder_.type && allocated_encoder_.encoder != NULL) {
1689 return allocated_encoder_;
1690 }
1691
1692 if (external_encoder_factory_ != NULL) {
1693 webrtc::VideoEncoder* encoder =
1694 external_encoder_factory_->CreateVideoEncoder(type);
1695 if (encoder != NULL) {
1696 return AllocatedEncoder(encoder, type, true);
1697 }
1698 }
1699
1700 if (type == webrtc::kVideoCodecVP8) {
1701 return AllocatedEncoder(
1702 webrtc::VideoEncoder::Create(webrtc::VideoEncoder::kVp8), type, false);
andresp@webrtc.org188d3b22014-11-07 13:21:04 +00001703 } else if (type == webrtc::kVideoCodecVP9) {
1704 return AllocatedEncoder(
1705 webrtc::VideoEncoder::Create(webrtc::VideoEncoder::kVp9), type, false);
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001706 }
1707
1708 // This shouldn't happen, we should not be trying to create something we don't
1709 // support.
1710 assert(false);
1711 return AllocatedEncoder(NULL, webrtc::kVideoCodecUnknown, false);
1712}
1713
1714void WebRtcVideoChannel2::WebRtcVideoSendStream::DestroyVideoEncoder(
1715 AllocatedEncoder* encoder) {
1716 if (encoder->external) {
1717 external_encoder_factory_->DestroyVideoEncoder(encoder->encoder);
1718 } else {
1719 delete encoder->encoder;
1720 }
1721}
1722
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001723void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodecAndOptions(
1724 const VideoCodecSettings& codec_settings,
1725 const VideoOptions& options) {
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001726 parameters_.encoder_config =
1727 CreateVideoEncoderConfig(last_dimensions_, codec_settings.codec);
pbos@webrtc.org86196c42015-02-16 21:02:00 +00001728 if (parameters_.encoder_config.streams.empty())
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001729 return;
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001730
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001731 format_ = VideoFormat(codec_settings.codec.width,
1732 codec_settings.codec.height,
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001733 VideoFormat::FpsToInterval(30),
1734 FOURCC_I420);
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001735
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001736 AllocatedEncoder new_encoder = CreateVideoEncoder(codec_settings.codec);
1737 parameters_.config.encoder_settings.encoder = new_encoder.encoder;
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001738 parameters_.config.encoder_settings.payload_name = codec_settings.codec.name;
1739 parameters_.config.encoder_settings.payload_type = codec_settings.codec.id;
1740 parameters_.config.rtp.fec = codec_settings.fec;
1741
1742 // Set RTX payload type if RTX is enabled.
1743 if (!parameters_.config.rtp.rtx.ssrcs.empty()) {
pbos@webrtc.orgb9557a92015-03-20 19:52:56 +00001744 if (codec_settings.rtx_payload_type == -1) {
1745 LOG(LS_WARNING) << "RTX SSRCs configured but there's no configured RTX "
1746 "payload type. Ignoring.";
1747 parameters_.config.rtp.rtx.ssrcs.clear();
1748 } else {
1749 parameters_.config.rtp.rtx.payload_type = codec_settings.rtx_payload_type;
1750 }
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001751 }
1752
Shao Changbine62202f2015-04-21 20:24:50 +08001753 if (HasNack(codec_settings.codec)) {
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001754 parameters_.config.rtp.nack.rtp_history_ms = kNackHistoryMs;
1755 }
1756
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00001757 options.suspend_below_min_bitrate.Get(
1758 &parameters_.config.suspend_below_min_bitrate);
1759
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001760 parameters_.codec_settings.Set(codec_settings);
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001761 parameters_.options = options;
pbos@webrtc.org543e5892014-07-23 07:01:31 +00001762
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001763 RecreateWebRtcStream();
pbos@webrtc.org7fe1e032014-10-14 04:25:33 +00001764 if (allocated_encoder_.encoder != new_encoder.encoder) {
1765 DestroyVideoEncoder(&allocated_encoder_);
1766 allocated_encoder_ = new_encoder;
1767 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001768}
1769
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001770void WebRtcVideoChannel2::WebRtcVideoSendStream::SetRtpExtensions(
1771 const std::vector<webrtc::RtpExtension>& rtp_extensions) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001772 rtc::CritScope cs(&lock_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001773 parameters_.config.rtp.extensions = rtp_extensions;
Peter Boström3c3f6462015-04-15 16:27:49 +02001774 if (stream_ != nullptr)
1775 RecreateWebRtcStream();
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001776}
1777
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001778webrtc::VideoEncoderConfig
1779WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoderConfig(
1780 const Dimensions& dimensions,
1781 const VideoCodec& codec) const {
1782 webrtc::VideoEncoderConfig encoder_config;
1783 if (dimensions.is_screencast) {
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001784 int screencast_min_bitrate_kbps;
1785 parameters_.options.screencast_min_bitrate.Get(
1786 &screencast_min_bitrate_kbps);
1787 encoder_config.min_transmit_bitrate_bps =
1788 screencast_min_bitrate_kbps * 1000;
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001789 encoder_config.content_type =
1790 webrtc::VideoEncoderConfig::ContentType::kScreen;
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001791 } else {
1792 encoder_config.min_transmit_bitrate_bps = 0;
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001793 encoder_config.content_type =
1794 webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo;
pbos@webrtc.orgefc82c22014-10-27 13:58:00 +00001795 }
1796
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001797 // Restrict dimensions according to codec max.
1798 int width = dimensions.width;
1799 int height = dimensions.height;
1800 if (!dimensions.is_screencast) {
1801 if (codec.width < width)
1802 width = codec.width;
1803 if (codec.height < height)
1804 height = codec.height;
1805 }
1806
1807 VideoCodec clamped_codec = codec;
1808 clamped_codec.width = width;
1809 clamped_codec.height = height;
pbos@webrtc.orgcddd17c2014-09-16 16:33:13 +00001810
pbos@webrtc.orgf1c8b902015-01-14 17:29:27 +00001811 encoder_config.streams = CreateVideoStreams(
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001812 clamped_codec, parameters_.options, parameters_.max_bitrate_bps,
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001813 dimensions.is_screencast ? 1 : parameters_.config.rtp.ssrcs.size());
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001814
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001815 // Conference mode screencast uses 2 temporal layers split at 100kbit.
1816 if (parameters_.options.conference_mode.GetWithDefaultIfUnset(false) &&
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001817 dimensions.is_screencast && encoder_config.streams.size() == 1) {
sprang@webrtc.org46d4d292014-12-23 15:19:35 +00001818 ScreenshareLayerConfig config = ScreenshareLayerConfig::GetDefault();
1819
1820 // For screenshare in conference mode, tl0 and tl1 bitrates are piggybacked
1821 // on the VideoCodec struct as target and max bitrates, respectively.
1822 // See eg. webrtc::VP8EncoderImpl::SetRates().
1823 encoder_config.streams[0].target_bitrate_bps =
1824 config.tl0_bitrate_kbps * 1000;
1825 encoder_config.streams[0].max_bitrate_bps = config.tl1_bitrate_kbps * 1000;
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001826 encoder_config.streams[0].temporal_layer_thresholds_bps.clear();
1827 encoder_config.streams[0].temporal_layer_thresholds_bps.push_back(
sprang@webrtc.org46d4d292014-12-23 15:19:35 +00001828 config.tl0_bitrate_kbps * 1000);
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001829 }
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00001830 return encoder_config;
1831}
1832
1833void WebRtcVideoChannel2::WebRtcVideoSendStream::SetDimensions(
1834 int width,
1835 int height,
1836 bool is_screencast) {
1837 if (last_dimensions_.width == width && last_dimensions_.height == height &&
1838 last_dimensions_.is_screencast == is_screencast) {
1839 // Configured using the same parameters, do not reconfigure.
1840 return;
1841 }
1842 LOG(LS_INFO) << "SetDimensions: " << width << "x" << height
1843 << (is_screencast ? " (screencast)" : " (not screencast)");
1844
1845 last_dimensions_.width = width;
1846 last_dimensions_.height = height;
1847 last_dimensions_.is_screencast = is_screencast;
1848
1849 assert(!parameters_.encoder_config.streams.empty());
1850
1851 VideoCodecSettings codec_settings;
1852 parameters_.codec_settings.Get(&codec_settings);
1853
1854 webrtc::VideoEncoderConfig encoder_config =
1855 CreateVideoEncoderConfig(last_dimensions_, codec_settings.codec);
1856
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02001857 encoder_config.encoder_specific_settings = ConfigureVideoEncoderSettings(
1858 codec_settings.codec, parameters_.options, is_screencast);
pbos@webrtc.orgb7ed7792014-10-31 13:08:10 +00001859
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00001860 bool stream_reconfigured = stream_->ReconfigureVideoEncoder(encoder_config);
1861
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00001862 encoder_config.encoder_specific_settings = NULL;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001863
1864 if (!stream_reconfigured) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001865 LOG(LS_WARNING) << "Failed to reconfigure video encoder for dimensions: "
1866 << width << "x" << height;
1867 return;
1868 }
pbos@webrtc.orgcddd17c2014-09-16 16:33:13 +00001869
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00001870 parameters_.encoder_config = encoder_config;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001871}
1872
1873void WebRtcVideoChannel2::WebRtcVideoSendStream::Start() {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001874 rtc::CritScope cs(&lock_);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001875 assert(stream_ != NULL);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001876 stream_->Start();
1877 sending_ = true;
1878}
1879
1880void WebRtcVideoChannel2::WebRtcVideoSendStream::Stop() {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001881 rtc::CritScope cs(&lock_);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001882 if (stream_ != NULL) {
1883 stream_->Stop();
1884 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001885 sending_ = false;
1886}
1887
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001888VideoSenderInfo
1889WebRtcVideoChannel2::WebRtcVideoSendStream::GetVideoSenderInfo() {
1890 VideoSenderInfo info;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00001891 webrtc::VideoSendStream::Stats stats;
1892 {
1893 rtc::CritScope cs(&lock_);
1894 for (uint32_t ssrc : parameters_.config.rtp.ssrcs)
1895 info.add_ssrc(ssrc);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001896
Peter Boström74d9ed72015-03-26 16:28:31 +01001897 VideoCodecSettings codec_settings;
1898 if (parameters_.codec_settings.Get(&codec_settings))
1899 info.codec_name = codec_settings.codec.name;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00001900 for (size_t i = 0; i < parameters_.encoder_config.streams.size(); ++i) {
1901 if (i == parameters_.encoder_config.streams.size() - 1) {
1902 info.preferred_bitrate +=
1903 parameters_.encoder_config.streams[i].max_bitrate_bps;
1904 } else {
1905 info.preferred_bitrate +=
1906 parameters_.encoder_config.streams[i].target_bitrate_bps;
1907 }
1908 }
pbos@webrtc.orgc3d2bd22014-08-12 20:55:10 +00001909
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00001910 if (stream_ == NULL)
1911 return info;
1912
1913 stats = stream_->GetStats();
1914
pbos@webrtc.org9a4410e2015-02-26 10:03:39 +00001915 info.adapt_changes = old_adapt_changes_;
1916 info.adapt_reason = CoordinatedVideoAdapter::ADAPTREASON_NONE;
1917
1918 if (capturer_ != NULL) {
1919 if (!capturer_->IsMuted()) {
1920 VideoFormat last_captured_frame_format;
1921 capturer_->GetStats(&info.adapt_frame_drops, &info.effects_frame_drops,
1922 &info.capturer_frame_time,
1923 &last_captured_frame_format);
1924 info.input_frame_width = last_captured_frame_format.width;
1925 info.input_frame_height = last_captured_frame_format.height;
1926 }
1927 if (capturer_->video_adapter() != nullptr) {
1928 info.adapt_changes += capturer_->video_adapter()->adaptation_changes();
1929 info.adapt_reason = capturer_->video_adapter()->adapt_reason();
1930 }
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00001931 }
1932 }
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001933 info.framerate_input = stats.input_frame_rate;
1934 info.framerate_sent = stats.encode_frame_rate;
pbos@webrtc.org3e6e2712015-02-26 12:19:31 +00001935 info.avg_encode_ms = stats.avg_encode_time_ms;
1936 info.encode_usage_percent = stats.encode_usage_percent;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001937
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00001938 info.nominal_bitrate = stats.media_bitrate_bps;
1939
pbos@webrtc.org273a4142014-12-01 15:23:21 +00001940 info.send_frame_width = 0;
1941 info.send_frame_height = 0;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00001942 for (std::map<uint32_t, webrtc::VideoSendStream::StreamStats>::iterator it =
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001943 stats.substreams.begin();
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00001944 it != stats.substreams.end(); ++it) {
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001945 // TODO(pbos): Wire up additional stats, such as padding bytes.
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00001946 webrtc::VideoSendStream::StreamStats stream_stats = it->second;
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59 +00001947 info.bytes_sent += stream_stats.rtp_stats.transmitted.payload_bytes +
1948 stream_stats.rtp_stats.transmitted.header_bytes +
1949 stream_stats.rtp_stats.transmitted.padding_bytes;
1950 info.packets_sent += stream_stats.rtp_stats.transmitted.packets;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001951 info.packets_lost += stream_stats.rtcp_stats.cumulative_lost;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00001952 if (stream_stats.width > info.send_frame_width)
1953 info.send_frame_width = stream_stats.width;
1954 if (stream_stats.height > info.send_frame_height)
1955 info.send_frame_height = stream_stats.height;
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00001956 info.firs_rcvd += stream_stats.rtcp_packet_type_counts.fir_packets;
1957 info.nacks_rcvd += stream_stats.rtcp_packet_type_counts.nack_packets;
1958 info.plis_rcvd += stream_stats.rtcp_packet_type_counts.pli_packets;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001959 }
1960
1961 if (!stats.substreams.empty()) {
1962 // TODO(pbos): Report fraction lost per SSRC.
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00001963 webrtc::VideoSendStream::StreamStats first_stream_stats =
1964 stats.substreams.begin()->second;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001965 info.fraction_lost =
1966 static_cast<float>(first_stream_stats.rtcp_stats.fraction_lost) /
1967 (1 << 8);
1968 }
1969
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001970 return info;
1971}
1972
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001973void WebRtcVideoChannel2::WebRtcVideoSendStream::FillBandwidthEstimationInfo(
1974 BandwidthEstimationInfo* bwe_info) {
1975 rtc::CritScope cs(&lock_);
1976 if (stream_ == NULL) {
1977 return;
1978 }
1979 webrtc::VideoSendStream::Stats stats = stream_->GetStats();
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00001980 for (std::map<uint32_t, webrtc::VideoSendStream::StreamStats>::iterator it =
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001981 stats.substreams.begin();
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00001982 it != stats.substreams.end(); ++it) {
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001983 bwe_info->transmit_bitrate += it->second.total_bitrate_bps;
1984 bwe_info->retransmit_bitrate += it->second.retransmit_bitrate_bps;
1985 }
pbos@webrtc.org891d4832015-02-26 13:15:22 +00001986 bwe_info->target_enc_bitrate += stats.target_media_bitrate_bps;
pbos@webrtc.org77e11bb2015-02-23 16:39:07 +00001987 bwe_info->actual_enc_bitrate += stats.media_bitrate_bps;
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001988}
1989
Peter Boströmdfd53fe2015-03-27 15:58:11 +01001990void WebRtcVideoChannel2::WebRtcVideoSendStream::SetMaxBitrateBps(
1991 int max_bitrate_bps) {
1992 rtc::CritScope cs(&lock_);
1993 parameters_.max_bitrate_bps = max_bitrate_bps;
1994
1995 // No need to reconfigure if the stream hasn't been configured yet.
1996 if (parameters_.encoder_config.streams.empty())
1997 return;
1998
1999 // Force a stream reconfigure to set the new max bitrate.
2000 int width = last_dimensions_.width;
2001 last_dimensions_.width = 0;
2002 SetDimensions(width, last_dimensions_.height, last_dimensions_.is_screencast);
2003}
pbos@webrtc.org42684be2014-10-03 11:25:45 +00002004
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002005void WebRtcVideoChannel2::WebRtcVideoSendStream::RecreateWebRtcStream() {
2006 if (stream_ != NULL) {
2007 call_->DestroyVideoSendStream(stream_);
2008 }
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00002009
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002010 VideoCodecSettings codec_settings;
2011 parameters_.codec_settings.Get(&codec_settings);
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00002012 parameters_.encoder_config.encoder_specific_settings =
Erik SprĂ¥ng143cec12015-04-28 10:01:41 +02002013 ConfigureVideoEncoderSettings(
2014 codec_settings.codec, parameters_.options,
2015 parameters_.encoder_config.content_type ==
2016 webrtc::VideoEncoderConfig::ContentType::kScreen);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002017
pbos@webrtc.orgb9557a92015-03-20 19:52:56 +00002018 webrtc::VideoSendStream::Config config = parameters_.config;
2019 if (!config.rtp.rtx.ssrcs.empty() && config.rtp.rtx.payload_type == -1) {
2020 LOG(LS_WARNING) << "RTX SSRCs configured but there's no configured RTX "
2021 "payload type the set codec. Ignoring RTX.";
2022 config.rtp.rtx.ssrcs.clear();
2023 }
2024 stream_ = call_->CreateVideoSendStream(config, parameters_.encoder_config);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002025
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00002026 parameters_.encoder_config.encoder_specific_settings = NULL;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00002027
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002028 if (sending_) {
2029 stream_->Start();
2030 }
2031}
2032
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002033WebRtcVideoChannel2::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
2034 webrtc::Call* call,
Peter Boströmd6f4c252015-03-26 16:23:04 +01002035 const std::vector<uint32>& ssrcs,
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002036 WebRtcVideoDecoderFactory* external_decoder_factory,
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00002037 bool default_stream,
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002038 const webrtc::VideoReceiveStream::Config& config,
2039 const std::vector<VideoCodecSettings>& recv_codecs)
2040 : call_(call),
Peter Boströmd6f4c252015-03-26 16:23:04 +01002041 ssrcs_(ssrcs),
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002042 stream_(NULL),
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00002043 default_stream_(default_stream),
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +00002044 config_(config),
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002045 external_decoder_factory_(external_decoder_factory),
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +00002046 renderer_(NULL),
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002047 last_width_(-1),
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002048 last_height_(-1),
2049 first_frame_timestamp_(-1),
2050 estimated_remote_start_ntp_time_ms_(0) {
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002051 config_.renderer = this;
2052 // SetRecvCodecs will also reset (start) the VideoReceiveStream.
2053 SetRecvCodecs(recv_codecs);
2054}
2055
2056WebRtcVideoChannel2::WebRtcVideoReceiveStream::~WebRtcVideoReceiveStream() {
2057 call_->DestroyVideoReceiveStream(stream_);
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002058 ClearDecoders(&allocated_decoders_);
2059}
2060
Peter Boströmd6f4c252015-03-26 16:23:04 +01002061const std::vector<uint32>&
2062WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetSsrcs() const {
2063 return ssrcs_;
2064}
2065
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002066WebRtcVideoChannel2::WebRtcVideoReceiveStream::AllocatedDecoder
2067WebRtcVideoChannel2::WebRtcVideoReceiveStream::CreateOrReuseVideoDecoder(
2068 std::vector<AllocatedDecoder>* old_decoders,
2069 const VideoCodec& codec) {
2070 webrtc::VideoCodecType type = CodecTypeFromName(codec.name);
2071
2072 for (size_t i = 0; i < old_decoders->size(); ++i) {
2073 if ((*old_decoders)[i].type == type) {
2074 AllocatedDecoder decoder = (*old_decoders)[i];
2075 (*old_decoders)[i] = old_decoders->back();
2076 old_decoders->pop_back();
2077 return decoder;
2078 }
2079 }
2080
2081 if (external_decoder_factory_ != NULL) {
2082 webrtc::VideoDecoder* decoder =
2083 external_decoder_factory_->CreateVideoDecoder(type);
2084 if (decoder != NULL) {
2085 return AllocatedDecoder(decoder, type, true);
2086 }
2087 }
2088
2089 if (type == webrtc::kVideoCodecVP8) {
2090 return AllocatedDecoder(
2091 webrtc::VideoDecoder::Create(webrtc::VideoDecoder::kVp8), type, false);
2092 }
2093
pbos@webrtc.orgb9557a92015-03-20 19:52:56 +00002094 if (type == webrtc::kVideoCodecVP9) {
2095 return AllocatedDecoder(
2096 webrtc::VideoDecoder::Create(webrtc::VideoDecoder::kVp9), type, false);
2097 }
2098
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002099 // This shouldn't happen, we should not be trying to create something we don't
2100 // support.
2101 assert(false);
2102 return AllocatedDecoder(NULL, webrtc::kVideoCodecUnknown, false);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002103}
2104
2105void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRecvCodecs(
2106 const std::vector<VideoCodecSettings>& recv_codecs) {
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002107 std::vector<AllocatedDecoder> old_decoders = allocated_decoders_;
2108 allocated_decoders_.clear();
2109 config_.decoders.clear();
2110 for (size_t i = 0; i < recv_codecs.size(); ++i) {
2111 AllocatedDecoder allocated_decoder =
2112 CreateOrReuseVideoDecoder(&old_decoders, recv_codecs[i].codec);
2113 allocated_decoders_.push_back(allocated_decoder);
2114
2115 webrtc::VideoReceiveStream::Decoder decoder;
2116 decoder.decoder = allocated_decoder.decoder;
2117 decoder.payload_type = recv_codecs[i].codec.id;
2118 decoder.payload_name = recv_codecs[i].codec.name;
2119 config_.decoders.push_back(decoder);
2120 }
2121
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002122 // TODO(pbos): Reconfigure RTX based on incoming recv_codecs.
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002123 config_.rtp.fec = recv_codecs.front().fec;
pbos@webrtc.org257e1302014-07-25 19:01:32 +00002124 config_.rtp.nack.rtp_history_ms =
Shao Changbine62202f2015-04-21 20:24:50 +08002125 HasNack(recv_codecs.begin()->codec) ? kNackHistoryMs : 0;
2126 config_.rtp.remb = HasRemb(recv_codecs.begin()->codec);
pbos@webrtc.org257e1302014-07-25 19:01:32 +00002127
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002128 ClearDecoders(&old_decoders);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002129 RecreateWebRtcStream();
2130}
2131
2132void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRtpExtensions(
2133 const std::vector<webrtc::RtpExtension>& extensions) {
2134 config_.rtp.extensions = extensions;
Peter Boström3c3f6462015-04-15 16:27:49 +02002135 if (stream_ != nullptr)
2136 RecreateWebRtcStream();
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002137}
2138
2139void WebRtcVideoChannel2::WebRtcVideoReceiveStream::RecreateWebRtcStream() {
2140 if (stream_ != NULL) {
2141 call_->DestroyVideoReceiveStream(stream_);
2142 }
2143 stream_ = call_->CreateVideoReceiveStream(config_);
2144 stream_->Start();
2145}
2146
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002147void WebRtcVideoChannel2::WebRtcVideoReceiveStream::ClearDecoders(
2148 std::vector<AllocatedDecoder>* allocated_decoders) {
2149 for (size_t i = 0; i < allocated_decoders->size(); ++i) {
2150 if ((*allocated_decoders)[i].external) {
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002151 external_decoder_factory_->DestroyVideoDecoder(
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002152 (*allocated_decoders)[i].decoder);
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002153 } else {
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002154 delete (*allocated_decoders)[i].decoder;
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002155 }
2156 }
pbos@webrtc.org96a93252014-11-03 14:46:44 +00002157 allocated_decoders->clear();
pbos@webrtc.org776e6f22014-10-29 15:28:39 +00002158}
2159
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002160void WebRtcVideoChannel2::WebRtcVideoReceiveStream::RenderFrame(
2161 const webrtc::I420VideoFrame& frame,
2162 int time_to_render_ms) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00002163 rtc::CritScope crit(&renderer_lock_);
magjed@webrtc.orgfc5ad952015-01-27 09:57:01 +00002164
2165 if (first_frame_timestamp_ < 0)
2166 first_frame_timestamp_ = frame.timestamp();
2167 int64_t rtp_time_elapsed_since_first_frame =
2168 (timestamp_wraparound_handler_.Unwrap(frame.timestamp()) -
2169 first_frame_timestamp_);
2170 int64_t elapsed_time_ms = rtp_time_elapsed_since_first_frame /
2171 (cricket::kVideoCodecClockrate / 1000);
2172 if (frame.ntp_time_ms() > 0)
2173 estimated_remote_start_ntp_time_ms_ = frame.ntp_time_ms() - elapsed_time_ms;
2174
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002175 if (renderer_ == NULL) {
2176 LOG(LS_WARNING) << "VideoReceiveStream not connected to a VideoRenderer.";
2177 return;
2178 }
2179
2180 if (frame.width() != last_width_ || frame.height() != last_height_) {
2181 SetSize(frame.width(), frame.height());
2182 }
2183
magjed@webrtc.org2386d6d2015-03-05 14:03:08 +00002184 const WebRtcVideoFrame render_frame(
2185 frame.video_frame_buffer(),
2186 elapsed_time_ms * rtc::kNumNanosecsPerMillisec,
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07002187 frame.render_time_ms() * rtc::kNumNanosecsPerMillisec, frame.rotation());
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002188 renderer_->RenderFrame(&render_frame);
2189}
2190
pbos@webrtc.org0d852d52015-02-09 15:14:36 +00002191bool WebRtcVideoChannel2::WebRtcVideoReceiveStream::IsTextureSupported() const {
2192 return true;
2193}
2194
pbos@webrtc.orga2a6fe62015-03-06 15:35:19 +00002195bool WebRtcVideoChannel2::WebRtcVideoReceiveStream::IsDefaultStream() const {
2196 return default_stream_;
2197}
2198
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002199void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRenderer(
2200 cricket::VideoRenderer* renderer) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00002201 rtc::CritScope crit(&renderer_lock_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002202 renderer_ = renderer;
2203 if (renderer_ != NULL && last_width_ != -1) {
2204 SetSize(last_width_, last_height_);
2205 }
2206}
2207
2208VideoRenderer* WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetRenderer() {
2209 // TODO(pbos): Remove GetRenderer and all uses of it, it's thread-unsafe by
2210 // design.
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00002211 rtc::CritScope crit(&renderer_lock_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002212 return renderer_;
2213}
2214
2215void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetSize(int width,
2216 int height) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00002217 rtc::CritScope crit(&renderer_lock_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00002218 if (!renderer_->SetSize(width, height, 0)) {
2219 LOG(LS_ERROR) << "Could not set renderer size.";
2220 }
2221 last_width_ = width;
2222 last_height_ = height;
2223}
2224
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002225VideoReceiverInfo
2226WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetVideoReceiverInfo() {
2227 VideoReceiverInfo info;
2228 info.add_ssrc(config_.rtp.remote_ssrc);
2229 webrtc::VideoReceiveStream::Stats stats = stream_->GetStats();
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59 +00002230 info.bytes_rcvd = stats.rtp_stats.transmitted.payload_bytes +
2231 stats.rtp_stats.transmitted.header_bytes +
2232 stats.rtp_stats.transmitted.padding_bytes;
2233 info.packets_rcvd = stats.rtp_stats.transmitted.packets;
Peter Boström393347f2015-04-22 14:52:45 +02002234 info.packets_lost = stats.rtcp_stats.cumulative_lost;
2235 info.fraction_lost =
2236 static_cast<float>(stats.rtcp_stats.fraction_lost) / (1 << 8);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002237
2238 info.framerate_rcvd = stats.network_frame_rate;
2239 info.framerate_decoded = stats.decode_frame_rate;
2240 info.framerate_output = stats.render_frame_rate;
2241
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002242 {
2243 rtc::CritScope frame_cs(&renderer_lock_);
2244 info.frame_width = last_width_;
2245 info.frame_height = last_height_;
2246 info.capture_start_ntp_time_ms = estimated_remote_start_ntp_time_ms_;
2247 }
2248
pbos@webrtc.org09c77b92015-02-25 10:42:16 +00002249 info.decode_ms = stats.decode_ms;
2250 info.max_decode_ms = stats.max_decode_ms;
2251 info.current_delay_ms = stats.current_delay_ms;
2252 info.target_delay_ms = stats.target_delay_ms;
2253 info.jitter_buffer_ms = stats.jitter_buffer_ms;
2254 info.min_playout_delay_ms = stats.min_playout_delay_ms;
2255 info.render_delay_ms = stats.render_delay_ms;
2256
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +00002257 info.firs_sent = stats.rtcp_packet_type_counts.fir_packets;
2258 info.plis_sent = stats.rtcp_packet_type_counts.pli_packets;
2259 info.nacks_sent = stats.rtcp_packet_type_counts.nack_packets;
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002260
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00002261 return info;
2262}
2263
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002264WebRtcVideoChannel2::VideoCodecSettings::VideoCodecSettings()
2265 : rtx_payload_type(-1) {}
2266
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002267bool WebRtcVideoChannel2::VideoCodecSettings::operator==(
2268 const WebRtcVideoChannel2::VideoCodecSettings& other) const {
2269 return codec == other.codec &&
2270 fec.ulpfec_payload_type == other.fec.ulpfec_payload_type &&
2271 fec.red_payload_type == other.fec.red_payload_type &&
Shao Changbine62202f2015-04-21 20:24:50 +08002272 fec.red_rtx_payload_type == other.fec.red_rtx_payload_type &&
pbos@webrtc.orga2ef4fe2014-11-07 10:54:43 +00002273 rtx_payload_type == other.rtx_payload_type;
2274}
2275
Peter Boströmee0b00e2015-04-22 18:41:14 +02002276bool WebRtcVideoChannel2::VideoCodecSettings::operator!=(
2277 const WebRtcVideoChannel2::VideoCodecSettings& other) const {
2278 return !(*this == other);
2279}
2280
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002281std::vector<WebRtcVideoChannel2::VideoCodecSettings>
2282WebRtcVideoChannel2::MapCodecs(const std::vector<VideoCodec>& codecs) {
2283 assert(!codecs.empty());
2284
2285 std::vector<VideoCodecSettings> video_codecs;
2286 std::map<int, bool> payload_used;
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002287 std::map<int, VideoCodec::CodecType> payload_codec_type;
pkasting@chromium.orgd3245462015-02-23 21:28:22 +00002288 // |rtx_mapping| maps video payload type to rtx payload type.
2289 std::map<int, int> rtx_mapping;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002290
2291 webrtc::FecConfig fec_settings;
2292
2293 for (size_t i = 0; i < codecs.size(); ++i) {
2294 const VideoCodec& in_codec = codecs[i];
2295 int payload_type = in_codec.id;
2296
2297 if (payload_used[payload_type]) {
2298 LOG(LS_ERROR) << "Payload type already registered: "
2299 << in_codec.ToString();
2300 return std::vector<VideoCodecSettings>();
2301 }
2302 payload_used[payload_type] = true;
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002303 payload_codec_type[payload_type] = in_codec.GetCodecType();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002304
2305 switch (in_codec.GetCodecType()) {
2306 case VideoCodec::CODEC_RED: {
2307 // RED payload type, should not have duplicates.
2308 assert(fec_settings.red_payload_type == -1);
2309 fec_settings.red_payload_type = in_codec.id;
2310 continue;
2311 }
2312
2313 case VideoCodec::CODEC_ULPFEC: {
2314 // ULPFEC payload type, should not have duplicates.
2315 assert(fec_settings.ulpfec_payload_type == -1);
2316 fec_settings.ulpfec_payload_type = in_codec.id;
2317 continue;
2318 }
2319
2320 case VideoCodec::CODEC_RTX: {
2321 int associated_payload_type;
2322 if (!in_codec.GetParam(kCodecParamAssociatedPayloadType,
pkasting@chromium.orge9facf82015-02-17 20:36:28 +00002323 &associated_payload_type) ||
2324 !IsValidRtpPayloadType(associated_payload_type)) {
2325 LOG(LS_ERROR)
2326 << "RTX codec with invalid or no associated payload type: "
2327 << in_codec.ToString();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002328 return std::vector<VideoCodecSettings>();
2329 }
2330 rtx_mapping[associated_payload_type] = in_codec.id;
2331 continue;
2332 }
2333
2334 case VideoCodec::CODEC_VIDEO:
2335 break;
2336 }
2337
2338 video_codecs.push_back(VideoCodecSettings());
2339 video_codecs.back().codec = in_codec;
2340 }
2341
2342 // One of these codecs should have been a video codec. Only having FEC
2343 // parameters into this code is a logic error.
2344 assert(!video_codecs.empty());
2345
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002346 for (std::map<int, int>::const_iterator it = rtx_mapping.begin();
2347 it != rtx_mapping.end();
2348 ++it) {
2349 if (!payload_used[it->first]) {
2350 LOG(LS_ERROR) << "RTX mapped to payload not in codec list.";
2351 return std::vector<VideoCodecSettings>();
2352 }
Shao Changbine62202f2015-04-21 20:24:50 +08002353 if (payload_codec_type[it->first] != VideoCodec::CODEC_VIDEO &&
2354 payload_codec_type[it->first] != VideoCodec::CODEC_RED) {
2355 LOG(LS_ERROR) << "RTX not mapped to regular video codec or RED codec.";
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002356 return std::vector<VideoCodecSettings>();
2357 }
Shao Changbine62202f2015-04-21 20:24:50 +08002358
2359 if (it->first == fec_settings.red_payload_type) {
2360 fec_settings.red_rtx_payload_type = it->second;
2361 }
pbos@webrtc.orge322a172014-06-13 11:47:28 +00002362 }
2363
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002364 for (size_t i = 0; i < video_codecs.size(); ++i) {
2365 video_codecs[i].fec = fec_settings;
Shao Changbine62202f2015-04-21 20:24:50 +08002366 if (rtx_mapping[video_codecs[i].codec.id] != 0 &&
2367 rtx_mapping[video_codecs[i].codec.id] !=
2368 fec_settings.red_payload_type) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002369 video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
2370 }
2371 }
2372
2373 return video_codecs;
2374}
2375
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00002376} // namespace cricket
2377
2378#endif // HAVE_WEBRTC_VIDEO