MediaController/Call instantiation.

talk/media/webrtc/webrtcvideoengine2.cc

 /*
  * libjingle
  * Copyright 2014 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 322 matching lines @@
 const int kVideoRtpBufferSize = 65536;
 
 // This constant is really an on/off, lower-level configurable NACK history
 // duration hasn't been implemented.
 static const int kNackHistoryMs = 1000;
 
 static const int kDefaultQpMax = 56;
 
 static const int kDefaultRtcpReceiverReportSsrc = 1;
 
-const int kMinBandwidthBps = 30000;
-const int kStartBandwidthBps = 300000;
-const int kMaxBandwidthBps = 2000000;
-
 std::vector<VideoCodec> DefaultVideoCodecList() {
   std::vector<VideoCodec> codecs;
   if (CodecIsInternallySupported(kVp9CodecName)) {
     codecs.push_back(MakeVideoCodecWithDefaultFeedbackParams(kDefaultVp9PlType,
                                                              kVp9CodecName));
     // TODO(andresp): Add rtx codec for vp9 and verify it works.
   }
   codecs.push_back(MakeVideoCodecWithDefaultFeedbackParams(kDefaultVp8PlType,
                                                            kVp8CodecName));
   if (CodecIsInternallySupported(kH264CodecName)) {
@@ skipping 172 matching lines @@
   LOG(LS_INFO) << "Creating default receive stream for SSRC=" << ssrc << ".";
   if (!channel->AddRecvStream(sp, true)) {
     LOG(LS_WARNING) << "Could not create default receive stream.";
   }
 
   channel->SetRenderer(ssrc, default_renderer_);
   default_recv_ssrc_ = ssrc;
   return kDeliverPacket;
 }
 
-WebRtcCallFactory::~WebRtcCallFactory() {
-}
-webrtc::Call* WebRtcCallFactory::CreateCall(
-    const webrtc::Call::Config& config) {
-  return webrtc::Call::Create(config);
-}
-
 VideoRenderer* DefaultUnsignalledSsrcHandler::GetDefaultRenderer() const {
   return default_renderer_;
 }
 
 void DefaultUnsignalledSsrcHandler::SetDefaultRenderer(
     VideoMediaChannel* channel,
     VideoRenderer* renderer) {
   default_renderer_ = renderer;
   if (default_recv_ssrc_ != 0) {
     channel->SetRenderer(default_recv_ssrc_, default_renderer_);
   }
 }
 
-WebRtcVideoEngine2::WebRtcVideoEngine2(WebRtcVoiceEngine* voice_engine)
-    : voice_engine_(voice_engine),
-      initialized_(false),
-      call_factory_(&default_call_factory_),
+WebRtcVideoEngine2::WebRtcVideoEngine2()
+    : initialized_(false),
       external_decoder_factory_(NULL),
       external_encoder_factory_(NULL) {
   LOG(LS_INFO) << "WebRtcVideoEngine2::WebRtcVideoEngine2()";
   video_codecs_ = GetSupportedCodecs();
   rtp_header_extensions_.push_back(
       RtpHeaderExtension(kRtpTimestampOffsetHeaderExtension,
                          kRtpTimestampOffsetHeaderExtensionDefaultId));
   rtp_header_extensions_.push_back(
       RtpHeaderExtension(kRtpAbsoluteSenderTimeHeaderExtension,
                          kRtpAbsoluteSenderTimeHeaderExtensionDefaultId));
   rtp_header_extensions_.push_back(
       RtpHeaderExtension(kRtpVideoRotationHeaderExtension,
                          kRtpVideoRotationHeaderExtensionDefaultId));
 }
 
 WebRtcVideoEngine2::~WebRtcVideoEngine2() {
   LOG(LS_INFO) << "WebRtcVideoEngine2::~WebRtcVideoEngine2";
 }
 
-void WebRtcVideoEngine2::SetCallFactory(WebRtcCallFactory* call_factory) {
-  DCHECK(!initialized_);
-  call_factory_ = call_factory;
-}
-
 void WebRtcVideoEngine2::Init() {
   LOG(LS_INFO) << "WebRtcVideoEngine2::Init";
   initialized_ = true;
 }
 
 int WebRtcVideoEngine2::GetCapabilities() { return VIDEO_RECV | VIDEO_SEND; }
 
 bool WebRtcVideoEngine2::SetDefaultEncoderConfig(
     const VideoEncoderConfig& config) {
   const VideoCodec& codec = config.max_codec;
@@ skipping 11 matching lines @@
   if (!supports_codec) {
     LOG(LS_ERROR) << "SetDefaultEncoderConfig, codec not supported: "
                   << codec.ToString();
     return false;
   }
 
   return true;
 }
 
 WebRtcVideoChannel2* WebRtcVideoEngine2::CreateChannel(
-    const VideoOptions& options,
-    VoiceMediaChannel* voice_channel) {
+    webrtc::Call* call,
+    const VideoOptions& options) {
   DCHECK(initialized_);
-  LOG(LS_INFO) << "CreateChannel: "
-               << (voice_channel != NULL ? "With" : "Without")
-               << " voice channel. Options: " << options.ToString();
-  WebRtcVideoChannel2* channel =
-      new WebRtcVideoChannel2(call_factory_, voice_engine_,
-          static_cast<WebRtcVoiceMediaChannel*>(voice_channel), options,
-          external_encoder_factory_, external_decoder_factory_);
-  if (!channel->Init()) {
-    delete channel;
-    return NULL;
-  }
+  LOG(LS_INFO) << "CreateChannel. Options: " << options.ToString();
+  WebRtcVideoChannel2* channel = new WebRtcVideoChannel2(call, options,
+      external_encoder_factory_, external_decoder_factory_);
   channel->SetRecvCodecs(video_codecs_);
   return channel;
 }
 
 const std::vector<VideoCodec>& WebRtcVideoEngine2::codecs() const {
   return video_codecs_;
 }
 
 const std::vector<RtpHeaderExtension>&
 WebRtcVideoEngine2::rtp_header_extensions() const {
@@ skipping 138 matching lines @@
                      codecs[i].max_fps,
                      0);
 
     AddDefaultFeedbackParams(&codec);
     supported_codecs.push_back(codec);
   }
   return supported_codecs;
 }
 
 WebRtcVideoChannel2::WebRtcVideoChannel2(
-    WebRtcCallFactory* call_factory,
-    WebRtcVoiceEngine* voice_engine,
-    WebRtcVoiceMediaChannel* voice_channel,
+    webrtc::Call* call,
     const VideoOptions& options,
     WebRtcVideoEncoderFactory* external_encoder_factory,
     WebRtcVideoDecoderFactory* external_decoder_factory)
-    : unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
-      voice_channel_(voice_channel),
-      voice_channel_id_(voice_channel ? voice_channel->voe_channel() : -1),
+    : call_(call),
+      unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
       external_encoder_factory_(external_encoder_factory),
       external_decoder_factory_(external_decoder_factory) {
   DCHECK(thread_checker_.CalledOnValidThread());
   SetDefaultOptions();
   options_.SetAll(options);
   options_.cpu_overuse_detection.Get(&signal_cpu_adaptation_);
-  webrtc::Call::Config config;
-  if (voice_engine != NULL) {
-    config.voice_engine = voice_engine->voe()->engine();
-  }
-  config.bitrate_config.min_bitrate_bps = kMinBandwidthBps;
-  config.bitrate_config.start_bitrate_bps = kStartBandwidthBps;
-  config.bitrate_config.max_bitrate_bps = kMaxBandwidthBps;
-  call_.reset(call_factory->CreateCall(config));
-  if (voice_channel_) {
-    voice_channel_->SetCall(call_.get());
-  }
   rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc;
   sending_ = false;
   default_send_ssrc_ = 0;
 }
 
 void WebRtcVideoChannel2::SetDefaultOptions() {
   options_.cpu_overuse_detection.Set(true);
   options_.dscp.Set(false);
   options_.suspend_below_min_bitrate.Set(false);
   options_.video_noise_reduction.Set(true);
   options_.screencast_min_bitrate.Set(0);
 }
 
 WebRtcVideoChannel2::~WebRtcVideoChannel2() {
-  DetachVoiceChannel();
   for (auto& kv : send_streams_)
     delete kv.second;
   for (auto& kv : receive_streams_)
     delete kv.second;
 }
 
-bool WebRtcVideoChannel2::Init() { return true; }
-
-void WebRtcVideoChannel2::DetachVoiceChannel() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  if (voice_channel_) {
-    voice_channel_->SetCall(nullptr);
-    voice_channel_ = nullptr;
-  }
-}
-
 bool WebRtcVideoChannel2::CodecIsExternallySupported(
     const std::string& name) const {
   if (external_encoder_factory_ == NULL) {
     return false;
   }
 
   const std::vector<WebRtcVideoEncoderFactory::VideoCodec> external_codecs =
       external_encoder_factory_->codecs();
   for (size_t c = 0; c < external_codecs.size(); ++c) {
     if (CodecNamesEq(name, external_codecs[c].name)) {
@@ skipping 270 matching lines @@
   if (!ValidateSendSsrcAvailability(sp))
     return false;
 
   for (uint32 used_ssrc : sp.ssrcs)
     send_ssrcs_.insert(used_ssrc);
 
   webrtc::VideoSendStream::Config config(this);
   config.overuse_callback = this;
 
   WebRtcVideoSendStream* stream =
-      new WebRtcVideoSendStream(call_.get(),
+      new WebRtcVideoSendStream(call_,
                                 sp,
                                 config,
                                 external_encoder_factory_,
                                 options_,
                                 bitrate_config_.max_bitrate_bps,
                                 send_codec_,
                                 send_rtp_extensions_);
 
   uint32 ssrc = sp.first_ssrc();
   DCHECK(ssrc != 0);
@@ skipping 102 matching lines @@
   // Set up A/V sync group based on sync label.
   config.sync_group = sp.sync_label;
 
   config.rtp.remb = false;
   VideoCodecSettings send_codec;
   if (send_codec_.Get(&send_codec)) {
     config.rtp.remb = HasRemb(send_codec.codec);
   }
 
   receive_streams_[ssrc] = new WebRtcVideoReceiveStream(
-      call_.get(), sp, config, external_decoder_factory_, default_stream,
+      call_, sp, config, external_decoder_factory_, default_stream,
       recv_codecs_);
 
   return true;
 }
 
 void WebRtcVideoChannel2::ConfigureReceiverRtp(
     webrtc::VideoReceiveStream::Config* config,
     const StreamParams& sp) const {
   uint32 ssrc = sp.first_ssrc();
 
@@ skipping 1502 matching lines @@
       video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
     }
   }
 
   return video_codecs;
 }
 
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VIDEO