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 130 matching lines @@
 // NOTE(ajm): Don't use hardcoded paths on platforms not explicitly specified
 // below.
 #if defined(CHROMEOS)
 const char kAecDumpByAudioOptionFilename[] = "/tmp/audio.aecdump";
 #elif defined(ANDROID)
 const char kAecDumpByAudioOptionFilename[] = "/sdcard/audio.aecdump";
 #else
 const char kAecDumpByAudioOptionFilename[] = "audio.aecdump";
 #endif
 
+// 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;
   }
   return true;
@@ skipping 423 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 682 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::CreateVoEChannel() {
+  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 63 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),
-      default_send_channel_id_(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) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::WebRtcVoiceMediaChannel";
+  RTC_DCHECK(nullptr != call);
   engine->RegisterChannel(this);
-  LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::WebRtcVoiceMediaChannel "
-                  << default_send_channel_id();
-  RTC_DCHECK(nullptr != call);
-  ConfigureSendChannel(default_send_channel_id());
   SetOptions(options);
 }
 
 WebRtcVoiceMediaChannel::~WebRtcVoiceMediaChannel() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::~WebRtcVoiceMediaChannel "
-                  << default_send_channel_id();
+  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(default_send_channel_id());
+  // Unregister ourselves from the engine.
+  engine()->UnregisterChannel(this);
 }
 
 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) &&
@@ skipping 318 matching lines @@
 
   // Cache the codecs in order to configure the channel created later.
   send_codecs_ = codecs;
   for (const auto& ch : send_channels_) {
     if (!SetSendCodecs(ch.second->channel(), codecs)) {
       return false;
     }
   }
 
   // Set nack status on receive channels and update |nack_enabled_|.
-  SetNack(receive_channels_, nack_enabled_);
+  for (const auto& ch : receive_channels_) {
+    SetNack(ch.second->channel(), nack_enabled_);
+  }
+
   return true;
 }
 
-void WebRtcVoiceMediaChannel::SetNack(const ChannelMap& channels,
-                                      bool nack_enabled) {
-  for (const auto& ch : channels) {
-    SetNack(ch.second->channel(), nack_enabled);
-  }
-}
-
 void WebRtcVoiceMediaChannel::SetNack(int channel, bool nack_enabled) {
   if (nack_enabled) {
     LOG(LS_INFO) << "Enabling NACK for channel " << channel;
     engine()->voe()->rtp()->SetNACKStatus(channel, true, kNackMaxPackets);
   } else {
     LOG(LS_INFO) << "Disabling NACK for channel " << channel;
     engine()->voe()->rtp()->SetNACKStatus(channel, false, 0);
   }
 }
 
@@ skipping 89 matching lines @@
   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(default_send_channel_id(),
-                                         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 121 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::CreateVoEChannel() {
+  int id = engine()->CreateVoEChannel();
+  if (id == -1) {
+    LOG_RTCERR0(CreateVoEChannel);
+    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 = GetSendChannelId(sp.first_ssrc());
-  if (channel != -1) {
-    LOG(LS_ERROR) << "Stream already exists with ssrc " << sp.first_ssrc();
+  uint32_t ssrc = sp.first_ssrc();
+  RTC_DCHECK(0 != ssrc);
+
+  if (GetSendChannelId(ssrc) != -1) {
+    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 = CreateVoEChannel();
+  if (channel == -1) {
+    return false;

[pthatcher1, 2015/10/15 05:15:04]

This could use a LOG(LS_ERROR).

[the sun, 2015/10/15 12:07:12]

Added LOG(LS_INFO) at start of AddSendStream() instead. CreateVoEChannel()
already logs its errors; now it is evident in what context it fails.

   }
-  if (default_channel_is_available) {
-    channel = default_send_channel_id();
-  } 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 local (send) SSRC.
+  if (engine()->voe()->rtp()->SetLocalSSRC(channel, ssrc) == -1) {
+    LOG_RTCERR2(SetLocalSSRC, 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;
   }
 
   // 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());
+  // Set the current codecs to be used for the new channel.
+  if (!send_codecs_.empty() && !SetSendCodecs(channel, send_codecs_)) {
+    RemoveSendStream(ssrc);
     return false;
   }

[pthatcher1, 2015/10/15 05:15:04]

Why do we do "add and then remove if SetSendCodecs fails" instead of trying to
SetSendCodecs and then add only if it succeeds?  That's how all the other
settings before this work.  What's special about SetSendCodecs?

[the sun, 2015/10/15 12:07:12]

Added comment.

 
   // 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) {
+    first_send_ssrc_ = ssrc;

[pthatcher1, 2015/10/15 05:15:04]

Would it make sense to call this "receiver_reports_ssrc_" or "rtcp_rr_ssrc_" and
default to 1 instead of -1?

[the sun, 2015/10/15 12:07:12]

Good idea, makes the logic clearer.

     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_t 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 = CreateVoEChannel();
   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) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  // Configure to use external transport.
-  if (engine()->voe()->network()->RegisterExternalTransport(
-          channel, *this) == -1) {
-    LOG_RTCERR2(SetExternalTransport, channel, this);
+
+  uint32_t rtcp_ssrc = kDefaultRtcpReceiverReportSsrc;
+  if (send_channels_.size() > 0) {
+    rtcp_ssrc = first_send_ssrc_;
+
+    // Associate receive channel with first send channel (so the receive channel
+    // can obtain RTT from the send channel)
+    int send_channel = send_channels_[first_send_ssrc_]->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;
   }
 
-  // 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(default_send_channel_id(), 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 send channel (so the receive channel
-  // can obtain RTT from the send channel).
-  engine()->voe()->base()->AssociateSendChannel(channel,
-                                                default_send_channel_id());
-  LOG(LS_INFO) << "VoiceEngine channel #"
-               << channel << " is associated with channel #"
-               << default_send_channel_id() << ".";
-
   // 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;
@@ skipping 152 matching lines @@
 }
 
 bool WebRtcVoiceMediaChannel::CanInsertDtmf() {
   return dtmf_allowed_;
 }
 
 bool WebRtcVoiceMediaChannel::InsertDtmf(uint32_t 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 = default_send_channel_id();
-      } else if (!send_channels_.empty()) {
+      if (send_channels_.size() > 0) {
         channel = send_channels_.begin()->second->channel();
       }
     } else {
       channel = GetSendChannelId(ssrc);
     }
     if (channel == -1) {
       LOG(LS_WARNING) << "InsertDtmf - The specified ssrc "
                       << ssrc << " is not in use.";
       return false;
     }
@@ skipping 97 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_t ssrc, bool muted) {
-  int channel =
-      (ssrc == 0) ? default_send_channel_id() : GetSendChannelId(ssrc);
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  int 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
   // 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 286 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(default_send_channel_id(), true);
-  // engine()->voe().EnableRTCP_XR(default_send_channel_id(), 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