ABANDONED: Remove the default receive channel in WVoE.

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 356 matching lines @@
 AudioOptions GetDefaultEngineOptions() {
   AudioOptions options;
   options.echo_cancellation.Set(true);
   options.auto_gain_control.Set(true);
   options.noise_suppression.Set(true);
   options.highpass_filter.Set(true);
   options.stereo_swapping.Set(false);
   options.audio_jitter_buffer_max_packets.Set(50);
   options.audio_jitter_buffer_fast_accelerate.Set(false);
   options.typing_detection.Set(true);
-  options.conference_mode.Set(false);
   options.adjust_agc_delta.Set(0);
   options.experimental_agc.Set(false);
   options.extended_filter_aec.Set(false);
   options.delay_agnostic_aec.Set(false);
   options.experimental_ns.Set(false);
   options.aec_dump.Set(false);
   return options;
 }
 
 std::string GetEnableString(bool enable) {
@@ skipping 1013 matching lines @@
       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_(call),
-      default_receive_ssrc_(0) {
+      using_default_recv_channel_(false),
+      default_recv_ssrc_(0) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   engine->RegisterChannel(this);
   LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::WebRtcVoiceMediaChannel "
                   << default_send_channel_id();
   RTC_DCHECK(nullptr != call);
   ConfigureSendChannel(default_send_channel_id());
   SetOptions(options);
 }
 
 WebRtcVoiceMediaChannel::~WebRtcVoiceMediaChannel() {
@@ skipping 56 matching lines @@
   options_.SetAll(options);
 
   if (send_ != SEND_NOTHING) {
     if (!engine()->ApplyOptions(options_)) {
       LOG(LS_WARNING) <<
           "Failed to apply engine options during channel SetOptions.";
       return false;
     }
   }
 
-  if (!SetRecvOptions(default_send_channel_id(), options)) {
-    return false;
-  }
   for (const auto& ch : receive_channels_) {
     if (!SetRecvOptions(ch.second->channel(), options)) {
       return false;
     }
   }
   if (dscp_option_changed) {
     rtc::DiffServCodePoint dscp = rtc::DSCP_DEFAULT;
     if (options_.dscp.GetWithDefaultIfUnset(false))
       dscp = kAudioDscpValue;
     if (MediaChannel::SetDscp(dscp) != 0) {
@@ skipping 394 matching lines @@
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::SetRecvRtpHeaderExtensions(
     const std::vector<RtpHeaderExtension>& extensions) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (receive_extensions_ == extensions) {
     return true;
   }
 
-  // The default channel may or may not be in |receive_channels_|. Set the rtp
-  // header extensions for default channel regardless.
-  if (!SetChannelRecvRtpHeaderExtensions(default_send_channel_id(),
-                                         extensions)) {
-    return false;
-  }
-
-  // Loop through all receive channels and enable/disable the extensions.
   for (const auto& ch : receive_channels_) {
     if (!SetChannelRecvRtpHeaderExtensions(ch.second->channel(), extensions)) {
       return false;
     }
   }
 
   receive_extensions_ = extensions;
 
   // Recreate AudioReceiveStream:s.
   {
@@ skipping 103 matching lines @@
 }
 
 bool WebRtcVoiceMediaChannel::ChangePlayout(bool playout) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (playout_ == playout) {
     return true;
   }
 
   // Change the playout of all channels to the new state.
   bool result = true;
-  if (receive_channels_.empty()) {
-    // Only toggle the default channel if we don't have any other channels.
-    result = SetPlayout(default_send_channel_id(), playout);
-  }
   for (const auto& ch : receive_channels_) {
     if (!SetPlayout(ch.second->channel(), playout)) {
       LOG(LS_ERROR) << "SetPlayout " << playout << " on channel "
                     << ch.second->channel() << " failed";
       result = false;
       break;
     }
   }
 
   if (result) {
@@ skipping 83 matching lines @@
 // TODO(ronghuawu): Change this method to return bool.
 void WebRtcVoiceMediaChannel::ConfigureSendChannel(int channel) {
   if (engine()->voe()->network()->RegisterExternalTransport(
           channel, *this) == -1) {
     LOG_RTCERR2(RegisterExternalTransport, channel, this);
   }
 
   // Enable RTCP (for quality stats and feedback messages)
   EnableRtcp(channel);
 
-  // Reset all recv codecs; they will be enabled via SetRecvCodecs.
-  ResetRecvCodecs(channel);
-
   // Set RTP header extension for the new channel.
   SetChannelSendRtpHeaderExtensions(channel, send_extensions_);
 }
 
 bool WebRtcVoiceMediaChannel::DeleteChannel(int channel) {
   if (engine()->voe()->network()->DeRegisterExternalTransport(channel) == -1) {
     LOG_RTCERR1(DeRegisterExternalTransport, channel);
   }
 
   if (engine()->voe()->base()->DeleteChannel(channel) == -1) {
@@ skipping 50 matching lines @@
     LOG_RTCERR2(SetSendSSRC, channel, sp.first_ssrc());
     return false;
   }
 
   // At this point the channel's local SSRC has been updated. If the channel is
   // the default channel make sure that all the receive channels are updated as
   // well. Receive channels have to have the same SSRC as the default channel in
   // order to send receiver reports with this SSRC.
   if (IsDefaultChannel(channel)) {
     for (const auto& ch : receive_channels_) {
-      // Only update the SSRC for non-default channels.
-      if (!IsDefaultChannel(ch.second->channel())) {
-        if (engine()->voe()->rtp()->SetLocalSSRC(ch.second->channel(),
-                                                 sp.first_ssrc()) != 0) {
-          LOG_RTCERR2(SetLocalSSRC, ch.second->channel(), sp.first_ssrc());
-          return false;
-        }
+      if (engine()->voe()->rtp()->SetLocalSSRC(ch.second->channel(),
+                                               sp.first_ssrc()) != 0) {
+        LOG_RTCERR2(SetLocalSSRC, ch.second->channel(), sp.first_ssrc());
+        return false;
       }
     }
   }
 
   if (engine()->voe()->rtp()->SetRTCP_CNAME(channel, sp.cname.c_str()) == -1) {
     LOG_RTCERR2(SetRTCP_CNAME, channel, sp.cname);
     return false;
   }
 
   // Set the current codecs to be used for the new channel.
@@ skipping 44 matching lines @@
   if (!ValidateStreamParams(sp)) {
     return false;
   }
 
   uint32 ssrc = sp.first_ssrc();
   if (ssrc == 0) {
     LOG(LS_WARNING) << "AddRecvStream with ssrc==0 is not supported.";
     return false;
   }
 
-  rtc::CritScope lock(&receive_channels_cs_);
+  // Remove the default receive stream if one had been created with this ssrc;
+  // we'll recreate it then.
+  if (using_default_recv_channel_ && ssrc == default_recv_ssrc_) {
+    RemoveRecvStream(ssrc);
+  }
 
   if (receive_channels_.find(ssrc) != receive_channels_.end()) {
     LOG(LS_ERROR) << "Stream already exists with ssrc " << ssrc;
     return false;
   }
-
   RTC_DCHECK(receive_stream_params_.find(ssrc) == receive_stream_params_.end());
 
-  // Reuse default channel for recv stream in non-conference mode call
-  // 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(default_send_channel_id(),
-                                       audio_transport);
-    receive_channels_.insert(std::make_pair(ssrc, channel_renderer));
-    receive_stream_params_[ssrc] = sp;
-    AddAudioReceiveStream(ssrc);
-    return SetPlayout(default_send_channel_id(), 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;
   }
 
+  webrtc::AudioTransport* audio_transport =
+      engine()->voe()->base()->audio_transport();
   WebRtcVoiceChannelRenderer* channel_renderer =
       new WebRtcVoiceChannelRenderer(channel, audio_transport);
   receive_channels_.insert(std::make_pair(ssrc, channel_renderer));
   receive_stream_params_[ssrc] = sp;
   AddAudioReceiveStream(ssrc);
 
   LOG(LS_INFO) << "New audio stream " << ssrc
                << " registered to VoiceEngine channel #"
                << channel << ".";
   return true;
@@ skipping 25 matching lines @@
   }
 
   // Associate receive channel to default send channel (so the receive channel
   // can obtain RTT from the send channel).
   engine()->voe()->base()->AssociateSendChannel(channel,
                                                 default_send_channel_id());
   LOG(LS_INFO) << "VoiceEngine channel #"
                << channel << " is associated with channel #"
                << default_send_channel_id() << ".";
 
-  // Use the same recv payload types as our default channel.
-  ResetRecvCodecs(channel);
-  if (!recv_codecs_.empty()) {
-    for (const auto& codec : recv_codecs_) {
-      webrtc::CodecInst voe_codec;
-      if (engine()->FindWebRtcCodec(codec, &voe_codec)) {
-        voe_codec.pltype = codec.id;
-        voe_codec.rate = 0;  // Needed to make GetRecPayloadType work for ISAC
-        if (engine()->voe()->codec()->GetRecPayloadType(
-            default_send_channel_id(), voe_codec) != -1) {
-          if (engine()->voe()->codec()->SetRecPayloadType(
-              channel, voe_codec) == -1) {
-            LOG_RTCERR2(SetRecPayloadType, channel, ToString(voe_codec));
-            return false;
-          }
-        }
+  // Turn off all supported codecs.
+  int ncodecs = engine()->voe()->codec()->NumOfCodecs();
+  for (int i = 0; i < ncodecs; ++i) {
+    webrtc::CodecInst voe_codec;
+    if (engine()->voe()->codec()->GetCodec(i, voe_codec) != -1) {
+      voe_codec.pltype = -1;
+      if (engine()->voe()->codec()->SetRecPayloadType(
+          channel, voe_codec) == -1) {
+        LOG_RTCERR2(SetRecPayloadType, channel, ToString(voe_codec));
+        return false;
       }
     }
   }
 
-  if (InConferenceMode()) {
-    // To be in par with the video, default_send_channel_id() is not used for
-    // receiving in a conference call.
-    if (receive_channels_.empty() && default_receive_ssrc_ == 0 && playout_) {
-      // This is the first stream in a multi user meeting. We can now
-      // disable playback of the default stream. This since the default
-      // stream will probably have received some initial packets before
-      // the new stream was added. This will mean that the CN state from
-      // the default channel will be mixed in with the other streams
-      // throughout the whole meeting, which might be disturbing.
-      LOG(LS_INFO) << "Disabling playback on the default voice channel";
-      SetPlayout(default_send_channel_id(), false);
+  // Only enable those configured for this channel.
+  for (const auto& codec : recv_codecs_) {
+    webrtc::CodecInst voe_codec;
+    if (engine()->FindWebRtcCodec(codec, &voe_codec)) {
+      voe_codec.pltype = codec.id;
+      if (engine()->voe()->codec()->SetRecPayloadType(
+          channel, voe_codec) == -1) {
+        LOG_RTCERR2(SetRecPayloadType, channel, ToString(voe_codec));
+        return false;
+      }
     }
   }
 
   SetNack(channel, nack_enabled_);
 
   // Set RTP header extension for the new channel.
   if (!SetChannelRecvRtpHeaderExtensions(channel, receive_extensions_)) {
     return false;
   }
 
   return SetPlayout(channel, playout_);
 }
 
 bool WebRtcVoiceMediaChannel::RemoveRecvStream(uint32 ssrc) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   LOG(LS_INFO) << "RemoveRecvStream: " << ssrc;
 
-  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;
   }
 
   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_) {
-    RTC_DCHECK(IsDefaultChannel(channel));
-    // Recycle the default channel is for recv stream.
-    if (playout_)
-      SetPlayout(default_send_channel_id(), false);
-
-    default_receive_ssrc_ = 0;
-    return true;
+  // Deregister default channel, if that's the one being destroyed.
+  if (using_default_recv_channel_ && ssrc == default_recv_ssrc_) {
+    using_default_recv_channel_ = false;
+    default_recv_ssrc_ = 0;
   }
 
   LOG(LS_INFO) << "Removing audio stream " << ssrc
                << " with VoiceEngine channel #" << channel << ".";
-  if (!DeleteChannel(channel))
-    return false;
-
-  bool enable_default_channel_playout = false;
-  if (receive_channels_.empty()) {
-    // The last stream was removed. We can now enable the default
-    // channel for new channels to be played out immediately without
-    // waiting for AddStream messages.
-    // We do this for both conference mode and non-conference mode.
-    // TODO(oja): Does the default channel still have it's CN state?
-    enable_default_channel_playout = true;
-  }
-  if (!InConferenceMode() && receive_channels_.size() == 1 &&
-      default_receive_ssrc_ != 0) {
-    // Only the default channel is active, enable the playout on default
-    // channel.
-    enable_default_channel_playout = true;
-  }
-  if (enable_default_channel_playout && playout_) {
-    LOG(LS_INFO) << "Enabling playback on the default voice channel";
-    SetPlayout(default_send_channel_id(), true);
-  }
-
-  return true;
+  return DeleteChannel(channel);
 }
 
 bool WebRtcVoiceMediaChannel::SetRemoteRenderer(uint32 ssrc,
                                                 AudioRenderer* renderer) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   ChannelMap::iterator it = receive_channels_.find(ssrc);
   if (it == receive_channels_.end()) {
     if (renderer) {
       // Return an error if trying to set a valid renderer with an invalid ssrc.
       LOG(LS_ERROR) << "SetRemoteRenderer failed with ssrc "<< ssrc;
@@ skipping 30 matching lines @@
     it->second->Start(renderer);
   else
     it->second->Stop();
 
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::GetActiveStreams(
     AudioInfo::StreamList* actives) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  // In conference mode, the default channel should not be in
-  // |receive_channels_|.
   actives->clear();
   for (const auto& ch : receive_channels_) {
     int level = GetOutputLevel(ch.second->channel());
     if (level > 0) {
       actives->push_back(std::make_pair(ch.first, level));
     }
   }
   return true;
 }
 
 int WebRtcVoiceMediaChannel::GetOutputLevel() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  // return the highest output level of all streams
-  int highest = GetOutputLevel(default_send_channel_id());
+  int highest = 0;
   for (const auto& ch : receive_channels_) {
     highest = std::max(GetOutputLevel(ch.second->channel()), highest);
   }
   return highest;
 }
 
 int WebRtcVoiceMediaChannel::GetTimeSinceLastTyping() {
   int ret;
   if (engine()->voe()->processing()->TimeSinceLastTyping(ret) == -1) {
     // In case of error, log the info and continue
@@ skipping 14 matching lines @@
     // In case of error, log the info and continue
     LOG_RTCERR5(SetTypingDetectionParameters, time_window,
                 cost_per_typing, reporting_threshold, penalty_decay,
                 type_event_delay);
   }
 }
 
 bool WebRtcVoiceMediaChannel::SetOutputScaling(
     uint32 ssrc, double left, double right) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  rtc::CritScope lock(&receive_channels_cs_);
-  // Collect the channels to scale the output volume.
-  std::vector<int> channels;
-  if (0 == ssrc) {  // Collect all channels, including the default one.
-    // Default channel is not in receive_channels_ if it is not being used for
-    // playout.
-    if (default_receive_ssrc_ == 0)
-      channels.push_back(default_send_channel_id());
-    for (const auto& ch : receive_channels_) {
-      channels.push_back(ch.second->channel());
-    }
-  } else {  // Collect only the channel of the specified ssrc.
-    int channel = GetReceiveChannelId(ssrc);
-    if (-1 == channel) {
-      LOG(LS_WARNING) << "Cannot find channel for ssrc:" << ssrc;
-      return false;
-    }
-    channels.push_back(channel);
+  int ch_id = GetReceiveChannelId(ssrc);
+  if (ch_id < 0) {
+    LOG(LS_WARNING) << "Cannot find channel for ssrc:" << ssrc;
+    return true;
   }
 
   // Scale the output volume for the collected channels. We first normalize to
   // scale the volume and then set the left and right pan.
   float scale = static_cast<float>(std::max(left, right));
   if (scale > 0.0001f) {
     left /= scale;
     right /= scale;
   }
-  for (int ch_id : channels) {
-    if (-1 == engine()->voe()->volume()->SetChannelOutputVolumeScaling(
-        ch_id, scale)) {
-      LOG_RTCERR2(SetChannelOutputVolumeScaling, ch_id, scale);
-      return false;
-    }
-    if (-1 == engine()->voe()->volume()->SetOutputVolumePan(
-        ch_id, static_cast<float>(left), static_cast<float>(right))) {
-      LOG_RTCERR3(SetOutputVolumePan, ch_id, left, right);
-      // Do not return if fails. SetOutputVolumePan is not available for all
-      // pltforms.
-    }
-    LOG(LS_INFO) << "SetOutputScaling to left=" << left * scale
-                 << " right=" << right * scale
-                 << " for channel " << ch_id << " and ssrc " << ssrc;
+  if (-1 == engine()->voe()->volume()->SetChannelOutputVolumeScaling(
+      ch_id, scale)) {
+    LOG_RTCERR2(SetChannelOutputVolumeScaling, ch_id, scale);
+    return false;
   }
+  if (-1 == engine()->voe()->volume()->SetOutputVolumePan(
+      ch_id, static_cast<float>(left), static_cast<float>(right))) {
+    LOG_RTCERR3(SetOutputVolumePan, ch_id, left, right);
+    // Do not return if fails. SetOutputVolumePan is not available for all
+    // pltforms.
+  }
+  LOG(LS_INFO) << "SetOutputScaling to left=" << left * scale
+               << " right=" << right * scale
+               << " for channel " << ch_id << " and ssrc " << ssrc;
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::CanInsertDtmf() {
   return dtmf_allowed_;
 }
 
 bool WebRtcVoiceMediaChannel::InsertDtmf(uint32 ssrc, int event,
                                          int duration, int flags) {
   if (!dtmf_allowed_) {
@@ skipping 41 matching lines @@
     }
   }
 
   return true;
 }
 
 void WebRtcVoiceMediaChannel::OnPacketReceived(
     rtc::Buffer* packet, const rtc::PacketTime& packet_time) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
 
-  // Forward packet to Call as well.
+  uint32 ssrc = 0;
+  if (!GetRtpSsrc(packet->data(), packet->size(), &ssrc)) {
+    return;
+  }
+
+  if (receive_channels_.empty()) {
+    // Create new channel, which will be the default receive channel.
+    StreamParams sp;
+    sp.ssrcs.push_back(ssrc);
+    LOG(LS_INFO) << "Creating default receive stream for SSRC=" << ssrc << ".";
+    if (!AddRecvStream(sp)) {
+      LOG(LS_WARNING) << "Could not create default receive stream.";
+      return;
+    }
+    using_default_recv_channel_ = true;
+    default_recv_ssrc_ = ssrc;
+  }
+
+  // Forward packet to Call. If the SSRC is unknown we'll return after this.
   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);
+  webrtc::PacketReceiver::DeliveryStatus delivery_result =
+      call_->Receiver()->DeliverPacket(webrtc::MediaType::AUDIO,
+          reinterpret_cast<const uint8_t*>(packet->data()), packet->size(),
+          webrtc_packet_time);
+  if (webrtc::PacketReceiver::DELIVERY_OK != delivery_result) {
+    return;
+  }
 
-  // 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 =
-      GetReceiveChannelId(ParseSsrc(packet->data(), packet->size(), false));
-  if (which_channel == -1) {
-    which_channel = default_send_channel_id();
-  }
+  // Find the channel to send this packet to. It must exist since webrtc::Call
+  // was able to demux the packet.
+  int channel = GetReceiveChannelId(ssrc);
+  RTC_DCHECK(channel != -1);
 
   // 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));
+      channel, packet->data(), packet->size(), webrtc_packet_time);
 }
 
 void WebRtcVoiceMediaChannel::OnRtcpReceived(
     rtc::Buffer* packet, const rtc::PacketTime& packet_time) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
 
   // 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;
   }
 
   // If it is a sender report, find the receive channel that is listening.
-  bool has_sent_to_default_channel = false;
   if (type == kRtcpTypeSR) {
     uint32 ssrc = 0;
     if (!GetRtcpSsrc(packet->data(), packet->size(), &ssrc)) {
       return;
     }
     int recv_channel_id = GetReceiveChannelId(ssrc);
     if (recv_channel_id != -1) {
       engine()->voe()->network()->ReceivedRTCPPacket(
           recv_channel_id, packet->data(), packet->size());
-
-      if (IsDefaultChannel(recv_channel_id))
-        has_sent_to_default_channel = true;
     }
   }
 
   // SR may continue RR and any RR entry may correspond to any one of the send
   // channels. So all RTCP packets must be forwarded all send channels. VoE
   // will filter out RR internally.
   for (const auto& ch : send_channels_) {
-    // Make sure not sending the same packet to default channel more than once.
-    if (IsDefaultChannel(ch.second->channel()) &&
-        has_sent_to_default_channel)
-      continue;
-
     engine()->voe()->network()->ReceivedRTCPPacket(
         ch.second->channel(), packet->data(), packet->size());
   }
 }
 
 bool WebRtcVoiceMediaChannel::MuteStream(uint32 ssrc, bool muted) {
   int channel =
       (ssrc == 0) ? default_send_channel_id() : GetSendChannelId(ssrc);
   if (channel == -1) {
     LOG(LS_WARNING) << "The specified ssrc " << ssrc << " is not in use.";
@@ skipping 174 matching lines @@
     sinfo.echo_return_loss_enhancement = echo_return_loss_enhancement;
     sinfo.echo_delay_median_ms = echo_delay_median_ms;
     sinfo.echo_delay_std_ms = echo_delay_std_ms;
     // TODO(ajm): Re-enable this metric once we have a reliable implementation.
     sinfo.aec_quality_min = -1;
     sinfo.typing_noise_detected = typing_noise_detected_;
 
     info->senders.push_back(sinfo);
   }
 
-  // Build the list of receivers, one for each receiving channel, or 1 in
-  // a 1:1 call.
-  std::vector<int> channels;
+  // Get the SSRC and stats for each receiver.
   for (const auto& ch : receive_channels_) {
-    channels.push_back(ch.second->channel());
-  }
-  if (channels.empty()) {
-    channels.push_back(default_send_channel_id());
-  }
-
-  // Get the SSRC and stats for each receiver, based on our own calculations.
-  for (int ch_id : channels) {
+    int ch_id = ch.second->channel();
     memset(&cs, 0, sizeof(cs));
     if (engine()->voe()->rtp()->GetRemoteSSRC(ch_id, ssrc) != -1 &&
         engine()->voe()->rtp()->GetRTCPStatistics(ch_id, cs) != -1 &&
         engine()->voe()->codec()->GetRecCodec(ch_id, codec) != -1) {
       VoiceReceiverInfo rinfo;
       rinfo.add_ssrc(ssrc);
       rinfo.bytes_rcvd = cs.bytesReceived;
       rinfo.packets_rcvd = cs.packetsReceived;
       // The next four fields are from the most recently sent RTCP report.
       // Convert Q8 to floating point.
@@ skipping 76 matching lines @@
   int ret = engine()->voe()->volume()->GetSpeechOutputLevel(channel, ulevel);
   return (ret == 0) ? static_cast<int>(ulevel) : -1;
 }
 
 int WebRtcVoiceMediaChannel::GetReceiveChannelId(uint32 ssrc) const {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   ChannelMap::const_iterator it = receive_channels_.find(ssrc);
   if (it != receive_channels_.end()) {
     return it->second->channel();
   }
-  return (ssrc == default_receive_ssrc_) ? default_send_channel_id() : -1;
+  return -1;
 }
 
 int WebRtcVoiceMediaChannel::GetSendChannelId(uint32 ssrc) const {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   ChannelMap::const_iterator it = send_channels_.find(ssrc);
   if (it != send_channels_.end()) {
     return it->second->channel();
   }
   return -1;
 }
@@ skipping 47 matching lines @@
     LOG_RTCERR2(SetRTCPStatus, channel, 1);
     return false;
   }
   // TODO(juberti): Enable VQMon and RTCP XR reports, once we know what
   // what we want to do with them.
   // engine()->voe().EnableVQMon(default_send_channel_id(), true);
   // engine()->voe().EnableRTCP_XR(default_send_channel_id(), true);
   return true;
 }
 
-bool WebRtcVoiceMediaChannel::ResetRecvCodecs(int channel) {
-  int ncodecs = engine()->voe()->codec()->NumOfCodecs();
-  for (int i = 0; i < ncodecs; ++i) {
-    webrtc::CodecInst voe_codec;
-    if (engine()->voe()->codec()->GetCodec(i, voe_codec) != -1) {
-      voe_codec.pltype = -1;
-      if (engine()->voe()->codec()->SetRecPayloadType(
-          channel, voe_codec) == -1) {
-        LOG_RTCERR2(SetRecPayloadType, channel, ToString(voe_codec));
-        return false;
-      }
-    }
-  }
-  return true;
-}
-
 bool WebRtcVoiceMediaChannel::SetPlayout(int channel, bool playout) {
   if (playout) {
     LOG(LS_INFO) << "Starting playout for channel #" << channel;
     if (engine()->voe()->base()->StartPlayout(channel) == -1) {
       LOG_RTCERR1(StartPlayout, channel);
       return false;
     }
   } else {
     LOG(LS_INFO) << "Stopping playout for channel #" << channel;
     engine()->voe()->base()->StopPlayout(channel);
   }
   return true;
 }
 
-uint32 WebRtcVoiceMediaChannel::ParseSsrc(const void* data, size_t len,
-                                        bool rtcp) {
-  size_t ssrc_pos = (!rtcp) ? 8 : 4;
-  uint32 ssrc = 0;
-  if (len >= (ssrc_pos + sizeof(ssrc))) {
-    ssrc = rtc::GetBE32(static_cast<const char*>(data) + ssrc_pos);
-  }
-  return ssrc;
-}
-
 // Convert VoiceEngine error code into VoiceMediaChannel::Error enum.
 VoiceMediaChannel::Error
     WebRtcVoiceMediaChannel::WebRtcErrorToChannelError(int err_code) {
   switch (err_code) {
     case 0:
       return ERROR_NONE;
     case VE_CANNOT_START_RECORDING:
     case VE_MIC_VOL_ERROR:
     case VE_GET_MIC_VOL_ERROR:
     case VE_CANNOT_ACCESS_MIC_VOL:
@@ skipping 74 matching lines @@
 }
 
 bool WebRtcVoiceMediaChannel::SetRecvCodecsInternal(
     const std::vector<AudioCodec>& new_codecs) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   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;
-      if (default_receive_ssrc_ == 0) {
-        // Set the receive codecs on the default channel explicitly if the
-        // default channel is not used by |receive_channels_|, this happens in
-        // conference mode or in non-conference mode when there is no playout
-        // channel.
-        // TODO(xians): Figure out how we use the default channel in conference
-        // mode.
-        if (engine()->voe()->codec()->SetRecPayloadType(
-            default_send_channel_id(), voe_codec) == -1) {
-          LOG_RTCERR2(SetRecPayloadType, default_send_channel_id(),
-                      ToString(voe_codec));
-          return false;
-        }
-      }
-
-      // Set the receive codecs on all receiving channels.
       for (const auto& ch : receive_channels_) {
         if (engine()->voe()->codec()->SetRecPayloadType(
                 ch.second->channel(), voe_codec) == -1) {
           LOG_RTCERR2(SetRecPayloadType, ch.second->channel(),
                       ToString(voe_codec));
           return false;
         }
       }
     } else {
       LOG(LS_WARNING) << "Unknown codec " << ToString(codec);
       return false;
     }
   }
   return true;
 }
 
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE