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 129 matching lines @@
 // NOTE(ajm): Don't use hardcoded paths on platforms not explicitly specified
 // below.
 #if defined(CHROMEOS)
 static const char kAecDumpByAudioOptionFilename[] = "/tmp/audio.aecdump";
 #elif defined(ANDROID)
 static const char kAecDumpByAudioOptionFilename[] = "/sdcard/audio.aecdump";
 #else
 static const char kAecDumpByAudioOptionFilename[] = "audio.aecdump";
 #endif
 
+namespace {
+
+bool ValidateStreamParams(const StreamParams& sp) {

[pthatcher1, 2015/10/02 02:33:30]

static?

[the sun, 2015/10/02 11:34:19]

Nope, it's in an anonymous namespace.

http://google-styleguide.googlecode.com/svn/trunk/cppguide.html#Namespaces

+  if (sp.ssrcs.empty()) {
+    LOG(LS_ERROR) << "No SSRCs in stream parameters: " << sp.ToString();
+    return false;
+  }
+  if (sp.ssrcs.size() > 1) {
+    LOG(LS_ERROR) << "Multiple SSRCs in stream parameters: " << sp.ToString();
+    return false;
+  }
+  return true;
+}
+
 // Dumps an AudioCodec in RFC 2327-ish format.
-static std::string ToString(const AudioCodec& codec) {
+std::string ToString(const AudioCodec& codec) {
   std::stringstream ss;
   ss << codec.name << "/" << codec.clockrate << "/" << codec.channels
      << " (" << codec.id << ")";
   return ss.str();
 }
 
-static std::string ToString(const webrtc::CodecInst& codec) {
+std::string ToString(const webrtc::CodecInst& codec) {
   std::stringstream ss;
   ss << codec.plname << "/" << codec.plfreq << "/" << codec.channels
      << " (" << codec.pltype << ")";
   return ss.str();
 }
 
-static void LogMultiline(rtc::LoggingSeverity sev, char* text) {
+void LogMultiline(rtc::LoggingSeverity sev, char* text) {
   const char* delim = "\r\n";
   for (char* tok = strtok(text, delim); tok; tok = strtok(NULL, delim)) {
     LOG_V(sev) << tok;
   }
 }
 
 // Severity is an integer because it comes is assumed to be from command line.
-static int SeverityToFilter(int severity) {
+int SeverityToFilter(int severity) {
   int filter = webrtc::kTraceNone;
   switch (severity) {
     case rtc::LS_VERBOSE:
       filter |= webrtc::kTraceAll;
       FALLTHROUGH();
     case rtc::LS_INFO:
       filter |= (webrtc::kTraceStateInfo | webrtc::kTraceInfo);
       FALLTHROUGH();
     case rtc::LS_WARNING:
       filter |= (webrtc::kTraceTerseInfo | webrtc::kTraceWarning);
       FALLTHROUGH();
     case rtc::LS_ERROR:
       filter |= (webrtc::kTraceError | webrtc::kTraceCritical);
   }
   return filter;
 }
 
-static bool IsCodec(const AudioCodec& codec, const char* ref_name) {
+bool IsCodec(const AudioCodec& codec, const char* ref_name) {
   return (_stricmp(codec.name.c_str(), ref_name) == 0);
 }
 
-static bool IsCodec(const webrtc::CodecInst& codec, const char* ref_name) {
+bool IsCodec(const webrtc::CodecInst& codec, const char* ref_name) {
   return (_stricmp(codec.plname, ref_name) == 0);
 }
 
-static bool IsCodecMultiRate(const webrtc::CodecInst& codec) {
+bool IsCodecMultiRate(const webrtc::CodecInst& codec) {
   for (size_t i = 0; i < ARRAY_SIZE(kCodecPrefs); ++i) {
     if (IsCodec(codec, kCodecPrefs[i].name) &&
         kCodecPrefs[i].clockrate == codec.plfreq) {
       return kCodecPrefs[i].is_multi_rate;
     }
   }
   return false;
 }
 
-static bool FindCodec(const std::vector<AudioCodec>& codecs,
+bool FindCodec(const std::vector<AudioCodec>& codecs,
                       const AudioCodec& codec,
                       AudioCodec* found_codec) {
   for (const AudioCodec& c : codecs) {
     if (c.Matches(codec)) {
       if (found_codec != NULL) {
         *found_codec = c;
       }
       return true;
     }
   }
   return false;
 }
 
-static bool IsNackEnabled(const AudioCodec& codec) {
+bool IsNackEnabled(const AudioCodec& codec) {
   return codec.HasFeedbackParam(FeedbackParam(kRtcpFbParamNack,
                                               kParamValueEmpty));
 }
 
-static int SelectPacketSize(const CodecPref& codec_pref, int ptime_ms) {
+int SelectPacketSize(const CodecPref& codec_pref, int ptime_ms) {
   int selected_packet_size_ms = codec_pref.packet_sizes_ms[0];
   for (int packet_size_ms : codec_pref.packet_sizes_ms) {
     if (packet_size_ms && packet_size_ms <= ptime_ms) {
       selected_packet_size_ms = packet_size_ms;
     }
   }
   return selected_packet_size_ms;
 }
 
 // If the AudioCodec param kCodecParamPTime is set, then we will set it to codec
 // pacsize if it's valid, or we will pick the next smallest value we support.
 // TODO(Brave): Query supported packet sizes from ACM when the API is ready.
-static bool SetPTimeAsPacketSize(webrtc::CodecInst* codec, int ptime_ms) {
+bool SetPTimeAsPacketSize(webrtc::CodecInst* codec, int ptime_ms) {
   for (const CodecPref& codec_pref : kCodecPrefs) {
     if ((IsCodec(*codec, codec_pref.name) &&
         codec_pref.clockrate == codec->plfreq) ||
         IsCodec(*codec, kG722CodecName)) {
       int packet_size_ms = SelectPacketSize(codec_pref, ptime_ms);
       if (packet_size_ms) {
         // Convert unit from milli-seconds to samples.
         codec->pacsize = (codec->plfreq / 1000) * packet_size_ms;
         return true;
       }
     }
   }
   return false;
 }
 
 // Return true if codec.params[feature] == "1", false otherwise.
-static bool IsCodecFeatureEnabled(const AudioCodec& codec,
+bool IsCodecFeatureEnabled(const AudioCodec& codec,
                                   const char* feature) {
   int value;
   return codec.GetParam(feature, &value) && value == 1;
 }
 
 // Use params[kCodecParamMaxAverageBitrate] if it is defined, use codec.bitrate
 // otherwise. If the value (either from params or codec.bitrate) <=0, use the
 // default configuration. If the value is beyond feasible bit rate of Opus,
 // clamp it. Returns the Opus bit rate for operation.
-static int GetOpusBitrate(const AudioCodec& codec, int max_playback_rate) {
+int GetOpusBitrate(const AudioCodec& codec, int max_playback_rate) {
   int bitrate = 0;
   bool use_param = true;
   if (!codec.GetParam(kCodecParamMaxAverageBitrate, &bitrate)) {
     bitrate = codec.bitrate;
     use_param = false;
   }
   if (bitrate <= 0) {
     if (max_playback_rate <= 8000) {
       bitrate = kOpusBitrateNb;
     } else if (max_playback_rate <= 16000) {
@@ skipping 12 matching lines @@
             "Supplied Opus bitrate";
     LOG(LS_WARNING) << rate_source
                     << " is invalid and is replaced by: "
                     << bitrate;
   }
   return bitrate;
 }
 
 // Returns kOpusDefaultPlaybackRate if params[kCodecParamMaxPlaybackRate] is not
 // defined. Returns the value of params[kCodecParamMaxPlaybackRate] otherwise.
-static int GetOpusMaxPlaybackRate(const AudioCodec& codec) {
+int GetOpusMaxPlaybackRate(const AudioCodec& codec) {
   int value;
   if (codec.GetParam(kCodecParamMaxPlaybackRate, &value)) {
     return value;
   }
   return kOpusDefaultMaxPlaybackRate;
 }
 
-static void GetOpusConfig(const AudioCodec& codec, webrtc::CodecInst* voe_codec,
+void GetOpusConfig(const AudioCodec& codec, webrtc::CodecInst* voe_codec,
                           bool* enable_codec_fec, int* max_playback_rate,
                           bool* enable_codec_dtx) {
   *enable_codec_fec = IsCodecFeatureEnabled(codec, kCodecParamUseInbandFec);
   *enable_codec_dtx = IsCodecFeatureEnabled(codec, kCodecParamUseDtx);
   *max_playback_rate = GetOpusMaxPlaybackRate(codec);
 
   // If OPUS, change what we send according to the "stereo" codec
   // parameter, and not the "channels" parameter.  We set
   // voe_codec.channels to 2 if "stereo=1" and 1 otherwise.  If
   // the bitrate is not specified, i.e. is <= zero, we set it to the
   // appropriate default value for mono or stereo Opus.
 
   voe_codec->channels = IsCodecFeatureEnabled(codec, kCodecParamStereo) ? 2 : 1;
   voe_codec->rate = GetOpusBitrate(codec, *max_playback_rate);
 }
 
 // Changes RTP timestamp rate of G722. This is due to the "bug" in the RFC
 // which says that G722 should be advertised as 8 kHz although it is a 16 kHz
 // codec.
-static void MaybeFixupG722(webrtc::CodecInst* voe_codec, int new_plfreq) {
+void MaybeFixupG722(webrtc::CodecInst* voe_codec, int new_plfreq) {
   if (IsCodec(*voe_codec, kG722CodecName)) {
     // If the ASSERT triggers, the codec definition in WebRTC VoiceEngine
     // has changed, and this special case is no longer needed.
     RTC_DCHECK(voe_codec->plfreq != new_plfreq);
     voe_codec->plfreq = new_plfreq;
   }
 }
 
 // Gets the default set of options applied to the engine. Historically, these
 // were supplied as a combination of flags from the channel manager (ec, agc,
 // ns, and highpass) and the rest hardcoded in InitInternal.
-static AudioOptions GetDefaultEngineOptions() {
+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;
 }
 
-static std::string GetEnableString(bool enable) {
+std::string GetEnableString(bool enable) {
   return enable ? "enable" : "disable";
 }
+} // namespace {
 
 WebRtcVoiceEngine::WebRtcVoiceEngine()
     : voe_wrapper_(new VoEWrapper()),
       tracing_(new VoETraceWrapper()),
       adm_(NULL),
       log_filter_(SeverityToFilter(kDefaultLogSeverity)),
       is_dumping_aec_(false) {
   Construct();
 }
 
@@ skipping 481 matching lines @@
   if (options.playout_sample_rate.Get(&playout_sample_rate)) {
     LOG(LS_INFO) << "Playout sample rate is " << playout_sample_rate;
     if (voe_wrapper_->hw()->SetPlayoutSampleRate(playout_sample_rate)) {
       LOG_RTCERR1(SetPlayoutSampleRate, playout_sample_rate);
     }
   }
 
   return true;
 }
 
-struct ResumeEntry {
-  ResumeEntry(WebRtcVoiceMediaChannel *c, bool p, SendFlags s)
-      : channel(c),
-        playout(p),
-        send(s) {
-  }
-
-  WebRtcVoiceMediaChannel *channel;
-  bool playout;
-  SendFlags send;
-};
-
 // TODO(juberti): Refactor this so that the core logic can be used to set the
 // soundclip device. At that time, reinstate the soundclip pause/resume code.
 bool WebRtcVoiceEngine::SetDevices(const Device* in_device,
                                    const Device* out_device) {
 #if !defined(IOS)
   int in_id = in_device ? rtc::FromString<int>(in_device->id) :
       kDefaultAudioDeviceId;
   int out_id = out_device ? rtc::FromString<int>(out_device->id) :
       kDefaultAudioDeviceId;
   // The device manager uses -1 as the default device, which was the case for
@@ skipping 521 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) {
+      default_recv_ssrc_(0),
+      default_recv_channel_id_(-1) {
   engine->RegisterChannel(this);
   LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::WebRtcVoiceMediaChannel "
                   << voe_channel();
   RTC_DCHECK(nullptr != call);
   ConfigureSendChannel(voe_channel());
   SetOptions(options);
 }
 
 WebRtcVoiceMediaChannel::~WebRtcVoiceMediaChannel() {
   LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::~WebRtcVoiceMediaChannel "
                   << voe_channel();
 
   // Remove any remaining send streams, the default channel will be deleted
   // later.
-  while (!send_channels_.empty())
+  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()) {
     RemoveRecvStream(receive_channels_.begin()->first);
   }
   RTC_DCHECK(receive_streams_.empty());
 
   // Delete the default channel.
   DeleteChannel(voe_channel());
 }
 
 bool WebRtcVoiceMediaChannel::SetSendParameters(
     const AudioSendParameters& params) {
   // TODO(pthatcher): Refactor this to be more clean now that we have
   // all the information at once.
   return (SetSendCodecs(params.codecs) &&
           SetSendRtpHeaderExtensions(params.extensions) &&
           SetMaxSendBandwidth(params.max_bandwidth_bps) &&
           SetOptions(params.options));
 }
 
 bool WebRtcVoiceMediaChannel::SetRecvParameters(
     const AudioRecvParameters& params) {
   // TODO(pthatcher): Refactor this to be more clean now that we have
   // all the information at once.
   return (SetRecvCodecs(params.codecs) &&
           SetRecvRtpHeaderExtensions(params.extensions));
 }
 
 bool WebRtcVoiceMediaChannel::SetOptions(const AudioOptions& options) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   LOG(LS_INFO) << "Setting voice channel options: "
                << options.ToString();
 
   // Check if DSCP value is changed from previous.
   bool dscp_option_changed = (options_.dscp != options.dscp);
 
   // TODO(xians): Add support to set different options for different send
   // streams after we support multiple APMs.
 
   // We retain all of the existing options, and apply the given ones
   // on top.  This means there is no way to "clear" options such that
   // they go back to the engine default.
   options_.SetAll(options);
 
   if (send_ != SEND_NOTHING) {
     if (!engine()->ApplyOptions(options_)) {
       LOG(LS_WARNING) <<
           "Failed to apply engine options during channel SetOptions.";
       return false;
     }
   }
 
+  for (const auto& ch : receive_channels_) {
+    if (!SetRecvOptions(ch.second->channel())) {
+      return false;
+    }
+  }
+  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";
+    }
+  }
+
+  RecreateAudioReceiveStreams();
+
+  LOG(LS_INFO) << "Set voice channel options.  Current options: "
+               << options_.ToString();
+  return true;
+}
+
+bool WebRtcVoiceMediaChannel::SetRecvOptions(int channel_id) {

[pthatcher1, 2015/10/02 02:33:30]

I think this method would be cleaner if you passed in the options with the id,
and then the calls sites passed in options_.

[the sun, 2015/10/02 11:34:19]

Done.

+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+
   // Receiver-side auto gain control happens per channel, so set it here from
-  // options. Note that, like conference mode, setting it on the engine won't
-  // have the desired effect, since voice channels don't inherit options from
-  // the media engine when those options are applied per-channel.
+  // options. Note that voice channels don't inherit options from the media
+  // engine when those options are applied per-channel.
   bool rx_auto_gain_control;
-  if (options.rx_auto_gain_control.Get(&rx_auto_gain_control)) {
+  if (options_.rx_auto_gain_control.Get(&rx_auto_gain_control)) {
     if (engine()->voe()->processing()->SetRxAgcStatus(

[pthatcher1, 2015/10/02 02:33:30]

Are sure we want to set this for all receive channels?

[the sun, 2015/10/02 11:34:19]

No, but it seems really weird that we don't. I'm asking ajm@ about it.

-            voe_channel(), rx_auto_gain_control,
+            channel_id, rx_auto_gain_control,
             webrtc::kAgcFixedDigital) == -1) {
       LOG_RTCERR1(SetRxAgcStatus, rx_auto_gain_control);
       return false;
     } else {
       LOG(LS_VERBOSE) << "Rx auto gain set to " << rx_auto_gain_control
                       << " with mode " << webrtc::kAgcFixedDigital;
     }
   }
-  if (options.rx_agc_target_dbov.IsSet() ||
-      options.rx_agc_digital_compression_gain.IsSet() ||
-      options.rx_agc_limiter.IsSet()) {
+  if (options_.rx_agc_target_dbov.IsSet() ||
+      options_.rx_agc_digital_compression_gain.IsSet() ||
+      options_.rx_agc_limiter.IsSet()) {
     webrtc::AgcConfig config;
     // If only some of the options are being overridden, get the current
     // settings for the channel and bail if they aren't available.
-    if (!options.rx_agc_target_dbov.IsSet() ||
-        !options.rx_agc_digital_compression_gain.IsSet() ||
-        !options.rx_agc_limiter.IsSet()) {
+    if (!options_.rx_agc_target_dbov.IsSet() ||
+        !options_.rx_agc_digital_compression_gain.IsSet() ||
+        !options_.rx_agc_limiter.IsSet()) {
       if (engine()->voe()->processing()->GetRxAgcConfig(
-              voe_channel(), config) != 0) {
+              channel_id, config) != 0) {
         LOG(LS_ERROR) << "Failed to get default rx agc configuration for "
-                      << "channel " << voe_channel() << ". Since not all rx "
+                      << "channel " << channel_id << ". Since not all rx "
                       << "agc options are specified, unable to safely set rx "
                       << "agc options.";
         return false;
       }
     }
     config.targetLeveldBOv =
-        options.rx_agc_target_dbov.GetWithDefaultIfUnset(
+        options_.rx_agc_target_dbov.GetWithDefaultIfUnset(
             config.targetLeveldBOv);
     config.digitalCompressionGaindB =
-        options.rx_agc_digital_compression_gain.GetWithDefaultIfUnset(
+        options_.rx_agc_digital_compression_gain.GetWithDefaultIfUnset(
             config.digitalCompressionGaindB);
-    config.limiterEnable = options.rx_agc_limiter.GetWithDefaultIfUnset(
+    config.limiterEnable = options_.rx_agc_limiter.GetWithDefaultIfUnset(
         config.limiterEnable);
     if (engine()->voe()->processing()->SetRxAgcConfig(
-            voe_channel(), config) == -1) {
-      LOG_RTCERR4(SetRxAgcConfig, voe_channel(), config.targetLeveldBOv,
+            channel_id, config) == -1) {
+      LOG_RTCERR4(SetRxAgcConfig, channel_id, config.targetLeveldBOv,
                   config.digitalCompressionGaindB, config.limiterEnable);
       return false;
     }
   }
-  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";
-    }
-  }
-
-  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:";
 
+  std::vector<int> payload_types;
   std::vector<AudioCodec> new_codecs;
   // Find all new codecs. We allow adding new codecs but don't allow changing
   // the payload type of codecs that is already configured since we might
   // already be receiving packets with that payload type.
-  for (const AudioCodec& codec : codecs) {
+  for (const auto& codec : codecs) {
     AudioCodec old_codec;
     if (FindCodec(recv_codecs_, codec, &old_codec)) {
       if (old_codec.id != codec.id) {
         LOG(LS_ERROR) << codec.name << " payload type changed.";
         return false;
       }
     } else {
+      payload_types.push_back(codec.id);
       new_codecs.push_back(codec);
     }
   }
   if (new_codecs.empty()) {
     // There are no new codecs to configure. Already configured codecs are
     // never removed.
     return true;
   }
 
+  // Verify no codecs have the same payload type.
+  std::sort(payload_types.begin(), payload_types.end());
+  auto it = std::unique(payload_types.begin(), payload_types.end());
+  if (payload_types.end() != it) {
+    return false;
+  }

[pthatcher1, 2015/10/02 02:33:30]

Can you move this into a separate static helper method?

[the sun, 2015/10/02 11:34:19]

Done.

+
   if (playout_) {
     // Receive codecs can not be changed while playing. So we temporarily
     // pause playout.
     PausePlayout();
   }
 
   bool result = SetRecvCodecsInternal(new_codecs);
   if (result) {
     recv_codecs_ = codecs;
   }
@@ skipping 207 matching lines @@
           return false;
         }
       }
     }
   }
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::SetSendCodecs(
     const std::vector<AudioCodec>& codecs) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   dtmf_allowed_ = false;
   for (const AudioCodec& codec : codecs) {
     // Find the DTMF telephone event "codec".
     if (IsCodec(codec, kDtmfCodecName)) {
       dtmf_allowed_ = true;
     }
   }
 
   // Cache the codecs in order to configure the channel created later.
   send_codecs_ = codecs;
@@ skipping 51 matching lines @@
 
   if (engine()->voe()->codec()->SetSendCodec(channel, send_codec) == -1) {
     LOG_RTCERR2(SetSendCodec, channel, ToString(send_codec));
     return false;
   }
   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(voe_channel(), 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 94 matching lines @@
 
 bool WebRtcVoiceMediaChannel::PausePlayout() {
   return ChangePlayout(false);
 }
 
 bool WebRtcVoiceMediaChannel::ResumePlayout() {
   return ChangePlayout(desired_playout_);
 }
 
 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(voe_channel(), 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 82 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) {
     LOG_RTCERR1(DeleteChannel, channel);
     return false;
   }
 
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::AddSendStream(const StreamParams& sp) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   // If the default channel is already used for sending create a new channel
   // otherwise use the default channel for sending.
   int channel = GetSendChannelNum(sp.first_ssrc());
   if (channel != -1) {
     LOG(LS_ERROR) << "Stream already exists with ssrc " << sp.first_ssrc();
     return false;
   }
 
   bool default_channel_is_available = true;
   for (const auto& ch : send_channels_) {
@@ skipping 31 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 32 matching lines @@
   }
 
   if (send_channels_.empty())
     ChangeSend(SEND_NOTHING);
 
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::AddRecvStream(const StreamParams& sp) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  rtc::CritScope lock(&receive_channels_cs_);
+  LOG(LS_INFO) << "AddRecvStream: " << sp.ToString();
 
-  if (!VERIFY(sp.ssrcs.size() == 1))
+  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;
+  }
 
-  if (ssrc == 0) {
-    LOG(LS_WARNING) << "AddRecvStream with 0 ssrc is not supported.";
-    return false;
+  // Remove the default receive stream if one had been created with this ssrc;
+  // we'll recreate it then.
+  if (-1 != default_recv_channel_id_ && 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(voe_channel(), audio_transport);
-    receive_channels_.insert(std::make_pair(ssrc, channel_renderer));
-    receive_stream_params_[ssrc] = sp;
-    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;
   }
 
+  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;
 }
 
 bool WebRtcVoiceMediaChannel::ConfigureRecvChannel(int channel) {
-  // Configure to use external transport, like our default channel.
+  // Configure to use external transport.
   if (engine()->voe()->network()->RegisterExternalTransport(
           channel, *this) == -1) {
     LOG_RTCERR2(SetExternalTransport, channel, this);
     return false;
   }
 
-  // Use the same SSRC as our default channel (so the RTCP reports are correct).
+  if (!SetRecvOptions(channel)) {
+    return false;
+  }
+
+  // Use the same SSRC as our default (send) channel, so the RTCP reports are

[pthatcher1, 2015/10/02 02:33:30]

"default (send) channel" or "default send channel"?

At least be consistent between here and below.

[the sun, 2015/10/02 11:34:19]

Done.

+  // correct.
   unsigned int send_ssrc = 0;
   webrtc::VoERTP_RTCP* rtp = engine()->voe()->rtp();
   if (rtp->GetLocalSSRC(voe_channel(), send_ssrc) == -1) {
     LOG_RTCERR1(GetSendSSRC, channel);
     return false;
   }
   if (rtp->SetLocalSSRC(channel, send_ssrc) == -1) {
     LOG_RTCERR1(SetSendSSRC, channel);
     return false;
   }
 
-  // Associate receive channel to default channel (so the receive channel can
-  // obtain RTT from the send channel)
+  // Associate receive channel to default send channel (so the receive channel
+  // can obtain RTT from the send channel)
   engine()->voe()->base()->AssociateSendChannel(channel, voe_channel());
   LOG(LS_INFO) << "VoiceEngine channel #"
                << channel << " is associated with channel #"
                << voe_channel() << ".";
 
-  // 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(
-            voe_channel(), 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, voe_channel() 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(voe_channel(), 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());
-  rtc::CritScope lock(&receive_channels_cs_);
+  LOG(LS_INFO) << "RemoveRecvStream: " << ssrc;
+
   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(voe_channel(), false);
-
-    default_receive_ssrc_ = 0;
-    return true;
+  // Deregister default channel, if that's the one being destroyed.
+  if (-1 != default_recv_channel_id_ && ssrc == default_recv_ssrc_) {
+    RTC_DCHECK(channel == default_recv_channel_id_);
+    default_recv_ssrc_ = 0;
+    default_recv_channel_id_ = -1;
   }
 
   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(voe_channel(), 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;
       return false;
     }
 
     // The channel likely has gone away, do nothing.
     return true;
@@ skipping 24 matching lines @@
   if (renderer)
     it->second->Start(renderer);
   else
     it->second->Stop();
 
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::GetActiveStreams(
     AudioInfo::StreamList* actives) {
-  // In conference mode, the default channel should not be in
-  // |receive_channels_|.
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   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() {
-  // return the highest output level of all streams
-  int highest = GetOutputLevel(voe_channel());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  int highest = 0;
   for (const auto& ch : receive_channels_) {
-    int level = GetOutputLevel(ch.second->channel());
-    highest = std::max(level, highest);
+    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
     LOG_RTCERR0(TimeSinceLastTyping);
     ret = -1;
@@ skipping 11 matching lines @@
           reporting_threshold, penalty_decay, type_event_delay) == -1) {
     // 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::CritScope lock(&receive_channels_cs_);
-  // Collect the channels to scale the output volume.
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  // Collect channels to scale output volume for (ssrc == 0 means all channels).
   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(voe_channel());
-    for (const auto& ch : receive_channels_) {
+  for (const auto& ch : receive_channels_) {
+    if (0 == ssrc || ch.first == ssrc) {
       channels.push_back(ch.second->channel());
     }
-  } else {  // Collect only the channel of the specified ssrc.
-    int channel = GetReceiveChannelNum(ssrc);
-    if (-1 == channel) {
-      LOG(LS_WARNING) << "Cannot find channel for ssrc:" << ssrc;
-      return false;
-    }
-    channels.push_back(channel);
+  }
+  if (0 != ssrc && channels.empty()) {
+    LOG(LS_WARNING) << "Cannot find channel for ssrc:" << ssrc;
+    return false;
   }
 
   // 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) {
@@ skipping 66 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;
+    }
+    default_recv_ssrc_ = ssrc;
+    default_recv_channel_id_ = receive_channels_[ssrc]->channel();
+    RTC_DCHECK(-1 != default_recv_channel_id_);
+  }
+
+  // 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 =
-      GetReceiveChannelNum(ParseSsrc(packet->data(), packet->size(), false));
-  if (which_channel == -1) {
-    which_channel = voe_channel();
-  }
+  // Find the channel to send this packet to. It must exist since webrtc::Call
+  // was able to demux the packet.
+  int channel = GetReceiveChannelNum(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 channel that is listening.
-  bool has_sent_to_default_channel = false;
+  // If it is a sender report, find the receive channel that is listening.
   if (type == kRtcpTypeSR) {
-    int which_channel =
-        GetReceiveChannelNum(ParseSsrc(packet->data(), packet->size(), true));
-    if (which_channel != -1) {
+    uint32 ssrc = 0;
+    if (!GetRtcpSsrc(packet->data(), packet->size(), &ssrc)) {
+      return;
+    }
+    int channel = GetReceiveChannelNum(ssrc);
+    if (channel != -1) {
       engine()->voe()->network()->ReceivedRTCPPacket(
-          which_channel, packet->data(), packet->size());
-
-      if (IsDefaultChannel(which_channel))
-        has_sent_to_default_channel = true;
+          channel, packet->data(), packet->size());
     }
   }
 
   // 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) ? voe_channel() : GetSendChannelNum(ssrc);
   if (channel == -1) {
     LOG(LS_WARNING) << "The specified ssrc " << ssrc << " is not in use.";
     return false;
@@ skipping 70 matching lines @@
       LOG(LS_INFO) << "Failed to set codec " << codec.plname
                    << " to bitrate " << bps << " bps"
                    << ", requires at least " << codec.rate << " bps.";
       return false;
     }
     return true;
   }
 }
 
 bool WebRtcVoiceMediaChannel::GetStats(VoiceMediaInfo* info) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+
   bool echo_metrics_on = false;
   // These can take on valid negative values, so use the lowest possible level
   // as default rather than -1.
   int echo_return_loss = -100;
   int echo_return_loss_enhancement = -100;
   // These can also be negative, but in practice -1 is only used to signal
   // insufficient data, since the resolution is limited to multiples of 4 ms.
   int echo_delay_median_ms = -1;
   int echo_delay_std_ms = -1;
   if (engine()->voe()->processing()->GetEcMetricsStatus(
@@ skipping 81 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(voe_channel());
-  }
-
-  // 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 62 matching lines @@
 
 void WebRtcVoiceMediaChannel::GetLastMediaError(
     uint32* ssrc, VoiceMediaChannel::Error* error) {
   RTC_DCHECK(ssrc != NULL);
   RTC_DCHECK(error != NULL);
   FindSsrc(voe_channel(), ssrc);
   *error = WebRtcErrorToChannelError(GetLastEngineError());
 }
 
 bool WebRtcVoiceMediaChannel::FindSsrc(int channel_num, uint32* ssrc) {
-  rtc::CritScope lock(&receive_channels_cs_);
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(ssrc != NULL);
   if (channel_num == -1 && send_ != SEND_NOTHING) {
     // Sometimes the VoiceEngine core will throw error with channel_num = -1.
     // This means the error is not limited to a specific channel.  Signal the
     // message using ssrc=0.  If the current channel is sending, use this
     // channel for sending the message.
     *ssrc = 0;
     return true;
   } else {
     // Check whether this is a sending channel.
@@ skipping 30 matching lines @@
 }
 
 int WebRtcVoiceMediaChannel::GetOutputLevel(int channel) {
   unsigned int ulevel;
   int ret =
       engine()->voe()->volume()->GetSpeechOutputLevel(channel, ulevel);
   return (ret == 0) ? static_cast<int>(ulevel) : -1;
 }
 
 int WebRtcVoiceMediaChannel::GetReceiveChannelNum(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_) ? voe_channel() : -1;
+  return -1;
 }
 
 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;
 }
 
 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
@@ skipping 39 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(voe_channel(), true);
   // engine()->voe().EnableRTCP_XR(voe_channel(), 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 68 matching lines @@
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   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) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  for (const auto& 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(
-            voe_channel(), voe_codec) == -1) {
-          LOG_RTCERR2(SetRecPayloadType, voe_channel(), 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