Remove default receive channel from WVoE; baby step 0.

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 36 matching lines @@
 #include "webrtc/base/byteorder.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/stringencode.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/common.h"
 #include "webrtc/modules/audio_processing/include/audio_processing.h"
 
 namespace cricket {
+namespace {
 
-static const int kMaxNumPacketSize = 6;
+const int kMaxNumPacketSize = 6;
 struct CodecPref {
   const char* name;
   int clockrate;
   int channels;
   int payload_type;
   bool is_multi_rate;
   int packet_sizes_ms[kMaxNumPacketSize];
 };
 // Note: keep the supported packet sizes in ascending order.
-static const CodecPref kCodecPrefs[] = {
+const CodecPref kCodecPrefs[] = {
   { kOpusCodecName,   48000, 2, 111, true,  { 10, 20, 40, 60 } },
   { kIsacCodecName,   16000, 1, 103, true,  { 30, 60 } },
   { kIsacCodecName,   32000, 1, 104, true,  { 30 } },
   // G722 should be advertised as 8000 Hz because of the RFC "bug".
   { kG722CodecName,   8000,  1, 9,   false, { 10, 20, 30, 40, 50, 60 } },
   { kIlbcCodecName,   8000,  1, 102, false, { 20, 30, 40, 60 } },
   { kPcmuCodecName,   8000,  1, 0,   false, { 10, 20, 30, 40, 50, 60 } },
   { kPcmaCodecName,   8000,  1, 8,   false, { 10, 20, 30, 40, 50, 60 } },
   { kCnCodecName,     32000, 1, 106, false, { } },
   { kCnCodecName,     16000, 1, 105, false, { } },
@@ skipping 11 matching lines @@
 //
 // On Windows systems which only support Wave Audio style default, uses either
 // -1 or 0 to select the default device.
 //
 // On Windows systems which support both "Default Communication Device" and
 // old Wave Audio style default, use -1 for Default Communications Device and
 // -2 for Wave Audio style default, which is what we want to use for clips.
 // It's not clear yet whether the -2 index is handled properly on other OSes.
 
 #ifdef WIN32
-static const int kDefaultAudioDeviceId = -1;
+const int kDefaultAudioDeviceId = -1;
 #else
-static const int kDefaultAudioDeviceId = 0;
+const int kDefaultAudioDeviceId = 0;
 #endif
 
 // Parameter used for NACK.
 // This value is equivalent to 5 seconds of audio data at 20 ms per packet.
-static const int kNackMaxPackets = 250;
+const int kNackMaxPackets = 250;
 
 // Codec parameters for Opus.
 // draft-spittka-payload-rtp-opus-03
 
 // Recommended bitrates:
 // 8-12 kb/s for NB speech,
 // 16-20 kb/s for WB speech,
 // 28-40 kb/s for FB speech,
 // 48-64 kb/s for FB mono music, and
 // 64-128 kb/s for FB stereo music.
 // The current implementation applies the following values to mono signals,
 // and multiplies them by 2 for stereo.
-static const int kOpusBitrateNb = 12000;
-static const int kOpusBitrateWb = 20000;
-static const int kOpusBitrateFb = 32000;
+const int kOpusBitrateNb = 12000;
+const int kOpusBitrateWb = 20000;
+const int kOpusBitrateFb = 32000;
 
 // Opus bitrate should be in the range between 6000 and 510000.
-static const int kOpusMinBitrate = 6000;
-static const int kOpusMaxBitrate = 510000;
+const int kOpusMinBitrate = 6000;
+const int kOpusMaxBitrate = 510000;
 
 // Default audio dscp value.
 // See http://tools.ietf.org/html/rfc2474 for details.
 // See also http://tools.ietf.org/html/draft-jennings-rtcweb-qos-00
-static const rtc::DiffServCodePoint kAudioDscpValue = rtc::DSCP_EF;
+const rtc::DiffServCodePoint kAudioDscpValue = rtc::DSCP_EF;
 
 // Ensure we open the file in a writeable path on ChromeOS and Android. This
 // workaround can be removed when it's possible to specify a filename for audio
 // option based AEC dumps.
 //
 // TODO(grunell): Use a string in the options instead of hardcoding it here
 // and let the embedder choose the filename (crbug.com/264223).
 //
 // NOTE(ajm): Don't use hardcoded paths on platforms not explicitly specified
 // below.
 #if defined(CHROMEOS)
-static const char kAecDumpByAudioOptionFilename[] = "/tmp/audio.aecdump";
+const char kAecDumpByAudioOptionFilename[] = "/tmp/audio.aecdump";
 #elif defined(ANDROID)
-static const char kAecDumpByAudioOptionFilename[] = "/sdcard/audio.aecdump";
+const char kAecDumpByAudioOptionFilename[] = "/sdcard/audio.aecdump";
 #else
-static const char kAecDumpByAudioOptionFilename[] = "audio.aecdump";
+const char kAecDumpByAudioOptionFilename[] = "audio.aecdump";
 #endif
 
 // 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 292 matching lines @@
   if (length < 72) {
     std::string msg(trace, length);
     LOG(LS_ERROR) << "Malformed webrtc log message: ";
     LOG_V(sev) << msg;
   } else {
     std::string msg(trace + 71, length - 72);
     LOG_V(sev) << "webrtc: " << msg;
   }
 }
 
-void WebRtcVoiceEngine::CallbackOnError(int channel_num, int err_code) {
+void WebRtcVoiceEngine::CallbackOnError(int channel_id, int err_code) {
+  RTC_DCHECK(channel_id == -1);
+  LOG(LS_WARNING) << "VoiceEngine error " << err_code << " reported on channel "
+                  << channel_id << ".";
   rtc::CritScope lock(&channels_cs_);
-  WebRtcVoiceMediaChannel* channel = NULL;
-  uint32 ssrc = 0;
-  LOG(LS_WARNING) << "VoiceEngine error " << err_code << " reported on channel "
-                  << channel_num << ".";
-  if (FindChannelAndSsrc(channel_num, &channel, &ssrc)) {
-    RTC_DCHECK(channel != NULL);
-    channel->OnError(ssrc, err_code);
-  } else {
-    LOG(LS_ERROR) << "VoiceEngine channel " << channel_num
-                  << " could not be found in channel list when error reported.";
+  for (WebRtcVoiceMediaChannel* channel : channels_) {
+    channel->OnError(err_code);
   }
 }
 
-bool WebRtcVoiceEngine::FindChannelAndSsrc(
-    int channel_num, WebRtcVoiceMediaChannel** channel, uint32* ssrc) const {
-  RTC_DCHECK(channel != NULL && ssrc != NULL);
-
-  *channel = NULL;
-  *ssrc = 0;
-  // Find corresponding channel and ssrc
-  for (WebRtcVoiceMediaChannel* ch : channels_) {
-    RTC_DCHECK(ch != NULL);
-    if (ch->FindSsrc(channel_num, ssrc)) {
-      *channel = ch;
-      return true;
-    }
-  }
-
-  return false;
-}
-
 void WebRtcVoiceEngine::RegisterChannel(WebRtcVoiceMediaChannel* channel) {
+  RTC_DCHECK(channel != NULL);
   rtc::CritScope lock(&channels_cs_);
   channels_.push_back(channel);
 }
 
 void WebRtcVoiceEngine::UnregisterChannel(WebRtcVoiceMediaChannel* channel) {
   rtc::CritScope lock(&channels_cs_);
   auto it = std::find(channels_.begin(), channels_.end(), channel);
   if (it != channels_.end()) {
     channels_.erase(it);
   }
@@ skipping 176 matching lines @@
       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) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   engine->RegisterChannel(this);
   LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::WebRtcVoiceMediaChannel "
                   << voe_channel();
   RTC_DCHECK(nullptr != call);
   ConfigureSendChannel(voe_channel());
   SetOptions(options);
 }
 
 WebRtcVoiceMediaChannel::~WebRtcVoiceMediaChannel() {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   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) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   // 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) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   // 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
@@ skipping 69 matching lines @@
 
   RecreateAudioReceiveStreams();
 
   LOG(LS_INFO) << "Set voice channel options.  Current options: "
                << options_.ToString();
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::SetRecvCodecs(
     const std::vector<AudioCodec>& codecs) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   // Set the payload types to be used for incoming media.
   LOG(LS_INFO) << "Setting receive voice codecs:";
 
   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) {
     AudioCodec old_codec;
     if (FindCodec(recv_codecs_, codec, &old_codec)) {
@@ skipping 231 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;
   }
 
@@ skipping 47 matching lines @@
       &webrtc::VoERTP_RTCP::SetReceiveAbsoluteSenderTimeStatus, channel_id,
       send_time_extension)) {
     return false;
   }
 
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::SetSendRtpHeaderExtensions(
     const std::vector<RtpHeaderExtension>& extensions) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (send_extensions_ == extensions) {
     return true;
   }
 
   // The default channel may or may not be in |send_channels_|. Set the rtp
   // header extensions for default channel regardless.
 
   if (!SetChannelSendRtpHeaderExtensions(voe_channel(), extensions)) {
     return false;
   }
@@ skipping 38 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);
   }
@@ skipping 68 matching lines @@
       return false;
     }
   }
 
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::SetAudioSend(uint32 ssrc, bool enable,
                                            const AudioOptions* options,
                                            AudioRenderer* renderer) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   // TODO(solenberg): The state change should be fully rolled back if any one of
   //                  these calls fail.
   if (!SetLocalRenderer(ssrc, renderer)) {
     return false;
   }
   if (!MuteStream(ssrc, !enable)) {
     return false;
   }
   if (enable && options) {
     return SetOptions(*options);
@@ skipping 25 matching lines @@
 
   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());
+  int channel = GetSendChannelId(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_) {
     if (IsDefaultChannel(ch.second->channel())) {
       default_channel_is_available = false;
       break;
@@ skipping 87 matching lines @@
   }
 
   if (send_channels_.empty())
     ChangeSend(SEND_NOTHING);
 
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::AddRecvStream(const StreamParams& sp) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  LOG(LS_INFO) << "AddRecvStream: " << sp.ToString();
+
   rtc::CritScope lock(&receive_channels_cs_);
 
   if (!VERIFY(sp.ssrcs.size() == 1))
     return false;
   uint32 ssrc = sp.first_ssrc();
 
   if (ssrc == 0) {
     LOG(LS_WARNING) << "AddRecvStream with 0 ssrc is not supported.";
     return false;
   }
@@ skipping 38 matching lines @@
   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) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   // Configure to use external transport, like our default channel.
   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).
   unsigned int send_ssrc = 0;
   webrtc::VoERTP_RTCP* rtp = engine()->voe()->rtp();
@@ skipping 52 matching lines @@
   // 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);
@@ skipping 38 matching lines @@
   if (enable_default_channel_playout && playout_) {
     LOG(LS_INFO) << "Enabling playback on the default voice channel";
     SetPlayout(voe_channel(), true);
   }
 
   return true;
 }
 
 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) {
+  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(voe_channel());
   for (const auto& ch : receive_channels_) {
     int level = GetOutputLevel(ch.second->channel());
     highest = std::max(level, highest);
   }
   return highest;
 }
 
 int WebRtcVoiceMediaChannel::GetTimeSinceLastTyping() {
@@ skipping 16 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_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(voe_channel());
     for (const auto& ch : receive_channels_) {
       channels.push_back(ch.second->channel());
     }
   } else {  // Collect only the channel of the specified ssrc.
-    int channel = GetReceiveChannelNum(ssrc);
+    int channel = GetReceiveChannelId(ssrc);
     if (-1 == channel) {
       LOG(LS_WARNING) << "Cannot find channel for ssrc:" << ssrc;
       return false;
     }
     channels.push_back(channel);
   }
 
   // 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));
@@ skipping 40 matching lines @@
           default_channel_is_inuse = true;
           break;
         }
       }
       if (default_channel_is_inuse) {
         channel = voe_channel();
       } else if (!send_channels_.empty()) {
         channel = send_channels_.begin()->second->channel();
       }
     } else {
-      channel = GetSendChannelNum(ssrc);
+      channel = GetSendChannelId(ssrc);
     }
     if (channel == -1) {
       LOG(LS_WARNING) << "InsertDtmf - The specified ssrc "
                       << ssrc << " is not in use.";
       return false;
     }
     // Send DTMF using out-of-band DTMF. ("true", as 3rd arg)
     if (engine()->voe()->dtmf()->SendTelephoneEvent(
             channel, event, true, duration) == -1) {
       LOG_RTCERR4(SendTelephoneEvent, channel, event, true, duration);
@@ skipping 21 matching lines @@
   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));
+      GetReceiveChannelId(ParseSsrc(packet->data(), packet->size(), false));
   if (which_channel == -1) {
     which_channel = voe_channel();
   }
 
   // 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));
 }
 
@@ skipping 15 matching lines @@
   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 (type == kRtcpTypeSR) {
     int which_channel =
-        GetReceiveChannelNum(ParseSsrc(packet->data(), packet->size(), true));
+        GetReceiveChannelId(ParseSsrc(packet->data(), packet->size(), true));
     if (which_channel != -1) {
       engine()->voe()->network()->ReceivedRTCPPacket(
           which_channel, packet->data(), packet->size());
 
       if (IsDefaultChannel(which_channel))
         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) ? voe_channel() : GetSendChannelNum(ssrc);
+  int channel = (ssrc == 0) ? voe_channel() : GetSendChannelId(ssrc);
   if (channel == -1) {
     LOG(LS_WARNING) << "The specified ssrc " << ssrc << " is not in use.";
     return false;
   }
   if (engine()->voe()->volume()->SetInputMute(channel, muted) == -1) {
     LOG_RTCERR2(SetInputMute, channel, muted);
     return false;
   }
   // We set the AGC to mute state only when all the channels are muted.
   // This implementation is not ideal, instead we should signal the AGC when
@@ skipping 63 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 166 matching lines @@
       // Get speech level.
       rinfo.audio_level = (engine()->voe()->volume()->
           GetSpeechOutputLevelFullRange(ch_id, level) != -1) ? level : -1;
       info->receivers.push_back(rinfo);
     }
   }
 
   return true;
 }
 
-bool WebRtcVoiceMediaChannel::FindSsrc(int channel_num, uint32* ssrc) {
-  rtc::CritScope lock(&receive_channels_cs_);
-  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.
-    for (const auto& ch : send_channels_) {
-      if (ch.second->channel() == channel_num) {
-        // This is a sending channel.
-        uint32 local_ssrc = 0;
-        if (engine()->voe()->rtp()->GetLocalSSRC(
-                channel_num, local_ssrc) != -1) {
-          *ssrc = local_ssrc;
-        }
-        return true;
-      }
-    }
-
-    // Check whether this is a receiving channel.
-    for (const auto& ch : receive_channels_) {
-      if (ch.second->channel() == channel_num) {
-        *ssrc = ch.first;
-        return true;
-      }
-    }
+void WebRtcVoiceMediaChannel::OnError(int error) {
+  if (send_ == SEND_NOTHING) {
+    return;
   }
-  return false;
-}
-
-void WebRtcVoiceMediaChannel::OnError(uint32 ssrc, int error) {
   if (error == VE_TYPING_NOISE_WARNING) {
     typing_noise_detected_ = true;
   } else if (error == VE_TYPING_NOISE_OFF_WARNING) {
     typing_noise_detected_ = false;
   }
 }
 
 int WebRtcVoiceMediaChannel::GetOutputLevel(int channel) {
-  unsigned int ulevel;
-  int ret =
-      engine()->voe()->volume()->GetSpeechOutputLevel(channel, ulevel);
+  unsigned int ulevel = 0;
+  int ret = engine()->voe()->volume()->GetSpeechOutputLevel(channel, ulevel);
   return (ret == 0) ? static_cast<int>(ulevel) : -1;
 }
 
-int WebRtcVoiceMediaChannel::GetReceiveChannelNum(uint32 ssrc) const {
+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_) ? voe_channel() : -1;
 }
 
-int WebRtcVoiceMediaChannel::GetSendChannelNum(uint32 ssrc) const {
+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;
 }
 
 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
@@ skipping 171 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) {
+  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.
@@ skipping 19 matching lines @@
       LOG(LS_WARNING) << "Unknown codec " << ToString(codec);
       return false;
     }
   }
   return true;
 }
 
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE