webrtcvideoengine2.cc revision 874ca3af5b163e1b3fd8802171e44ee252557842 
1/*
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
31#include <algorithm>
32#include <set>
33#include <string>
34
35#include "talk/media/base/videocapturer.h"
36#include "talk/media/base/videorenderer.h"
37#include "talk/media/webrtc/constants.h"
38#include "talk/media/webrtc/simulcast.h"
39#include "talk/media/webrtc/webrtcvideoencoderfactory.h"
40#include "talk/media/webrtc/webrtcvideoframe.h"
41#include "talk/media/webrtc/webrtcvoiceengine.h"
42#include "webrtc/base/buffer.h"
43#include "webrtc/base/logging.h"
44#include "webrtc/base/stringutils.h"
45#include "webrtc/base/timeutils.h"
46#include "webrtc/call.h"
47#include "webrtc/modules/video_coding/codecs/h264/include/h264.h"
48#include "webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h"
49#include "webrtc/system_wrappers/interface/field_trial.h"
50#include "webrtc/system_wrappers/interface/trace_event.h"
51#include "webrtc/video_decoder.h"
52#include "webrtc/video_encoder.h"
53
54#define UNIMPLEMENTED                                                 \
55  LOG(LS_ERROR) << "Call to unimplemented function " << __FUNCTION__; \
56  RTC_NOTREACHED()
57
58namespace cricket {
59namespace {
60
61// Wrap cricket::WebRtcVideoEncoderFactory as a webrtc::VideoEncoderFactory.
62class EncoderFactoryAdapter : public webrtc::VideoEncoderFactory {
63 public:
64  // EncoderFactoryAdapter doesn't take ownership of |factory|, which is owned
65  // by e.g. PeerConnectionFactory.
66  explicit EncoderFactoryAdapter(cricket::WebRtcVideoEncoderFactory* factory)
67      : factory_(factory) {}
68  virtual ~EncoderFactoryAdapter() {}
69
70  // Implement webrtc::VideoEncoderFactory.
71  webrtc::VideoEncoder* Create() override {
72    return factory_->CreateVideoEncoder(webrtc::kVideoCodecVP8);
73  }
74
75  void Destroy(webrtc::VideoEncoder* encoder) override {
76    return factory_->DestroyVideoEncoder(encoder);
77  }
78
79 private:
80  cricket::WebRtcVideoEncoderFactory* const factory_;
81};
82
83// An encoder factory that wraps Create requests for simulcastable codec types
84// with a webrtc::SimulcastEncoderAdapter. Non simulcastable codec type
85// requests are just passed through to the contained encoder factory.
86class WebRtcSimulcastEncoderFactory
87    : public cricket::WebRtcVideoEncoderFactory {
88 public:
89  // WebRtcSimulcastEncoderFactory doesn't take ownership of |factory|, which is
90  // owned by e.g. PeerConnectionFactory.
91  explicit WebRtcSimulcastEncoderFactory(
92      cricket::WebRtcVideoEncoderFactory* factory)
93      : factory_(factory) {}
94
95  static bool UseSimulcastEncoderFactory(
96      const std::vector<VideoCodec>& codecs) {
97    // If any codec is VP8, use the simulcast factory. If asked to create a
98    // non-VP8 codec, we'll just return a contained factory encoder directly.
99    for (const auto& codec : codecs) {
100      if (codec.type == webrtc::kVideoCodecVP8) {
101        return true;
102      }
103    }
104    return false;
105  }
106
107  webrtc::VideoEncoder* CreateVideoEncoder(
108      webrtc::VideoCodecType type) override {
109    DCHECK(factory_ != NULL);
110    // If it's a codec type we can simulcast, create a wrapped encoder.
111    if (type == webrtc::kVideoCodecVP8) {
112      return new webrtc::SimulcastEncoderAdapter(
113          new EncoderFactoryAdapter(factory_));
114    }
115    webrtc::VideoEncoder* encoder = factory_->CreateVideoEncoder(type);
116    if (encoder) {
117      non_simulcast_encoders_.push_back(encoder);
118    }
119    return encoder;
120  }
121
122  const std::vector<VideoCodec>& codecs() const override {
123    return factory_->codecs();
124  }
125
126  bool EncoderTypeHasInternalSource(
127      webrtc::VideoCodecType type) const override {
128    return factory_->EncoderTypeHasInternalSource(type);
129  }
130
131  void DestroyVideoEncoder(webrtc::VideoEncoder* encoder) override {
132    // Check first to see if the encoder wasn't wrapped in a
133    // SimulcastEncoderAdapter. In that case, ask the factory to destroy it.
134    if (std::remove(non_simulcast_encoders_.begin(),
135                    non_simulcast_encoders_.end(),
136                    encoder) != non_simulcast_encoders_.end()) {
137      factory_->DestroyVideoEncoder(encoder);
138      return;
139    }
140
141    // Otherwise, SimulcastEncoderAdapter can be deleted directly, and will call
142    // DestroyVideoEncoder on the factory for individual encoder instances.
143    delete encoder;
144  }
145
146 private:
147  cricket::WebRtcVideoEncoderFactory* factory_;
148  // A list of encoders that were created without being wrapped in a
149  // SimulcastEncoderAdapter.
150  std::vector<webrtc::VideoEncoder*> non_simulcast_encoders_;
151};
152
153bool CodecIsInternallySupported(const std::string& codec_name) {
154  if (CodecNamesEq(codec_name, kVp8CodecName)) {
155    return true;
156  }
157  if (CodecNamesEq(codec_name, kVp9CodecName)) {
158    const std::string group_name =
159        webrtc::field_trial::FindFullName("WebRTC-SupportVP9");
160    return group_name == "Enabled" || group_name == "EnabledByFlag";
161  }
162  if (CodecNamesEq(codec_name, kH264CodecName)) {
163    return webrtc::H264Encoder::IsSupported() &&
164        webrtc::H264Decoder::IsSupported();
165  }
166  return false;
167}
168
169void AddDefaultFeedbackParams(VideoCodec* codec) {
170  codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamCcm, kRtcpFbCcmParamFir));
171  codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamNack, kParamValueEmpty));
172  codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamNack, kRtcpFbNackParamPli));
173  codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamRemb, kParamValueEmpty));
174}
175
176static VideoCodec MakeVideoCodecWithDefaultFeedbackParams(int payload_type,
177                                                          const char* name) {
178  VideoCodec codec(payload_type, name, kDefaultVideoMaxWidth,
179                   kDefaultVideoMaxHeight, kDefaultVideoMaxFramerate, 0);
180  AddDefaultFeedbackParams(&codec);
181  return codec;
182}
183
184static std::string CodecVectorToString(const std::vector<VideoCodec>& codecs) {
185  std::stringstream out;
186  out << '{';
187  for (size_t i = 0; i < codecs.size(); ++i) {
188    out << codecs[i].ToString();
189    if (i != codecs.size() - 1) {
190      out << ", ";
191    }
192  }
193  out << '}';
194  return out.str();
195}
196
197static bool ValidateCodecFormats(const std::vector<VideoCodec>& codecs) {
198  bool has_video = false;
199  for (size_t i = 0; i < codecs.size(); ++i) {
200    if (!codecs[i].ValidateCodecFormat()) {
201      return false;
202    }
203    if (codecs[i].GetCodecType() == VideoCodec::CODEC_VIDEO) {
204      has_video = true;
205    }
206  }
207  if (!has_video) {
208    LOG(LS_ERROR) << "Setting codecs without a video codec is invalid: "
209                  << CodecVectorToString(codecs);
210    return false;
211  }
212  return true;
213}
214
215static bool ValidateStreamParams(const StreamParams& sp) {
216  if (sp.ssrcs.empty()) {
217    LOG(LS_ERROR) << "No SSRCs in stream parameters: " << sp.ToString();
218    return false;
219  }
220
221  std::vector<uint32> primary_ssrcs;
222  sp.GetPrimarySsrcs(&primary_ssrcs);
223  std::vector<uint32> rtx_ssrcs;
224  sp.GetFidSsrcs(primary_ssrcs, &rtx_ssrcs);
225  for (uint32_t rtx_ssrc : rtx_ssrcs) {
226    bool rtx_ssrc_present = false;
227    for (uint32_t sp_ssrc : sp.ssrcs) {
228      if (sp_ssrc == rtx_ssrc) {
229        rtx_ssrc_present = true;
230        break;
231      }
232    }
233    if (!rtx_ssrc_present) {
234      LOG(LS_ERROR) << "RTX SSRC '" << rtx_ssrc
235                    << "' missing from StreamParams ssrcs: " << sp.ToString();
236      return false;
237    }
238  }
239  if (!rtx_ssrcs.empty() && primary_ssrcs.size() != rtx_ssrcs.size()) {
240    LOG(LS_ERROR)
241        << "RTX SSRCs exist, but don't cover all SSRCs (unsupported): "
242        << sp.ToString();
243    return false;
244  }
245
246  return true;
247}
248
249static std::string RtpExtensionsToString(
250    const std::vector<RtpHeaderExtension>& extensions) {
251  std::stringstream out;
252  out << '{';
253  for (size_t i = 0; i < extensions.size(); ++i) {
254    out << "{" << extensions[i].uri << ": " << extensions[i].id << "}";
255    if (i != extensions.size() - 1) {
256      out << ", ";
257    }
258  }
259  out << '}';
260  return out.str();
261}
262
263inline const webrtc::RtpExtension* FindHeaderExtension(
264    const std::vector<webrtc::RtpExtension>& extensions,
265    const std::string& name) {
266  for (const auto& kv : extensions) {
267    if (kv.name == name) {
268      return &kv;
269    }
270  }
271  return NULL;
272}
273
274// Merges two fec configs and logs an error if a conflict arises
275// such that merging in different order would trigger a different output.
276static void MergeFecConfig(const webrtc::FecConfig& other,
277                           webrtc::FecConfig* output) {
278  if (other.ulpfec_payload_type != -1) {
279    if (output->ulpfec_payload_type != -1 &&
280        output->ulpfec_payload_type != other.ulpfec_payload_type) {
281      LOG(LS_WARNING) << "Conflict merging ulpfec_payload_type configs: "
282                      << output->ulpfec_payload_type << " and "
283                      << other.ulpfec_payload_type;
284    }
285    output->ulpfec_payload_type = other.ulpfec_payload_type;
286  }
287  if (other.red_payload_type != -1) {
288    if (output->red_payload_type != -1 &&
289        output->red_payload_type != other.red_payload_type) {
290      LOG(LS_WARNING) << "Conflict merging red_payload_type configs: "
291                      << output->red_payload_type << " and "
292                      << other.red_payload_type;
293    }
294    output->red_payload_type = other.red_payload_type;
295  }
296  if (other.red_rtx_payload_type != -1) {
297    if (output->red_rtx_payload_type != -1 &&
298        output->red_rtx_payload_type != other.red_rtx_payload_type) {
299      LOG(LS_WARNING) << "Conflict merging red_rtx_payload_type configs: "
300                      << output->red_rtx_payload_type << " and "
301                      << other.red_rtx_payload_type;
302    }
303    output->red_rtx_payload_type = other.red_rtx_payload_type;
304  }
305}
306}  // namespace
307
308// Constants defined in talk/media/webrtc/constants.h
309// TODO(pbos): Move these to a separate constants.cc file.
310const int kMinVideoBitrate = 30;
311const int kStartVideoBitrate = 300;
312const int kMaxVideoBitrate = 2000;
313
314const int kVideoMtu = 1200;
315const int kVideoRtpBufferSize = 65536;
316
317// This constant is really an on/off, lower-level configurable NACK history
318// duration hasn't been implemented.
319static const int kNackHistoryMs = 1000;
320
321static const int kDefaultQpMax = 56;
322
323static const int kDefaultRtcpReceiverReportSsrc = 1;
324
325const int kMinBandwidthBps = 30000;
326const int kStartBandwidthBps = 300000;
327const int kMaxBandwidthBps = 2000000;
328
329std::vector<VideoCodec> DefaultVideoCodecList() {
330  std::vector<VideoCodec> codecs;
331  if (CodecIsInternallySupported(kVp9CodecName)) {
332    codecs.push_back(MakeVideoCodecWithDefaultFeedbackParams(kDefaultVp9PlType,
333                                                             kVp9CodecName));
334    // TODO(andresp): Add rtx codec for vp9 and verify it works.
335  }
336  codecs.push_back(MakeVideoCodecWithDefaultFeedbackParams(kDefaultVp8PlType,
337                                                           kVp8CodecName));
338  if (CodecIsInternallySupported(kH264CodecName)) {
339    codecs.push_back(MakeVideoCodecWithDefaultFeedbackParams(kDefaultH264PlType,
340                                                             kH264CodecName));
341  }
342  codecs.push_back(
343      VideoCodec::CreateRtxCodec(kDefaultRtxVp8PlType, kDefaultVp8PlType));
344  codecs.push_back(VideoCodec(kDefaultRedPlType, kRedCodecName));
345  codecs.push_back(VideoCodec(kDefaultUlpfecType, kUlpfecCodecName));
346  return codecs;
347}
348
349static bool FindFirstMatchingCodec(const std::vector<VideoCodec>& codecs,
350                                   const VideoCodec& requested_codec,
351                                   VideoCodec* matching_codec) {
352  for (size_t i = 0; i < codecs.size(); ++i) {
353    if (requested_codec.Matches(codecs[i])) {
354      *matching_codec = codecs[i];
355      return true;
356    }
357  }
358  return false;
359}
360
361static bool ValidateRtpHeaderExtensionIds(
362    const std::vector<RtpHeaderExtension>& extensions) {
363  std::set<int> extensions_used;
364  for (size_t i = 0; i < extensions.size(); ++i) {
365    if (extensions[i].id <= 0 || extensions[i].id >= 15 ||
366        !extensions_used.insert(extensions[i].id).second) {
367      LOG(LS_ERROR) << "RTP extensions are with incorrect or duplicate ids.";
368      return false;
369    }
370  }
371  return true;
372}
373
374static bool CompareRtpHeaderExtensionIds(
375    const webrtc::RtpExtension& extension1,
376    const webrtc::RtpExtension& extension2) {
377  // Sorting on ID is sufficient, more than one extension per ID is unsupported.
378  return extension1.id > extension2.id;
379}
380
381static std::vector<webrtc::RtpExtension> FilterRtpExtensions(
382    const std::vector<RtpHeaderExtension>& extensions) {
383  std::vector<webrtc::RtpExtension> webrtc_extensions;
384  for (size_t i = 0; i < extensions.size(); ++i) {
385    // Unsupported extensions will be ignored.
386    if (webrtc::RtpExtension::IsSupportedForVideo(extensions[i].uri)) {
387      webrtc_extensions.push_back(webrtc::RtpExtension(
388          extensions[i].uri, extensions[i].id));
389    } else {
390      LOG(LS_WARNING) << "Unsupported RTP extension: " << extensions[i].uri;
391    }
392  }
393
394  // Sort filtered headers to make sure that they can later be compared
395  // regardless of in which order they were entered.
396  std::sort(webrtc_extensions.begin(), webrtc_extensions.end(),
397            CompareRtpHeaderExtensionIds);
398  return webrtc_extensions;
399}
400
401static bool RtpExtensionsHaveChanged(
402    const std::vector<webrtc::RtpExtension>& before,
403    const std::vector<webrtc::RtpExtension>& after) {
404  if (before.size() != after.size())
405    return true;
406  for (size_t i = 0; i < before.size(); ++i) {
407    if (before[i].id != after[i].id)
408      return true;
409    if (before[i].name != after[i].name)
410      return true;
411  }
412  return false;
413}
414
415std::vector<webrtc::VideoStream>
416WebRtcVideoChannel2::WebRtcVideoSendStream::CreateSimulcastVideoStreams(
417    const VideoCodec& codec,
418    const VideoOptions& options,
419    int max_bitrate_bps,
420    size_t num_streams) {
421  int max_qp = kDefaultQpMax;
422  codec.GetParam(kCodecParamMaxQuantization, &max_qp);
423
424  return GetSimulcastConfig(
425      num_streams, GetSimulcastBitrateMode(options), codec.width, codec.height,
426      max_bitrate_bps, max_qp,
427      codec.framerate != 0 ? codec.framerate : kDefaultVideoMaxFramerate);
428}
429
430std::vector<webrtc::VideoStream>
431WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoStreams(
432    const VideoCodec& codec,
433    const VideoOptions& options,
434    int max_bitrate_bps,
435    size_t num_streams) {
436  int codec_max_bitrate_kbps;
437  if (codec.GetParam(kCodecParamMaxBitrate, &codec_max_bitrate_kbps)) {
438    max_bitrate_bps = codec_max_bitrate_kbps * 1000;
439  }
440  if (num_streams != 1) {
441    return CreateSimulcastVideoStreams(codec, options, max_bitrate_bps,
442                                       num_streams);
443  }
444
445  // For unset max bitrates set default bitrate for non-simulcast.
446  if (max_bitrate_bps <= 0)
447    max_bitrate_bps = kMaxVideoBitrate * 1000;
448
449  webrtc::VideoStream stream;
450  stream.width = codec.width;
451  stream.height = codec.height;
452  stream.max_framerate =
453      codec.framerate != 0 ? codec.framerate : kDefaultVideoMaxFramerate;
454
455  stream.min_bitrate_bps = kMinVideoBitrate * 1000;
456  stream.target_bitrate_bps = stream.max_bitrate_bps = max_bitrate_bps;
457
458  int max_qp = kDefaultQpMax;
459  codec.GetParam(kCodecParamMaxQuantization, &max_qp);
460  stream.max_qp = max_qp;
461  std::vector<webrtc::VideoStream> streams;
462  streams.push_back(stream);
463  return streams;
464}
465
466void* WebRtcVideoChannel2::WebRtcVideoSendStream::ConfigureVideoEncoderSettings(
467    const VideoCodec& codec,
468    const VideoOptions& options,
469    bool is_screencast) {
470  // No automatic resizing when using simulcast.
471  bool automatic_resize = !is_screencast && ssrcs_.size() == 1;
472  bool frame_dropping = !is_screencast;
473  bool denoising;
474  if (is_screencast) {
475    denoising = false;
476  } else {
477    options.video_noise_reduction.Get(&denoising);
478  }
479
480  if (CodecNamesEq(codec.name, kVp8CodecName)) {
481    encoder_settings_.vp8 = webrtc::VideoEncoder::GetDefaultVp8Settings();
482    encoder_settings_.vp8.automaticResizeOn = automatic_resize;
483    encoder_settings_.vp8.denoisingOn = denoising;
484    encoder_settings_.vp8.frameDroppingOn = frame_dropping;
485    return &encoder_settings_.vp8;
486  }
487  if (CodecNamesEq(codec.name, kVp9CodecName)) {
488    encoder_settings_.vp9 = webrtc::VideoEncoder::GetDefaultVp9Settings();
489    encoder_settings_.vp9.denoisingOn = denoising;
490    encoder_settings_.vp9.frameDroppingOn = frame_dropping;
491    return &encoder_settings_.vp9;
492  }
493  return NULL;
494}
495
496DefaultUnsignalledSsrcHandler::DefaultUnsignalledSsrcHandler()
497    : default_recv_ssrc_(0), default_renderer_(NULL) {}
498
499UnsignalledSsrcHandler::Action DefaultUnsignalledSsrcHandler::OnUnsignalledSsrc(
500    WebRtcVideoChannel2* channel,
501    uint32_t ssrc) {
502  if (default_recv_ssrc_ != 0) {  // Already one default stream.
503    LOG(LS_WARNING) << "Unknown SSRC, but default receive stream already set.";
504    return kDropPacket;
505  }
506
507  StreamParams sp;
508  sp.ssrcs.push_back(ssrc);
509  LOG(LS_INFO) << "Creating default receive stream for SSRC=" << ssrc << ".";
510  if (!channel->AddRecvStream(sp, true)) {
511    LOG(LS_WARNING) << "Could not create default receive stream.";
512  }
513
514  channel->SetRenderer(ssrc, default_renderer_);
515  default_recv_ssrc_ = ssrc;
516  return kDeliverPacket;
517}
518
519WebRtcCallFactory::~WebRtcCallFactory() {
520}
521webrtc::Call* WebRtcCallFactory::CreateCall(
522    const webrtc::Call::Config& config) {
523  return webrtc::Call::Create(config);
524}
525
526VideoRenderer* DefaultUnsignalledSsrcHandler::GetDefaultRenderer() const {
527  return default_renderer_;
528}
529
530void DefaultUnsignalledSsrcHandler::SetDefaultRenderer(
531    VideoMediaChannel* channel,
532    VideoRenderer* renderer) {
533  default_renderer_ = renderer;
534  if (default_recv_ssrc_ != 0) {
535    channel->SetRenderer(default_recv_ssrc_, default_renderer_);
536  }
537}
538
539WebRtcVideoEngine2::WebRtcVideoEngine2(WebRtcVoiceEngine* voice_engine)
540    : voice_engine_(voice_engine),
541      initialized_(false),
542      call_factory_(&default_call_factory_),
543      external_decoder_factory_(NULL),
544      external_encoder_factory_(NULL) {
545  LOG(LS_INFO) << "WebRtcVideoEngine2::WebRtcVideoEngine2()";
546  video_codecs_ = GetSupportedCodecs();
547  rtp_header_extensions_.push_back(
548      RtpHeaderExtension(kRtpTimestampOffsetHeaderExtension,
549                         kRtpTimestampOffsetHeaderExtensionDefaultId));
550  rtp_header_extensions_.push_back(
551      RtpHeaderExtension(kRtpAbsoluteSenderTimeHeaderExtension,
552                         kRtpAbsoluteSenderTimeHeaderExtensionDefaultId));
553  rtp_header_extensions_.push_back(
554      RtpHeaderExtension(kRtpVideoRotationHeaderExtension,
555                         kRtpVideoRotationHeaderExtensionDefaultId));
556}
557
558WebRtcVideoEngine2::~WebRtcVideoEngine2() {
559  LOG(LS_INFO) << "WebRtcVideoEngine2::~WebRtcVideoEngine2";
560}
561
562void WebRtcVideoEngine2::SetCallFactory(WebRtcCallFactory* call_factory) {
563  DCHECK(!initialized_);
564  call_factory_ = call_factory;
565}
566
567void WebRtcVideoEngine2::Init() {
568  LOG(LS_INFO) << "WebRtcVideoEngine2::Init";
569  initialized_ = true;
570}
571
572int WebRtcVideoEngine2::GetCapabilities() { return VIDEO_RECV | VIDEO_SEND; }
573
574bool WebRtcVideoEngine2::SetDefaultEncoderConfig(
575    const VideoEncoderConfig& config) {
576  const VideoCodec& codec = config.max_codec;
577  bool supports_codec = false;
578  for (size_t i = 0; i < video_codecs_.size(); ++i) {
579    if (CodecNamesEq(video_codecs_[i].name, codec.name)) {
580      video_codecs_[i].width = codec.width;
581      video_codecs_[i].height = codec.height;
582      video_codecs_[i].framerate = codec.framerate;
583      supports_codec = true;
584      break;
585    }
586  }
587
588  if (!supports_codec) {
589    LOG(LS_ERROR) << "SetDefaultEncoderConfig, codec not supported: "
590                  << codec.ToString();
591    return false;
592  }
593
594  return true;
595}
596
597WebRtcVideoChannel2* WebRtcVideoEngine2::CreateChannel(
598    const VideoOptions& options,
599    VoiceMediaChannel* voice_channel) {
600  DCHECK(initialized_);
601  LOG(LS_INFO) << "CreateChannel: "
602               << (voice_channel != NULL ? "With" : "Without")
603               << " voice channel. Options: " << options.ToString();
604  WebRtcVideoChannel2* channel =
605      new WebRtcVideoChannel2(call_factory_, voice_engine_,
606          static_cast<WebRtcVoiceMediaChannel*>(voice_channel), options,
607          external_encoder_factory_, external_decoder_factory_);
608  if (!channel->Init()) {
609    delete channel;
610    return NULL;
611  }
612  channel->SetRecvCodecs(video_codecs_);
613  return channel;
614}
615
616const std::vector<VideoCodec>& WebRtcVideoEngine2::codecs() const {
617  return video_codecs_;
618}
619
620const std::vector<RtpHeaderExtension>&
621WebRtcVideoEngine2::rtp_header_extensions() const {
622  return rtp_header_extensions_;
623}
624
625void WebRtcVideoEngine2::SetLogging(int min_sev, const char* filter) {
626  // TODO(pbos): Set up logging.
627  LOG(LS_VERBOSE) << "SetLogging: " << min_sev << '"' << filter << '"';
628  // if min_sev == -1, we keep the current log level.
629  if (min_sev < 0) {
630    DCHECK(min_sev == -1);
631    return;
632  }
633}
634
635void WebRtcVideoEngine2::SetExternalDecoderFactory(
636    WebRtcVideoDecoderFactory* decoder_factory) {
637  DCHECK(!initialized_);
638  external_decoder_factory_ = decoder_factory;
639}
640
641void WebRtcVideoEngine2::SetExternalEncoderFactory(
642    WebRtcVideoEncoderFactory* encoder_factory) {
643  DCHECK(!initialized_);
644  if (external_encoder_factory_ == encoder_factory)
645    return;
646
647  // No matter what happens we shouldn't hold on to a stale
648  // WebRtcSimulcastEncoderFactory.
649  simulcast_encoder_factory_.reset();
650
651  if (encoder_factory &&
652      WebRtcSimulcastEncoderFactory::UseSimulcastEncoderFactory(
653          encoder_factory->codecs())) {
654    simulcast_encoder_factory_.reset(
655        new WebRtcSimulcastEncoderFactory(encoder_factory));
656    encoder_factory = simulcast_encoder_factory_.get();
657  }
658  external_encoder_factory_ = encoder_factory;
659
660  video_codecs_ = GetSupportedCodecs();
661}
662
663bool WebRtcVideoEngine2::EnableTimedRender() {
664  // TODO(pbos): Figure out whether this can be removed.
665  return true;
666}
667
668// Checks to see whether we comprehend and could receive a particular codec
669bool WebRtcVideoEngine2::FindCodec(const VideoCodec& in) {
670  // TODO(pbos): Probe encoder factory to figure out that the codec is supported
671  // if supported by the encoder factory. Add a corresponding test that fails
672  // with this code (that doesn't ask the factory).
673  for (size_t j = 0; j < video_codecs_.size(); ++j) {
674    VideoCodec codec(video_codecs_[j].id, video_codecs_[j].name, 0, 0, 0, 0);
675    if (codec.Matches(in)) {
676      return true;
677    }
678  }
679  return false;
680}
681
682// Tells whether the |requested| codec can be transmitted or not. If it can be
683// transmitted |out| is set with the best settings supported. Aspect ratio will
684// be set as close to |current|'s as possible. If not set |requested|'s
685// dimensions will be used for aspect ratio matching.
686bool WebRtcVideoEngine2::CanSendCodec(const VideoCodec& requested,
687                                      const VideoCodec& current,
688                                      VideoCodec* out) {
689  DCHECK(out != NULL);
690
691  if (requested.width != requested.height &&
692      (requested.height == 0 || requested.width == 0)) {
693    // 0xn and nx0 are invalid resolutions.
694    return false;
695  }
696
697  VideoCodec matching_codec;
698  if (!FindFirstMatchingCodec(video_codecs_, requested, &matching_codec)) {
699    // Codec not supported.
700    return false;
701  }
702
703  out->id = requested.id;
704  out->name = requested.name;
705  out->preference = requested.preference;
706  out->params = requested.params;
707  out->framerate = std::min(requested.framerate, matching_codec.framerate);
708  out->params = requested.params;
709  out->feedback_params = requested.feedback_params;
710  out->width = requested.width;
711  out->height = requested.height;
712  if (requested.width == 0 && requested.height == 0) {
713    return true;
714  }
715
716  while (out->width > matching_codec.width) {
717    out->width /= 2;
718    out->height /= 2;
719  }
720
721  return out->width > 0 && out->height > 0;
722}
723
724// Ignore spammy trace messages, mostly from the stats API when we haven't
725// gotten RTCP info yet from the remote side.
726bool WebRtcVideoEngine2::ShouldIgnoreTrace(const std::string& trace) {
727  static const char* const kTracesToIgnore[] = {NULL};
728  for (const char* const* p = kTracesToIgnore; *p; ++p) {
729    if (trace.find(*p) == 0) {
730      return true;
731    }
732  }
733  return false;
734}
735
736std::vector<VideoCodec> WebRtcVideoEngine2::GetSupportedCodecs() const {
737  std::vector<VideoCodec> supported_codecs = DefaultVideoCodecList();
738
739  if (external_encoder_factory_ == NULL) {
740    return supported_codecs;
741  }
742
743  const std::vector<WebRtcVideoEncoderFactory::VideoCodec>& codecs =
744      external_encoder_factory_->codecs();
745  for (size_t i = 0; i < codecs.size(); ++i) {
746    // Don't add internally-supported codecs twice.
747    if (CodecIsInternallySupported(codecs[i].name)) {
748      continue;
749    }
750
751    // External video encoders are given payloads 120-127. This also means that
752    // we only support up to 8 external payload types.
753    const int kExternalVideoPayloadTypeBase = 120;
754    size_t payload_type = kExternalVideoPayloadTypeBase + i;
755    DCHECK(payload_type < 128);
756    VideoCodec codec(static_cast<int>(payload_type),
757                     codecs[i].name,
758                     codecs[i].max_width,
759                     codecs[i].max_height,
760                     codecs[i].max_fps,
761                     0);
762
763    AddDefaultFeedbackParams(&codec);
764    supported_codecs.push_back(codec);
765  }
766  return supported_codecs;
767}
768
769WebRtcVideoChannel2::WebRtcVideoChannel2(
770    WebRtcCallFactory* call_factory,
771    WebRtcVoiceEngine* voice_engine,
772    WebRtcVoiceMediaChannel* voice_channel,
773    const VideoOptions& options,
774    WebRtcVideoEncoderFactory* external_encoder_factory,
775    WebRtcVideoDecoderFactory* external_decoder_factory)
776    : unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
777      voice_channel_(voice_channel),
778      voice_channel_id_(voice_channel ? voice_channel->voe_channel() : -1),
779      external_encoder_factory_(external_encoder_factory),
780      external_decoder_factory_(external_decoder_factory) {
781  DCHECK(thread_checker_.CalledOnValidThread());
782  SetDefaultOptions();
783  options_.SetAll(options);
784  options_.cpu_overuse_detection.Get(&signal_cpu_adaptation_);
785  webrtc::Call::Config config(this);
786  config.overuse_callback = this;
787  if (voice_engine != NULL) {
788    config.voice_engine = voice_engine->voe()->engine();
789  }
790  config.bitrate_config.min_bitrate_bps = kMinBandwidthBps;
791  config.bitrate_config.start_bitrate_bps = kStartBandwidthBps;
792  config.bitrate_config.max_bitrate_bps = kMaxBandwidthBps;
793  call_.reset(call_factory->CreateCall(config));
794  if (voice_channel_) {
795    voice_channel_->SetCall(call_.get());
796  }
797  rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc;
798  sending_ = false;
799  default_send_ssrc_ = 0;
800}
801
802void WebRtcVideoChannel2::SetDefaultOptions() {
803  options_.cpu_overuse_detection.Set(true);
804  options_.dscp.Set(false);
805  options_.suspend_below_min_bitrate.Set(false);
806  options_.video_noise_reduction.Set(true);
807  options_.screencast_min_bitrate.Set(0);
808}
809
810WebRtcVideoChannel2::~WebRtcVideoChannel2() {
811  DetachVoiceChannel();
812  for (auto& kv : send_streams_)
813    delete kv.second;
814  for (auto& kv : receive_streams_)
815    delete kv.second;
816}
817
818bool WebRtcVideoChannel2::Init() { return true; }
819
820void WebRtcVideoChannel2::DetachVoiceChannel() {
821  DCHECK(thread_checker_.CalledOnValidThread());
822  if (voice_channel_) {
823    voice_channel_->SetCall(nullptr);
824    voice_channel_ = nullptr;
825  }
826}
827
828bool WebRtcVideoChannel2::CodecIsExternallySupported(
829    const std::string& name) const {
830  if (external_encoder_factory_ == NULL) {
831    return false;
832  }
833
834  const std::vector<WebRtcVideoEncoderFactory::VideoCodec> external_codecs =
835      external_encoder_factory_->codecs();
836  for (size_t c = 0; c < external_codecs.size(); ++c) {
837    if (CodecNamesEq(name, external_codecs[c].name)) {
838      return true;
839    }
840  }
841  return false;
842}
843
844std::vector<WebRtcVideoChannel2::VideoCodecSettings>
845WebRtcVideoChannel2::FilterSupportedCodecs(
846    const std::vector<WebRtcVideoChannel2::VideoCodecSettings>& mapped_codecs)
847    const {
848  std::vector<VideoCodecSettings> supported_codecs;
849  for (size_t i = 0; i < mapped_codecs.size(); ++i) {
850    const VideoCodecSettings& codec = mapped_codecs[i];
851    if (CodecIsInternallySupported(codec.codec.name) ||
852        CodecIsExternallySupported(codec.codec.name)) {
853      supported_codecs.push_back(codec);
854    }
855  }
856  return supported_codecs;
857}
858
859bool WebRtcVideoChannel2::ReceiveCodecsHaveChanged(
860    std::vector<VideoCodecSettings> before,
861    std::vector<VideoCodecSettings> after) {
862  if (before.size() != after.size()) {
863    return true;
864  }
865  // The receive codec order doesn't matter, so we sort the codecs before
866  // comparing. This is necessary because currently the
867  // only way to change the send codec is to munge SDP, which causes
868  // the receive codec list to change order, which causes the streams
869  // to be recreates which causes a "blink" of black video.  In order
870  // to support munging the SDP in this way without recreating receive
871  // streams, we ignore the order of the received codecs so that
872  // changing the order doesn't cause this "blink".
873  auto comparison =
874      [](const VideoCodecSettings& codec1, const VideoCodecSettings& codec2) {
875        return codec1.codec.id > codec2.codec.id;
876      };
877  std::sort(before.begin(), before.end(), comparison);
878  std::sort(after.begin(), after.end(), comparison);
879  for (size_t i = 0; i < before.size(); ++i) {
880    // For the same reason that we sort the codecs, we also ignore the
881    // preference.  We don't want a preference change on the receive
882    // side to cause recreation of the stream.
883    before[i].codec.preference = 0;
884    after[i].codec.preference = 0;
885    if (before[i] != after[i]) {
886      return true;
887    }
888  }
889  return false;
890}
891
892bool WebRtcVideoChannel2::SetSendParameters(const VideoSendParameters& params) {
893  // TODO(pbos): Refactor this to only recreate the send streams once
894  // instead of 4 times.
895  return (SetSendCodecs(params.codecs) &&
896          SetSendRtpHeaderExtensions(params.extensions) &&
897          SetMaxSendBandwidth(params.max_bandwidth_bps) &&
898          SetOptions(params.options));
899}
900
901bool WebRtcVideoChannel2::SetRecvParameters(const VideoRecvParameters& params) {
902  // TODO(pbos): Refactor this to only recreate the recv streams once
903  // instead of twice.
904  return (SetRecvCodecs(params.codecs) &&
905          SetRecvRtpHeaderExtensions(params.extensions));
906}
907
908std::string WebRtcVideoChannel2::CodecSettingsVectorToString(
909    const std::vector<VideoCodecSettings>& codecs) {
910  std::stringstream out;
911  out << '{';
912  for (size_t i = 0; i < codecs.size(); ++i) {
913    out << codecs[i].codec.ToString();
914    if (i != codecs.size() - 1) {
915      out << ", ";
916    }
917  }
918  out << '}';
919  return out.str();
920}
921
922bool WebRtcVideoChannel2::SetRecvCodecs(const std::vector<VideoCodec>& codecs) {
923  TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRecvCodecs");
924  LOG(LS_INFO) << "SetRecvCodecs: " << CodecVectorToString(codecs);
925  if (!ValidateCodecFormats(codecs)) {
926    return false;
927  }
928
929  const std::vector<VideoCodecSettings> mapped_codecs = MapCodecs(codecs);
930  if (mapped_codecs.empty()) {
931    LOG(LS_ERROR) << "SetRecvCodecs called without any video codecs.";
932    return false;
933  }
934
935  std::vector<VideoCodecSettings> supported_codecs =
936      FilterSupportedCodecs(mapped_codecs);
937
938  if (mapped_codecs.size() != supported_codecs.size()) {
939    LOG(LS_ERROR) << "SetRecvCodecs called with unsupported video codecs.";
940    return false;
941  }
942
943  // Prevent reconfiguration when setting identical receive codecs.
944  if (!ReceiveCodecsHaveChanged(recv_codecs_, supported_codecs)) {
945    LOG(LS_INFO)
946        << "Ignoring call to SetRecvCodecs because codecs haven't changed.";
947    return true;
948  }
949
950  LOG(LS_INFO) << "Changing recv codecs from "
951               << CodecSettingsVectorToString(recv_codecs_) << " to "
952               << CodecSettingsVectorToString(supported_codecs);
953  recv_codecs_ = supported_codecs;
954
955  rtc::CritScope stream_lock(&stream_crit_);
956  for (std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
957           receive_streams_.begin();
958       it != receive_streams_.end();
959       ++it) {
960    it->second->SetRecvCodecs(recv_codecs_);
961  }
962
963  return true;
964}
965
966bool WebRtcVideoChannel2::SetSendCodecs(const std::vector<VideoCodec>& codecs) {
967  TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetSendCodecs");
968  LOG(LS_INFO) << "SetSendCodecs: " << CodecVectorToString(codecs);
969  if (!ValidateCodecFormats(codecs)) {
970    return false;
971  }
972
973  const std::vector<VideoCodecSettings> supported_codecs =
974      FilterSupportedCodecs(MapCodecs(codecs));
975
976  if (supported_codecs.empty()) {
977    LOG(LS_ERROR) << "No video codecs supported.";
978    return false;
979  }
980
981  LOG(LS_INFO) << "Using codec: " << supported_codecs.front().codec.ToString();
982
983  VideoCodecSettings old_codec;
984  if (send_codec_.Get(&old_codec) && supported_codecs.front() == old_codec) {
985    LOG(LS_INFO) << "Ignore call to SetSendCodecs because first supported "
986                    "codec hasn't changed.";
987    // Using same codec, avoid reconfiguring.
988    return true;
989  }
990
991  send_codec_.Set(supported_codecs.front());
992
993  rtc::CritScope stream_lock(&stream_crit_);
994  LOG(LS_INFO) << "Change the send codec because SetSendCodecs has a different "
995                  "first supported codec.";
996  for (auto& kv : send_streams_) {
997    DCHECK(kv.second != nullptr);
998    kv.second->SetCodec(supported_codecs.front());
999  }
1000  LOG(LS_INFO) << "SetNackAndRemb on all the receive streams because the send "
1001                  "codec has changed.";
1002  for (auto& kv : receive_streams_) {
1003    DCHECK(kv.second != nullptr);
1004    kv.second->SetNackAndRemb(HasNack(supported_codecs.front().codec),
1005                              HasRemb(supported_codecs.front().codec));
1006  }
1007
1008  // TODO(holmer): Changing the codec parameters shouldn't necessarily mean that
1009  // we change the min/max of bandwidth estimation. Reevaluate this.
1010  VideoCodec codec = supported_codecs.front().codec;
1011  int bitrate_kbps;
1012  if (codec.GetParam(kCodecParamMinBitrate, &bitrate_kbps) &&
1013      bitrate_kbps > 0) {
1014    bitrate_config_.min_bitrate_bps = bitrate_kbps * 1000;
1015  } else {
1016    bitrate_config_.min_bitrate_bps = 0;
1017  }
1018  if (codec.GetParam(kCodecParamStartBitrate, &bitrate_kbps) &&
1019      bitrate_kbps > 0) {
1020    bitrate_config_.start_bitrate_bps = bitrate_kbps * 1000;
1021  } else {
1022    // Do not reconfigure start bitrate unless it's specified and positive.
1023    bitrate_config_.start_bitrate_bps = -1;
1024  }
1025  if (codec.GetParam(kCodecParamMaxBitrate, &bitrate_kbps) &&
1026      bitrate_kbps > 0) {
1027    bitrate_config_.max_bitrate_bps = bitrate_kbps * 1000;
1028  } else {
1029    bitrate_config_.max_bitrate_bps = -1;
1030  }
1031  call_->SetBitrateConfig(bitrate_config_);
1032
1033  return true;
1034}
1035
1036bool WebRtcVideoChannel2::GetSendCodec(VideoCodec* codec) {
1037  VideoCodecSettings codec_settings;
1038  if (!send_codec_.Get(&codec_settings)) {
1039    LOG(LS_VERBOSE) << "GetSendCodec: No send codec set.";
1040    return false;
1041  }
1042  *codec = codec_settings.codec;
1043  return true;
1044}
1045
1046bool WebRtcVideoChannel2::SetSendStreamFormat(uint32 ssrc,
1047                                              const VideoFormat& format) {
1048  LOG(LS_VERBOSE) << "SetSendStreamFormat:" << ssrc << " -> "
1049                  << format.ToString();
1050  rtc::CritScope stream_lock(&stream_crit_);
1051  if (send_streams_.find(ssrc) == send_streams_.end()) {
1052    return false;
1053  }
1054  return send_streams_[ssrc]->SetVideoFormat(format);
1055}
1056
1057bool WebRtcVideoChannel2::SetRender(bool render) {
1058  // TODO(pbos): Implement. Or refactor away as it shouldn't be needed.
1059  LOG(LS_VERBOSE) << "SetRender: " << (render ? "true" : "false");
1060  return true;
1061}
1062
1063bool WebRtcVideoChannel2::SetSend(bool send) {
1064  LOG(LS_VERBOSE) << "SetSend: " << (send ? "true" : "false");
1065  if (send && !send_codec_.IsSet()) {
1066    LOG(LS_ERROR) << "SetSend(true) called before setting codec.";
1067    return false;
1068  }
1069  if (send) {
1070    StartAllSendStreams();
1071  } else {
1072    StopAllSendStreams();
1073  }
1074  sending_ = send;
1075  return true;
1076}
1077
1078bool WebRtcVideoChannel2::ValidateSendSsrcAvailability(
1079    const StreamParams& sp) const {
1080  for (uint32_t ssrc: sp.ssrcs) {
1081    if (send_ssrcs_.find(ssrc) != send_ssrcs_.end()) {
1082      LOG(LS_ERROR) << "Send stream with SSRC '" << ssrc << "' already exists.";
1083      return false;
1084    }
1085  }
1086  return true;
1087}
1088
1089bool WebRtcVideoChannel2::ValidateReceiveSsrcAvailability(
1090    const StreamParams& sp) const {
1091  for (uint32_t ssrc: sp.ssrcs) {
1092    if (receive_ssrcs_.find(ssrc) != receive_ssrcs_.end()) {
1093      LOG(LS_ERROR) << "Receive stream with SSRC '" << ssrc
1094                    << "' already exists.";
1095      return false;
1096    }
1097  }
1098  return true;
1099}
1100
1101bool WebRtcVideoChannel2::AddSendStream(const StreamParams& sp) {
1102  LOG(LS_INFO) << "AddSendStream: " << sp.ToString();
1103  if (!ValidateStreamParams(sp))
1104    return false;
1105
1106  rtc::CritScope stream_lock(&stream_crit_);
1107
1108  if (!ValidateSendSsrcAvailability(sp))
1109    return false;
1110
1111  for (uint32 used_ssrc : sp.ssrcs)
1112    send_ssrcs_.insert(used_ssrc);
1113
1114  WebRtcVideoSendStream* stream =
1115      new WebRtcVideoSendStream(call_.get(),
1116                                external_encoder_factory_,
1117                                options_,
1118                                bitrate_config_.max_bitrate_bps,
1119                                send_codec_,
1120                                sp,
1121                                send_rtp_extensions_);
1122
1123  uint32 ssrc = sp.first_ssrc();
1124  DCHECK(ssrc != 0);
1125  send_streams_[ssrc] = stream;
1126
1127  if (rtcp_receiver_report_ssrc_ == kDefaultRtcpReceiverReportSsrc) {
1128    rtcp_receiver_report_ssrc_ = ssrc;
1129    LOG(LS_INFO) << "SetLocalSsrc on all the receive streams because we added "
1130                    "a send stream.";
1131    for (auto& kv : receive_streams_)
1132      kv.second->SetLocalSsrc(ssrc);
1133  }
1134  if (default_send_ssrc_ == 0) {
1135    default_send_ssrc_ = ssrc;
1136  }
1137  if (sending_) {
1138    stream->Start();
1139  }
1140
1141  return true;
1142}
1143
1144bool WebRtcVideoChannel2::RemoveSendStream(uint32 ssrc) {
1145  LOG(LS_INFO) << "RemoveSendStream: " << ssrc;
1146
1147  if (ssrc == 0) {
1148    if (default_send_ssrc_ == 0) {
1149      LOG(LS_ERROR) << "No default send stream active.";
1150      return false;
1151    }
1152
1153    LOG(LS_VERBOSE) << "Removing default stream: " << default_send_ssrc_;
1154    ssrc = default_send_ssrc_;
1155  }
1156
1157  WebRtcVideoSendStream* removed_stream;
1158  {
1159    rtc::CritScope stream_lock(&stream_crit_);
1160    std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1161        send_streams_.find(ssrc);
1162    if (it == send_streams_.end()) {
1163      return false;
1164    }
1165
1166    for (uint32 old_ssrc : it->second->GetSsrcs())
1167      send_ssrcs_.erase(old_ssrc);
1168
1169    removed_stream = it->second;
1170    send_streams_.erase(it);
1171  }
1172
1173  delete removed_stream;
1174
1175  if (ssrc == default_send_ssrc_) {
1176    default_send_ssrc_ = 0;
1177  }
1178
1179  return true;
1180}
1181
1182void WebRtcVideoChannel2::DeleteReceiveStream(
1183    WebRtcVideoChannel2::WebRtcVideoReceiveStream* stream) {
1184  for (uint32 old_ssrc : stream->GetSsrcs())
1185    receive_ssrcs_.erase(old_ssrc);
1186  delete stream;
1187}
1188
1189bool WebRtcVideoChannel2::AddRecvStream(const StreamParams& sp) {
1190  return AddRecvStream(sp, false);
1191}
1192
1193bool WebRtcVideoChannel2::AddRecvStream(const StreamParams& sp,
1194                                        bool default_stream) {
1195  DCHECK(thread_checker_.CalledOnValidThread());
1196
1197  LOG(LS_INFO) << "AddRecvStream" << (default_stream ? " (default stream)" : "")
1198               << ": " << sp.ToString();
1199  if (!ValidateStreamParams(sp))
1200    return false;
1201
1202  uint32 ssrc = sp.first_ssrc();
1203  DCHECK(ssrc != 0);  // TODO(pbos): Is this ever valid?
1204
1205  rtc::CritScope stream_lock(&stream_crit_);
1206  // Remove running stream if this was a default stream.
1207  auto prev_stream = receive_streams_.find(ssrc);
1208  if (prev_stream != receive_streams_.end()) {
1209    if (default_stream || !prev_stream->second->IsDefaultStream()) {
1210      LOG(LS_ERROR) << "Receive stream for SSRC '" << ssrc
1211                    << "' already exists.";
1212      return false;
1213    }
1214    DeleteReceiveStream(prev_stream->second);
1215    receive_streams_.erase(prev_stream);
1216  }
1217
1218  if (!ValidateReceiveSsrcAvailability(sp))
1219    return false;
1220
1221  for (uint32 used_ssrc : sp.ssrcs)
1222    receive_ssrcs_.insert(used_ssrc);
1223
1224  webrtc::VideoReceiveStream::Config config;
1225  ConfigureReceiverRtp(&config, sp);
1226
1227  // Set up A/V sync group based on sync label.
1228  config.sync_group = sp.sync_label;
1229
1230  config.rtp.remb = false;
1231  VideoCodecSettings send_codec;
1232  if (send_codec_.Get(&send_codec)) {
1233    config.rtp.remb = HasRemb(send_codec.codec);
1234  }
1235
1236  receive_streams_[ssrc] = new WebRtcVideoReceiveStream(
1237      call_.get(), sp, external_decoder_factory_, default_stream, config,
1238      recv_codecs_);
1239
1240  return true;
1241}
1242
1243void WebRtcVideoChannel2::ConfigureReceiverRtp(
1244    webrtc::VideoReceiveStream::Config* config,
1245    const StreamParams& sp) const {
1246  uint32 ssrc = sp.first_ssrc();
1247
1248  config->rtp.remote_ssrc = ssrc;
1249  config->rtp.local_ssrc = rtcp_receiver_report_ssrc_;
1250
1251  config->rtp.extensions = recv_rtp_extensions_;
1252
1253  // TODO(pbos): This protection is against setting the same local ssrc as
1254  // remote which is not permitted by the lower-level API. RTCP requires a
1255  // corresponding sender SSRC. Figure out what to do when we don't have
1256  // (receive-only) or know a good local SSRC.
1257  if (config->rtp.remote_ssrc == config->rtp.local_ssrc) {
1258    if (config->rtp.local_ssrc != kDefaultRtcpReceiverReportSsrc) {
1259      config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc;
1260    } else {
1261      config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc + 1;
1262    }
1263  }
1264
1265  for (size_t i = 0; i < recv_codecs_.size(); ++i) {
1266    MergeFecConfig(recv_codecs_[i].fec, &config->rtp.fec);
1267  }
1268
1269  for (size_t i = 0; i < recv_codecs_.size(); ++i) {
1270    uint32 rtx_ssrc;
1271    if (recv_codecs_[i].rtx_payload_type != -1 &&
1272        sp.GetFidSsrc(ssrc, &rtx_ssrc)) {
1273      webrtc::VideoReceiveStream::Config::Rtp::Rtx& rtx =
1274          config->rtp.rtx[recv_codecs_[i].codec.id];
1275      rtx.ssrc = rtx_ssrc;
1276      rtx.payload_type = recv_codecs_[i].rtx_payload_type;
1277    }
1278  }
1279}
1280
1281bool WebRtcVideoChannel2::RemoveRecvStream(uint32 ssrc) {
1282  LOG(LS_INFO) << "RemoveRecvStream: " << ssrc;
1283  if (ssrc == 0) {
1284    LOG(LS_ERROR) << "RemoveRecvStream with 0 ssrc is not supported.";
1285    return false;
1286  }
1287
1288  rtc::CritScope stream_lock(&stream_crit_);
1289  std::map<uint32, WebRtcVideoReceiveStream*>::iterator stream =
1290      receive_streams_.find(ssrc);
1291  if (stream == receive_streams_.end()) {
1292    LOG(LS_ERROR) << "Stream not found for ssrc: " << ssrc;
1293    return false;
1294  }
1295  DeleteReceiveStream(stream->second);
1296  receive_streams_.erase(stream);
1297
1298  return true;
1299}
1300
1301bool WebRtcVideoChannel2::SetRenderer(uint32 ssrc, VideoRenderer* renderer) {
1302  LOG(LS_INFO) << "SetRenderer: ssrc:" << ssrc << " "
1303               << (renderer ? "(ptr)" : "NULL");
1304  if (ssrc == 0) {
1305    default_unsignalled_ssrc_handler_.SetDefaultRenderer(this, renderer);
1306    return true;
1307  }
1308
1309  rtc::CritScope stream_lock(&stream_crit_);
1310  std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
1311      receive_streams_.find(ssrc);
1312  if (it == receive_streams_.end()) {
1313    return false;
1314  }
1315
1316  it->second->SetRenderer(renderer);
1317  return true;
1318}
1319
1320bool WebRtcVideoChannel2::GetRenderer(uint32 ssrc, VideoRenderer** renderer) {
1321  if (ssrc == 0) {
1322    *renderer = default_unsignalled_ssrc_handler_.GetDefaultRenderer();
1323    return *renderer != NULL;
1324  }
1325
1326  rtc::CritScope stream_lock(&stream_crit_);
1327  std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
1328      receive_streams_.find(ssrc);
1329  if (it == receive_streams_.end()) {
1330    return false;
1331  }
1332  *renderer = it->second->GetRenderer();
1333  return true;
1334}
1335
1336bool WebRtcVideoChannel2::GetStats(VideoMediaInfo* info) {
1337  info->Clear();
1338  FillSenderStats(info);
1339  FillReceiverStats(info);
1340  webrtc::Call::Stats stats = call_->GetStats();
1341  FillBandwidthEstimationStats(stats, info);
1342  if (stats.rtt_ms != -1) {
1343    for (size_t i = 0; i < info->senders.size(); ++i) {
1344      info->senders[i].rtt_ms = stats.rtt_ms;
1345    }
1346  }
1347  return true;
1348}
1349
1350void WebRtcVideoChannel2::FillSenderStats(VideoMediaInfo* video_media_info) {
1351  rtc::CritScope stream_lock(&stream_crit_);
1352  for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1353           send_streams_.begin();
1354       it != send_streams_.end();
1355       ++it) {
1356    video_media_info->senders.push_back(it->second->GetVideoSenderInfo());
1357  }
1358}
1359
1360void WebRtcVideoChannel2::FillReceiverStats(VideoMediaInfo* video_media_info) {
1361  rtc::CritScope stream_lock(&stream_crit_);
1362  for (std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
1363           receive_streams_.begin();
1364       it != receive_streams_.end();
1365       ++it) {
1366    video_media_info->receivers.push_back(it->second->GetVideoReceiverInfo());
1367  }
1368}
1369
1370void WebRtcVideoChannel2::FillBandwidthEstimationStats(
1371    const webrtc::Call::Stats& stats,
1372    VideoMediaInfo* video_media_info) {
1373  BandwidthEstimationInfo bwe_info;
1374  bwe_info.available_send_bandwidth = stats.send_bandwidth_bps;
1375  bwe_info.available_recv_bandwidth = stats.recv_bandwidth_bps;
1376  bwe_info.bucket_delay = stats.pacer_delay_ms;
1377
1378  // Get send stream bitrate stats.
1379  rtc::CritScope stream_lock(&stream_crit_);
1380  for (std::map<uint32, WebRtcVideoSendStream*>::iterator stream =
1381           send_streams_.begin();
1382       stream != send_streams_.end();
1383       ++stream) {
1384    stream->second->FillBandwidthEstimationInfo(&bwe_info);
1385  }
1386  video_media_info->bw_estimations.push_back(bwe_info);
1387}
1388
1389bool WebRtcVideoChannel2::SetCapturer(uint32 ssrc, VideoCapturer* capturer) {
1390  LOG(LS_INFO) << "SetCapturer: " << ssrc << " -> "
1391               << (capturer != NULL ? "(capturer)" : "NULL");
1392  DCHECK(ssrc != 0);
1393  {
1394    rtc::CritScope stream_lock(&stream_crit_);
1395    if (send_streams_.find(ssrc) == send_streams_.end()) {
1396      LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc;
1397      return false;
1398    }
1399    if (!send_streams_[ssrc]->SetCapturer(capturer)) {
1400      return false;
1401    }
1402  }
1403
1404  if (capturer) {
1405    capturer->SetApplyRotation(
1406        !FindHeaderExtension(send_rtp_extensions_,
1407                             kRtpVideoRotationHeaderExtension));
1408  }
1409  {
1410    rtc::CritScope lock(&capturer_crit_);
1411    capturers_[ssrc] = capturer;
1412  }
1413  return true;
1414}
1415
1416bool WebRtcVideoChannel2::SendIntraFrame() {
1417  // TODO(pbos): Implement.
1418  LOG(LS_VERBOSE) << "SendIntraFrame().";
1419  return true;
1420}
1421
1422bool WebRtcVideoChannel2::RequestIntraFrame() {
1423  // TODO(pbos): Implement.
1424  LOG(LS_VERBOSE) << "SendIntraFrame().";
1425  return true;
1426}
1427
1428void WebRtcVideoChannel2::OnPacketReceived(
1429    rtc::Buffer* packet,
1430    const rtc::PacketTime& packet_time) {
1431  const webrtc::PacketReceiver::DeliveryStatus delivery_result =
1432      call_->Receiver()->DeliverPacket(webrtc::MediaType::VIDEO,
1433          reinterpret_cast<const uint8_t*>(packet->data()), packet->size());
1434  switch (delivery_result) {
1435    case webrtc::PacketReceiver::DELIVERY_OK:
1436      return;
1437    case webrtc::PacketReceiver::DELIVERY_PACKET_ERROR:
1438      return;
1439    case webrtc::PacketReceiver::DELIVERY_UNKNOWN_SSRC:
1440      break;
1441  }
1442
1443  uint32 ssrc = 0;
1444  if (!GetRtpSsrc(packet->data(), packet->size(), &ssrc)) {
1445    return;
1446  }
1447
1448  int payload_type = 0;
1449  if (!GetRtpPayloadType(packet->data(), packet->size(), &payload_type)) {
1450    return;
1451  }
1452
1453  // See if this payload_type is registered as one that usually gets its own
1454  // SSRC (RTX) or at least is safe to drop either way (ULPFEC). If it is, and
1455  // it wasn't handled above by DeliverPacket, that means we don't know what
1456  // stream it associates with, and we shouldn't ever create an implicit channel
1457  // for these.
1458  for (auto& codec : recv_codecs_) {
1459    if (payload_type == codec.rtx_payload_type ||
1460        payload_type == codec.fec.red_rtx_payload_type ||
1461        payload_type == codec.fec.ulpfec_payload_type) {
1462      return;
1463    }
1464  }
1465
1466  switch (unsignalled_ssrc_handler_->OnUnsignalledSsrc(this, ssrc)) {
1467    case UnsignalledSsrcHandler::kDropPacket:
1468      return;
1469    case UnsignalledSsrcHandler::kDeliverPacket:
1470      break;
1471  }
1472
1473  if (call_->Receiver()->DeliverPacket(webrtc::MediaType::VIDEO,
1474          reinterpret_cast<const uint8_t*>(packet->data()), packet->size()) !=
1475      webrtc::PacketReceiver::DELIVERY_OK) {
1476    LOG(LS_WARNING) << "Failed to deliver RTP packet on re-delivery.";
1477    return;
1478  }
1479}
1480
1481void WebRtcVideoChannel2::OnRtcpReceived(
1482    rtc::Buffer* packet,
1483    const rtc::PacketTime& packet_time) {
1484  if (call_->Receiver()->DeliverPacket(webrtc::MediaType::VIDEO,
1485          reinterpret_cast<const uint8_t*>(packet->data()), packet->size()) !=
1486      webrtc::PacketReceiver::DELIVERY_OK) {
1487    LOG(LS_WARNING) << "Failed to deliver RTCP packet.";
1488  }
1489}
1490
1491void WebRtcVideoChannel2::OnReadyToSend(bool ready) {
1492  LOG(LS_VERBOSE) << "OnReadyToSend: " << (ready ? "Ready." : "Not ready.");
1493  call_->SignalNetworkState(ready ? webrtc::kNetworkUp : webrtc::kNetworkDown);
1494}
1495
1496bool WebRtcVideoChannel2::MuteStream(uint32 ssrc, bool mute) {
1497  LOG(LS_VERBOSE) << "MuteStream: " << ssrc << " -> "
1498                  << (mute ? "mute" : "unmute");
1499  DCHECK(ssrc != 0);
1500  rtc::CritScope stream_lock(&stream_crit_);
1501  if (send_streams_.find(ssrc) == send_streams_.end()) {
1502    LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc;
1503    return false;
1504  }
1505
1506  send_streams_[ssrc]->MuteStream(mute);
1507  return true;
1508}
1509
1510bool WebRtcVideoChannel2::SetRecvRtpHeaderExtensions(
1511    const std::vector<RtpHeaderExtension>& extensions) {
1512  TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRecvRtpHeaderExtensions");
1513  LOG(LS_INFO) << "SetRecvRtpHeaderExtensions: "
1514               << RtpExtensionsToString(extensions);
1515  if (!ValidateRtpHeaderExtensionIds(extensions))
1516    return false;
1517
1518  std::vector<webrtc::RtpExtension> filtered_extensions =
1519      FilterRtpExtensions(extensions);
1520  if (!RtpExtensionsHaveChanged(recv_rtp_extensions_, filtered_extensions)) {
1521    LOG(LS_INFO) << "Ignoring call to SetRecvRtpHeaderExtensions because "
1522                    "header extensions haven't changed.";
1523    return true;
1524  }
1525
1526  recv_rtp_extensions_ = filtered_extensions;
1527
1528  rtc::CritScope stream_lock(&stream_crit_);
1529  for (std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
1530           receive_streams_.begin();
1531       it != receive_streams_.end();
1532       ++it) {
1533    it->second->SetRtpExtensions(recv_rtp_extensions_);
1534  }
1535  return true;
1536}
1537
1538bool WebRtcVideoChannel2::SetSendRtpHeaderExtensions(
1539    const std::vector<RtpHeaderExtension>& extensions) {
1540  TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetSendRtpHeaderExtensions");
1541  LOG(LS_INFO) << "SetSendRtpHeaderExtensions: "
1542               << RtpExtensionsToString(extensions);
1543  if (!ValidateRtpHeaderExtensionIds(extensions))
1544    return false;
1545
1546  std::vector<webrtc::RtpExtension> filtered_extensions =
1547      FilterRtpExtensions(extensions);
1548  if (!RtpExtensionsHaveChanged(send_rtp_extensions_, filtered_extensions)) {
1549    LOG(LS_INFO) << "Ignoring call to SetSendRtpHeaderExtensions because "
1550                    "header extensions haven't changed.";
1551    return true;
1552  }
1553
1554  send_rtp_extensions_ = filtered_extensions;
1555
1556  const webrtc::RtpExtension* cvo_extension = FindHeaderExtension(
1557      send_rtp_extensions_, kRtpVideoRotationHeaderExtension);
1558
1559  rtc::CritScope stream_lock(&stream_crit_);
1560  for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1561           send_streams_.begin();
1562       it != send_streams_.end();
1563       ++it) {
1564    it->second->SetRtpExtensions(send_rtp_extensions_);
1565    it->second->SetApplyRotation(!cvo_extension);
1566  }
1567  return true;
1568}
1569
1570// Counter-intuitively this method doesn't only set global bitrate caps but also
1571// per-stream codec max bitrates. This is to permit SetMaxSendBitrate (b=AS) to
1572// raise bitrates above the 2000k default bitrate cap.
1573bool WebRtcVideoChannel2::SetMaxSendBandwidth(int max_bitrate_bps) {
1574  // TODO(pbos): Figure out whether b=AS means max bitrate for this
1575  // WebRtcVideoChannel2 (in which case we're good), or per sender (SSRC), in
1576  // which case this should not set a Call::BitrateConfig but rather reconfigure
1577  // all senders.
1578  LOG(LS_INFO) << "SetMaxSendBandwidth: " << max_bitrate_bps << "bps.";
1579  if (max_bitrate_bps == bitrate_config_.max_bitrate_bps)
1580    return true;
1581
1582  if (max_bitrate_bps <= 0) {
1583    // Unsetting max bitrate.
1584    max_bitrate_bps = -1;
1585  }
1586  bitrate_config_.start_bitrate_bps = -1;
1587  bitrate_config_.max_bitrate_bps = max_bitrate_bps;
1588  if (max_bitrate_bps > 0 &&
1589      bitrate_config_.min_bitrate_bps > max_bitrate_bps) {
1590    bitrate_config_.min_bitrate_bps = max_bitrate_bps;
1591  }
1592  call_->SetBitrateConfig(bitrate_config_);
1593  rtc::CritScope stream_lock(&stream_crit_);
1594  for (auto& kv : send_streams_)
1595    kv.second->SetMaxBitrateBps(max_bitrate_bps);
1596  return true;
1597}
1598
1599bool WebRtcVideoChannel2::SetOptions(const VideoOptions& options) {
1600  TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetOptions");
1601  LOG(LS_INFO) << "SetOptions: " << options.ToString();
1602  VideoOptions old_options = options_;
1603  options_.SetAll(options);
1604  if (options_ == old_options) {
1605    // No new options to set.
1606    return true;
1607  }
1608  {
1609    rtc::CritScope lock(&capturer_crit_);
1610    options_.cpu_overuse_detection.Get(&signal_cpu_adaptation_);
1611  }
1612  rtc::DiffServCodePoint dscp = options_.dscp.GetWithDefaultIfUnset(false)
1613                                    ? rtc::DSCP_AF41
1614                                    : rtc::DSCP_DEFAULT;
1615  MediaChannel::SetDscp(dscp);
1616  rtc::CritScope stream_lock(&stream_crit_);
1617  for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1618           send_streams_.begin();
1619       it != send_streams_.end();
1620       ++it) {
1621    it->second->SetOptions(options_);
1622  }
1623  return true;
1624}
1625
1626void WebRtcVideoChannel2::SetInterface(NetworkInterface* iface) {
1627  MediaChannel::SetInterface(iface);
1628  // Set the RTP recv/send buffer to a bigger size
1629  MediaChannel::SetOption(NetworkInterface::ST_RTP,
1630                          rtc::Socket::OPT_RCVBUF,
1631                          kVideoRtpBufferSize);
1632
1633  // Speculative change to increase the outbound socket buffer size.
1634  // In b/15152257, we are seeing a significant number of packets discarded
1635  // due to lack of socket buffer space, although it's not yet clear what the
1636  // ideal value should be.
1637  MediaChannel::SetOption(NetworkInterface::ST_RTP,
1638                          rtc::Socket::OPT_SNDBUF,
1639                          kVideoRtpBufferSize);
1640}
1641
1642void WebRtcVideoChannel2::UpdateAspectRatio(int ratio_w, int ratio_h) {
1643  // TODO(pbos): Implement.
1644}
1645
1646void WebRtcVideoChannel2::OnMessage(rtc::Message* msg) {
1647  // Ignored.
1648}
1649
1650void WebRtcVideoChannel2::OnLoadUpdate(Load load) {
1651  // OnLoadUpdate can not take any locks that are held while creating streams
1652  // etc. Doing so establishes lock-order inversions between the webrtc process
1653  // thread on stream creation and locks such as stream_crit_ while calling out.
1654  rtc::CritScope stream_lock(&capturer_crit_);
1655  if (!signal_cpu_adaptation_)
1656    return;
1657  // Do not adapt resolution for screen content as this will likely result in
1658  // blurry and unreadable text.
1659  for (auto& kv : capturers_) {
1660    if (kv.second != nullptr
1661        && !kv.second->IsScreencast()
1662        && kv.second->video_adapter() != nullptr) {
1663      kv.second->video_adapter()->OnCpuResolutionRequest(
1664          load == kOveruse ? CoordinatedVideoAdapter::DOWNGRADE
1665                           : CoordinatedVideoAdapter::UPGRADE);
1666    }
1667  }
1668}
1669
1670bool WebRtcVideoChannel2::SendRtp(const uint8_t* data, size_t len) {
1671  rtc::Buffer packet(data, len, kMaxRtpPacketLen);
1672  return MediaChannel::SendPacket(&packet);
1673}
1674
1675bool WebRtcVideoChannel2::SendRtcp(const uint8_t* data, size_t len) {
1676  rtc::Buffer packet(data, len, kMaxRtpPacketLen);
1677  return MediaChannel::SendRtcp(&packet);
1678}
1679
1680void WebRtcVideoChannel2::StartAllSendStreams() {
1681  rtc::CritScope stream_lock(&stream_crit_);
1682  for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1683           send_streams_.begin();
1684       it != send_streams_.end();
1685       ++it) {
1686    it->second->Start();
1687  }
1688}
1689
1690void WebRtcVideoChannel2::StopAllSendStreams() {
1691  rtc::CritScope stream_lock(&stream_crit_);
1692  for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
1693           send_streams_.begin();
1694       it != send_streams_.end();
1695       ++it) {
1696    it->second->Stop();
1697  }
1698}
1699
1700WebRtcVideoChannel2::WebRtcVideoSendStream::VideoSendStreamParameters::
1701    VideoSendStreamParameters(
1702        const webrtc::VideoSendStream::Config& config,
1703        const VideoOptions& options,
1704        int max_bitrate_bps,
1705        const Settable<VideoCodecSettings>& codec_settings)
1706    : config(config),
1707      options(options),
1708      max_bitrate_bps(max_bitrate_bps),
1709      codec_settings(codec_settings) {
1710}
1711
1712WebRtcVideoChannel2::WebRtcVideoSendStream::AllocatedEncoder::AllocatedEncoder(
1713    webrtc::VideoEncoder* encoder,
1714    webrtc::VideoCodecType type,
1715    bool external)
1716    : encoder(encoder),
1717      external_encoder(nullptr),
1718      type(type),
1719      external(external) {
1720  if (external) {
1721    external_encoder = encoder;
1722    this->encoder =
1723        new webrtc::VideoEncoderSoftwareFallbackWrapper(type, encoder);
1724  }
1725}
1726
1727WebRtcVideoChannel2::WebRtcVideoSendStream::WebRtcVideoSendStream(
1728    webrtc::Call* call,
1729    WebRtcVideoEncoderFactory* external_encoder_factory,
1730    const VideoOptions& options,
1731    int max_bitrate_bps,
1732    const Settable<VideoCodecSettings>& codec_settings,
1733    const StreamParams& sp,
1734    const std::vector<webrtc::RtpExtension>& rtp_extensions)
1735    : ssrcs_(sp.ssrcs),
1736      ssrc_groups_(sp.ssrc_groups),
1737      call_(call),
1738      external_encoder_factory_(external_encoder_factory),
1739      stream_(NULL),
1740      parameters_(webrtc::VideoSendStream::Config(),
1741                  options,
1742                  max_bitrate_bps,
1743                  codec_settings),
1744      allocated_encoder_(NULL, webrtc::kVideoCodecUnknown, false),
1745      capturer_(NULL),
1746      sending_(false),
1747      muted_(false),
1748      old_adapt_changes_(0),
1749      first_frame_timestamp_ms_(0),
1750      last_frame_timestamp_ms_(0) {
1751  parameters_.config.rtp.max_packet_size = kVideoMtu;
1752
1753  sp.GetPrimarySsrcs(&parameters_.config.rtp.ssrcs);
1754  sp.GetFidSsrcs(parameters_.config.rtp.ssrcs,
1755                 &parameters_.config.rtp.rtx.ssrcs);
1756  parameters_.config.rtp.c_name = sp.cname;
1757  parameters_.config.rtp.extensions = rtp_extensions;
1758
1759  VideoCodecSettings params;
1760  if (codec_settings.Get(&params)) {
1761    SetCodec(params);
1762  }
1763}
1764
1765WebRtcVideoChannel2::WebRtcVideoSendStream::~WebRtcVideoSendStream() {
1766  DisconnectCapturer();
1767  if (stream_ != NULL) {
1768    call_->DestroyVideoSendStream(stream_);
1769  }
1770  DestroyVideoEncoder(&allocated_encoder_);
1771}
1772
1773static void CreateBlackFrame(webrtc::VideoFrame* video_frame,
1774                             int width,
1775                             int height) {
1776  video_frame->CreateEmptyFrame(width, height, width, (width + 1) / 2,
1777                                (width + 1) / 2);
1778  memset(video_frame->buffer(webrtc::kYPlane), 16,
1779         video_frame->allocated_size(webrtc::kYPlane));
1780  memset(video_frame->buffer(webrtc::kUPlane), 128,
1781         video_frame->allocated_size(webrtc::kUPlane));
1782  memset(video_frame->buffer(webrtc::kVPlane), 128,
1783         video_frame->allocated_size(webrtc::kVPlane));
1784}
1785
1786void WebRtcVideoChannel2::WebRtcVideoSendStream::InputFrame(
1787    VideoCapturer* capturer,
1788    const VideoFrame* frame) {
1789  TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::InputFrame");
1790  webrtc::VideoFrame video_frame(frame->GetVideoFrameBuffer(), 0, 0,
1791                                 frame->GetVideoRotation());
1792  rtc::CritScope cs(&lock_);
1793  if (stream_ == NULL) {
1794    // Frame input before send codecs are configured, dropping frame.
1795    return;
1796  }
1797
1798  // Not sending, abort early to prevent expensive reconfigurations while
1799  // setting up codecs etc.
1800  if (!sending_)
1801    return;
1802
1803  if (format_.width == 0) {  // Dropping frames.
1804    DCHECK(format_.height == 0);
1805    LOG(LS_VERBOSE) << "VideoFormat 0x0 set, Dropping frame.";
1806    return;
1807  }
1808  if (muted_) {
1809    // Create a black frame to transmit instead.
1810    CreateBlackFrame(&video_frame,
1811                     static_cast<int>(frame->GetWidth()),
1812                     static_cast<int>(frame->GetHeight()));
1813  }
1814
1815  int64_t frame_delta_ms = frame->GetTimeStamp() / rtc::kNumNanosecsPerMillisec;
1816  // frame->GetTimeStamp() is essentially a delta, align to webrtc time
1817  if (first_frame_timestamp_ms_ == 0) {
1818    first_frame_timestamp_ms_ = rtc::Time() - frame_delta_ms;
1819  }
1820
1821  last_frame_timestamp_ms_ = first_frame_timestamp_ms_ + frame_delta_ms;
1822  video_frame.set_render_time_ms(last_frame_timestamp_ms_);
1823  // Reconfigure codec if necessary.
1824  SetDimensions(
1825      video_frame.width(), video_frame.height(), capturer->IsScreencast());
1826
1827  LOG(LS_VERBOSE) << "IncomingCapturedFrame: " << video_frame.width() << "x"
1828                  << video_frame.height() << " -> (codec) "
1829                  << parameters_.encoder_config.streams.back().width << "x"
1830                  << parameters_.encoder_config.streams.back().height;
1831  stream_->Input()->IncomingCapturedFrame(video_frame);
1832}
1833
1834bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetCapturer(
1835    VideoCapturer* capturer) {
1836  TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::SetCapturer");
1837  if (!DisconnectCapturer() && capturer == NULL) {
1838    return false;
1839  }
1840
1841  {
1842    rtc::CritScope cs(&lock_);
1843
1844    if (capturer == NULL) {
1845      if (stream_ != NULL) {
1846        LOG(LS_VERBOSE) << "Disabling capturer, sending black frame.";
1847        webrtc::VideoFrame black_frame;
1848
1849        CreateBlackFrame(&black_frame, last_dimensions_.width,
1850                         last_dimensions_.height);
1851
1852        // Force this black frame not to be dropped due to timestamp order
1853        // check. As IncomingCapturedFrame will drop the frame if this frame's
1854        // timestamp is less than or equal to last frame's timestamp, it is
1855        // necessary to give this black frame a larger timestamp than the
1856        // previous one.
1857        last_frame_timestamp_ms_ +=
1858            format_.interval / rtc::kNumNanosecsPerMillisec;
1859        black_frame.set_render_time_ms(last_frame_timestamp_ms_);
1860        stream_->Input()->IncomingCapturedFrame(black_frame);
1861      }
1862
1863      capturer_ = NULL;
1864      return true;
1865    }
1866
1867    capturer_ = capturer;
1868  }
1869  // Lock cannot be held while connecting the capturer to prevent lock-order
1870  // violations.
1871  capturer->SignalVideoFrame.connect(this, &WebRtcVideoSendStream::InputFrame);
1872  return true;
1873}
1874
1875bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetVideoFormat(
1876    const VideoFormat& format) {
1877  if ((format.width == 0 || format.height == 0) &&
1878      format.width != format.height) {
1879    LOG(LS_ERROR) << "Can't set VideoFormat, width or height is zero (but not "
1880                     "both, 0x0 drops frames).";
1881    return false;
1882  }
1883
1884  rtc::CritScope cs(&lock_);
1885  if (format.width == 0 && format.height == 0) {
1886    LOG(LS_INFO)
1887        << "0x0 resolution selected. Captured frames will be dropped for ssrc: "
1888        << parameters_.config.rtp.ssrcs[0] << ".";
1889  } else {
1890    // TODO(pbos): Fix me, this only affects the last stream!
1891    parameters_.encoder_config.streams.back().max_framerate =
1892        VideoFormat::IntervalToFps(format.interval);
1893    SetDimensions(format.width, format.height, false);
1894  }
1895
1896  format_ = format;
1897  return true;
1898}
1899
1900void WebRtcVideoChannel2::WebRtcVideoSendStream::MuteStream(bool mute) {
1901  rtc::CritScope cs(&lock_);
1902  muted_ = mute;
1903}
1904
1905bool WebRtcVideoChannel2::WebRtcVideoSendStream::DisconnectCapturer() {
1906  cricket::VideoCapturer* capturer;
1907  {
1908    rtc::CritScope cs(&lock_);
1909    if (capturer_ == NULL)
1910      return false;
1911
1912    if (capturer_->video_adapter() != nullptr)
1913      old_adapt_changes_ += capturer_->video_adapter()->adaptation_changes();
1914
1915    capturer = capturer_;
1916    capturer_ = NULL;
1917  }
1918  capturer->SignalVideoFrame.disconnect(this);
1919  return true;
1920}
1921
1922const std::vector<uint32>&
1923WebRtcVideoChannel2::WebRtcVideoSendStream::GetSsrcs() const {
1924  return ssrcs_;
1925}
1926
1927void WebRtcVideoChannel2::WebRtcVideoSendStream::SetApplyRotation(
1928    bool apply_rotation) {
1929  rtc::CritScope cs(&lock_);
1930  if (capturer_ == NULL)
1931    return;
1932
1933  capturer_->SetApplyRotation(apply_rotation);
1934}
1935
1936void WebRtcVideoChannel2::WebRtcVideoSendStream::SetOptions(
1937    const VideoOptions& options) {
1938  rtc::CritScope cs(&lock_);
1939  VideoCodecSettings codec_settings;
1940  if (parameters_.codec_settings.Get(&codec_settings)) {
1941    LOG(LS_INFO) << "SetCodecAndOptions because of SetOptions; options="
1942                 << options.ToString();
1943    SetCodecAndOptions(codec_settings, options);
1944  } else {
1945    parameters_.options = options;
1946  }
1947}
1948
1949void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodec(
1950    const VideoCodecSettings& codec_settings) {
1951  rtc::CritScope cs(&lock_);
1952  LOG(LS_INFO) << "SetCodecAndOptions because of SetCodec.";
1953  SetCodecAndOptions(codec_settings, parameters_.options);
1954}
1955
1956webrtc::VideoCodecType CodecTypeFromName(const std::string& name) {
1957  if (CodecNamesEq(name, kVp8CodecName)) {
1958    return webrtc::kVideoCodecVP8;
1959  } else if (CodecNamesEq(name, kVp9CodecName)) {
1960    return webrtc::kVideoCodecVP9;
1961  } else if (CodecNamesEq(name, kH264CodecName)) {
1962    return webrtc::kVideoCodecH264;
1963  }
1964  return webrtc::kVideoCodecUnknown;
1965}
1966
1967WebRtcVideoChannel2::WebRtcVideoSendStream::AllocatedEncoder
1968WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoder(
1969    const VideoCodec& codec) {
1970  webrtc::VideoCodecType type = CodecTypeFromName(codec.name);
1971
1972  // Do not re-create encoders of the same type.
1973  if (type == allocated_encoder_.type && allocated_encoder_.encoder != NULL) {
1974    return allocated_encoder_;
1975  }
1976
1977  if (external_encoder_factory_ != NULL) {
1978    webrtc::VideoEncoder* encoder =
1979        external_encoder_factory_->CreateVideoEncoder(type);
1980    if (encoder != NULL) {
1981      return AllocatedEncoder(encoder, type, true);
1982    }
1983  }
1984
1985  if (type == webrtc::kVideoCodecVP8) {
1986    return AllocatedEncoder(
1987        webrtc::VideoEncoder::Create(webrtc::VideoEncoder::kVp8), type, false);
1988  } else if (type == webrtc::kVideoCodecVP9) {
1989    return AllocatedEncoder(
1990        webrtc::VideoEncoder::Create(webrtc::VideoEncoder::kVp9), type, false);
1991  } else if (type == webrtc::kVideoCodecH264) {
1992    return AllocatedEncoder(
1993        webrtc::VideoEncoder::Create(webrtc::VideoEncoder::kH264), type, false);
1994  }
1995
1996  // This shouldn't happen, we should not be trying to create something we don't
1997  // support.
1998  DCHECK(false);
1999  return AllocatedEncoder(NULL, webrtc::kVideoCodecUnknown, false);
2000}
2001
2002void WebRtcVideoChannel2::WebRtcVideoSendStream::DestroyVideoEncoder(
2003    AllocatedEncoder* encoder) {
2004  if (encoder->external) {
2005    external_encoder_factory_->DestroyVideoEncoder(encoder->external_encoder);
2006  }
2007  delete encoder->encoder;
2008}
2009
2010void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodecAndOptions(
2011    const VideoCodecSettings& codec_settings,
2012    const VideoOptions& options) {
2013  parameters_.encoder_config =
2014      CreateVideoEncoderConfig(last_dimensions_, codec_settings.codec);
2015  if (parameters_.encoder_config.streams.empty())
2016    return;
2017
2018  format_ = VideoFormat(codec_settings.codec.width,
2019                        codec_settings.codec.height,
2020                        VideoFormat::FpsToInterval(30),
2021                        FOURCC_I420);
2022
2023  AllocatedEncoder new_encoder = CreateVideoEncoder(codec_settings.codec);
2024  parameters_.config.encoder_settings.encoder = new_encoder.encoder;
2025  parameters_.config.encoder_settings.payload_name = codec_settings.codec.name;
2026  parameters_.config.encoder_settings.payload_type = codec_settings.codec.id;
2027  parameters_.config.rtp.fec = codec_settings.fec;
2028
2029  // Set RTX payload type if RTX is enabled.
2030  if (!parameters_.config.rtp.rtx.ssrcs.empty()) {
2031    if (codec_settings.rtx_payload_type == -1) {
2032      LOG(LS_WARNING) << "RTX SSRCs configured but there's no configured RTX "
2033                         "payload type. Ignoring.";
2034      parameters_.config.rtp.rtx.ssrcs.clear();
2035    } else {
2036      parameters_.config.rtp.rtx.payload_type = codec_settings.rtx_payload_type;
2037    }
2038  }
2039
2040  parameters_.config.rtp.nack.rtp_history_ms =
2041      HasNack(codec_settings.codec) ? kNackHistoryMs : 0;
2042
2043  options.suspend_below_min_bitrate.Get(
2044      &parameters_.config.suspend_below_min_bitrate);
2045
2046  parameters_.codec_settings.Set(codec_settings);
2047  parameters_.options = options;
2048
2049  LOG(LS_INFO)
2050      << "RecreateWebRtcStream (send) because of SetCodecAndOptions; options="
2051      << options.ToString();
2052  RecreateWebRtcStream();
2053  if (allocated_encoder_.encoder != new_encoder.encoder) {
2054    DestroyVideoEncoder(&allocated_encoder_);
2055    allocated_encoder_ = new_encoder;
2056  }
2057}
2058
2059void WebRtcVideoChannel2::WebRtcVideoSendStream::SetRtpExtensions(
2060    const std::vector<webrtc::RtpExtension>& rtp_extensions) {
2061  rtc::CritScope cs(&lock_);
2062  parameters_.config.rtp.extensions = rtp_extensions;
2063  if (stream_ != nullptr) {
2064    LOG(LS_INFO) << "RecreateWebRtcStream (send) because of SetRtpExtensions";
2065    RecreateWebRtcStream();
2066  }
2067}
2068
2069webrtc::VideoEncoderConfig
2070WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoderConfig(
2071    const Dimensions& dimensions,
2072    const VideoCodec& codec) const {
2073  webrtc::VideoEncoderConfig encoder_config;
2074  if (dimensions.is_screencast) {
2075    int screencast_min_bitrate_kbps;
2076    parameters_.options.screencast_min_bitrate.Get(
2077        &screencast_min_bitrate_kbps);
2078    encoder_config.min_transmit_bitrate_bps =
2079        screencast_min_bitrate_kbps * 1000;
2080    encoder_config.content_type =
2081        webrtc::VideoEncoderConfig::ContentType::kScreen;
2082  } else {
2083    encoder_config.min_transmit_bitrate_bps = 0;
2084    encoder_config.content_type =
2085        webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo;
2086  }
2087
2088  // Restrict dimensions according to codec max.
2089  int width = dimensions.width;
2090  int height = dimensions.height;
2091  if (!dimensions.is_screencast) {
2092    if (codec.width < width)
2093      width = codec.width;
2094    if (codec.height < height)
2095      height = codec.height;
2096  }
2097
2098  VideoCodec clamped_codec = codec;
2099  clamped_codec.width = width;
2100  clamped_codec.height = height;
2101
2102  encoder_config.streams = CreateVideoStreams(
2103      clamped_codec, parameters_.options, parameters_.max_bitrate_bps,
2104      dimensions.is_screencast ? 1 : parameters_.config.rtp.ssrcs.size());
2105
2106  // Conference mode screencast uses 2 temporal layers split at 100kbit.
2107  if (parameters_.options.conference_mode.GetWithDefaultIfUnset(false) &&
2108      dimensions.is_screencast && encoder_config.streams.size() == 1) {
2109    ScreenshareLayerConfig config = ScreenshareLayerConfig::GetDefault();
2110
2111    // For screenshare in conference mode, tl0 and tl1 bitrates are piggybacked
2112    // on the VideoCodec struct as target and max bitrates, respectively.
2113    // See eg. webrtc::VP8EncoderImpl::SetRates().
2114    encoder_config.streams[0].target_bitrate_bps =
2115        config.tl0_bitrate_kbps * 1000;
2116    encoder_config.streams[0].max_bitrate_bps = config.tl1_bitrate_kbps * 1000;
2117    encoder_config.streams[0].temporal_layer_thresholds_bps.clear();
2118    encoder_config.streams[0].temporal_layer_thresholds_bps.push_back(
2119        config.tl0_bitrate_kbps * 1000);
2120  }
2121  return encoder_config;
2122}
2123
2124void WebRtcVideoChannel2::WebRtcVideoSendStream::SetDimensions(
2125    int width,
2126    int height,
2127    bool is_screencast) {
2128  if (last_dimensions_.width == width && last_dimensions_.height == height &&
2129      last_dimensions_.is_screencast == is_screencast) {
2130    // Configured using the same parameters, do not reconfigure.
2131    return;
2132  }
2133  LOG(LS_INFO) << "SetDimensions: " << width << "x" << height
2134               << (is_screencast ? " (screencast)" : " (not screencast)");
2135
2136  last_dimensions_.width = width;
2137  last_dimensions_.height = height;
2138  last_dimensions_.is_screencast = is_screencast;
2139
2140  DCHECK(!parameters_.encoder_config.streams.empty());
2141
2142  VideoCodecSettings codec_settings;
2143  parameters_.codec_settings.Get(&codec_settings);
2144
2145  webrtc::VideoEncoderConfig encoder_config =
2146      CreateVideoEncoderConfig(last_dimensions_, codec_settings.codec);
2147
2148  encoder_config.encoder_specific_settings = ConfigureVideoEncoderSettings(
2149      codec_settings.codec, parameters_.options, is_screencast);
2150
2151  bool stream_reconfigured = stream_->ReconfigureVideoEncoder(encoder_config);
2152
2153  encoder_config.encoder_specific_settings = NULL;
2154
2155  if (!stream_reconfigured) {
2156    LOG(LS_WARNING) << "Failed to reconfigure video encoder for dimensions: "
2157                    << width << "x" << height;
2158    return;
2159  }
2160
2161  parameters_.encoder_config = encoder_config;
2162}
2163
2164void WebRtcVideoChannel2::WebRtcVideoSendStream::Start() {
2165  rtc::CritScope cs(&lock_);
2166  DCHECK(stream_ != NULL);
2167  stream_->Start();
2168  sending_ = true;
2169}
2170
2171void WebRtcVideoChannel2::WebRtcVideoSendStream::Stop() {
2172  rtc::CritScope cs(&lock_);
2173  if (stream_ != NULL) {
2174    stream_->Stop();
2175  }
2176  sending_ = false;
2177}
2178
2179VideoSenderInfo
2180WebRtcVideoChannel2::WebRtcVideoSendStream::GetVideoSenderInfo() {
2181  VideoSenderInfo info;
2182  webrtc::VideoSendStream::Stats stats;
2183  {
2184    rtc::CritScope cs(&lock_);
2185    for (uint32_t ssrc : parameters_.config.rtp.ssrcs)
2186      info.add_ssrc(ssrc);
2187
2188    VideoCodecSettings codec_settings;
2189    if (parameters_.codec_settings.Get(&codec_settings))
2190      info.codec_name = codec_settings.codec.name;
2191    for (size_t i = 0; i < parameters_.encoder_config.streams.size(); ++i) {
2192      if (i == parameters_.encoder_config.streams.size() - 1) {
2193        info.preferred_bitrate +=
2194            parameters_.encoder_config.streams[i].max_bitrate_bps;
2195      } else {
2196        info.preferred_bitrate +=
2197            parameters_.encoder_config.streams[i].target_bitrate_bps;
2198      }
2199    }
2200
2201    if (stream_ == NULL)
2202      return info;
2203
2204    stats = stream_->GetStats();
2205
2206    info.adapt_changes = old_adapt_changes_;
2207    info.adapt_reason = CoordinatedVideoAdapter::ADAPTREASON_NONE;
2208
2209    if (capturer_ != NULL) {
2210      if (!capturer_->IsMuted()) {
2211        VideoFormat last_captured_frame_format;
2212        capturer_->GetStats(&info.adapt_frame_drops, &info.effects_frame_drops,
2213                            &info.capturer_frame_time,
2214                            &last_captured_frame_format);
2215        info.input_frame_width = last_captured_frame_format.width;
2216        info.input_frame_height = last_captured_frame_format.height;
2217      }
2218      if (capturer_->video_adapter() != nullptr) {
2219        info.adapt_changes += capturer_->video_adapter()->adaptation_changes();
2220        info.adapt_reason = capturer_->video_adapter()->adapt_reason();
2221      }
2222    }
2223  }
2224  info.ssrc_groups = ssrc_groups_;
2225  info.framerate_input = stats.input_frame_rate;
2226  info.framerate_sent = stats.encode_frame_rate;
2227  info.avg_encode_ms = stats.avg_encode_time_ms;
2228  info.encode_usage_percent = stats.encode_usage_percent;
2229
2230  info.nominal_bitrate = stats.media_bitrate_bps;
2231
2232  info.send_frame_width = 0;
2233  info.send_frame_height = 0;
2234  for (std::map<uint32_t, webrtc::VideoSendStream::StreamStats>::iterator it =
2235           stats.substreams.begin();
2236       it != stats.substreams.end(); ++it) {
2237    // TODO(pbos): Wire up additional stats, such as padding bytes.
2238    webrtc::VideoSendStream::StreamStats stream_stats = it->second;
2239    info.bytes_sent += stream_stats.rtp_stats.transmitted.payload_bytes +
2240                       stream_stats.rtp_stats.transmitted.header_bytes +
2241                       stream_stats.rtp_stats.transmitted.padding_bytes;
2242    info.packets_sent += stream_stats.rtp_stats.transmitted.packets;
2243    info.packets_lost += stream_stats.rtcp_stats.cumulative_lost;
2244    if (stream_stats.width > info.send_frame_width)
2245      info.send_frame_width = stream_stats.width;
2246    if (stream_stats.height > info.send_frame_height)
2247      info.send_frame_height = stream_stats.height;
2248    info.firs_rcvd += stream_stats.rtcp_packet_type_counts.fir_packets;
2249    info.nacks_rcvd += stream_stats.rtcp_packet_type_counts.nack_packets;
2250    info.plis_rcvd += stream_stats.rtcp_packet_type_counts.pli_packets;
2251  }
2252
2253  if (!stats.substreams.empty()) {
2254    // TODO(pbos): Report fraction lost per SSRC.
2255    webrtc::VideoSendStream::StreamStats first_stream_stats =
2256        stats.substreams.begin()->second;
2257    info.fraction_lost =
2258        static_cast<float>(first_stream_stats.rtcp_stats.fraction_lost) /
2259        (1 << 8);
2260  }
2261
2262  return info;
2263}
2264
2265void WebRtcVideoChannel2::WebRtcVideoSendStream::FillBandwidthEstimationInfo(
2266    BandwidthEstimationInfo* bwe_info) {
2267  rtc::CritScope cs(&lock_);
2268  if (stream_ == NULL) {
2269    return;
2270  }
2271  webrtc::VideoSendStream::Stats stats = stream_->GetStats();
2272  for (std::map<uint32_t, webrtc::VideoSendStream::StreamStats>::iterator it =
2273           stats.substreams.begin();
2274       it != stats.substreams.end(); ++it) {
2275    bwe_info->transmit_bitrate += it->second.total_bitrate_bps;
2276    bwe_info->retransmit_bitrate += it->second.retransmit_bitrate_bps;
2277  }
2278  bwe_info->target_enc_bitrate += stats.target_media_bitrate_bps;
2279  bwe_info->actual_enc_bitrate += stats.media_bitrate_bps;
2280}
2281
2282void WebRtcVideoChannel2::WebRtcVideoSendStream::SetMaxBitrateBps(
2283    int max_bitrate_bps) {
2284  rtc::CritScope cs(&lock_);
2285  parameters_.max_bitrate_bps = max_bitrate_bps;
2286
2287  // No need to reconfigure if the stream hasn't been configured yet.
2288  if (parameters_.encoder_config.streams.empty())
2289    return;
2290
2291  // Force a stream reconfigure to set the new max bitrate.
2292  int width = last_dimensions_.width;
2293  last_dimensions_.width = 0;
2294  SetDimensions(width, last_dimensions_.height, last_dimensions_.is_screencast);
2295}
2296
2297void WebRtcVideoChannel2::WebRtcVideoSendStream::RecreateWebRtcStream() {
2298  if (stream_ != NULL) {
2299    call_->DestroyVideoSendStream(stream_);
2300  }
2301
2302  VideoCodecSettings codec_settings;
2303  parameters_.codec_settings.Get(&codec_settings);
2304  parameters_.encoder_config.encoder_specific_settings =
2305      ConfigureVideoEncoderSettings(
2306          codec_settings.codec, parameters_.options,
2307          parameters_.encoder_config.content_type ==
2308              webrtc::VideoEncoderConfig::ContentType::kScreen);
2309
2310  webrtc::VideoSendStream::Config config = parameters_.config;
2311  if (!config.rtp.rtx.ssrcs.empty() && config.rtp.rtx.payload_type == -1) {
2312    LOG(LS_WARNING) << "RTX SSRCs configured but there's no configured RTX "
2313                       "payload type the set codec. Ignoring RTX.";
2314    config.rtp.rtx.ssrcs.clear();
2315  }
2316  stream_ = call_->CreateVideoSendStream(config, parameters_.encoder_config);
2317
2318  parameters_.encoder_config.encoder_specific_settings = NULL;
2319
2320  if (sending_) {
2321    stream_->Start();
2322  }
2323}
2324
2325WebRtcVideoChannel2::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
2326    webrtc::Call* call,
2327    const StreamParams& sp,
2328    WebRtcVideoDecoderFactory* external_decoder_factory,
2329    bool default_stream,
2330    const webrtc::VideoReceiveStream::Config& config,
2331    const std::vector<VideoCodecSettings>& recv_codecs)
2332    : call_(call),
2333      ssrcs_(sp.ssrcs),
2334      ssrc_groups_(sp.ssrc_groups),
2335      stream_(NULL),
2336      default_stream_(default_stream),
2337      config_(config),
2338      external_decoder_factory_(external_decoder_factory),
2339      renderer_(NULL),
2340      last_width_(-1),
2341      last_height_(-1),
2342      first_frame_timestamp_(-1),
2343      estimated_remote_start_ntp_time_ms_(0) {
2344  config_.renderer = this;
2345  // SetRecvCodecs will also reset (start) the VideoReceiveStream.
2346  LOG(LS_INFO) << "SetRecvCodecs (recv) because we are creating the receive "
2347                  "stream for the first time: "
2348               << CodecSettingsVectorToString(recv_codecs);
2349  SetRecvCodecs(recv_codecs);
2350}
2351
2352WebRtcVideoChannel2::WebRtcVideoReceiveStream::AllocatedDecoder::
2353    AllocatedDecoder(webrtc::VideoDecoder* decoder,
2354                     webrtc::VideoCodecType type,
2355                     bool external)
2356    : decoder(decoder),
2357      external_decoder(nullptr),
2358      type(type),
2359      external(external) {
2360  if (external) {
2361    external_decoder = decoder;
2362    this->decoder =
2363        new webrtc::VideoDecoderSoftwareFallbackWrapper(type, external_decoder);
2364  }
2365}
2366
2367WebRtcVideoChannel2::WebRtcVideoReceiveStream::~WebRtcVideoReceiveStream() {
2368  call_->DestroyVideoReceiveStream(stream_);
2369  ClearDecoders(&allocated_decoders_);
2370}
2371
2372const std::vector<uint32>&
2373WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetSsrcs() const {
2374  return ssrcs_;
2375}
2376
2377WebRtcVideoChannel2::WebRtcVideoReceiveStream::AllocatedDecoder
2378WebRtcVideoChannel2::WebRtcVideoReceiveStream::CreateOrReuseVideoDecoder(
2379    std::vector<AllocatedDecoder>* old_decoders,
2380    const VideoCodec& codec) {
2381  webrtc::VideoCodecType type = CodecTypeFromName(codec.name);
2382
2383  for (size_t i = 0; i < old_decoders->size(); ++i) {
2384    if ((*old_decoders)[i].type == type) {
2385      AllocatedDecoder decoder = (*old_decoders)[i];
2386      (*old_decoders)[i] = old_decoders->back();
2387      old_decoders->pop_back();
2388      return decoder;
2389    }
2390  }
2391
2392  if (external_decoder_factory_ != NULL) {
2393    webrtc::VideoDecoder* decoder =
2394        external_decoder_factory_->CreateVideoDecoder(type);
2395    if (decoder != NULL) {
2396      return AllocatedDecoder(decoder, type, true);
2397    }
2398  }
2399
2400  if (type == webrtc::kVideoCodecVP8) {
2401    return AllocatedDecoder(
2402        webrtc::VideoDecoder::Create(webrtc::VideoDecoder::kVp8), type, false);
2403  }
2404
2405  if (type == webrtc::kVideoCodecVP9) {
2406    return AllocatedDecoder(
2407        webrtc::VideoDecoder::Create(webrtc::VideoDecoder::kVp9), type, false);
2408  }
2409
2410  if (type == webrtc::kVideoCodecH264) {
2411    return AllocatedDecoder(
2412        webrtc::VideoDecoder::Create(webrtc::VideoDecoder::kH264), type, false);
2413  }
2414
2415  // This shouldn't happen, we should not be trying to create something we don't
2416  // support.
2417  DCHECK(false);
2418  return AllocatedDecoder(NULL, webrtc::kVideoCodecUnknown, false);
2419}
2420
2421void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRecvCodecs(
2422    const std::vector<VideoCodecSettings>& recv_codecs) {
2423  std::vector<AllocatedDecoder> old_decoders = allocated_decoders_;
2424  allocated_decoders_.clear();
2425  config_.decoders.clear();
2426  for (size_t i = 0; i < recv_codecs.size(); ++i) {
2427    AllocatedDecoder allocated_decoder =
2428        CreateOrReuseVideoDecoder(&old_decoders, recv_codecs[i].codec);
2429    allocated_decoders_.push_back(allocated_decoder);
2430
2431    webrtc::VideoReceiveStream::Decoder decoder;
2432    decoder.decoder = allocated_decoder.decoder;
2433    decoder.payload_type = recv_codecs[i].codec.id;
2434    decoder.payload_name = recv_codecs[i].codec.name;
2435    config_.decoders.push_back(decoder);
2436  }
2437
2438  // TODO(pbos): Reconfigure RTX based on incoming recv_codecs.
2439  config_.rtp.fec = recv_codecs.front().fec;
2440  config_.rtp.nack.rtp_history_ms =
2441      HasNack(recv_codecs.begin()->codec) ? kNackHistoryMs : 0;
2442
2443  ClearDecoders(&old_decoders);
2444  LOG(LS_INFO) << "RecreateWebRtcStream (recv) because of SetRecvCodecs: "
2445               << CodecSettingsVectorToString(recv_codecs);
2446  RecreateWebRtcStream();
2447}
2448
2449void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetLocalSsrc(
2450    uint32_t local_ssrc) {
2451  // TODO(pbos): Consider turning this sanity check into a DCHECK. You should
2452  // not be able to create a sender with the same SSRC as a receiver, but right
2453  // now this can't be done due to unittests depending on receiving what they
2454  // are sending from the same MediaChannel.
2455  if (local_ssrc == config_.rtp.remote_ssrc) {
2456    LOG(LS_INFO) << "Ignoring call to SetLocalSsrc because parameters are "
2457                    "unchanged; local_ssrc=" << local_ssrc;
2458    return;
2459  }
2460
2461  config_.rtp.local_ssrc = local_ssrc;
2462  LOG(LS_INFO)
2463      << "RecreateWebRtcStream (recv) because of SetLocalSsrc; local_ssrc="
2464      << local_ssrc;
2465  RecreateWebRtcStream();
2466}
2467
2468void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetNackAndRemb(
2469    bool nack_enabled, bool remb_enabled) {
2470  int nack_history_ms = nack_enabled ? kNackHistoryMs : 0;
2471  if (config_.rtp.nack.rtp_history_ms == nack_history_ms &&
2472      config_.rtp.remb == remb_enabled) {
2473    LOG(LS_INFO) << "Ignoring call to SetNackAndRemb because parameters are "
2474                    "unchanged; nack=" << nack_enabled
2475                 << ", remb=" << remb_enabled;
2476    return;
2477  }
2478  config_.rtp.remb = remb_enabled;
2479  config_.rtp.nack.rtp_history_ms = nack_history_ms;
2480  LOG(LS_INFO) << "RecreateWebRtcStream (recv) because of SetNackAndRemb; nack="
2481               << nack_enabled << ", remb=" << remb_enabled;
2482  RecreateWebRtcStream();
2483}
2484
2485void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRtpExtensions(
2486    const std::vector<webrtc::RtpExtension>& extensions) {
2487  config_.rtp.extensions = extensions;
2488  LOG(LS_INFO) << "RecreateWebRtcStream (recv) because of SetRtpExtensions";
2489  RecreateWebRtcStream();
2490}
2491
2492void WebRtcVideoChannel2::WebRtcVideoReceiveStream::RecreateWebRtcStream() {
2493  if (stream_ != NULL) {
2494    call_->DestroyVideoReceiveStream(stream_);
2495  }
2496  stream_ = call_->CreateVideoReceiveStream(config_);
2497  stream_->Start();
2498}
2499
2500void WebRtcVideoChannel2::WebRtcVideoReceiveStream::ClearDecoders(
2501    std::vector<AllocatedDecoder>* allocated_decoders) {
2502  for (size_t i = 0; i < allocated_decoders->size(); ++i) {
2503    if ((*allocated_decoders)[i].external) {
2504      external_decoder_factory_->DestroyVideoDecoder(
2505          (*allocated_decoders)[i].external_decoder);
2506    }
2507    delete (*allocated_decoders)[i].decoder;
2508  }
2509  allocated_decoders->clear();
2510}
2511
2512void WebRtcVideoChannel2::WebRtcVideoReceiveStream::RenderFrame(
2513    const webrtc::VideoFrame& frame,
2514    int time_to_render_ms) {
2515  rtc::CritScope crit(&renderer_lock_);
2516
2517  if (first_frame_timestamp_ < 0)
2518    first_frame_timestamp_ = frame.timestamp();
2519  int64_t rtp_time_elapsed_since_first_frame =
2520      (timestamp_wraparound_handler_.Unwrap(frame.timestamp()) -
2521       first_frame_timestamp_);
2522  int64_t elapsed_time_ms = rtp_time_elapsed_since_first_frame /
2523                            (cricket::kVideoCodecClockrate / 1000);
2524  if (frame.ntp_time_ms() > 0)
2525    estimated_remote_start_ntp_time_ms_ = frame.ntp_time_ms() - elapsed_time_ms;
2526
2527  if (renderer_ == NULL) {
2528    LOG(LS_WARNING) << "VideoReceiveStream not connected to a VideoRenderer.";
2529    return;
2530  }
2531
2532  if (frame.width() != last_width_ || frame.height() != last_height_) {
2533    SetSize(frame.width(), frame.height());
2534  }
2535
2536  const WebRtcVideoFrame render_frame(
2537      frame.video_frame_buffer(),
2538      elapsed_time_ms * rtc::kNumNanosecsPerMillisec,
2539      frame.render_time_ms() * rtc::kNumNanosecsPerMillisec, frame.rotation());
2540  renderer_->RenderFrame(&render_frame);
2541}
2542
2543bool WebRtcVideoChannel2::WebRtcVideoReceiveStream::IsTextureSupported() const {
2544  return true;
2545}
2546
2547bool WebRtcVideoChannel2::WebRtcVideoReceiveStream::IsDefaultStream() const {
2548  return default_stream_;
2549}
2550
2551void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRenderer(
2552    cricket::VideoRenderer* renderer) {
2553  rtc::CritScope crit(&renderer_lock_);
2554  renderer_ = renderer;
2555  if (renderer_ != NULL && last_width_ != -1) {
2556    SetSize(last_width_, last_height_);
2557  }
2558}
2559
2560VideoRenderer* WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetRenderer() {
2561  // TODO(pbos): Remove GetRenderer and all uses of it, it's thread-unsafe by
2562  // design.
2563  rtc::CritScope crit(&renderer_lock_);
2564  return renderer_;
2565}
2566
2567void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetSize(int width,
2568                                                            int height) {
2569  rtc::CritScope crit(&renderer_lock_);
2570  if (!renderer_->SetSize(width, height, 0)) {
2571    LOG(LS_ERROR) << "Could not set renderer size.";
2572  }
2573  last_width_ = width;
2574  last_height_ = height;
2575}
2576
2577VideoReceiverInfo
2578WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetVideoReceiverInfo() {
2579  VideoReceiverInfo info;
2580  info.ssrc_groups = ssrc_groups_;
2581  info.add_ssrc(config_.rtp.remote_ssrc);
2582  webrtc::VideoReceiveStream::Stats stats = stream_->GetStats();
2583  info.bytes_rcvd = stats.rtp_stats.transmitted.payload_bytes +
2584                    stats.rtp_stats.transmitted.header_bytes +
2585                    stats.rtp_stats.transmitted.padding_bytes;
2586  info.packets_rcvd = stats.rtp_stats.transmitted.packets;
2587  info.packets_lost = stats.rtcp_stats.cumulative_lost;
2588  info.fraction_lost =
2589      static_cast<float>(stats.rtcp_stats.fraction_lost) / (1 << 8);
2590
2591  info.framerate_rcvd = stats.network_frame_rate;
2592  info.framerate_decoded = stats.decode_frame_rate;
2593  info.framerate_output = stats.render_frame_rate;
2594
2595  {
2596    rtc::CritScope frame_cs(&renderer_lock_);
2597    info.frame_width = last_width_;
2598    info.frame_height = last_height_;
2599    info.capture_start_ntp_time_ms = estimated_remote_start_ntp_time_ms_;
2600  }
2601
2602  info.decode_ms = stats.decode_ms;
2603  info.max_decode_ms = stats.max_decode_ms;
2604  info.current_delay_ms = stats.current_delay_ms;
2605  info.target_delay_ms = stats.target_delay_ms;
2606  info.jitter_buffer_ms = stats.jitter_buffer_ms;
2607  info.min_playout_delay_ms = stats.min_playout_delay_ms;
2608  info.render_delay_ms = stats.render_delay_ms;
2609
2610  info.firs_sent = stats.rtcp_packet_type_counts.fir_packets;
2611  info.plis_sent = stats.rtcp_packet_type_counts.pli_packets;
2612  info.nacks_sent = stats.rtcp_packet_type_counts.nack_packets;
2613
2614  return info;
2615}
2616
2617WebRtcVideoChannel2::VideoCodecSettings::VideoCodecSettings()
2618    : rtx_payload_type(-1) {}
2619
2620bool WebRtcVideoChannel2::VideoCodecSettings::operator==(
2621    const WebRtcVideoChannel2::VideoCodecSettings& other) const {
2622  return codec == other.codec &&
2623         fec.ulpfec_payload_type == other.fec.ulpfec_payload_type &&
2624         fec.red_payload_type == other.fec.red_payload_type &&
2625         fec.red_rtx_payload_type == other.fec.red_rtx_payload_type &&
2626         rtx_payload_type == other.rtx_payload_type;
2627}
2628
2629bool WebRtcVideoChannel2::VideoCodecSettings::operator!=(
2630    const WebRtcVideoChannel2::VideoCodecSettings& other) const {
2631  return !(*this == other);
2632}
2633
2634std::vector<WebRtcVideoChannel2::VideoCodecSettings>
2635WebRtcVideoChannel2::MapCodecs(const std::vector<VideoCodec>& codecs) {
2636  DCHECK(!codecs.empty());
2637
2638  std::vector<VideoCodecSettings> video_codecs;
2639  std::map<int, bool> payload_used;
2640  std::map<int, VideoCodec::CodecType> payload_codec_type;
2641  // |rtx_mapping| maps video payload type to rtx payload type.
2642  std::map<int, int> rtx_mapping;
2643
2644  webrtc::FecConfig fec_settings;
2645
2646  for (size_t i = 0; i < codecs.size(); ++i) {
2647    const VideoCodec& in_codec = codecs[i];
2648    int payload_type = in_codec.id;
2649
2650    if (payload_used[payload_type]) {
2651      LOG(LS_ERROR) << "Payload type already registered: "
2652                    << in_codec.ToString();
2653      return std::vector<VideoCodecSettings>();
2654    }
2655    payload_used[payload_type] = true;
2656    payload_codec_type[payload_type] = in_codec.GetCodecType();
2657
2658    switch (in_codec.GetCodecType()) {
2659      case VideoCodec::CODEC_RED: {
2660        // RED payload type, should not have duplicates.
2661        DCHECK(fec_settings.red_payload_type == -1);
2662        fec_settings.red_payload_type = in_codec.id;
2663        continue;
2664      }
2665
2666      case VideoCodec::CODEC_ULPFEC: {
2667        // ULPFEC payload type, should not have duplicates.
2668        DCHECK(fec_settings.ulpfec_payload_type == -1);
2669        fec_settings.ulpfec_payload_type = in_codec.id;
2670        continue;
2671      }
2672
2673      case VideoCodec::CODEC_RTX: {
2674        int associated_payload_type;
2675        if (!in_codec.GetParam(kCodecParamAssociatedPayloadType,
2676                               &associated_payload_type) ||
2677            !IsValidRtpPayloadType(associated_payload_type)) {
2678          LOG(LS_ERROR)
2679              << "RTX codec with invalid or no associated payload type: "
2680              << in_codec.ToString();
2681          return std::vector<VideoCodecSettings>();
2682        }
2683        rtx_mapping[associated_payload_type] = in_codec.id;
2684        continue;
2685      }
2686
2687      case VideoCodec::CODEC_VIDEO:
2688        break;
2689    }
2690
2691    video_codecs.push_back(VideoCodecSettings());
2692    video_codecs.back().codec = in_codec;
2693  }
2694
2695  // One of these codecs should have been a video codec. Only having FEC
2696  // parameters into this code is a logic error.
2697  DCHECK(!video_codecs.empty());
2698
2699  for (std::map<int, int>::const_iterator it = rtx_mapping.begin();
2700       it != rtx_mapping.end();
2701       ++it) {
2702    if (!payload_used[it->first]) {
2703      LOG(LS_ERROR) << "RTX mapped to payload not in codec list.";
2704      return std::vector<VideoCodecSettings>();
2705    }
2706    if (payload_codec_type[it->first] != VideoCodec::CODEC_VIDEO &&
2707        payload_codec_type[it->first] != VideoCodec::CODEC_RED) {
2708      LOG(LS_ERROR) << "RTX not mapped to regular video codec or RED codec.";
2709      return std::vector<VideoCodecSettings>();
2710    }
2711
2712    if (it->first == fec_settings.red_payload_type) {
2713      fec_settings.red_rtx_payload_type = it->second;
2714    }
2715  }
2716
2717  for (size_t i = 0; i < video_codecs.size(); ++i) {
2718    video_codecs[i].fec = fec_settings;
2719    if (rtx_mapping[video_codecs[i].codec.id] != 0 &&
2720        rtx_mapping[video_codecs[i].codec.id] !=
2721            fec_settings.red_payload_type) {
2722      video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
2723    }
2724  }
2725
2726  return video_codecs;
2727}
2728
2729}  // namespace cricket
2730
2731#endif  // HAVE_WEBRTC_VIDEO
2732