Remove the default send 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 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
 
-namespace {
+// See: https://code.google.com/p/webrtc/issues/detail?id=4740
+const int kDefaultRtcpReceiverReportSsrc = 1;
 
 bool ValidateStreamParams(const StreamParams& sp) {
   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;
   }
@@ skipping 411 matching lines @@
   LOG(LS_INFO) << "WebRtcVoiceEngine::Terminate";
   initialized_ = false;
 
   StopAecDump();
 
   voe_wrapper_->base()->Terminate();
 }
 
 VoiceMediaChannel* WebRtcVoiceEngine::CreateChannel(webrtc::Call* call,
     const AudioOptions& options) {
-  WebRtcVoiceMediaChannel* ch =
-      new WebRtcVoiceMediaChannel(this, options, call);
-  if (!ch->valid()) {
-    delete ch;
-    return nullptr;
-  }
-  return ch;
+  return new WebRtcVoiceMediaChannel(this, options, call);
 }
 
 bool WebRtcVoiceEngine::SetOptions(const AudioOptions& options) {
   if (!ApplyOptions(options)) {
     return false;
   }
   options_ = options;
   return true;
 }
 
@@ skipping 704 matching lines @@
   if (is_dumping_aec_) {
     // Stop dumping AEC when we are dumping.
     if (voe_wrapper_->processing()->StopDebugRecording() !=
         webrtc::AudioProcessing::kNoError) {
       LOG_RTCERR0(StopDebugRecording);
     }
     is_dumping_aec_ = false;
   }
 }
 
-int WebRtcVoiceEngine::CreateVoiceChannel(VoEWrapper* voice_engine_wrapper) {
-  return voice_engine_wrapper->base()->CreateChannel(voe_config_);
-}
-
-int WebRtcVoiceEngine::CreateMediaVoiceChannel() {
-  return CreateVoiceChannel(voe_wrapper_.get());
+int WebRtcVoiceEngine::CreateVoiceChannel() {

[pthatcher1, 2015/10/01 19:57:56]

Can we rename this CreateVoeChannel?

[the sun, 2015/10/13 15:07:03]

Done.

+  return voe_wrapper_->base()->CreateChannel(voe_config_);
 }
 
 class WebRtcVoiceMediaChannel::WebRtcVoiceChannelRenderer
     : public AudioRenderer::Sink {
  public:
   WebRtcVoiceChannelRenderer(int ch,
                              webrtc::AudioTransport* voe_audio_transport)
       : channel_(ch),
         voe_audio_transport_(voe_audio_transport),
         renderer_(NULL) {}
@@ skipping 69 matching lines @@
 
   // Protects |renderer_| in Start(), Stop() and OnClose().
   rtc::CriticalSection lock_;
 };
 
 // WebRtcVoiceMediaChannel
 WebRtcVoiceMediaChannel::WebRtcVoiceMediaChannel(WebRtcVoiceEngine* engine,
                                                  const AudioOptions& options,
                                                  webrtc::Call* call)
     : engine_(engine),
-      voe_channel_(engine->CreateMediaVoiceChannel()),
       send_bitrate_setting_(false),
       send_bitrate_bps_(0),
       options_(),
       dtmf_allowed_(false),
       desired_playout_(false),
       nack_enabled_(false),
       playout_(false),
       typing_noise_detected_(false),
       desired_send_(SEND_NOTHING),
       send_(SEND_NOTHING),
       call_(call),
       default_recv_ssrc_(0),
       default_recv_channel_id_(-1) {
+  LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::WebRtcVoiceMediaChannel";
+  RTC_DCHECK(nullptr != call);
   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();
+  LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::~WebRtcVoiceMediaChannel";
 
-  // Remove any remaining send streams, the default channel will be deleted
-  // later.
+  // Remove any remaining send streams.
   while (!send_channels_.empty()) {
     RemoveSendStream(send_channels_.begin()->first);
   }
 
-  // Unregister ourselves from the engine.
-  engine()->UnregisterChannel(this);
-
-  // Remove any remaining streams.
+  // Remove any remaining receive streams.
   while (!receive_channels_.empty()) {
     RemoveRecvStream(receive_channels_.begin()->first);
   }
   RTC_DCHECK(receive_streams_.empty());
 
-  // Delete the default channel.
-  DeleteChannel(voe_channel());
+  // Unregister ourselves from the engine.
+  engine()->UnregisterChannel(this);
 }
 
 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));
@@ skipping 498 matching lines @@
 
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::SetSendRtpHeaderExtensions(
     const std::vector<RtpHeaderExtension>& extensions) {
   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;
-  }
-
   // Loop through all send channels and enable/disable the extensions.
   for (const auto& ch : send_channels_) {
     if (!SetChannelSendRtpHeaderExtensions(ch.second->channel(), extensions)) {
       return false;
     }
   }
 
   send_extensions_ = extensions;
   return true;
 }
@@ skipping 126 matching lines @@
   }
   if (!MuteStream(ssrc, !enable)) {
     return false;
   }
   if (enable && options) {
     return SetOptions(*options);
   }
   return true;
 }
 
-// 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);
+int WebRtcVoiceMediaChannel::CreateChannel() {

[pthatcher1, 2015/10/01 19:57:56]

Again, can this be called CreateVoeChannel?

[the sun, 2015/10/13 15:07:03]

Done.

+  int id = engine()->CreateVoiceChannel();
+  if (id == -1) {
+    LOG_RTCERR0(CreateVoiceChannel);
+    return -1;
   }
 
-  // Enable RTCP (for quality stats and feedback messages)
-  EnableRtcp(channel);
-
-  // Set RTP header extension for the new channel.
-  SetChannelSendRtpHeaderExtensions(channel, send_extensions_);
+  if (engine()->voe()->network()->RegisterExternalTransport(id, *this) == -1) {
+    LOG_RTCERR2(RegisterExternalTransport, id, this);
+    engine()->voe()->base()->DeleteChannel(id);
+    return -1;
+  }
+  return id;
 }
 
 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();
+  uint32 ssrc = sp.first_ssrc();
+  RTC_DCHECK(0 != ssrc);
+
+  if (-1 != GetSendChannelNum(ssrc)) {

[pthatcher1, 2015/10/01 19:57:56]

"-1 != X" here and "X == -1" below.  Please be consistent.  And given how
everything in the rest of the file is "X != -1", I'd go with that here.

[the sun, 2015/10/13 15:07:03]

Done.

+    LOG(LS_ERROR) << "Stream already exists with ssrc " << 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;
-    }
+  // Create a new channel for sending audio data.
+  int channel = CreateChannel();
+  if (channel == -1) {
+    return false;
   }
-  if (default_channel_is_available) {
-    channel = voe_channel();
-  } else {
-    // Create a new channel for sending audio data.
-    channel = engine()->CreateMediaVoiceChannel();
-    if (channel == -1) {
-      LOG_RTCERR0(CreateChannel);
-      return false;
-    }
 
-    ConfigureSendChannel(channel);
+  // Enable RTCP (for quality stats and feedback messages).
+  if (engine()->voe()->rtp()->SetRTCPStatus(channel, true) == -1) {
+    LOG_RTCERR2(SetRTCPStatus, channel, 1);
+  }
+
+  SetChannelSendRtpHeaderExtensions(channel, send_extensions_);
+
+  // Set the send (local) SSRC.
+  // If there are multiple send SSRCs, we can only set the first one here, and
+  // the rest of the SSRC(s) need to be set after SetSendCodec has been called
+  // (with a codec requires multiple SSRC(s)).

[pthatcher1, 2015/10/01 19:57:56]

What does "with a codec requires multiple SSRC(s)" mean?

[the sun, 2015/10/13 15:07:03]

We don't support any audio codecs that require multiple SSRCs.

+  if (engine()->voe()->rtp()->SetLocalSSRC(channel, ssrc) == -1) {
+    LOG_RTCERR2(SetSendSSRC, channel, ssrc);
+    DeleteChannel(channel);
+    return false;
+  }
+
+  if (engine()->voe()->rtp()->SetRTCP_CNAME(channel, sp.cname.c_str()) == -1) {
+    LOG_RTCERR2(SetRTCP_CNAME, channel, sp.cname);
+    DeleteChannel(channel);
+    return false;
+  }
+
+  // Set the current codecs to be used for the new channel.
+  if (!send_codecs_.empty() && !SetSendCodecs(channel, send_codecs_)) {
+    DeleteChannel(channel);
+    return false;
   }
 
   // Save the channel to send_channels_, so that RemoveSendStream() can still
   // delete the channel in case failure happens below.
   webrtc::AudioTransport* audio_transport =
       engine()->voe()->base()->audio_transport();
   send_channels_.insert(
-      std::make_pair(sp.first_ssrc(),
+      std::make_pair(ssrc,
                      new WebRtcVoiceChannelRenderer(channel, audio_transport)));
 
-  // Set the send (local) SSRC.
-  // If there are multiple send SSRCs, we can only set the first one here, and
-  // the rest of the SSRC(s) need to be set after SetSendCodec has been called
-  // (with a codec requires multiple SSRC(s)).
-  if (engine()->voe()->rtp()->SetLocalSSRC(channel, sp.first_ssrc()) == -1) {
-    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)) {
+  // the first send channel make sure that all the receive channels are updated
+  // with the same SSRC in order to send receiver reports.
+  if (send_channels_.size() == 1) {
     for (const auto& ch : receive_channels_) {
-      if (engine()->voe()->rtp()->SetLocalSSRC(ch.second->channel(),
-                                               sp.first_ssrc()) != 0) {
-        LOG_RTCERR2(SetLocalSSRC, ch.second->channel(), sp.first_ssrc());
+      int recv_channel = ch.second->channel();
+      if (engine()->voe()->rtp()->SetLocalSSRC(recv_channel, ssrc) != 0) {
+        LOG_RTCERR2(SetLocalSSRC, ch.second->channel(), ssrc);
         return false;
       }
+      engine()->voe()->base()->AssociateSendChannel(recv_channel, channel);
+      LOG(LS_INFO) << "VoiceEngine channel #" << recv_channel
+                   << " is associated with channel #" << channel << ".";
     }
   }
 
-  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.
-  if (!send_codecs_.empty() && !SetSendCodecs(channel, send_codecs_))
-    return false;
-
   return ChangeSend(channel, desired_send_);
 }
 
 bool WebRtcVoiceMediaChannel::RemoveSendStream(uint32 ssrc) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   ChannelMap::iterator it = send_channels_.find(ssrc);
   if (it == send_channels_.end()) {
     LOG(LS_WARNING) << "Try to remove stream with ssrc " << ssrc
                     << " which doesn't exist.";
     return false;
   }
 
   int channel = it->second->channel();
   ChangeSend(channel, SEND_NOTHING);
 
   // Delete the WebRtcVoiceChannelRenderer object connected to the channel,
   // this will disconnect the audio renderer with the send channel.
   delete it->second;
   send_channels_.erase(it);
 
-  if (IsDefaultChannel(channel)) {
-    // Do not delete the default channel since the receive channels depend on
-    // the default channel, recycle it instead.
-    ChangeSend(channel, SEND_NOTHING);
-  } else {
-    // Clean up and delete the send channel.
-    LOG(LS_INFO) << "Removing audio send stream " << ssrc
-                 << " with VoiceEngine channel #" << channel << ".";
-    if (!DeleteChannel(channel))
-      return false;
+  // Clean up and delete the send channel.
+  LOG(LS_INFO) << "Removing audio send stream " << ssrc
+               << " with VoiceEngine channel #" << channel << ".";
+  if (!DeleteChannel(channel)) {
+    return false;
   }
-
-  if (send_channels_.empty())
+  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();
 
   if (!ValidateStreamParams(sp)) {
     return false;
   }
@@ skipping 10 matching lines @@
     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());
 
   // Create a new channel for receiving audio data.
-  int channel = engine()->CreateMediaVoiceChannel();
+  int channel = CreateChannel();
   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.
-  if (engine()->voe()->network()->RegisterExternalTransport(
-          channel, *this) == -1) {
-    LOG_RTCERR2(SetExternalTransport, channel, this);
-    return false;
-  }
-
   if (!SetRecvOptions(channel)) {
     return false;
   }
 
-  // Use the same SSRC as our default (send) channel, so the RTCP reports are
-  // 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);
+  uint32 rtcp_ssrc = kDefaultRtcpReceiverReportSsrc;
+  if (send_channels_.size() > 0) {
+    rtcp_ssrc = send_channels_.begin()->first;
+
+    // Associate receive channel to default send channel (so the receive channel
+    // can obtain RTT from the send channel)
+    int send_channel = send_channels_.begin()->second->channel();
+    engine()->voe()->base()->AssociateSendChannel(channel, send_channel);
+    LOG(LS_INFO) << "VoiceEngine channel #" << channel
+                 << " is associated with channel #" << send_channel << ".";
+  }
+  if (engine()->voe()->rtp()->SetLocalSSRC(channel, rtcp_ssrc) == -1) {
+    LOG_RTCERR1(SetLocalSSRC, channel);
     return false;
   }
-  if (rtp->SetLocalSSRC(channel, send_ssrc) == -1) {
-    LOG_RTCERR1(SetSendSSRC, channel);
-    return false;
-  }
-
-  // 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() << ".";
 
   // 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));
@@ skipping 190 matching lines @@
   }
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::CanInsertDtmf() {
   return dtmf_allowed_;
 }
 
 bool WebRtcVoiceMediaChannel::InsertDtmf(uint32 ssrc, int event,
                                          int duration, int flags) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (!dtmf_allowed_) {
     return false;
   }
 
   // Send the event.
   if (flags & cricket::DF_SEND) {
     int channel = -1;
     if (ssrc == 0) {
-      bool default_channel_is_inuse = false;
-      for (const auto& ch : send_channels_) {
-        if (IsDefaultChannel(ch.second->channel())) {
-          default_channel_is_inuse = true;
-          break;
-        }
-      }
-      if (default_channel_is_inuse) {
-        channel = voe_channel();
-      } else if (!send_channels_.empty()) {
+      if (send_channels_.size() > 0) {
         channel = send_channels_.begin()->second->channel();
       }
     } else {
       channel = GetSendChannelNum(ssrc);
     }
     if (channel == -1) {
       LOG(LS_WARNING) << "InsertDtmf - The specified ssrc "
                       << ssrc << " is not in use.";
       return false;
     }
@@ skipping 98 matching lines @@
   // 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_) {
     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 = -1;
+  if (ssrc == 0) {
+    if (send_channels_.size() > 0) {
+      channel = send_channels_.begin()->second->channel();
+    }

[pthatcher1, 2015/10/01 19:57:56]

The only thing that ever used ssrc=0 here was GTP, and we don't have to worry
about it anymore.

Plus, if we did support MuteStream(0) to mean "mute the default one", then we'd
have to worry about what happens when you call MuteStream(0) and then
SendAddStream().  But since no one calls MuteStream(0), I vote we just remove
support for it.

[the sun, 2015/10/13 15:07:03]

Done.

+  } else {
+    channel = GetSendChannelNum(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
   // the mic channel is muted/unmuted. We can't do it today because there
   // is no good way to know which stream is mapping to the mic channel.
   bool all_muted = muted;
   for (const auto& ch : send_channels_) {
     if (!all_muted) {
       break;
     }
     if (engine()->voe()->volume()->GetInputMute(ch.second->channel(),
                                                 all_muted)) {
       LOG_RTCERR1(GetInputMute, ch.second->channel());
       return false;
     }
   }
 
   webrtc::AudioProcessing* ap = engine()->voe()->base()->audio_processing();
-  if (ap)
+  if (ap) {
     ap->set_output_will_be_muted(all_muted);
+  }
   return true;
 }
 
 // TODO(minyue): SetMaxSendBandwidth() is subject to be renamed to
 // SetMaxSendBitrate() in future.
 bool WebRtcVoiceMediaChannel::SetMaxSendBandwidth(int bps) {
   LOG(LS_INFO) << "WebRtcVoiceMediaChannel::SetMaxSendBandwidth.";
-
   return SetSendBitrateInternal(bps);
 }
 
 bool WebRtcVoiceMediaChannel::SetSendBitrateInternal(int bps) {
   LOG(LS_INFO) << "WebRtcVoiceMediaChannel::SetSendBitrateInternal.";
 
   send_bitrate_setting_ = true;
   send_bitrate_bps_ = bps;
 
   if (!send_codec_) {
@@ skipping 260 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())
+  if (it != receive_channels_.end()) {
     return it->second->channel();
+  }
   return -1;
 }
 
 int WebRtcVoiceMediaChannel::GetSendChannelNum(uint32 ssrc) const {

[pthatcher1, 2015/10/01 19:57:56]

Can you rename this to GetSendChannelBySsrc?

[the sun, 2015/10/13 15:07:03]

Not going to do that right now.

+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   ChannelMap::const_iterator it = send_channels_.find(ssrc);
-  if (it != send_channels_.end())
+  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 27 matching lines @@
         return true;
       } else {
         break;
       }
     }
   }
   LOG(LS_WARNING) << "RED params " << red_params << " are invalid.";
   return false;
 }
 
-bool WebRtcVoiceMediaChannel::EnableRtcp(int channel) {
-  if (engine()->voe()->rtp()->SetRTCPStatus(channel, true) == -1) {
-    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::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);
@@ skipping 107 matching lines @@
       LOG(LS_WARNING) << "Unknown codec " << ToString(codec);
       return false;
     }
   }
   return true;
 }
 
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE