WebRtcVoiceEngine refactoring - moving codec configuration code into Send/RecvStreams

webrtc/media/engine/webrtcvoiceengine.cc

 /*
  *  Copyright (c) 2004 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 1122 matching lines @@
 }
 
 int WebRtcVoiceEngine::CreateVoEChannel() {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   return voe_wrapper_->base()->CreateChannel(voe_config_);
 }
 
 class WebRtcVoiceMediaChannel::WebRtcAudioSendStream
     : public AudioSource::Sink {
  public:
-  WebRtcAudioSendStream(int ch, webrtc::AudioTransport* voe_audio_transport,
-                        uint32_t ssrc, const std::string& c_name,
+  WebRtcAudioSendStream(int ch,
+                        WebRtcVoiceEngine* engine,

[the sun, 2016/04/01 08:29:06]

WebRtcAudioReceive/SendStream should be thin proxy classes that help WVoMC to
recreate AudioReceive/SendStream if any of the config settings change.

I'd like to break them out into separate source files, once they have matured.
So, the intention is that WebRtcAudioReceive/SendStream should NOT know about
the engine, and I am not convinced it makes sense for them to take on the
responsibilities of WVoMC in the way proposed here.

Going forward, the streams will be configured with live encoder/decoder objects,
and as I see it, the responsibility of creating those will still fall on WVoMC
(although the calls referencing the voe_channel_id will be gone).

+                        webrtc::AudioTransport* voe_audio_transport,
+                        uint32_t ssrc,
+                        const std::string& c_name,
                         const std::vector<webrtc::RtpExtension>& extensions,
                         webrtc::Call* call)
-      : voe_audio_transport_(voe_audio_transport),
+      : engine_(engine),
+        voe_audio_transport_(voe_audio_transport),
         call_(call),
         config_(nullptr) {
     RTC_DCHECK_GE(ch, 0);
     // TODO(solenberg): Once we're not using FakeWebRtcVoiceEngine anymore:
     // RTC_DCHECK(voe_audio_transport);
     RTC_DCHECK(call);
     audio_capture_thread_checker_.DetachFromThread();
     config_.rtp.ssrc = ssrc;
     config_.rtp.c_name = c_name;
     config_.voe_channel_id = ch;
@@ skipping 92 matching lines @@
     source_ = nullptr;
     UpdateSendState();
   }
 
   // Accessor to the VoE channel ID.
   int channel() const {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     return config_.voe_channel_id;
   }
 
+  bool SetSendCodecs(const WebRtcVoiceMediaChannel::SendCodecSpec& spec);
+  bool SetSendCodec(const webrtc::CodecInst& send_codec);
+  void SetNack(bool nack_enabled);
+
  private:
+  WebRtcVoiceEngine* engine() { return engine_; }
+  int GetLastEngineError() { return engine()->GetLastEngineError(); }
+
   void UpdateSendState() {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     RTC_DCHECK(stream_);
     if (send_ && source_ != nullptr) {
       stream_->Start();
     } else {  // !send || source_ = nullptr
       stream_->Stop();
     }
   }
 
   rtc::ThreadChecker worker_thread_checker_;
   rtc::ThreadChecker audio_capture_thread_checker_;
+  WebRtcVoiceEngine* engine_ = nullptr;
   webrtc::AudioTransport* const voe_audio_transport_ = nullptr;
   webrtc::Call* call_ = nullptr;
   webrtc::AudioSendStream::Config config_;
   // The stream is owned by WebRtcAudioSendStream and may be reallocated if
   // configuration changes.
   webrtc::AudioSendStream* stream_ = nullptr;
 
   // Raw pointer to AudioSource owned by LocalAudioTrackHandler.
   // PeerConnection will make sure invalidating the pointer before the object
   // goes away.
   AudioSource* source_ = nullptr;
   bool send_ = false;
 
+
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WebRtcAudioSendStream);
 };
 
 class WebRtcVoiceMediaChannel::WebRtcAudioReceiveStream {
  public:
   WebRtcAudioReceiveStream(int ch,
+                           WebRtcVoiceEngine* engine,
                            uint32_t remote_ssrc,
                            uint32_t local_ssrc,
                            bool use_transport_cc,
                            const std::string& sync_group,
                            const std::vector<webrtc::RtpExtension>& extensions,
                            webrtc::Call* call)
-      : call_(call), config_() {
+      : engine_(engine), call_(call), config_() {
     RTC_DCHECK_GE(ch, 0);
     RTC_DCHECK(call);
     config_.rtp.remote_ssrc = remote_ssrc;
     config_.rtp.local_ssrc = local_ssrc;
     config_.voe_channel_id = ch;
     config_.sync_group = sync_group;
     RecreateAudioReceiveStream(use_transport_cc, extensions);
   }
 
   ~WebRtcAudioReceiveStream() {
@@ skipping 20 matching lines @@
   int channel() const {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     return config_.voe_channel_id;
   }
 
   void SetRawAudioSink(std::unique_ptr<webrtc::AudioSinkInterface> sink) {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     stream_->SetSink(std::move(sink));
   }
 
+  void SetNack(bool nack_enabled);
+
  private:
+  WebRtcVoiceEngine* engine() { return engine_; }
   void RecreateAudioReceiveStream(
       bool use_transport_cc,
       const std::vector<webrtc::RtpExtension>& extensions) {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     if (stream_) {
       call_->DestroyAudioReceiveStream(stream_);
       stream_ = nullptr;
     }
     config_.rtp.extensions = extensions;
     config_.rtp.transport_cc = use_transport_cc;
     RTC_DCHECK(!stream_);
     stream_ = call_->CreateAudioReceiveStream(config_);
     RTC_CHECK(stream_);
   }
 
   rtc::ThreadChecker worker_thread_checker_;
+  WebRtcVoiceEngine* engine_ = nullptr;
   webrtc::Call* call_ = nullptr;
   webrtc::AudioReceiveStream::Config config_;
   // The stream is owned by WebRtcAudioReceiveStream and may be reallocated if
   // configuration changes.
   webrtc::AudioReceiveStream* stream_ = nullptr;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WebRtcAudioReceiveStream);
 };
 
 WebRtcVoiceMediaChannel::WebRtcVoiceMediaChannel(WebRtcVoiceEngine* engine,
@@ skipping 273 matching lines @@
         break;
       }
     }
 
     // Latch in the new state.
     send_codec_spec_ = std::move(send_codec_spec);
   }
 
   // Cache the codecs in order to configure the channel created later.
   for (const auto& ch : send_streams_) {
-    if (!SetSendCodecs(ch.second->channel())) {
+    if (!ch.second->SetSendCodecs(send_codec_spec_)) {
       return false;
     }
   }
 
+  if (send_bitrate_setting_) {
+    SetSendBitrateInternal(send_bitrate_bps_);
+  }
+
   // Set nack status on receive channels.
   if (!send_streams_.empty()) {
     for (const auto& kv : recv_streams_) {
-      SetNack(kv.second->channel(), send_codec_spec_.nack_enabled);
+      kv.second->SetNack(send_codec_spec_.nack_enabled);
     }
   }
 
   // Check if the transport cc feedback has changed on the preferred send codec,
   // and in that case reconfigure all receive streams.
   if (recv_transport_cc_enabled_ != send_codec_spec_.transport_cc_enabled) {
     LOG(LS_INFO) << "Recreate all the receive streams because the send "
                     "codec has changed.";
     recv_transport_cc_enabled_ = send_codec_spec_.transport_cc_enabled;
     for (auto& kv : recv_streams_) {
       kv.second->RecreateAudioReceiveStream(recv_transport_cc_enabled_);
     }
   }
 
   return true;
 }
 
-// Apply current codec settings to a single voe::Channel used for sending.
-bool WebRtcVoiceMediaChannel::SetSendCodecs(int channel) {
-  // Disable VAD, FEC, and RED unless we know the other side wants them.
-  engine()->voe()->codec()->SetVADStatus(channel, false);
-  engine()->voe()->rtp()->SetNACKStatus(channel, false, 0);
-  engine()->voe()->rtp()->SetREDStatus(channel, false);
-  engine()->voe()->codec()->SetFECStatus(channel, false);
-
-  if (send_codec_spec_.red_payload_type != -1) {
-    // Enable redundant encoding of the specified codec. Treat any
-    // failure as a fatal internal error.
-    LOG(LS_INFO) << "Enabling RED on channel " << channel;
-    if (engine()->voe()->rtp()->SetREDStatus(channel, true,
-        send_codec_spec_.red_payload_type) == -1) {
-      LOG_RTCERR3(SetREDStatus, channel, true,
-                  send_codec_spec_.red_payload_type);
-      return false;
-    }
-  }
-
-  SetNack(channel, send_codec_spec_.nack_enabled);
-
-  // Set the codec immediately, since SetVADStatus() depends on whether
-  // the current codec is mono or stereo.
-  if (!SetSendCodec(channel, send_codec_spec_.codec_inst)) {
-    return false;
-  }
-
-  // FEC should be enabled after SetSendCodec.
-  if (send_codec_spec_.enable_codec_fec) {
-    LOG(LS_INFO) << "Attempt to enable codec internal FEC on channel "
-                 << channel;
-    if (engine()->voe()->codec()->SetFECStatus(channel, true) == -1) {
-      // Enable codec internal FEC. Treat any failure as fatal internal error.
-      LOG_RTCERR2(SetFECStatus, channel, true);
-      return false;
-    }
-  }
-
-  if (IsCodec(send_codec_spec_.codec_inst, kOpusCodecName)) {
-    // DTX and maxplaybackrate should be set after SetSendCodec. Because current
-    // send codec has to be Opus.
-
-    // Set Opus internal DTX.
-    LOG(LS_INFO) << "Attempt to "
-                 << (send_codec_spec_.enable_opus_dtx ? "enable" : "disable")
-                 << " Opus DTX on channel "
-                 << channel;
-    if (engine()->voe()->codec()->SetOpusDtx(channel,
-        send_codec_spec_.enable_opus_dtx)) {
-      LOG_RTCERR2(SetOpusDtx, channel, send_codec_spec_.enable_opus_dtx);
-      return false;
-    }
-
-    // If opus_max_playback_rate <= 0, the default maximum playback rate
-    // (48 kHz) will be used.
-    if (send_codec_spec_.opus_max_playback_rate > 0) {
-      LOG(LS_INFO) << "Attempt to set maximum playback rate to "
-                   << send_codec_spec_.opus_max_playback_rate
-                   << " Hz on channel "
-                   << channel;
-      if (engine()->voe()->codec()->SetOpusMaxPlaybackRate(
-          channel, send_codec_spec_.opus_max_playback_rate) == -1) {
-        LOG_RTCERR2(SetOpusMaxPlaybackRate, channel,
-                    send_codec_spec_.opus_max_playback_rate);
-        return false;
-      }
-    }
-  }
-
-  if (send_bitrate_setting_) {
-    SetSendBitrateInternal(send_bitrate_bps_);
-  }
-
-  // Set the CN payloadtype and the VAD status.
-  if (send_codec_spec_.cng_payload_type != -1) {
-    // The CN payload type for 8000 Hz clockrate is fixed at 13.
-    if (send_codec_spec_.cng_plfreq != 8000) {
-      webrtc::PayloadFrequencies cn_freq;
-      switch (send_codec_spec_.cng_plfreq) {
-        case 16000:
-          cn_freq = webrtc::kFreq16000Hz;
-          break;
-        case 32000:
-          cn_freq = webrtc::kFreq32000Hz;
-          break;
-        default:
-          RTC_NOTREACHED();
-          return false;
-      }
-      if (engine()->voe()->codec()->SetSendCNPayloadType(
-              channel, send_codec_spec_.cng_payload_type, cn_freq) == -1) {
-        LOG_RTCERR3(SetSendCNPayloadType, channel,
-                    send_codec_spec_.cng_payload_type, cn_freq);
-        // TODO(ajm): This failure condition will be removed from VoE.
-        // Restore the return here when we update to a new enough webrtc.
-        //
-        // Not returning false because the SetSendCNPayloadType will fail if
-        // the channel is already sending.
-        // This can happen if the remote description is applied twice, for
-        // example in the case of ROAP on top of JSEP, where both side will
-        // send the offer.
-      }
-    }
-
-    // Only turn on VAD if we have a CN payload type that matches the
-    // clockrate for the codec we are going to use.
-    if (send_codec_spec_.cng_plfreq == send_codec_spec_.codec_inst.plfreq &&
-        send_codec_spec_.codec_inst.channels == 1) {
-      // TODO(minyue): If CN frequency == 48000 Hz is allowed, consider the
-      // interaction between VAD and Opus FEC.
-      LOG(LS_INFO) << "Enabling VAD";
-      if (engine()->voe()->codec()->SetVADStatus(channel, true) == -1) {
-        LOG_RTCERR2(SetVADStatus, channel, true);
-        return false;
-      }
-    }
-  }
-  return true;
-}
-
-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);
-  }
-}
-
-bool WebRtcVoiceMediaChannel::SetSendCodec(
-    int channel, const webrtc::CodecInst& send_codec) {
-  LOG(LS_INFO) << "Send channel " << channel <<  " selected voice codec "
-               << ToString(send_codec) << ", bitrate=" << send_codec.rate;
-
-  webrtc::CodecInst current_codec = {0};
-  if (engine()->voe()->codec()->GetSendCodec(channel, current_codec) == 0 &&
-      (send_codec == current_codec)) {
-    // Codec is already configured, we can return without setting it again.
-    return true;
-  }
-
-  if (engine()->voe()->codec()->SetSendCodec(channel, send_codec) == -1) {
-    LOG_RTCERR2(SetSendCodec, channel, ToString(send_codec));
-    return false;
-  }
-  return true;
-}
-
 bool WebRtcVoiceMediaChannel::SetPlayout(bool playout) {
   desired_playout_ = playout;
   return ChangePlayout(desired_playout_);
 }
 
 bool WebRtcVoiceMediaChannel::PausePlayout() {
   return ChangePlayout(false);
 }
 
 bool WebRtcVoiceMediaChannel::ResumePlayout() {
@@ skipping 97 matching lines @@
   // Create a new channel for sending audio data.
   int channel = CreateVoEChannel();
   if (channel == -1) {
     return false;
   }
 
   // Save the channel to send_streams_, so that RemoveSendStream() can still
   // delete the channel in case failure happens below.
   webrtc::AudioTransport* audio_transport =
       engine()->voe()->base()->audio_transport();
-  send_streams_.insert(std::make_pair(ssrc, new WebRtcAudioSendStream(
-      channel, audio_transport, ssrc, sp.cname, send_rtp_extensions_, call_)));
+  WebRtcAudioSendStream* send_stream =
+      new WebRtcAudioSendStream(channel, engine(), audio_transport, ssrc,
+                                sp.cname, send_rtp_extensions_, call_);
+  send_streams_.insert(std::make_pair(ssrc, send_stream));
 
   // Set the current codecs to be used for the new channel. We need to do this
   // after adding the channel to send_channels_, because of how max bitrate is
   // currently being configured by SetSendCodec().
-  if (HasSendCodec() && !SetSendCodecs(channel)) {
+  if (HasSendCodec() && !send_stream->SetSendCodecs(send_codec_spec_)) {
     RemoveSendStream(ssrc);
     return false;
   }
 
+  if (send_bitrate_setting_) {
+    SetSendBitrateInternal(send_bitrate_bps_);
+  }
+
   // At this point the channel's local SSRC has been updated. If the channel is
   // 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_streams_.size() == 1) {
     receiver_reports_ssrc_ = ssrc;
     for (const auto& stream : recv_streams_) {
       int recv_channel = stream.second->channel();
       if (engine()->voe()->rtp()->SetLocalSSRC(recv_channel, ssrc) != 0) {
         LOG_RTCERR2(SetLocalSSRC, recv_channel, ssrc);
         return false;
@@ skipping 96 matching lines @@
 
   const int send_channel = GetSendChannelId(receiver_reports_ssrc_);
   if (send_channel != -1) {
     // Associate receive channel with first send channel (so the receive channel
     // can obtain RTT from the send channel)
     engine()->voe()->base()->AssociateSendChannel(channel, send_channel);
     LOG(LS_INFO) << "VoiceEngine channel #" << channel
                  << " is associated with channel #" << send_channel << ".";
   }
 
-  recv_streams_.insert(std::make_pair(
-      ssrc, new WebRtcAudioReceiveStream(channel, ssrc, receiver_reports_ssrc_,
-                                         recv_transport_cc_enabled_,
-                                         sp.sync_label, recv_rtp_extensions_,
-                                         call_)));
+  WebRtcAudioReceiveStream* recv_stream = new WebRtcAudioReceiveStream(
+      channel, engine(), ssrc, receiver_reports_ssrc_,
+      recv_transport_cc_enabled_, sp.sync_label, recv_rtp_extensions_, call_);
+  recv_streams_.insert(std::make_pair(ssrc, recv_stream));
 
-  SetNack(channel, send_codec_spec_.nack_enabled);
+  recv_stream->SetNack(send_codec_spec_.nack_enabled);
   SetPlayout(channel, playout_);
 
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::RemoveRecvStream(uint32_t ssrc) {
   TRACE_EVENT0("webrtc", "WebRtcVoiceMediaChannel::RemoveRecvStream");
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   LOG(LS_INFO) << "RemoveRecvStream: " << ssrc;
 
@@ skipping 308 matching lines @@
   if (bps <= 0)
     return true;
 
   webrtc::CodecInst codec = send_codec_spec_.codec_inst;
   bool is_multi_rate = WebRtcVoiceCodecs::IsCodecMultiRate(codec);
 
   if (is_multi_rate) {
     // If codec is multi-rate then just set the bitrate.
     codec.rate = bps;
     for (const auto& ch : send_streams_) {
-      if (!SetSendCodec(ch.second->channel(), codec)) {
+      if (!ch.second->SetSendCodec(codec)) {
         LOG(LS_INFO) << "Failed to set codec " << codec.plname
                      << " to bitrate " << bps << " bps.";
         return false;
       }
     }
     return true;
   } else {
     // If codec is not multi-rate and |bps| is less than the fixed bitrate
     // then fail. If codec is not multi-rate and |bps| exceeds or equal the
     // fixed bitrate then ignore.
@@ skipping 133 matching lines @@
     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;
 }
+
+// Apply current codec settings to a single voe::Channel used for sending.
+bool WebRtcVoiceMediaChannel::WebRtcAudioSendStream::SetSendCodecs(
+    const WebRtcVoiceMediaChannel::SendCodecSpec& send_codec_spec) {
+  // Disable VAD, FEC, and RED unless we know the other side wants them.
+  engine()->voe()->codec()->SetVADStatus(channel(), false);
+  engine()->voe()->rtp()->SetNACKStatus(channel(), false, 0);
+  engine()->voe()->rtp()->SetREDStatus(channel(), false);
+  engine()->voe()->codec()->SetFECStatus(channel(), false);
+
+  if (send_codec_spec.red_payload_type != -1) {
+    // Enable redundant encoding of the specified codec. Treat any
+    // failure as a fatal internal error.
+    LOG(LS_INFO) << "Enabling RED on channel " << channel();
+    if (engine()->voe()->rtp()->SetREDStatus(
+            channel(), true, send_codec_spec.red_payload_type) == -1) {
+      LOG_RTCERR3(SetREDStatus, channel(), true,
+                  send_codec_spec.red_payload_type);
+      return false;
+    }
+  }
+
+  SetNack(send_codec_spec.nack_enabled);
+
+  // Set the codec immediately, since SetVADStatus() depends on whether
+  // the current codec is mono or stereo.
+  if (!SetSendCodec(send_codec_spec.codec_inst)) {
+    return false;
+  }
+
+  // FEC should be enabled after SetSendCodec.
+  if (send_codec_spec.enable_codec_fec) {
+    LOG(LS_INFO) << "Attempt to enable codec internal FEC on channel "
+                 << channel();
+    if (engine()->voe()->codec()->SetFECStatus(channel(), true) == -1) {
+      // Enable codec internal FEC. Treat any failure as fatal internal error.
+      LOG_RTCERR2(SetFECStatus, channel(), true);
+      return false;
+    }
+  }
+
+  if (IsCodec(send_codec_spec.codec_inst, kOpusCodecName)) {
+    // DTX and maxplaybackrate should be set after SetSendCodec. Because current
+    // send codec has to be Opus.
+
+    // Set Opus internal DTX.
+    LOG(LS_INFO) << "Attempt to "
+                 << (send_codec_spec.enable_opus_dtx ? "enable" : "disable")
+                 << " Opus DTX on channel " << channel();
+    if (engine()->voe()->codec()->SetOpusDtx(
+            channel(), send_codec_spec.enable_opus_dtx)) {
+      LOG_RTCERR2(SetOpusDtx, channel(), send_codec_spec.enable_opus_dtx);
+      return false;
+    }
+
+    // If opus_max_playback_rate <= 0, the default maximum playback rate
+    // (48 kHz) will be used.
+    if (send_codec_spec.opus_max_playback_rate > 0) {
+      LOG(LS_INFO) << "Attempt to set maximum playback rate to "
+                   << send_codec_spec.opus_max_playback_rate
+                   << " Hz on channel " << channel();
+      if (engine()->voe()->codec()->SetOpusMaxPlaybackRate(
+              channel(), send_codec_spec.opus_max_playback_rate) == -1) {
+        LOG_RTCERR2(SetOpusMaxPlaybackRate, channel(),
+                    send_codec_spec.opus_max_playback_rate);
+        return false;
+      }
+    }
+  }
+
+  // Set the CN payloadtype and the VAD status.
+  if (send_codec_spec.cng_payload_type != -1) {
+    // The CN payload type for 8000 Hz clockrate is fixed at 13.
+    if (send_codec_spec.cng_plfreq != 8000) {
+      webrtc::PayloadFrequencies cn_freq;
+      switch (send_codec_spec.cng_plfreq) {
+        case 16000:
+          cn_freq = webrtc::kFreq16000Hz;
+          break;
+        case 32000:
+          cn_freq = webrtc::kFreq32000Hz;
+          break;
+        default:
+          RTC_NOTREACHED();
+          return false;
+      }
+      if (engine()->voe()->codec()->SetSendCNPayloadType(
+              channel(), send_codec_spec.cng_payload_type, cn_freq) == -1) {
+        LOG_RTCERR3(SetSendCNPayloadType, channel(),
+                    send_codec_spec.cng_payload_type, cn_freq);
+        // TODO(ajm): This failure condition will be removed from VoE.
+        // Restore the return here when we update to a new enough webrtc.
+        //
+        // Not returning false because the SetSendCNPayloadType will fail if
+        // the channel is already sending.
+        // This can happen if the remote description is applied twice, for
+        // example in the case of ROAP on top of JSEP, where both side will
+        // send the offer.
+      }
+    }
+
+    // Only turn on VAD if we have a CN payload type that matches the
+    // clockrate for the codec we are going to use.
+    if (send_codec_spec.cng_plfreq == send_codec_spec.codec_inst.plfreq &&
+        send_codec_spec.codec_inst.channels == 1) {
+      // TODO(minyue): If CN frequency == 48000 Hz is allowed, consider the
+      // interaction between VAD and Opus FEC.
+      LOG(LS_INFO) << "Enabling VAD";
+      if (engine()->voe()->codec()->SetVADStatus(channel(), true) == -1) {
+        LOG_RTCERR2(SetVADStatus, channel(), true);
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+bool WebRtcVoiceMediaChannel::WebRtcAudioSendStream::SetSendCodec(
+    const webrtc::CodecInst& send_codec) {
+  LOG(LS_INFO) << "Send channel " << channel() << " selected voice codec "
+               << ToString(send_codec) << ", bitrate=" << send_codec.rate;
+
+  webrtc::CodecInst current_codec = {0};
+  if (engine()->voe()->codec()->GetSendCodec(channel(), current_codec) == 0 &&
+      (send_codec == current_codec)) {
+    // Codec is already configured, we can return without setting it again.
+    return true;
+  }
+
+  if (engine()->voe()->codec()->SetSendCodec(channel(), send_codec) == -1) {
+    LOG_RTCERR2(SetSendCodec, channel(), ToString(send_codec));
+    return false;
+  }
+  return true;
+}
+
+void WebRtcVoiceMediaChannel::WebRtcAudioSendStream::SetNack(
+    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);
+  }
+}
+
+void WebRtcVoiceMediaChannel::WebRtcAudioReceiveStream::SetNack(
+    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);
+  }
+}
+
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE