blob: 1d7c006c2002869333a5c9eb3affe62be52a2c15 [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.org3c107582014-07-20 15:27:35 +000031#include <set>
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000032#include <string>
33
34#include "libyuv/convert_from.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000035#include "talk/media/base/videocapturer.h"
36#include "talk/media/base/videorenderer.h"
buildbot@webrtc.orgdf9bbbe2014-06-19 19:54:33 +000037#include "talk/media/webrtc/constants.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000038#include "talk/media/webrtc/webrtcvideocapturer.h"
39#include "talk/media/webrtc/webrtcvideoframe.h"
40#include "talk/media/webrtc/webrtcvoiceengine.h"
buildbot@webrtc.orga09a9992014-08-13 17:26:08 +000041#include "webrtc/base/buffer.h"
42#include "webrtc/base/logging.h"
43#include "webrtc/base/stringutils.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000044#include "webrtc/call.h"
pbos@webrtc.orgab990ae2014-09-17 09:02:25 +000045#include "webrtc/video_encoder.h"
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000046
47#define UNIMPLEMENTED \
48 LOG(LS_ERROR) << "Call to unimplemented function " << __FUNCTION__; \
49 ASSERT(false)
50
51namespace cricket {
52
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000053// This constant is really an on/off, lower-level configurable NACK history
54// duration hasn't been implemented.
55static const int kNackHistoryMs = 1000;
56
buildbot@webrtc.org933d88a2014-09-18 20:23:05 +000057static const int kDefaultQpMax = 56;
58
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000059static const int kDefaultRtcpReceiverReportSsrc = 1;
60
61struct VideoCodecPref {
62 int payload_type;
pbos@webrtc.org97fdeb82014-08-22 10:36:23 +000063 int width;
64 int height;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000065 const char* name;
66 int rtx_payload_type;
pbos@webrtc.org97fdeb82014-08-22 10:36:23 +000067} kDefaultVideoCodecPref = {100, 640, 400, kVp8CodecName, 96};
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000068
pbos@webrtc.org97fdeb82014-08-22 10:36:23 +000069VideoCodecPref kRedPref = {116, -1, -1, kRedCodecName, -1};
70VideoCodecPref kUlpfecPref = {117, -1, -1, kUlpfecCodecName, -1};
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000071
72static bool FindFirstMatchingCodec(const std::vector<VideoCodec>& codecs,
73 const VideoCodec& requested_codec,
74 VideoCodec* matching_codec) {
75 for (size_t i = 0; i < codecs.size(); ++i) {
76 if (requested_codec.Matches(codecs[i])) {
77 *matching_codec = codecs[i];
78 return true;
79 }
80 }
81 return false;
82}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +000083
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +000084static void AddDefaultFeedbackParams(VideoCodec* codec) {
85 const FeedbackParam kFir(kRtcpFbParamCcm, kRtcpFbCcmParamFir);
86 codec->AddFeedbackParam(kFir);
87 const FeedbackParam kNack(kRtcpFbParamNack, kParamValueEmpty);
88 codec->AddFeedbackParam(kNack);
89 const FeedbackParam kPli(kRtcpFbParamNack, kRtcpFbNackParamPli);
90 codec->AddFeedbackParam(kPli);
91 const FeedbackParam kRemb(kRtcpFbParamRemb, kParamValueEmpty);
92 codec->AddFeedbackParam(kRemb);
93}
94
95static bool IsNackEnabled(const VideoCodec& codec) {
96 return codec.HasFeedbackParam(
97 FeedbackParam(kRtcpFbParamNack, kParamValueEmpty));
98}
99
pbos@webrtc.org257e1302014-07-25 19:01:32 +0000100static bool IsRembEnabled(const VideoCodec& codec) {
101 return codec.HasFeedbackParam(
102 FeedbackParam(kRtcpFbParamRemb, kParamValueEmpty));
103}
104
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000105static VideoCodec DefaultVideoCodec() {
106 VideoCodec default_codec(kDefaultVideoCodecPref.payload_type,
107 kDefaultVideoCodecPref.name,
pbos@webrtc.org97fdeb82014-08-22 10:36:23 +0000108 kDefaultVideoCodecPref.width,
109 kDefaultVideoCodecPref.height,
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000110 kDefaultFramerate,
111 0);
pbos@webrtc.orgf99c2f22014-06-13 12:27:38 +0000112 AddDefaultFeedbackParams(&default_codec);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000113 return default_codec;
114}
115
116static VideoCodec DefaultRedCodec() {
117 return VideoCodec(kRedPref.payload_type, kRedPref.name, 0, 0, 0, 0);
118}
119
120static VideoCodec DefaultUlpfecCodec() {
121 return VideoCodec(kUlpfecPref.payload_type, kUlpfecPref.name, 0, 0, 0, 0);
122}
123
124static std::vector<VideoCodec> DefaultVideoCodecs() {
125 std::vector<VideoCodec> codecs;
126 codecs.push_back(DefaultVideoCodec());
127 codecs.push_back(DefaultRedCodec());
128 codecs.push_back(DefaultUlpfecCodec());
129 if (kDefaultVideoCodecPref.rtx_payload_type != -1) {
130 codecs.push_back(
131 VideoCodec::CreateRtxCodec(kDefaultVideoCodecPref.rtx_payload_type,
132 kDefaultVideoCodecPref.payload_type));
133 }
134 return codecs;
135}
136
pbos@webrtc.org3c107582014-07-20 15:27:35 +0000137static bool ValidateRtpHeaderExtensionIds(
138 const std::vector<RtpHeaderExtension>& extensions) {
139 std::set<int> extensions_used;
140 for (size_t i = 0; i < extensions.size(); ++i) {
141 if (extensions[i].id < 0 || extensions[i].id >= 15 ||
142 !extensions_used.insert(extensions[i].id).second) {
143 LOG(LS_ERROR) << "RTP extensions are with incorrect or duplicate ids.";
144 return false;
145 }
146 }
147 return true;
148}
149
150static std::vector<webrtc::RtpExtension> FilterRtpExtensions(
151 const std::vector<RtpHeaderExtension>& extensions) {
152 std::vector<webrtc::RtpExtension> webrtc_extensions;
153 for (size_t i = 0; i < extensions.size(); ++i) {
154 // Unsupported extensions will be ignored.
155 if (webrtc::RtpExtension::IsSupported(extensions[i].uri)) {
156 webrtc_extensions.push_back(webrtc::RtpExtension(
157 extensions[i].uri, extensions[i].id));
158 } else {
159 LOG(LS_WARNING) << "Unsupported RTP extension: " << extensions[i].uri;
160 }
161 }
162 return webrtc_extensions;
163}
164
pbos@webrtc.org0d523ee2014-06-05 09:10:55 +0000165WebRtcVideoEncoderFactory2::~WebRtcVideoEncoderFactory2() {
166}
167
buildbot@webrtc.orgd41eaeb2014-06-12 07:13:26 +0000168std::vector<webrtc::VideoStream> WebRtcVideoEncoderFactory2::CreateVideoStreams(
169 const VideoCodec& codec,
170 const VideoOptions& options,
171 size_t num_streams) {
172 assert(SupportsCodec(codec));
173 if (num_streams != 1) {
174 LOG(LS_ERROR) << "Unsupported number of streams: " << num_streams;
175 return std::vector<webrtc::VideoStream>();
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +0000176 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000177
buildbot@webrtc.orgd41eaeb2014-06-12 07:13:26 +0000178 webrtc::VideoStream stream;
179 stream.width = codec.width;
180 stream.height = codec.height;
181 stream.max_framerate =
182 codec.framerate != 0 ? codec.framerate : kDefaultFramerate;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000183
buildbot@webrtc.orgd41eaeb2014-06-12 07:13:26 +0000184 int min_bitrate = kMinVideoBitrate;
185 codec.GetParam(kCodecParamMinBitrate, &min_bitrate);
186 int max_bitrate = kMaxVideoBitrate;
187 codec.GetParam(kCodecParamMaxBitrate, &max_bitrate);
188 stream.min_bitrate_bps = min_bitrate * 1000;
189 stream.target_bitrate_bps = stream.max_bitrate_bps = max_bitrate * 1000;
190
buildbot@webrtc.org933d88a2014-09-18 20:23:05 +0000191 int max_qp = kDefaultQpMax;
buildbot@webrtc.orgd41eaeb2014-06-12 07:13:26 +0000192 codec.GetParam(kCodecParamMaxQuantization, &max_qp);
193 stream.max_qp = max_qp;
194 std::vector<webrtc::VideoStream> streams;
195 streams.push_back(stream);
196 return streams;
197}
198
199webrtc::VideoEncoder* WebRtcVideoEncoderFactory2::CreateVideoEncoder(
200 const VideoCodec& codec,
201 const VideoOptions& options) {
202 assert(SupportsCodec(codec));
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000203 if (_stricmp(codec.name.c_str(), kVp8CodecName) == 0) {
pbos@webrtc.orgab990ae2014-09-17 09:02:25 +0000204 return webrtc::VideoEncoder::Create(webrtc::VideoEncoder::kVp8);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000205 }
206 // This shouldn't happen, we should be able to create encoders for all codecs
207 // we support.
208 assert(false);
209 return NULL;
210}
211
212void* WebRtcVideoEncoderFactory2::CreateVideoEncoderSettings(
213 const VideoCodec& codec,
214 const VideoOptions& options) {
215 assert(SupportsCodec(codec));
216 if (_stricmp(codec.name.c_str(), kVp8CodecName) == 0) {
pbos@webrtc.org6cd6ba82014-09-18 12:42:28 +0000217 webrtc::VideoCodecVP8* settings = new webrtc::VideoCodecVP8(
218 webrtc::VideoEncoder::GetDefaultVp8Settings());
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000219 options.video_noise_reduction.Get(&settings->denoisingOn);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000220 return settings;
221 }
222 return NULL;
223}
224
225void WebRtcVideoEncoderFactory2::DestroyVideoEncoderSettings(
226 const VideoCodec& codec,
227 void* encoder_settings) {
228 assert(SupportsCodec(codec));
229 if (encoder_settings == NULL) {
230 return;
231 }
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000232 if (_stricmp(codec.name.c_str(), kVp8CodecName) == 0) {
233 delete reinterpret_cast<webrtc::VideoCodecVP8*>(encoder_settings);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000234 }
buildbot@webrtc.orgd41eaeb2014-06-12 07:13:26 +0000235}
236
237bool WebRtcVideoEncoderFactory2::SupportsCodec(const VideoCodec& codec) {
buildbot@webrtc.orgdf9bbbe2014-06-19 19:54:33 +0000238 return _stricmp(codec.name.c_str(), kVp8CodecName) == 0;
buildbot@webrtc.orgd41eaeb2014-06-12 07:13:26 +0000239}
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000240
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000241DefaultUnsignalledSsrcHandler::DefaultUnsignalledSsrcHandler()
242 : default_recv_ssrc_(0), default_renderer_(NULL) {}
243
244UnsignalledSsrcHandler::Action DefaultUnsignalledSsrcHandler::OnUnsignalledSsrc(
245 VideoMediaChannel* channel,
246 uint32_t ssrc) {
247 if (default_recv_ssrc_ != 0) { // Already one default stream.
248 LOG(LS_WARNING) << "Unknown SSRC, but default receive stream already set.";
249 return kDropPacket;
250 }
251
252 StreamParams sp;
253 sp.ssrcs.push_back(ssrc);
254 LOG(LS_INFO) << "Creating default receive stream for SSRC=" << ssrc << ".";
255 if (!channel->AddRecvStream(sp)) {
256 LOG(LS_WARNING) << "Could not create default receive stream.";
257 }
258
259 channel->SetRenderer(ssrc, default_renderer_);
260 default_recv_ssrc_ = ssrc;
261 return kDeliverPacket;
262}
263
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000264WebRtcCallFactory::~WebRtcCallFactory() {
265}
266webrtc::Call* WebRtcCallFactory::CreateCall(
267 const webrtc::Call::Config& config) {
268 return webrtc::Call::Create(config);
269}
270
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +0000271VideoRenderer* DefaultUnsignalledSsrcHandler::GetDefaultRenderer() const {
272 return default_renderer_;
273}
274
275void DefaultUnsignalledSsrcHandler::SetDefaultRenderer(
276 VideoMediaChannel* channel,
277 VideoRenderer* renderer) {
278 default_renderer_ = renderer;
279 if (default_recv_ssrc_ != 0) {
280 channel->SetRenderer(default_recv_ssrc_, default_renderer_);
281 }
282}
283
pbos@webrtc.org97fdeb82014-08-22 10:36:23 +0000284WebRtcVideoEngine2::WebRtcVideoEngine2()
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +0000285 : worker_thread_(NULL),
286 voice_engine_(NULL),
287 video_codecs_(DefaultVideoCodecs()),
buildbot@webrtc.org992febb2014-09-05 16:39:08 +0000288 default_codec_format_(kDefaultVideoCodecPref.width,
289 kDefaultVideoCodecPref.height,
290 FPS_TO_INTERVAL(kDefaultFramerate),
291 FOURCC_ANY),
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +0000292 initialized_(false),
293 cpu_monitor_(new rtc::CpuMonitor(NULL)),
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000294 call_factory_(&default_call_factory_),
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000295 external_decoder_factory_(NULL),
296 external_encoder_factory_(NULL) {
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +0000297 LOG(LS_INFO) << "WebRtcVideoEngine2::WebRtcVideoEngine2()";
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000298 rtp_header_extensions_.push_back(
299 RtpHeaderExtension(kRtpTimestampOffsetHeaderExtension,
300 kRtpTimestampOffsetHeaderExtensionDefaultId));
301 rtp_header_extensions_.push_back(
302 RtpHeaderExtension(kRtpAbsoluteSenderTimeHeaderExtension,
303 kRtpAbsoluteSenderTimeHeaderExtensionDefaultId));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000304}
305
306WebRtcVideoEngine2::~WebRtcVideoEngine2() {
307 LOG(LS_INFO) << "WebRtcVideoEngine2::~WebRtcVideoEngine2";
308
309 if (initialized_) {
310 Terminate();
311 }
312}
313
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000314void WebRtcVideoEngine2::SetCallFactory(WebRtcCallFactory* call_factory) {
315 call_factory_ = call_factory;
316}
317
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000318bool WebRtcVideoEngine2::Init(rtc::Thread* worker_thread) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000319 LOG(LS_INFO) << "WebRtcVideoEngine2::Init";
320 worker_thread_ = worker_thread;
321 ASSERT(worker_thread_ != NULL);
322
323 cpu_monitor_->set_thread(worker_thread_);
324 if (!cpu_monitor_->Start(kCpuMonitorPeriodMs)) {
325 LOG(LS_ERROR) << "Failed to start CPU monitor.";
326 cpu_monitor_.reset();
327 }
328
329 initialized_ = true;
330 return true;
331}
332
333void WebRtcVideoEngine2::Terminate() {
334 LOG(LS_INFO) << "WebRtcVideoEngine2::Terminate";
335
336 cpu_monitor_->Stop();
337
338 initialized_ = false;
339}
340
341int WebRtcVideoEngine2::GetCapabilities() { return VIDEO_RECV | VIDEO_SEND; }
342
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000343bool WebRtcVideoEngine2::SetDefaultEncoderConfig(
344 const VideoEncoderConfig& config) {
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000345 const VideoCodec& codec = config.max_codec;
346 // TODO(pbos): Make use of external encoder factory.
347 if (!GetVideoEncoderFactory()->SupportsCodec(codec)) {
348 LOG(LS_ERROR) << "SetDefaultEncoderConfig, codec not supported:"
349 << codec.ToString();
350 return false;
351 }
352
buildbot@webrtc.org992febb2014-09-05 16:39:08 +0000353 default_codec_format_ =
354 VideoFormat(codec.width,
355 codec.height,
356 VideoFormat::FpsToInterval(codec.framerate),
357 FOURCC_ANY);
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000358 video_codecs_.clear();
359 video_codecs_.push_back(codec);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000360 return true;
361}
362
363VideoEncoderConfig WebRtcVideoEngine2::GetDefaultEncoderConfig() const {
364 return VideoEncoderConfig(DefaultVideoCodec());
365}
366
367WebRtcVideoChannel2* WebRtcVideoEngine2::CreateChannel(
368 VoiceMediaChannel* voice_channel) {
369 LOG(LS_INFO) << "CreateChannel: "
370 << (voice_channel != NULL ? "With" : "Without")
371 << " voice channel.";
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000372 WebRtcVideoChannel2* channel = new WebRtcVideoChannel2(
373 call_factory_, voice_channel, GetVideoEncoderFactory());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000374 if (!channel->Init()) {
375 delete channel;
376 return NULL;
377 }
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000378 channel->SetRecvCodecs(video_codecs_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000379 return channel;
380}
381
382const std::vector<VideoCodec>& WebRtcVideoEngine2::codecs() const {
383 return video_codecs_;
384}
385
386const std::vector<RtpHeaderExtension>&
387WebRtcVideoEngine2::rtp_header_extensions() const {
388 return rtp_header_extensions_;
389}
390
391void WebRtcVideoEngine2::SetLogging(int min_sev, const char* filter) {
392 // TODO(pbos): Set up logging.
393 LOG(LS_VERBOSE) << "SetLogging: " << min_sev << '"' << filter << '"';
394 // if min_sev == -1, we keep the current log level.
395 if (min_sev < 0) {
396 assert(min_sev == -1);
397 return;
398 }
399}
400
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000401void WebRtcVideoEngine2::SetExternalDecoderFactory(
402 WebRtcVideoDecoderFactory* decoder_factory) {
403 external_decoder_factory_ = decoder_factory;
404}
405
406void WebRtcVideoEngine2::SetExternalEncoderFactory(
407 WebRtcVideoEncoderFactory* encoder_factory) {
408 if (external_encoder_factory_ == encoder_factory) {
409 return;
410 }
411 if (external_encoder_factory_) {
412 external_encoder_factory_->RemoveObserver(this);
413 }
414 external_encoder_factory_ = encoder_factory;
415 if (external_encoder_factory_) {
416 external_encoder_factory_->AddObserver(this);
417 }
418
419 // Invoke OnCodecAvailable() here in case the list of codecs is already
420 // available when the encoder factory is installed. If not the encoder
421 // factory will invoke the callback later when the codecs become available.
422 OnCodecsAvailable();
423}
424
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000425bool WebRtcVideoEngine2::EnableTimedRender() {
426 // TODO(pbos): Figure out whether this can be removed.
427 return true;
428}
429
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000430// Checks to see whether we comprehend and could receive a particular codec
431bool WebRtcVideoEngine2::FindCodec(const VideoCodec& in) {
432 // TODO(pbos): Probe encoder factory to figure out that the codec is supported
433 // if supported by the encoder factory. Add a corresponding test that fails
434 // with this code (that doesn't ask the factory).
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000435 for (size_t j = 0; j < video_codecs_.size(); ++j) {
436 VideoCodec codec(video_codecs_[j].id, video_codecs_[j].name, 0, 0, 0, 0);
437 if (codec.Matches(in)) {
438 return true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000439 }
440 }
441 return false;
442}
443
444// Tells whether the |requested| codec can be transmitted or not. If it can be
445// transmitted |out| is set with the best settings supported. Aspect ratio will
446// be set as close to |current|'s as possible. If not set |requested|'s
447// dimensions will be used for aspect ratio matching.
448bool WebRtcVideoEngine2::CanSendCodec(const VideoCodec& requested,
449 const VideoCodec& current,
450 VideoCodec* out) {
451 assert(out != NULL);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000452
453 if (requested.width != requested.height &&
454 (requested.height == 0 || requested.width == 0)) {
455 // 0xn and nx0 are invalid resolutions.
456 return false;
457 }
458
459 VideoCodec matching_codec;
460 if (!FindFirstMatchingCodec(video_codecs_, requested, &matching_codec)) {
461 // Codec not supported.
462 return false;
463 }
464
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000465 out->id = requested.id;
466 out->name = requested.name;
467 out->preference = requested.preference;
468 out->params = requested.params;
469 out->framerate =
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000470 rtc::_min(requested.framerate, matching_codec.framerate);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000471 out->params = requested.params;
472 out->feedback_params = requested.feedback_params;
pbos@webrtc.org8fdeee62014-07-20 14:40:23 +0000473 out->width = requested.width;
474 out->height = requested.height;
475 if (requested.width == 0 && requested.height == 0) {
476 return true;
477 }
478
479 while (out->width > matching_codec.width) {
480 out->width /= 2;
481 out->height /= 2;
482 }
483
484 return out->width > 0 && out->height > 0;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000485}
486
487bool WebRtcVideoEngine2::SetVoiceEngine(WebRtcVoiceEngine* voice_engine) {
488 if (initialized_) {
489 LOG(LS_WARNING) << "SetVoiceEngine can not be called after Init";
490 return false;
491 }
492 voice_engine_ = voice_engine;
493 return true;
494}
495
496// Ignore spammy trace messages, mostly from the stats API when we haven't
497// gotten RTCP info yet from the remote side.
498bool WebRtcVideoEngine2::ShouldIgnoreTrace(const std::string& trace) {
499 static const char* const kTracesToIgnore[] = {NULL};
500 for (const char* const* p = kTracesToIgnore; *p; ++p) {
501 if (trace.find(*p) == 0) {
502 return true;
503 }
504 }
505 return false;
506}
507
buildbot@webrtc.orgd41eaeb2014-06-12 07:13:26 +0000508WebRtcVideoEncoderFactory2* WebRtcVideoEngine2::GetVideoEncoderFactory() {
509 return &default_video_encoder_factory_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000510}
511
pbos@webrtc.org0a2087a2014-09-23 09:40:22 +0000512void WebRtcVideoEngine2::OnCodecsAvailable() {
513 // TODO(pbos): Implement.
514}
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +0000515// Thin map between VideoFrame and an existing webrtc::I420VideoFrame
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000516// to avoid having to copy the rendered VideoFrame prematurely.
517// This implementation is only safe to use in a const context and should never
518// be written to.
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +0000519class WebRtcVideoRenderFrame : public VideoFrame {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000520 public:
521 explicit WebRtcVideoRenderFrame(const webrtc::I420VideoFrame* frame)
522 : frame_(frame) {}
523
524 virtual bool InitToBlack(int w,
525 int h,
526 size_t pixel_width,
527 size_t pixel_height,
528 int64 elapsed_time,
529 int64 time_stamp) OVERRIDE {
530 UNIMPLEMENTED;
531 return false;
532 }
533
534 virtual bool Reset(uint32 fourcc,
535 int w,
536 int h,
537 int dw,
538 int dh,
539 uint8* sample,
540 size_t sample_size,
541 size_t pixel_width,
542 size_t pixel_height,
543 int64 elapsed_time,
544 int64 time_stamp,
545 int rotation) OVERRIDE {
546 UNIMPLEMENTED;
547 return false;
548 }
549
550 virtual size_t GetWidth() const OVERRIDE {
551 return static_cast<size_t>(frame_->width());
552 }
553 virtual size_t GetHeight() const OVERRIDE {
554 return static_cast<size_t>(frame_->height());
555 }
556
557 virtual const uint8* GetYPlane() const OVERRIDE {
558 return frame_->buffer(webrtc::kYPlane);
559 }
560 virtual const uint8* GetUPlane() const OVERRIDE {
561 return frame_->buffer(webrtc::kUPlane);
562 }
563 virtual const uint8* GetVPlane() const OVERRIDE {
564 return frame_->buffer(webrtc::kVPlane);
565 }
566
567 virtual uint8* GetYPlane() OVERRIDE {
568 UNIMPLEMENTED;
569 return NULL;
570 }
571 virtual uint8* GetUPlane() OVERRIDE {
572 UNIMPLEMENTED;
573 return NULL;
574 }
575 virtual uint8* GetVPlane() OVERRIDE {
576 UNIMPLEMENTED;
577 return NULL;
578 }
579
580 virtual int32 GetYPitch() const OVERRIDE {
581 return frame_->stride(webrtc::kYPlane);
582 }
583 virtual int32 GetUPitch() const OVERRIDE {
584 return frame_->stride(webrtc::kUPlane);
585 }
586 virtual int32 GetVPitch() const OVERRIDE {
587 return frame_->stride(webrtc::kVPlane);
588 }
589
590 virtual void* GetNativeHandle() const OVERRIDE { return NULL; }
591
592 virtual size_t GetPixelWidth() const OVERRIDE { return 1; }
593 virtual size_t GetPixelHeight() const OVERRIDE { return 1; }
594
595 virtual int64 GetElapsedTime() const OVERRIDE {
596 // Convert millisecond render time to ns timestamp.
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000597 return frame_->render_time_ms() * rtc::kNumNanosecsPerMillisec;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000598 }
599 virtual int64 GetTimeStamp() const OVERRIDE {
600 // Convert 90K rtp timestamp to ns timestamp.
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000601 return (frame_->timestamp() / 90) * rtc::kNumNanosecsPerMillisec;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000602 }
603 virtual void SetElapsedTime(int64 elapsed_time) OVERRIDE { UNIMPLEMENTED; }
604 virtual void SetTimeStamp(int64 time_stamp) OVERRIDE { UNIMPLEMENTED; }
605
606 virtual int GetRotation() const OVERRIDE {
607 UNIMPLEMENTED;
608 return ROTATION_0;
609 }
610
611 virtual VideoFrame* Copy() const OVERRIDE {
612 UNIMPLEMENTED;
613 return NULL;
614 }
615
616 virtual bool MakeExclusive() OVERRIDE {
617 UNIMPLEMENTED;
618 return false;
619 }
620
621 virtual size_t CopyToBuffer(uint8* buffer, size_t size) const {
622 UNIMPLEMENTED;
623 return 0;
624 }
625
626 // TODO(fbarchard): Refactor into base class and share with LMI
627 virtual size_t ConvertToRgbBuffer(uint32 to_fourcc,
628 uint8* buffer,
629 size_t size,
630 int stride_rgb) const OVERRIDE {
631 size_t width = GetWidth();
632 size_t height = GetHeight();
633 size_t needed = (stride_rgb >= 0 ? stride_rgb : -stride_rgb) * height;
634 if (size < needed) {
635 LOG(LS_WARNING) << "RGB buffer is not large enough";
636 return needed;
637 }
638
639 if (libyuv::ConvertFromI420(GetYPlane(),
640 GetYPitch(),
641 GetUPlane(),
642 GetUPitch(),
643 GetVPlane(),
644 GetVPitch(),
645 buffer,
646 stride_rgb,
647 static_cast<int>(width),
648 static_cast<int>(height),
649 to_fourcc)) {
650 LOG(LS_ERROR) << "RGB type not supported: " << to_fourcc;
651 return 0; // 0 indicates error
652 }
653 return needed;
654 }
655
656 protected:
657 virtual VideoFrame* CreateEmptyFrame(int w,
658 int h,
659 size_t pixel_width,
660 size_t pixel_height,
661 int64 elapsed_time,
662 int64 time_stamp) const OVERRIDE {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000663 WebRtcVideoFrame* frame = new WebRtcVideoFrame();
664 frame->InitToBlack(
665 w, h, pixel_width, pixel_height, elapsed_time, time_stamp);
666 return frame;
667 }
668
669 private:
670 const webrtc::I420VideoFrame* const frame_;
671};
672
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000673WebRtcVideoChannel2::WebRtcVideoChannel2(
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000674 WebRtcCallFactory* call_factory,
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000675 VoiceMediaChannel* voice_channel,
676 WebRtcVideoEncoderFactory2* encoder_factory)
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +0000677 : unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
678 encoder_factory_(encoder_factory) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000679 // TODO(pbos): Connect the video and audio with |voice_channel|.
680 webrtc::Call::Config config(this);
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000681 config.overuse_callback = this;
682 call_.reset(call_factory->CreateCall(config));
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000683
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000684 rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc;
685 sending_ = false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000686 default_send_ssrc_ = 0;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +0000687
688 SetDefaultOptions();
689}
690
691void WebRtcVideoChannel2::SetDefaultOptions() {
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000692 options_.cpu_overuse_detection.Set(false);
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +0000693 options_.suspend_below_min_bitrate.Set(false);
pbos@webrtc.org42684be2014-10-03 11:25:45 +0000694 options_.use_payload_padding.Set(false);
695 options_.video_noise_reduction.Set(true);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000696}
697
698WebRtcVideoChannel2::~WebRtcVideoChannel2() {
699 for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
700 send_streams_.begin();
701 it != send_streams_.end();
702 ++it) {
703 delete it->second;
704 }
705
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000706 for (std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000707 receive_streams_.begin();
708 it != receive_streams_.end();
709 ++it) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000710 delete it->second;
711 }
712}
713
714bool WebRtcVideoChannel2::Init() { return true; }
715
716namespace {
717
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000718static std::string CodecVectorToString(const std::vector<VideoCodec>& codecs) {
719 std::stringstream out;
720 out << '{';
721 for (size_t i = 0; i < codecs.size(); ++i) {
722 out << codecs[i].ToString();
723 if (i != codecs.size() - 1) {
724 out << ", ";
725 }
726 }
727 out << '}';
728 return out.str();
729}
730
pbos@webrtc.orge322a172014-06-13 11:47:28 +0000731static bool ValidateCodecFormats(const std::vector<VideoCodec>& codecs) {
732 bool has_video = false;
733 for (size_t i = 0; i < codecs.size(); ++i) {
734 if (!codecs[i].ValidateCodecFormat()) {
735 return false;
736 }
737 if (codecs[i].GetCodecType() == VideoCodec::CODEC_VIDEO) {
738 has_video = true;
739 }
740 }
741 if (!has_video) {
742 LOG(LS_ERROR) << "Setting codecs without a video codec is invalid: "
743 << CodecVectorToString(codecs);
744 return false;
745 }
746 return true;
747}
748
pbos@webrtc.org587ef602014-06-16 17:32:02 +0000749static std::string RtpExtensionsToString(
750 const std::vector<RtpHeaderExtension>& extensions) {
751 std::stringstream out;
752 out << '{';
753 for (size_t i = 0; i < extensions.size(); ++i) {
754 out << "{" << extensions[i].uri << ": " << extensions[i].id << "}";
755 if (i != extensions.size() - 1) {
756 out << ", ";
757 }
758 }
759 out << '}';
760 return out.str();
761}
762
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000763} // namespace
764
765bool WebRtcVideoChannel2::SetRecvCodecs(const std::vector<VideoCodec>& codecs) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000766 LOG(LS_INFO) << "SetRecvCodecs: " << CodecVectorToString(codecs);
767 if (!ValidateCodecFormats(codecs)) {
768 return false;
769 }
770
771 const std::vector<VideoCodecSettings> mapped_codecs = MapCodecs(codecs);
772 if (mapped_codecs.empty()) {
773 LOG(LS_ERROR) << "SetRecvCodecs called without video codec payloads.";
774 return false;
775 }
776
777 // TODO(pbos): Add a decoder factory which controls supported codecs.
778 // Blocked on webrtc:2854.
779 for (size_t i = 0; i < mapped_codecs.size(); ++i) {
buildbot@webrtc.orgdf9bbbe2014-06-19 19:54:33 +0000780 if (_stricmp(mapped_codecs[i].codec.name.c_str(), kVp8CodecName) != 0) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000781 LOG(LS_ERROR) << "SetRecvCodecs called with unsupported codec: '"
782 << mapped_codecs[i].codec.name << "'";
783 return false;
784 }
785 }
786
787 recv_codecs_ = mapped_codecs;
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000788
789 for (std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
790 receive_streams_.begin();
791 it != receive_streams_.end();
792 ++it) {
793 it->second->SetRecvCodecs(recv_codecs_);
794 }
795
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000796 return true;
797}
798
799bool WebRtcVideoChannel2::SetSendCodecs(const std::vector<VideoCodec>& codecs) {
800 LOG(LS_INFO) << "SetSendCodecs: " << CodecVectorToString(codecs);
801 if (!ValidateCodecFormats(codecs)) {
802 return false;
803 }
804
805 const std::vector<VideoCodecSettings> supported_codecs =
806 FilterSupportedCodecs(MapCodecs(codecs));
807
808 if (supported_codecs.empty()) {
809 LOG(LS_ERROR) << "No video codecs supported by encoder factory.";
810 return false;
811 }
812
813 send_codec_.Set(supported_codecs.front());
814 LOG(LS_INFO) << "Using codec: " << supported_codecs.front().codec.ToString();
815
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000816 for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
817 send_streams_.begin();
818 it != send_streams_.end();
819 ++it) {
820 assert(it->second != NULL);
821 it->second->SetCodec(supported_codecs.front());
822 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000823
824 return true;
825}
826
827bool WebRtcVideoChannel2::GetSendCodec(VideoCodec* codec) {
828 VideoCodecSettings codec_settings;
829 if (!send_codec_.Get(&codec_settings)) {
830 LOG(LS_VERBOSE) << "GetSendCodec: No send codec set.";
831 return false;
832 }
833 *codec = codec_settings.codec;
834 return true;
835}
836
837bool WebRtcVideoChannel2::SetSendStreamFormat(uint32 ssrc,
838 const VideoFormat& format) {
839 LOG(LS_VERBOSE) << "SetSendStreamFormat:" << ssrc << " -> "
840 << format.ToString();
841 if (send_streams_.find(ssrc) == send_streams_.end()) {
842 return false;
843 }
844 return send_streams_[ssrc]->SetVideoFormat(format);
845}
846
847bool WebRtcVideoChannel2::SetRender(bool render) {
848 // TODO(pbos): Implement. Or refactor away as it shouldn't be needed.
849 LOG(LS_VERBOSE) << "SetRender: " << (render ? "true" : "false");
850 return true;
851}
852
853bool WebRtcVideoChannel2::SetSend(bool send) {
854 LOG(LS_VERBOSE) << "SetSend: " << (send ? "true" : "false");
855 if (send && !send_codec_.IsSet()) {
856 LOG(LS_ERROR) << "SetSend(true) called before setting codec.";
857 return false;
858 }
859 if (send) {
860 StartAllSendStreams();
861 } else {
862 StopAllSendStreams();
863 }
864 sending_ = send;
865 return true;
866}
867
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000868bool WebRtcVideoChannel2::AddSendStream(const StreamParams& sp) {
869 LOG(LS_INFO) << "AddSendStream: " << sp.ToString();
870 if (sp.ssrcs.empty()) {
871 LOG(LS_ERROR) << "No SSRCs in stream parameters.";
872 return false;
873 }
874
875 uint32 ssrc = sp.first_ssrc();
876 assert(ssrc != 0);
877 // TODO(pbos): Make sure none of sp.ssrcs are used, not just the identifying
878 // ssrc.
879 if (send_streams_.find(ssrc) != send_streams_.end()) {
880 LOG(LS_ERROR) << "Send stream with ssrc '" << ssrc << "' already exists.";
881 return false;
882 }
883
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +0000884 std::vector<uint32> primary_ssrcs;
885 sp.GetPrimarySsrcs(&primary_ssrcs);
886 std::vector<uint32> rtx_ssrcs;
887 sp.GetFidSsrcs(primary_ssrcs, &rtx_ssrcs);
888 if (!rtx_ssrcs.empty() && primary_ssrcs.size() != rtx_ssrcs.size()) {
889 LOG(LS_ERROR)
890 << "RTX SSRCs exist, but don't cover all SSRCs (unsupported): "
891 << sp.ToString();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000892 return false;
893 }
894
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000895 WebRtcVideoSendStream* stream =
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +0000896 new WebRtcVideoSendStream(call_.get(),
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +0000897 encoder_factory_,
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +0000898 options_,
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +0000899 send_codec_,
900 sp,
901 send_rtp_extensions_);
902
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000903 send_streams_[ssrc] = stream;
904
905 if (rtcp_receiver_report_ssrc_ == kDefaultRtcpReceiverReportSsrc) {
906 rtcp_receiver_report_ssrc_ = ssrc;
907 }
908 if (default_send_ssrc_ == 0) {
909 default_send_ssrc_ = ssrc;
910 }
911 if (sending_) {
912 stream->Start();
913 }
914
915 return true;
916}
917
918bool WebRtcVideoChannel2::RemoveSendStream(uint32 ssrc) {
919 LOG(LS_INFO) << "RemoveSendStream: " << ssrc;
920
921 if (ssrc == 0) {
922 if (default_send_ssrc_ == 0) {
923 LOG(LS_ERROR) << "No default send stream active.";
924 return false;
925 }
926
927 LOG(LS_VERBOSE) << "Removing default stream: " << default_send_ssrc_;
928 ssrc = default_send_ssrc_;
929 }
930
931 std::map<uint32, WebRtcVideoSendStream*>::iterator it =
932 send_streams_.find(ssrc);
933 if (it == send_streams_.end()) {
934 return false;
935 }
936
937 delete it->second;
938 send_streams_.erase(it);
939
940 if (ssrc == default_send_ssrc_) {
941 default_send_ssrc_ = 0;
942 }
943
944 return true;
945}
946
947bool WebRtcVideoChannel2::AddRecvStream(const StreamParams& sp) {
948 LOG(LS_INFO) << "AddRecvStream: " << sp.ToString();
949 assert(sp.ssrcs.size() > 0);
950
951 uint32 ssrc = sp.first_ssrc();
952 assert(ssrc != 0); // TODO(pbos): Is this ever valid?
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000953
954 // TODO(pbos): Check if any of the SSRCs overlap.
955 if (receive_streams_.find(ssrc) != receive_streams_.end()) {
956 LOG(LS_ERROR) << "Receive stream for SSRC " << ssrc << "already exists.";
957 return false;
958 }
959
pbos@webrtc.orgbd249bc2014-07-07 04:45:15 +0000960 webrtc::VideoReceiveStream::Config config;
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000961 ConfigureReceiverRtp(&config, sp);
962 receive_streams_[ssrc] =
963 new WebRtcVideoReceiveStream(call_.get(), config, recv_codecs_);
964
965 return true;
966}
967
968void WebRtcVideoChannel2::ConfigureReceiverRtp(
969 webrtc::VideoReceiveStream::Config* config,
970 const StreamParams& sp) const {
971 uint32 ssrc = sp.first_ssrc();
972
973 config->rtp.remote_ssrc = ssrc;
974 config->rtp.local_ssrc = rtcp_receiver_report_ssrc_;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000975
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000976 config->rtp.extensions = recv_rtp_extensions_;
pbos@webrtc.org257e1302014-07-25 19:01:32 +0000977
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000978 // TODO(pbos): This protection is against setting the same local ssrc as
979 // remote which is not permitted by the lower-level API. RTCP requires a
980 // corresponding sender SSRC. Figure out what to do when we don't have
981 // (receive-only) or know a good local SSRC.
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000982 if (config->rtp.remote_ssrc == config->rtp.local_ssrc) {
983 if (config->rtp.local_ssrc != kDefaultRtcpReceiverReportSsrc) {
984 config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000985 } else {
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000986 config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc + 1;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000987 }
988 }
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +0000989
990 for (size_t i = 0; i < recv_codecs_.size(); ++i) {
991 if (recv_codecs_[i].codec.id == kDefaultVideoCodecPref.payload_type) {
992 config->rtp.fec = recv_codecs_[i].fec;
993 uint32 rtx_ssrc;
994 if (recv_codecs_[i].rtx_payload_type != -1 &&
995 sp.GetFidSsrc(ssrc, &rtx_ssrc)) {
996 config->rtp.rtx[kDefaultVideoCodecPref.payload_type].ssrc = rtx_ssrc;
997 config->rtp.rtx[kDefaultVideoCodecPref.payload_type].payload_type =
998 recv_codecs_[i].rtx_payload_type;
999 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001000 break;
1001 }
1002 }
1003
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001004}
1005
1006bool WebRtcVideoChannel2::RemoveRecvStream(uint32 ssrc) {
1007 LOG(LS_INFO) << "RemoveRecvStream: " << ssrc;
1008 if (ssrc == 0) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001009 LOG(LS_ERROR) << "RemoveRecvStream with 0 ssrc is not supported.";
1010 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001011 }
1012
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001013 std::map<uint32, WebRtcVideoReceiveStream*>::iterator stream =
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001014 receive_streams_.find(ssrc);
1015 if (stream == receive_streams_.end()) {
1016 LOG(LS_ERROR) << "Stream not found for ssrc: " << ssrc;
1017 return false;
1018 }
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001019 delete stream->second;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001020 receive_streams_.erase(stream);
1021
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001022 return true;
1023}
1024
1025bool WebRtcVideoChannel2::SetRenderer(uint32 ssrc, VideoRenderer* renderer) {
1026 LOG(LS_INFO) << "SetRenderer: ssrc:" << ssrc << " "
1027 << (renderer ? "(ptr)" : "NULL");
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001028 if (ssrc == 0) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001029 default_unsignalled_ssrc_handler_.SetDefaultRenderer(this, renderer);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001030 return true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001031 }
1032
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001033 std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
1034 receive_streams_.find(ssrc);
1035 if (it == receive_streams_.end()) {
1036 return false;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001037 }
1038
1039 it->second->SetRenderer(renderer);
1040 return true;
1041}
1042
1043bool WebRtcVideoChannel2::GetRenderer(uint32 ssrc, VideoRenderer** renderer) {
1044 if (ssrc == 0) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001045 *renderer = default_unsignalled_ssrc_handler_.GetDefaultRenderer();
1046 return *renderer != NULL;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001047 }
1048
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001049 std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
1050 receive_streams_.find(ssrc);
1051 if (it == receive_streams_.end()) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001052 return false;
1053 }
1054 *renderer = it->second->GetRenderer();
1055 return true;
1056}
1057
1058bool WebRtcVideoChannel2::GetStats(const StatsOptions& options,
1059 VideoMediaInfo* info) {
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001060 info->Clear();
1061 FillSenderStats(info);
1062 FillReceiverStats(info);
1063 FillBandwidthEstimationStats(info);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001064 return true;
1065}
1066
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001067void WebRtcVideoChannel2::FillSenderStats(VideoMediaInfo* video_media_info) {
1068 for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1069 send_streams_.begin();
1070 it != send_streams_.end();
1071 ++it) {
1072 video_media_info->senders.push_back(it->second->GetVideoSenderInfo());
1073 }
1074}
1075
1076void WebRtcVideoChannel2::FillReceiverStats(VideoMediaInfo* video_media_info) {
1077 for (std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
1078 receive_streams_.begin();
1079 it != receive_streams_.end();
1080 ++it) {
1081 video_media_info->receivers.push_back(it->second->GetVideoReceiverInfo());
1082 }
1083}
1084
1085void WebRtcVideoChannel2::FillBandwidthEstimationStats(
1086 VideoMediaInfo* video_media_info) {
1087 // TODO(pbos): Implement.
1088}
1089
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001090bool WebRtcVideoChannel2::SetCapturer(uint32 ssrc, VideoCapturer* capturer) {
1091 LOG(LS_INFO) << "SetCapturer: " << ssrc << " -> "
1092 << (capturer != NULL ? "(capturer)" : "NULL");
1093 assert(ssrc != 0);
1094 if (send_streams_.find(ssrc) == send_streams_.end()) {
1095 LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc;
1096 return false;
1097 }
1098 return send_streams_[ssrc]->SetCapturer(capturer);
1099}
1100
1101bool WebRtcVideoChannel2::SendIntraFrame() {
1102 // TODO(pbos): Implement.
1103 LOG(LS_VERBOSE) << "SendIntraFrame().";
1104 return true;
1105}
1106
1107bool WebRtcVideoChannel2::RequestIntraFrame() {
1108 // TODO(pbos): Implement.
1109 LOG(LS_VERBOSE) << "SendIntraFrame().";
1110 return true;
1111}
1112
1113void WebRtcVideoChannel2::OnPacketReceived(
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001114 rtc::Buffer* packet,
1115 const rtc::PacketTime& packet_time) {
pbos@webrtc.org4e545cc2014-05-14 13:58:13 +00001116 const webrtc::PacketReceiver::DeliveryStatus delivery_result =
1117 call_->Receiver()->DeliverPacket(
1118 reinterpret_cast<const uint8_t*>(packet->data()), packet->length());
1119 switch (delivery_result) {
1120 case webrtc::PacketReceiver::DELIVERY_OK:
1121 return;
1122 case webrtc::PacketReceiver::DELIVERY_PACKET_ERROR:
1123 return;
1124 case webrtc::PacketReceiver::DELIVERY_UNKNOWN_SSRC:
1125 break;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001126 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001127
1128 uint32 ssrc = 0;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001129 if (!GetRtpSsrc(packet->data(), packet->length(), &ssrc)) {
1130 return;
1131 }
1132
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001133 // TODO(pbos): Make sure that the unsignalled SSRC uses the video payload.
1134 // Also figure out whether RTX needs to be handled.
1135 switch (unsignalled_ssrc_handler_->OnUnsignalledSsrc(this, ssrc)) {
1136 case UnsignalledSsrcHandler::kDropPacket:
1137 return;
1138 case UnsignalledSsrcHandler::kDeliverPacket:
1139 break;
1140 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001141
pbos@webrtc.org1e019d12014-05-16 11:38:45 +00001142 if (call_->Receiver()->DeliverPacket(
1143 reinterpret_cast<const uint8_t*>(packet->data()), packet->length()) !=
1144 webrtc::PacketReceiver::DELIVERY_OK) {
pbos@webrtc.orgafb554f42014-08-12 23:17:13 +00001145 LOG(LS_WARNING) << "Failed to deliver RTP packet on re-delivery.";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001146 return;
1147 }
1148}
1149
1150void WebRtcVideoChannel2::OnRtcpReceived(
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001151 rtc::Buffer* packet,
1152 const rtc::PacketTime& packet_time) {
pbos@webrtc.org1e019d12014-05-16 11:38:45 +00001153 if (call_->Receiver()->DeliverPacket(
1154 reinterpret_cast<const uint8_t*>(packet->data()), packet->length()) !=
1155 webrtc::PacketReceiver::DELIVERY_OK) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001156 LOG(LS_WARNING) << "Failed to deliver RTCP packet.";
1157 }
1158}
1159
1160void WebRtcVideoChannel2::OnReadyToSend(bool ready) {
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00001161 LOG(LS_VERBOSE) << "OnReadyToSend: " << (ready ? "Ready." : "Not ready.");
1162 call_->SignalNetworkState(ready ? webrtc::Call::kNetworkUp
1163 : webrtc::Call::kNetworkDown);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001164}
1165
1166bool WebRtcVideoChannel2::MuteStream(uint32 ssrc, bool mute) {
1167 LOG(LS_VERBOSE) << "MuteStream: " << ssrc << " -> "
1168 << (mute ? "mute" : "unmute");
1169 assert(ssrc != 0);
1170 if (send_streams_.find(ssrc) == send_streams_.end()) {
1171 LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc;
1172 return false;
1173 }
pbos@webrtc.orgef8bb8d2014-08-13 21:36:18 +00001174
1175 send_streams_[ssrc]->MuteStream(mute);
1176 return true;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001177}
1178
1179bool WebRtcVideoChannel2::SetRecvRtpHeaderExtensions(
1180 const std::vector<RtpHeaderExtension>& extensions) {
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001181 LOG(LS_INFO) << "SetRecvRtpHeaderExtensions: "
1182 << RtpExtensionsToString(extensions);
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001183 if (!ValidateRtpHeaderExtensionIds(extensions))
1184 return false;
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001185
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001186 recv_rtp_extensions_ = FilterRtpExtensions(extensions);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001187 for (std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
1188 receive_streams_.begin();
1189 it != receive_streams_.end();
1190 ++it) {
1191 it->second->SetRtpExtensions(recv_rtp_extensions_);
1192 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001193 return true;
1194}
1195
1196bool WebRtcVideoChannel2::SetSendRtpHeaderExtensions(
1197 const std::vector<RtpHeaderExtension>& extensions) {
pbos@webrtc.org587ef602014-06-16 17:32:02 +00001198 LOG(LS_INFO) << "SetSendRtpHeaderExtensions: "
1199 << RtpExtensionsToString(extensions);
pbos@webrtc.org3c107582014-07-20 15:27:35 +00001200 if (!ValidateRtpHeaderExtensionIds(extensions))
1201 return false;
1202
1203 send_rtp_extensions_ = FilterRtpExtensions(extensions);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001204 for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1205 send_streams_.begin();
1206 it != send_streams_.end();
1207 ++it) {
1208 it->second->SetRtpExtensions(send_rtp_extensions_);
1209 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001210 return true;
1211}
1212
1213bool WebRtcVideoChannel2::SetStartSendBandwidth(int bps) {
1214 // TODO(pbos): Implement.
1215 LOG(LS_VERBOSE) << "SetStartSendBandwidth: " << bps;
1216 return true;
1217}
1218
1219bool WebRtcVideoChannel2::SetMaxSendBandwidth(int bps) {
1220 // TODO(pbos): Implement.
1221 LOG(LS_VERBOSE) << "SetMaxSendBandwidth: " << bps;
1222 return true;
1223}
1224
1225bool WebRtcVideoChannel2::SetOptions(const VideoOptions& options) {
1226 LOG(LS_VERBOSE) << "SetOptions: " << options.ToString();
1227 options_.SetAll(options);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001228 for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1229 send_streams_.begin();
1230 it != send_streams_.end();
1231 ++it) {
1232 it->second->SetOptions(options_);
1233 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001234 return true;
1235}
1236
1237void WebRtcVideoChannel2::SetInterface(NetworkInterface* iface) {
1238 MediaChannel::SetInterface(iface);
1239 // Set the RTP recv/send buffer to a bigger size
1240 MediaChannel::SetOption(NetworkInterface::ST_RTP,
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001241 rtc::Socket::OPT_RCVBUF,
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001242 kVideoRtpBufferSize);
1243
1244 // TODO(sriniv): Remove or re-enable this.
1245 // As part of b/8030474, send-buffer is size now controlled through
1246 // portallocator flags.
1247 // network_interface_->SetOption(NetworkInterface::ST_RTP,
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001248 // rtc::Socket::OPT_SNDBUF,
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001249 // kVideoRtpBufferSize);
1250}
1251
1252void WebRtcVideoChannel2::UpdateAspectRatio(int ratio_w, int ratio_h) {
1253 // TODO(pbos): Implement.
1254}
1255
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001256void WebRtcVideoChannel2::OnMessage(rtc::Message* msg) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001257 // Ignored.
1258}
1259
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001260void WebRtcVideoChannel2::OnLoadUpdate(Load load) {
1261 for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1262 send_streams_.begin();
1263 it != send_streams_.end();
1264 ++it) {
1265 it->second->OnCpuResolutionRequest(load == kOveruse
1266 ? CoordinatedVideoAdapter::DOWNGRADE
1267 : CoordinatedVideoAdapter::UPGRADE);
1268 }
1269}
1270
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001271bool WebRtcVideoChannel2::SendRtp(const uint8_t* data, size_t len) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001272 rtc::Buffer packet(data, len, kMaxRtpPacketLen);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001273 return MediaChannel::SendPacket(&packet);
1274}
1275
1276bool WebRtcVideoChannel2::SendRtcp(const uint8_t* data, size_t len) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001277 rtc::Buffer packet(data, len, kMaxRtpPacketLen);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001278 return MediaChannel::SendRtcp(&packet);
1279}
1280
1281void WebRtcVideoChannel2::StartAllSendStreams() {
1282 for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1283 send_streams_.begin();
1284 it != send_streams_.end();
1285 ++it) {
1286 it->second->Start();
1287 }
1288}
1289
1290void WebRtcVideoChannel2::StopAllSendStreams() {
1291 for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1292 send_streams_.begin();
1293 it != send_streams_.end();
1294 ++it) {
1295 it->second->Stop();
1296 }
1297}
1298
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001299WebRtcVideoChannel2::WebRtcVideoSendStream::VideoSendStreamParameters::
1300 VideoSendStreamParameters(
1301 const webrtc::VideoSendStream::Config& config,
1302 const VideoOptions& options,
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001303 const Settable<VideoCodecSettings>& codec_settings)
1304 : config(config), options(options), codec_settings(codec_settings) {
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001305}
1306
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001307WebRtcVideoChannel2::WebRtcVideoSendStream::WebRtcVideoSendStream(
1308 webrtc::Call* call,
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001309 WebRtcVideoEncoderFactory2* encoder_factory,
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001310 const VideoOptions& options,
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001311 const Settable<VideoCodecSettings>& codec_settings,
1312 const StreamParams& sp,
1313 const std::vector<webrtc::RtpExtension>& rtp_extensions)
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001314 : call_(call),
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001315 encoder_factory_(encoder_factory),
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001316 stream_(NULL),
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +00001317 parameters_(webrtc::VideoSendStream::Config(), options, codec_settings),
1318 capturer_(NULL),
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001319 sending_(false),
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001320 muted_(false) {
1321 parameters_.config.rtp.max_packet_size = kVideoMtu;
1322
1323 sp.GetPrimarySsrcs(&parameters_.config.rtp.ssrcs);
1324 sp.GetFidSsrcs(parameters_.config.rtp.ssrcs,
1325 &parameters_.config.rtp.rtx.ssrcs);
1326 parameters_.config.rtp.c_name = sp.cname;
1327 parameters_.config.rtp.extensions = rtp_extensions;
1328
1329 VideoCodecSettings params;
1330 if (codec_settings.Get(&params)) {
1331 SetCodec(params);
1332 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001333}
1334
1335WebRtcVideoChannel2::WebRtcVideoSendStream::~WebRtcVideoSendStream() {
1336 DisconnectCapturer();
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001337 if (stream_ != NULL) {
1338 call_->DestroyVideoSendStream(stream_);
1339 }
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001340 delete parameters_.config.encoder_settings.encoder;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001341}
1342
1343static void SetWebRtcFrameToBlack(webrtc::I420VideoFrame* video_frame) {
1344 assert(video_frame != NULL);
1345 memset(video_frame->buffer(webrtc::kYPlane),
1346 16,
1347 video_frame->allocated_size(webrtc::kYPlane));
1348 memset(video_frame->buffer(webrtc::kUPlane),
1349 128,
1350 video_frame->allocated_size(webrtc::kUPlane));
1351 memset(video_frame->buffer(webrtc::kVPlane),
1352 128,
1353 video_frame->allocated_size(webrtc::kVPlane));
1354}
1355
1356static void CreateBlackFrame(webrtc::I420VideoFrame* video_frame,
1357 int width,
1358 int height) {
1359 video_frame->CreateEmptyFrame(
1360 width, height, width, (width + 1) / 2, (width + 1) / 2);
1361 SetWebRtcFrameToBlack(video_frame);
1362}
1363
1364static void ConvertToI420VideoFrame(const VideoFrame& frame,
1365 webrtc::I420VideoFrame* i420_frame) {
1366 i420_frame->CreateFrame(
1367 static_cast<int>(frame.GetYPitch() * frame.GetHeight()),
1368 frame.GetYPlane(),
1369 static_cast<int>(frame.GetUPitch() * ((frame.GetHeight() + 1) / 2)),
1370 frame.GetUPlane(),
1371 static_cast<int>(frame.GetVPitch() * ((frame.GetHeight() + 1) / 2)),
1372 frame.GetVPlane(),
1373 static_cast<int>(frame.GetWidth()),
1374 static_cast<int>(frame.GetHeight()),
1375 static_cast<int>(frame.GetYPitch()),
1376 static_cast<int>(frame.GetUPitch()),
1377 static_cast<int>(frame.GetVPitch()));
1378}
1379
1380void WebRtcVideoChannel2::WebRtcVideoSendStream::InputFrame(
1381 VideoCapturer* capturer,
1382 const VideoFrame* frame) {
1383 LOG(LS_VERBOSE) << "InputFrame: " << frame->GetWidth() << "x"
1384 << frame->GetHeight();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001385 // Lock before copying, can be called concurrently when swapping input source.
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001386 rtc::CritScope frame_cs(&frame_lock_);
pbos@webrtc.orgd60d79a2014-09-24 07:10:57 +00001387 ConvertToI420VideoFrame(*frame, &video_frame_);
1388
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001389 rtc::CritScope cs(&lock_);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001390 if (stream_ == NULL) {
1391 LOG(LS_WARNING) << "Capturer inputting frames before send codecs are "
1392 "configured, dropping.";
1393 return;
1394 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001395 if (format_.width == 0) { // Dropping frames.
1396 assert(format_.height == 0);
1397 LOG(LS_VERBOSE) << "VideoFormat 0x0 set, Dropping frame.";
1398 return;
1399 }
pbos@webrtc.orgd60d79a2014-09-24 07:10:57 +00001400 if (muted_) {
1401 // Create a black frame to transmit instead.
1402 CreateBlackFrame(&video_frame_,
1403 static_cast<int>(frame->GetWidth()),
1404 static_cast<int>(frame->GetHeight()));
1405 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001406 // Reconfigure codec if necessary.
pbos@webrtc.orgc4175b92014-09-03 15:25:49 +00001407 SetDimensions(
1408 video_frame_.width(), video_frame_.height(), capturer->IsScreencast());
1409
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001410 LOG(LS_VERBOSE) << "SwapFrame: " << video_frame_.width() << "x"
1411 << video_frame_.height() << " -> (codec) "
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00001412 << parameters_.encoder_config.streams.back().width << "x"
1413 << parameters_.encoder_config.streams.back().height;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001414 stream_->Input()->SwapFrame(&video_frame_);
1415}
1416
1417bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetCapturer(
1418 VideoCapturer* capturer) {
1419 if (!DisconnectCapturer() && capturer == NULL) {
1420 return false;
1421 }
1422
1423 {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001424 rtc::CritScope cs(&lock_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001425
pbos@webrtc.org9359cb32014-07-23 15:44:48 +00001426 if (capturer == NULL) {
1427 if (stream_ != NULL) {
1428 LOG(LS_VERBOSE) << "Disabling capturer, sending black frame.";
1429 webrtc::I420VideoFrame black_frame;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001430
pbos@webrtc.org9359cb32014-07-23 15:44:48 +00001431 int width = format_.width;
1432 int height = format_.height;
1433 int half_width = (width + 1) / 2;
1434 black_frame.CreateEmptyFrame(
1435 width, height, width, half_width, half_width);
1436 SetWebRtcFrameToBlack(&black_frame);
pbos@webrtc.orgc4175b92014-09-03 15:25:49 +00001437 SetDimensions(width, height, false);
pbos@webrtc.org9359cb32014-07-23 15:44:48 +00001438 stream_->Input()->SwapFrame(&black_frame);
1439 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001440
1441 capturer_ = NULL;
1442 return true;
1443 }
1444
1445 capturer_ = capturer;
1446 }
1447 // Lock cannot be held while connecting the capturer to prevent lock-order
1448 // violations.
1449 capturer->SignalVideoFrame.connect(this, &WebRtcVideoSendStream::InputFrame);
1450 return true;
1451}
1452
1453bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetVideoFormat(
1454 const VideoFormat& format) {
1455 if ((format.width == 0 || format.height == 0) &&
1456 format.width != format.height) {
1457 LOG(LS_ERROR) << "Can't set VideoFormat, width or height is zero (but not "
1458 "both, 0x0 drops frames).";
1459 return false;
1460 }
1461
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001462 rtc::CritScope cs(&lock_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001463 if (format.width == 0 && format.height == 0) {
1464 LOG(LS_INFO)
1465 << "0x0 resolution selected. Captured frames will be dropped for ssrc: "
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001466 << parameters_.config.rtp.ssrcs[0] << ".";
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001467 } else {
1468 // TODO(pbos): Fix me, this only affects the last stream!
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00001469 parameters_.encoder_config.streams.back().max_framerate =
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001470 VideoFormat::IntervalToFps(format.interval);
pbos@webrtc.orgc4175b92014-09-03 15:25:49 +00001471 SetDimensions(format.width, format.height, false);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001472 }
1473
1474 format_ = format;
1475 return true;
1476}
1477
pbos@webrtc.orgef8bb8d2014-08-13 21:36:18 +00001478void WebRtcVideoChannel2::WebRtcVideoSendStream::MuteStream(bool mute) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001479 rtc::CritScope cs(&lock_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001480 muted_ = mute;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001481}
1482
1483bool WebRtcVideoChannel2::WebRtcVideoSendStream::DisconnectCapturer() {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001484 rtc::CritScope cs(&lock_);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001485 if (capturer_ == NULL) {
1486 return false;
1487 }
1488 capturer_->SignalVideoFrame.disconnect(this);
1489 capturer_ = NULL;
1490 return true;
1491}
1492
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001493void WebRtcVideoChannel2::WebRtcVideoSendStream::SetOptions(
1494 const VideoOptions& options) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001495 rtc::CritScope cs(&lock_);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001496 VideoCodecSettings codec_settings;
1497 if (parameters_.codec_settings.Get(&codec_settings)) {
1498 SetCodecAndOptions(codec_settings, options);
1499 } else {
1500 parameters_.options = options;
1501 }
1502}
1503void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodec(
1504 const VideoCodecSettings& codec_settings) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001505 rtc::CritScope cs(&lock_);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001506 SetCodecAndOptions(codec_settings, parameters_.options);
1507}
1508void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodecAndOptions(
1509 const VideoCodecSettings& codec_settings,
1510 const VideoOptions& options) {
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001511 std::vector<webrtc::VideoStream> video_streams =
1512 encoder_factory_->CreateVideoStreams(
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001513 codec_settings.codec, options, parameters_.config.rtp.ssrcs.size());
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001514 if (video_streams.empty()) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001515 return;
1516 }
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00001517 parameters_.encoder_config.streams = video_streams;
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001518 format_ = VideoFormat(codec_settings.codec.width,
1519 codec_settings.codec.height,
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001520 VideoFormat::FpsToInterval(30),
1521 FOURCC_I420);
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001522
1523 webrtc::VideoEncoder* old_encoder =
1524 parameters_.config.encoder_settings.encoder;
1525 parameters_.config.encoder_settings.encoder =
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001526 encoder_factory_->CreateVideoEncoder(codec_settings.codec, options);
1527 parameters_.config.encoder_settings.payload_name = codec_settings.codec.name;
1528 parameters_.config.encoder_settings.payload_type = codec_settings.codec.id;
1529 parameters_.config.rtp.fec = codec_settings.fec;
1530
1531 // Set RTX payload type if RTX is enabled.
1532 if (!parameters_.config.rtp.rtx.ssrcs.empty()) {
1533 parameters_.config.rtp.rtx.payload_type = codec_settings.rtx_payload_type;
pbos@webrtc.org543e5892014-07-23 07:01:31 +00001534
1535 options.use_payload_padding.Get(
1536 &parameters_.config.rtp.rtx.pad_with_redundant_payloads);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001537 }
1538
1539 if (IsNackEnabled(codec_settings.codec)) {
1540 parameters_.config.rtp.nack.rtp_history_ms = kNackHistoryMs;
1541 }
1542
pbos@webrtc.org5ff71ab2014-07-23 07:28:56 +00001543 options.suspend_below_min_bitrate.Get(
1544 &parameters_.config.suspend_below_min_bitrate);
1545
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001546 parameters_.codec_settings.Set(codec_settings);
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001547 parameters_.options = options;
pbos@webrtc.org543e5892014-07-23 07:01:31 +00001548
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001549 RecreateWebRtcStream();
1550 delete old_encoder;
1551}
1552
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001553void WebRtcVideoChannel2::WebRtcVideoSendStream::SetRtpExtensions(
1554 const std::vector<webrtc::RtpExtension>& rtp_extensions) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001555 rtc::CritScope cs(&lock_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001556 parameters_.config.rtp.extensions = rtp_extensions;
1557 RecreateWebRtcStream();
1558}
1559
pbos@webrtc.orgc4175b92014-09-03 15:25:49 +00001560void WebRtcVideoChannel2::WebRtcVideoSendStream::SetDimensions(
1561 int width,
1562 int height,
1563 bool override_max) {
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00001564 assert(!parameters_.encoder_config.streams.empty());
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001565 LOG(LS_VERBOSE) << "SetDimensions: " << width << "x" << height;
pbos@webrtc.orgc4175b92014-09-03 15:25:49 +00001566
1567 VideoCodecSettings codec_settings;
1568 parameters_.codec_settings.Get(&codec_settings);
1569 // Restrict dimensions according to codec max.
1570 if (!override_max) {
1571 if (codec_settings.codec.width < width)
1572 width = codec_settings.codec.width;
1573 if (codec_settings.codec.height < height)
1574 height = codec_settings.codec.height;
1575 }
1576
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00001577 if (parameters_.encoder_config.streams.back().width == width &&
1578 parameters_.encoder_config.streams.back().height == height) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001579 return;
1580 }
1581
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00001582 webrtc::VideoEncoderConfig encoder_config = parameters_.encoder_config;
1583 encoder_config.encoder_specific_settings =
1584 encoder_factory_->CreateVideoEncoderSettings(codec_settings.codec,
1585 parameters_.options);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001586
pbos@webrtc.orgcddd17c2014-09-16 16:33:13 +00001587 VideoCodec codec = codec_settings.codec;
1588 codec.width = width;
1589 codec.height = height;
pbos@webrtc.orgcddd17c2014-09-16 16:33:13 +00001590
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00001591 encoder_config.streams = encoder_factory_->CreateVideoStreams(
1592 codec, parameters_.options, parameters_.config.rtp.ssrcs.size());
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001593
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00001594 bool stream_reconfigured = stream_->ReconfigureVideoEncoder(encoder_config);
1595
1596 encoder_factory_->DestroyVideoEncoderSettings(
1597 codec_settings.codec,
1598 encoder_config.encoder_specific_settings);
1599
1600 encoder_config.encoder_specific_settings = NULL;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001601
1602 if (!stream_reconfigured) {
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001603 LOG(LS_WARNING) << "Failed to reconfigure video encoder for dimensions: "
1604 << width << "x" << height;
1605 return;
1606 }
pbos@webrtc.orgcddd17c2014-09-16 16:33:13 +00001607
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00001608 parameters_.encoder_config = encoder_config;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001609}
1610
1611void WebRtcVideoChannel2::WebRtcVideoSendStream::Start() {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001612 rtc::CritScope cs(&lock_);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001613 assert(stream_ != NULL);
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001614 stream_->Start();
1615 sending_ = true;
1616}
1617
1618void WebRtcVideoChannel2::WebRtcVideoSendStream::Stop() {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001619 rtc::CritScope cs(&lock_);
pbos@webrtc.org5301b0f2014-07-17 08:51:46 +00001620 if (stream_ != NULL) {
1621 stream_->Stop();
1622 }
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001623 sending_ = false;
1624}
1625
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001626VideoSenderInfo
1627WebRtcVideoChannel2::WebRtcVideoSendStream::GetVideoSenderInfo() {
1628 VideoSenderInfo info;
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001629 rtc::CritScope cs(&lock_);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001630 for (size_t i = 0; i < parameters_.config.rtp.ssrcs.size(); ++i) {
1631 info.add_ssrc(parameters_.config.rtp.ssrcs[i]);
1632 }
1633
pbos@webrtc.orgc3d2bd22014-08-12 20:55:10 +00001634 if (stream_ == NULL) {
1635 return info;
1636 }
1637
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001638 webrtc::VideoSendStream::Stats stats = stream_->GetStats();
1639 info.framerate_input = stats.input_frame_rate;
1640 info.framerate_sent = stats.encode_frame_rate;
1641
1642 for (std::map<uint32_t, webrtc::StreamStats>::iterator it =
1643 stats.substreams.begin();
1644 it != stats.substreams.end();
1645 ++it) {
1646 // TODO(pbos): Wire up additional stats, such as padding bytes.
1647 webrtc::StreamStats stream_stats = it->second;
1648 info.bytes_sent += stream_stats.rtp_stats.bytes +
1649 stream_stats.rtp_stats.header_bytes +
1650 stream_stats.rtp_stats.padding_bytes;
1651 info.packets_sent += stream_stats.rtp_stats.packets;
1652 info.packets_lost += stream_stats.rtcp_stats.cumulative_lost;
1653 }
1654
1655 if (!stats.substreams.empty()) {
1656 // TODO(pbos): Report fraction lost per SSRC.
1657 webrtc::StreamStats first_stream_stats = stats.substreams.begin()->second;
1658 info.fraction_lost =
1659 static_cast<float>(first_stream_stats.rtcp_stats.fraction_lost) /
1660 (1 << 8);
1661 }
1662
1663 if (capturer_ != NULL && !capturer_->IsMuted()) {
1664 VideoFormat last_captured_frame_format;
1665 capturer_->GetStats(&info.adapt_frame_drops,
1666 &info.effects_frame_drops,
1667 &info.capturer_frame_time,
1668 &last_captured_frame_format);
1669 info.input_frame_width = last_captured_frame_format.width;
1670 info.input_frame_height = last_captured_frame_format.height;
1671 info.send_frame_width =
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00001672 static_cast<int>(parameters_.encoder_config.streams.front().width);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001673 info.send_frame_height =
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00001674 static_cast<int>(parameters_.encoder_config.streams.front().height);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001675 }
1676
1677 // TODO(pbos): Support or remove the following stats.
1678 info.packets_cached = -1;
1679 info.rtt_ms = -1;
1680
1681 return info;
1682}
1683
pbos@webrtc.org42684be2014-10-03 11:25:45 +00001684void WebRtcVideoChannel2::WebRtcVideoSendStream::OnCpuResolutionRequest(
1685 CoordinatedVideoAdapter::AdaptRequest adapt_request) {
1686 rtc::CritScope cs(&lock_);
1687 bool adapt_cpu;
1688 parameters_.options.cpu_overuse_detection.Get(&adapt_cpu);
1689 if (!adapt_cpu) {
1690 return;
1691 }
1692 if (capturer_ == NULL || capturer_->video_adapter() == NULL) {
1693 return;
1694 }
1695
1696 capturer_->video_adapter()->OnCpuResolutionRequest(adapt_request);
1697}
1698
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001699void WebRtcVideoChannel2::WebRtcVideoSendStream::RecreateWebRtcStream() {
1700 if (stream_ != NULL) {
1701 call_->DestroyVideoSendStream(stream_);
1702 }
pbos@webrtc.org6ae48c62014-06-06 10:49:19 +00001703
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001704 VideoCodecSettings codec_settings;
1705 parameters_.codec_settings.Get(&codec_settings);
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00001706 parameters_.encoder_config.encoder_specific_settings =
1707 encoder_factory_->CreateVideoEncoderSettings(codec_settings.codec,
1708 parameters_.options);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001709
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00001710 stream_ = call_->CreateVideoSendStream(parameters_.config,
1711 parameters_.encoder_config);
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001712
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +00001713 encoder_factory_->DestroyVideoEncoderSettings(
1714 codec_settings.codec,
1715 parameters_.encoder_config.encoder_specific_settings);
1716
1717 parameters_.encoder_config.encoder_specific_settings = NULL;
pbos@webrtc.org6f48f1b2014-07-22 16:29:54 +00001718
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001719 if (sending_) {
1720 stream_->Start();
1721 }
1722}
1723
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001724WebRtcVideoChannel2::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
1725 webrtc::Call* call,
1726 const webrtc::VideoReceiveStream::Config& config,
1727 const std::vector<VideoCodecSettings>& recv_codecs)
1728 : call_(call),
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001729 stream_(NULL),
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +00001730 config_(config),
1731 renderer_(NULL),
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001732 last_width_(-1),
pbos@webrtc.orgb648b9d2014-08-26 11:08:06 +00001733 last_height_(-1) {
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001734 config_.renderer = this;
1735 // SetRecvCodecs will also reset (start) the VideoReceiveStream.
1736 SetRecvCodecs(recv_codecs);
1737}
1738
1739WebRtcVideoChannel2::WebRtcVideoReceiveStream::~WebRtcVideoReceiveStream() {
1740 call_->DestroyVideoReceiveStream(stream_);
1741}
1742
1743void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRecvCodecs(
1744 const std::vector<VideoCodecSettings>& recv_codecs) {
1745 // TODO(pbos): Reconfigure RTX based on incoming recv_codecs.
1746 // TODO(pbos): Base receive codecs off recv_codecs_ and set up using a
1747 // DecoderFactory similar to send side. Pending webrtc:2854.
1748 // Also set up default codecs if there's nothing in recv_codecs_.
1749 webrtc::VideoCodec codec;
1750 memset(&codec, 0, sizeof(codec));
1751
1752 codec.plType = kDefaultVideoCodecPref.payload_type;
1753 strcpy(codec.plName, kDefaultVideoCodecPref.name);
1754 codec.codecType = webrtc::kVideoCodecVP8;
1755 codec.codecSpecific.VP8.resilience = webrtc::kResilientStream;
1756 codec.codecSpecific.VP8.numberOfTemporalLayers = 1;
1757 codec.codecSpecific.VP8.denoisingOn = true;
1758 codec.codecSpecific.VP8.errorConcealmentOn = false;
1759 codec.codecSpecific.VP8.automaticResizeOn = false;
1760 codec.codecSpecific.VP8.frameDroppingOn = true;
1761 codec.codecSpecific.VP8.keyFrameInterval = 3000;
1762 // Bitrates don't matter and are ignored for the receiver. This is put in to
1763 // have the current underlying implementation accept the VideoCodec.
1764 codec.minBitrate = codec.startBitrate = codec.maxBitrate = 300;
1765 config_.codecs.clear();
1766 config_.codecs.push_back(codec);
1767
1768 config_.rtp.fec = recv_codecs.front().fec;
1769
pbos@webrtc.org257e1302014-07-25 19:01:32 +00001770 config_.rtp.nack.rtp_history_ms =
1771 IsNackEnabled(recv_codecs.begin()->codec) ? kNackHistoryMs : 0;
1772 config_.rtp.remb = IsRembEnabled(recv_codecs.begin()->codec);
1773
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001774 RecreateWebRtcStream();
1775}
1776
1777void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRtpExtensions(
1778 const std::vector<webrtc::RtpExtension>& extensions) {
1779 config_.rtp.extensions = extensions;
1780 RecreateWebRtcStream();
1781}
1782
1783void WebRtcVideoChannel2::WebRtcVideoReceiveStream::RecreateWebRtcStream() {
1784 if (stream_ != NULL) {
1785 call_->DestroyVideoReceiveStream(stream_);
1786 }
1787 stream_ = call_->CreateVideoReceiveStream(config_);
1788 stream_->Start();
1789}
1790
1791void WebRtcVideoChannel2::WebRtcVideoReceiveStream::RenderFrame(
1792 const webrtc::I420VideoFrame& frame,
1793 int time_to_render_ms) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001794 rtc::CritScope crit(&renderer_lock_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001795 if (renderer_ == NULL) {
1796 LOG(LS_WARNING) << "VideoReceiveStream not connected to a VideoRenderer.";
1797 return;
1798 }
1799
1800 if (frame.width() != last_width_ || frame.height() != last_height_) {
1801 SetSize(frame.width(), frame.height());
1802 }
1803
1804 LOG(LS_VERBOSE) << "RenderFrame: (" << frame.width() << "x" << frame.height()
1805 << ")";
1806
1807 const WebRtcVideoRenderFrame render_frame(&frame);
1808 renderer_->RenderFrame(&render_frame);
1809}
1810
1811void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRenderer(
1812 cricket::VideoRenderer* renderer) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001813 rtc::CritScope crit(&renderer_lock_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001814 renderer_ = renderer;
1815 if (renderer_ != NULL && last_width_ != -1) {
1816 SetSize(last_width_, last_height_);
1817 }
1818}
1819
1820VideoRenderer* WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetRenderer() {
1821 // TODO(pbos): Remove GetRenderer and all uses of it, it's thread-unsafe by
1822 // design.
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001823 rtc::CritScope crit(&renderer_lock_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001824 return renderer_;
1825}
1826
1827void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetSize(int width,
1828 int height) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001829 rtc::CritScope crit(&renderer_lock_);
pbos@webrtc.orgd1ea06b2014-07-18 09:35:58 +00001830 if (!renderer_->SetSize(width, height, 0)) {
1831 LOG(LS_ERROR) << "Could not set renderer size.";
1832 }
1833 last_width_ = width;
1834 last_height_ = height;
1835}
1836
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001837VideoReceiverInfo
1838WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetVideoReceiverInfo() {
1839 VideoReceiverInfo info;
1840 info.add_ssrc(config_.rtp.remote_ssrc);
1841 webrtc::VideoReceiveStream::Stats stats = stream_->GetStats();
1842 info.bytes_rcvd = stats.rtp_stats.bytes + stats.rtp_stats.header_bytes +
1843 stats.rtp_stats.padding_bytes;
1844 info.packets_rcvd = stats.rtp_stats.packets;
1845
1846 info.framerate_rcvd = stats.network_frame_rate;
1847 info.framerate_decoded = stats.decode_frame_rate;
1848 info.framerate_output = stats.render_frame_rate;
1849
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001850 rtc::CritScope frame_cs(&renderer_lock_);
pbos@webrtc.orge6f84ae2014-07-18 11:11:55 +00001851 info.frame_width = last_width_;
1852 info.frame_height = last_height_;
1853
1854 // TODO(pbos): Support or remove the following stats.
1855 info.packets_concealed = -1;
1856
1857 return info;
1858}
1859
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001860WebRtcVideoChannel2::VideoCodecSettings::VideoCodecSettings()
1861 : rtx_payload_type(-1) {}
1862
1863std::vector<WebRtcVideoChannel2::VideoCodecSettings>
1864WebRtcVideoChannel2::MapCodecs(const std::vector<VideoCodec>& codecs) {
1865 assert(!codecs.empty());
1866
1867 std::vector<VideoCodecSettings> video_codecs;
1868 std::map<int, bool> payload_used;
pbos@webrtc.orge322a172014-06-13 11:47:28 +00001869 std::map<int, VideoCodec::CodecType> payload_codec_type;
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001870 std::map<int, int> rtx_mapping; // video payload type -> rtx payload type.
1871
1872 webrtc::FecConfig fec_settings;
1873
1874 for (size_t i = 0; i < codecs.size(); ++i) {
1875 const VideoCodec& in_codec = codecs[i];
1876 int payload_type = in_codec.id;
1877
1878 if (payload_used[payload_type]) {
1879 LOG(LS_ERROR) << "Payload type already registered: "
1880 << in_codec.ToString();
1881 return std::vector<VideoCodecSettings>();
1882 }
1883 payload_used[payload_type] = true;
pbos@webrtc.orge322a172014-06-13 11:47:28 +00001884 payload_codec_type[payload_type] = in_codec.GetCodecType();
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001885
1886 switch (in_codec.GetCodecType()) {
1887 case VideoCodec::CODEC_RED: {
1888 // RED payload type, should not have duplicates.
1889 assert(fec_settings.red_payload_type == -1);
1890 fec_settings.red_payload_type = in_codec.id;
1891 continue;
1892 }
1893
1894 case VideoCodec::CODEC_ULPFEC: {
1895 // ULPFEC payload type, should not have duplicates.
1896 assert(fec_settings.ulpfec_payload_type == -1);
1897 fec_settings.ulpfec_payload_type = in_codec.id;
1898 continue;
1899 }
1900
1901 case VideoCodec::CODEC_RTX: {
1902 int associated_payload_type;
1903 if (!in_codec.GetParam(kCodecParamAssociatedPayloadType,
1904 &associated_payload_type)) {
1905 LOG(LS_ERROR) << "RTX codec without associated payload type: "
1906 << in_codec.ToString();
1907 return std::vector<VideoCodecSettings>();
1908 }
1909 rtx_mapping[associated_payload_type] = in_codec.id;
1910 continue;
1911 }
1912
1913 case VideoCodec::CODEC_VIDEO:
1914 break;
1915 }
1916
1917 video_codecs.push_back(VideoCodecSettings());
1918 video_codecs.back().codec = in_codec;
1919 }
1920
1921 // One of these codecs should have been a video codec. Only having FEC
1922 // parameters into this code is a logic error.
1923 assert(!video_codecs.empty());
1924
pbos@webrtc.orge322a172014-06-13 11:47:28 +00001925 for (std::map<int, int>::const_iterator it = rtx_mapping.begin();
1926 it != rtx_mapping.end();
1927 ++it) {
1928 if (!payload_used[it->first]) {
1929 LOG(LS_ERROR) << "RTX mapped to payload not in codec list.";
1930 return std::vector<VideoCodecSettings>();
1931 }
1932 if (payload_codec_type[it->first] != VideoCodec::CODEC_VIDEO) {
1933 LOG(LS_ERROR) << "RTX not mapped to regular video codec.";
1934 return std::vector<VideoCodecSettings>();
1935 }
1936 }
1937
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +00001938 // TODO(pbos): Write tests that figure out that I have not verified that RTX
1939 // codecs aren't mapped to bogus payloads.
1940 for (size_t i = 0; i < video_codecs.size(); ++i) {
1941 video_codecs[i].fec = fec_settings;
1942 if (rtx_mapping[video_codecs[i].codec.id] != 0) {
1943 video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
1944 }
1945 }
1946
1947 return video_codecs;
1948}
1949
1950std::vector<WebRtcVideoChannel2::VideoCodecSettings>
1951WebRtcVideoChannel2::FilterSupportedCodecs(
1952 const std::vector<WebRtcVideoChannel2::VideoCodecSettings>& mapped_codecs) {
1953 std::vector<VideoCodecSettings> supported_codecs;
1954 for (size_t i = 0; i < mapped_codecs.size(); ++i) {
1955 if (encoder_factory_->SupportsCodec(mapped_codecs[i].codec)) {
1956 supported_codecs.push_back(mapped_codecs[i]);
1957 }
1958 }
1959 return supported_codecs;
1960}
1961
1962} // namespace cricket
1963
1964#endif // HAVE_WEBRTC_VIDEO