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