MediaController/Call instantiation.

talk/media/webrtc/webrtcvoiceengine.cc

 /*
  * libjingle
  * Copyright 2004 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 561 matching lines @@
   StopAecDump();
 
   voe_wrapper_->base()->Terminate();
   desired_local_monitor_enable_ = false;
 }
 
 int WebRtcVoiceEngine::GetCapabilities() {
   return AUDIO_SEND | AUDIO_RECV;
 }
 
-VoiceMediaChannel* WebRtcVoiceEngine::CreateChannel(
+VoiceMediaChannel* WebRtcVoiceEngine::CreateChannel(webrtc::Call* call,
     const AudioOptions& options) {
-  WebRtcVoiceMediaChannel* ch = new WebRtcVoiceMediaChannel(this);
+  WebRtcVoiceMediaChannel* ch = new WebRtcVoiceMediaChannel(this, call);
   if (!ch->valid()) {
     delete ch;
     return nullptr;
   }
   if (!ch->SetOptions(options)) {
     LOG(LS_WARNING) << "Failed to set options while creating channel.";
   }
   return ch;
 }
 
@@ skipping 1087 matching lines @@
   // Raw pointer to AudioRenderer owned by LocalAudioTrackHandler.
   // PeerConnection will make sure invalidating the pointer before the object
   // goes away.
   AudioRenderer* renderer_;
 
   // Protects |renderer_| in Start(), Stop() and OnClose().
   rtc::CriticalSection lock_;
 };
 
 // WebRtcVoiceMediaChannel
-WebRtcVoiceMediaChannel::WebRtcVoiceMediaChannel(WebRtcVoiceEngine* engine)
+WebRtcVoiceMediaChannel::WebRtcVoiceMediaChannel(WebRtcVoiceEngine* engine,
+                                                 webrtc::Call* call)
     : engine_(engine),
       voe_channel_(engine->CreateMediaVoiceChannel()),
       send_bitrate_setting_(false),
       send_bitrate_bps_(0),
       options_(),
       dtmf_allowed_(false),
       desired_playout_(false),
       nack_enabled_(false),
       playout_(false),
       typing_noise_detected_(false),
       desired_send_(SEND_NOTHING),
       send_(SEND_NOTHING),
-      call_(nullptr),
+      call_(call),
       default_receive_ssrc_(0) {
   engine->RegisterChannel(this);
   LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::WebRtcVoiceMediaChannel "
                   << voe_channel();
+  DCHECK(nullptr != call);
   ConfigureSendChannel(voe_channel());
 }
 
 WebRtcVoiceMediaChannel::~WebRtcVoiceMediaChannel() {
   LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::~WebRtcVoiceMediaChannel "
                   << voe_channel();
-  DCHECK(receive_streams_.empty() || call_);
 
   // Remove any remaining send streams, the default channel will be deleted
   // later.
   while (!send_channels_.empty())
     RemoveSendStream(send_channels_.begin()->first);
 
   // Unregister ourselves from the engine.
   engine()->UnregisterChannel(this);
   // Remove any remaining streams.
   while (!receive_channels_.empty()) {
@@ skipping 99 matching lines @@
   }
   if (dscp_option_changed) {
     rtc::DiffServCodePoint dscp = rtc::DSCP_DEFAULT;
     if (options_.dscp.GetWithDefaultIfUnset(false))
       dscp = kAudioDscpValue;
     if (MediaChannel::SetDscp(dscp) != 0) {
       LOG(LS_WARNING) << "Failed to set DSCP settings for audio channel";
     }
   }
 
-  SetCall(call_);
+  RecreateAudioReceiveStreams();
 
   LOG(LS_INFO) << "Set voice channel options.  Current options: "
                << options_.ToString();
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::SetRecvCodecs(
     const std::vector<AudioCodec>& codecs) {
   // Set the payload types to be used for incoming media.
   LOG(LS_INFO) << "Setting receive voice codecs:";
@@ skipping 348 matching lines @@
     }
 
     const RtpHeaderExtension* send_time_extension =
         FindHeaderExtension(extensions, kRtpAbsoluteSenderTimeHeaderExtension);
     if (send_time_extension) {
       exts.push_back({
           kRtpAbsoluteSenderTimeHeaderExtension, send_time_extension->id});
     }
 
     recv_rtp_extensions_.swap(exts);
-    SetCall(call_);
+    RecreateAudioReceiveStreams();
   }
 
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::SetChannelRecvRtpHeaderExtensions(
     int channel_id, const std::vector<RtpHeaderExtension>& extensions) {
   const RtpHeaderExtension* audio_level_extension =
       FindHeaderExtension(extensions, kRtpAudioLevelHeaderExtension);
   if (!SetHeaderExtension(
@@ skipping 338 matching lines @@
   // when the default channel is not being used.
   webrtc::AudioTransport* audio_transport =
       engine()->voe()->base()->audio_transport();
   if (!InConferenceMode() && default_receive_ssrc_ == 0) {
     LOG(LS_INFO) << "Recv stream " << ssrc << " reuse default channel";
     default_receive_ssrc_ = ssrc;
     WebRtcVoiceChannelRenderer* channel_renderer =
         new WebRtcVoiceChannelRenderer(voe_channel(), audio_transport);
     receive_channels_.insert(std::make_pair(ssrc, channel_renderer));
     receive_stream_params_[ssrc] = sp;
-    TryAddAudioRecvStream(ssrc);
+    AddAudioReceiveStream(ssrc);
     return SetPlayout(voe_channel(), playout_);
   }
 
   // Create a new channel for receiving audio data.
   int channel = engine()->CreateMediaVoiceChannel();
   if (channel == -1) {
     LOG_RTCERR0(CreateChannel);
     return false;
   }
 
   if (!ConfigureRecvChannel(channel)) {
     DeleteChannel(channel);
     return false;
   }
 
   WebRtcVoiceChannelRenderer* channel_renderer =
       new WebRtcVoiceChannelRenderer(channel, audio_transport);
   receive_channels_.insert(std::make_pair(ssrc, channel_renderer));
   receive_stream_params_[ssrc] = sp;
-  TryAddAudioRecvStream(ssrc);
+  AddAudioReceiveStream(ssrc);
 
   LOG(LS_INFO) << "New audio stream " << ssrc
                << " registered to VoiceEngine channel #"
                << channel << ".";
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::ConfigureRecvChannel(int channel) {
   // Configure to use external transport, like our default channel.
   if (engine()->voe()->network()->RegisterExternalTransport(
@@ skipping 68 matching lines @@
 bool WebRtcVoiceMediaChannel::RemoveRecvStream(uint32 ssrc) {
   DCHECK(thread_checker_.CalledOnValidThread());
   rtc::CritScope lock(&receive_channels_cs_);
   ChannelMap::iterator it = receive_channels_.find(ssrc);
   if (it == receive_channels_.end()) {
     LOG(LS_WARNING) << "Try to remove stream with ssrc " << ssrc
                     << " which doesn't exist.";
     return false;
   }
 
-  TryRemoveAudioRecvStream(ssrc);
+  RemoveAudioReceiveStream(ssrc);
   receive_stream_params_.erase(ssrc);
 
   // Delete the WebRtcVoiceChannelRenderer object connected to the channel, this
   // will disconnect the audio renderer with the receive channel.
   // Cache the channel before the deletion.
   const int channel = it->second->channel();
   delete it->second;
   receive_channels_.erase(it);
 
   if (ssrc == default_receive_ssrc_) {
@@ skipping 273 matching lines @@
     }
   }
 
   return true;
 }
 
 void WebRtcVoiceMediaChannel::OnPacketReceived(
     rtc::Buffer* packet, const rtc::PacketTime& packet_time) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  // If hooked up to a "Call", forward packet there too.
-  if (call_) {
-    const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp,
-                                                packet_time.not_before);
-    call_->Receiver()->DeliverPacket(
-        webrtc::MediaType::AUDIO,
-        reinterpret_cast<const uint8_t*>(packet->data()), packet->size(),
-        webrtc_packet_time);
-  }
+  // Forward packet to Call as well.
+  const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp,
+                                              packet_time.not_before);
+  call_->Receiver()->DeliverPacket(webrtc::MediaType::AUDIO,
+      reinterpret_cast<const uint8_t*>(packet->data()), packet->size(),
+      webrtc_packet_time);
 
   // Pick which channel to send this packet to. If this packet doesn't match
   // any multiplexed streams, just send it to the default channel. Otherwise,
   // send it to the specific decoder instance for that stream.
   int which_channel =
       GetReceiveChannelNum(ParseSsrc(packet->data(), packet->size(), false));
   if (which_channel == -1) {
     which_channel = voe_channel();
   }
 
@@ skipping 16 matching lines @@
   // Pass it off to the decoder.
   engine()->voe()->network()->ReceivedRTPPacket(
       which_channel, packet->data(), packet->size(),
       webrtc::PacketTime(packet_time.timestamp, packet_time.not_before));
 }
 
 void WebRtcVoiceMediaChannel::OnRtcpReceived(
     rtc::Buffer* packet, const rtc::PacketTime& packet_time) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  // If hooked up to a "Call", forward packet there too.
-  if (call_) {
-    const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp,
-                                                packet_time.not_before);
-    call_->Receiver()->DeliverPacket(
-        webrtc::MediaType::AUDIO,
-        reinterpret_cast<const uint8_t*>(packet->data()), packet->size(),
-        webrtc_packet_time);
-  }
+  // Forward packet to Call as well.
+  const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp,
+                                              packet_time.not_before);
+  call_->Receiver()->DeliverPacket(webrtc::MediaType::AUDIO,
+      reinterpret_cast<const uint8_t*>(packet->data()), packet->size(),
+      webrtc_packet_time);
 
   // Sending channels need all RTCP packets with feedback information.
   // Even sender reports can contain attached report blocks.
   // Receiving channels need sender reports in order to create
   // correct receiver reports.
   int type = 0;
   if (!GetRtcpType(packet->data(), packet->size(), &type)) {
     LOG(LS_WARNING) << "Failed to parse type from received RTCP packet";
     return;
   }
@@ skipping 364 matching lines @@
 }
 
 int WebRtcVoiceMediaChannel::GetSendChannelNum(uint32 ssrc) const {
   ChannelMap::const_iterator it = send_channels_.find(ssrc);
   if (it != send_channels_.end())
     return it->second->channel();
 
   return -1;
 }
 
-void WebRtcVoiceMediaChannel::SetCall(webrtc::Call* call) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  for (const auto& it : receive_channels_) {
-    TryRemoveAudioRecvStream(it.first);
-  }
-  call_ = call;
-  for (const auto& it : receive_channels_) {
-    TryAddAudioRecvStream(it.first);
-  }
-}
-
 bool WebRtcVoiceMediaChannel::GetRedSendCodec(const AudioCodec& red_codec,
     const std::vector<AudioCodec>& all_codecs, webrtc::CodecInst* send_codec) {
   // Get the RED encodings from the parameter with no name. This may
   // change based on what is discussed on the Jingle list.
   // The encoding parameter is of the form "a/b"; we only support where
   // a == b. Verify this and parse out the value into red_pt.
   // If the parameter value is absent (as it will be until we wire up the
   // signaling of this message), use the second codec specified (i.e. the
   // one after "red") as the encoding parameter.
   int red_pt = -1;
@@ skipping 126 matching lines @@
     id = extension->id;
     uri = extension->uri;
   }
   if ((engine()->voe()->rtp()->*setter)(channel_id, enable, id) != 0) {
     LOG_RTCERR4(*setter, uri, channel_id, enable, id);
     return false;
   }
   return true;
 }
 
-void WebRtcVoiceMediaChannel::TryAddAudioRecvStream(uint32 ssrc) {
+void WebRtcVoiceMediaChannel::RecreateAudioReceiveStreams() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  for (const auto& it : receive_channels_) {
+    RemoveAudioReceiveStream(it.first);
+  }
+  for (const auto& it : receive_channels_) {
+    AddAudioReceiveStream(it.first);
+  }
+}
+
+void WebRtcVoiceMediaChannel::AddAudioReceiveStream(uint32 ssrc) {
   DCHECK(thread_checker_.CalledOnValidThread());
   WebRtcVoiceChannelRenderer* channel = receive_channels_[ssrc];
   DCHECK(channel != nullptr);
   DCHECK(receive_streams_.find(ssrc) == receive_streams_.end());
-  // If we are hooked up to a webrtc::Call, create an AudioReceiveStream too.
-  if (!call_) {
-    return;
-  }
   webrtc::AudioReceiveStream::Config config;
   config.rtp.remote_ssrc = ssrc;
   // Only add RTP extensions if we support combined A/V BWE.
   config.rtp.extensions = recv_rtp_extensions_;
   config.combined_audio_video_bwe =
       options_.combined_audio_video_bwe.GetWithDefaultIfUnset(false);
   config.voe_channel_id = channel->channel();
   config.sync_group = receive_stream_params_[ssrc].sync_label;
   webrtc::AudioReceiveStream* s = call_->CreateAudioReceiveStream(config);
   receive_streams_.insert(std::make_pair(ssrc, s));
 }
 
-void WebRtcVoiceMediaChannel::TryRemoveAudioRecvStream(uint32 ssrc) {
+void WebRtcVoiceMediaChannel::RemoveAudioReceiveStream(uint32 ssrc) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  // If we are hooked up to a webrtc::Call, assume there is an
-  // AudioReceiveStream to destroy too.
-  if (call_) {
-    auto stream_it = receive_streams_.find(ssrc);
-    if (stream_it != receive_streams_.end()) {
-      call_->DestroyAudioReceiveStream(stream_it->second);
-      receive_streams_.erase(stream_it);
-    }
+  auto stream_it = receive_streams_.find(ssrc);
+  if (stream_it != receive_streams_.end()) {
+    call_->DestroyAudioReceiveStream(stream_it->second);
+    receive_streams_.erase(stream_it);
   }
 }
 
 bool WebRtcVoiceMediaChannel::SetRecvCodecsInternal(
     const std::vector<AudioCodec>& new_codecs) {
   for (const AudioCodec& codec : new_codecs) {
     webrtc::CodecInst voe_codec;
     if (engine()->FindWebRtcCodec(codec, &voe_codec)) {
       LOG(LS_INFO) << ToString(codec);
       voe_codec.pltype = codec.id;
@@ skipping 36 matching lines @@
 
 int WebRtcSoundclipStream::Rewind() {
   mem_.Rewind();
   // Return -1 to keep VoiceEngine from looping.
   return (loop_) ? 0 : -1;
 }
 
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE