Configure VoE NACK through AudioSendStream::Config.

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 46 matching lines @@
 // -1 or 0 to select the default device.
 #ifdef WIN32
 const int kDefaultAudioDeviceId = -1;
 #elif !defined(WEBRTC_IOS)
 const int kDefaultAudioDeviceId = 0;
 #endif
 
 // Parameter used for NACK.
 // This value is equivalent to 5 seconds of audio data at 20 ms per packet.
 const int kNackMaxPackets = 250;
+constexpr int kNackRtpHistoryMs = 5000;
 
 // 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.
@@ skipping 377 matching lines @@
     {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, {}},
     {kCnCodecName, 8000, 1, 13, false, {}},
     {kDtmfCodecName, 8000, 1, 126, false, {}}
 };
 } // namespace {
 
+bool SendCodecSpec::operator==(const SendCodecSpec& rhs) const {
+  if (nack_enabled != rhs.nack_enabled) {
+    return false;
+  }
+  if (transport_cc_enabled != rhs.transport_cc_enabled) {
+    return false;
+  }
+  if (enable_codec_fec != rhs.enable_codec_fec) {
+    return false;
+  }
+  if (enable_opus_dtx != rhs.enable_opus_dtx) {
+    return false;
+  }
+  if (opus_max_playback_rate != rhs.opus_max_playback_rate) {
+    return false;
+  }
+  if (red_payload_type != rhs.red_payload_type) {
+    return false;
+  }
+  if (cng_payload_type != rhs.cng_payload_type) {
+    return false;
+  }
+  if (cng_plfreq != rhs.cng_plfreq) {
+    return false;
+  }
+  if (codec_inst != rhs.codec_inst) {
+    return false;
+  }
+  return true;
+}
+
+bool SendCodecSpec::operator!=(const SendCodecSpec& rhs) const {
+  return !(*this == rhs);
+}
+
 bool WebRtcVoiceEngine::ToCodecInst(const AudioCodec& in,
                                     webrtc::CodecInst* out) {
   return WebRtcVoiceCodecs::ToCodecInst(in, out);
 }
 
 WebRtcVoiceEngine::WebRtcVoiceEngine(
     webrtc::AudioDeviceModule* adm,
     const rtc::scoped_refptr<webrtc::AudioDecoderFactory>& decoder_factory)
     : WebRtcVoiceEngine(adm, decoder_factory, new VoEWrapper()) {
   audio_state_ = webrtc::AudioState::Create(MakeAudioStateConfig(voe()));
@@ skipping 588 matching lines @@
   return adm_;
 }
 
 class WebRtcVoiceMediaChannel::WebRtcAudioSendStream
     : public AudioSource::Sink {
  public:
   WebRtcAudioSendStream(int ch,
                         webrtc::AudioTransport* voe_audio_transport,
                         uint32_t ssrc,
                         const std::string& c_name,
+                        const SendCodecSpec& send_codec_spec,
                         const std::vector<webrtc::RtpExtension>& extensions,
                         webrtc::Call* call,
                         webrtc::Transport* send_transport)
       : voe_audio_transport_(voe_audio_transport),
         call_(call),
         config_(send_transport),
         rtp_parameters_(CreateRtpParametersWithOneEncoding()) {
     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;
-    RecreateAudioSendStream(extensions);
+    config_.rtp.extensions = extensions;
+    RecreateAudioSendStream(send_codec_spec);
   }
 
   ~WebRtcAudioSendStream() override {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     ClearSource();
     call_->DestroyAudioSendStream(stream_);
   }
 
+  void RecreateAudioSendStream(const SendCodecSpec& send_codec_spec) {
+    RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+    if (stream_) {
+      call_->DestroyAudioSendStream(stream_);
+      stream_ = nullptr;
+    }
+    config_.rtp.nack.rtp_history_ms =
+        send_codec_spec.nack_enabled ? kNackRtpHistoryMs : 0;
+    RTC_DCHECK(!stream_);
+    stream_ = call_->CreateAudioSendStream(config_);
+    RTC_CHECK(stream_);
+    UpdateSendState();
+  }
+
   void RecreateAudioSendStream(
       const std::vector<webrtc::RtpExtension>& extensions) {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     if (stream_) {
       call_->DestroyAudioSendStream(stream_);
       stream_ = nullptr;
     }
     config_.rtp.extensions = extensions;
     RTC_DCHECK(!stream_);
     stream_ = call_->CreateAudioSendStream(config_);
@@ skipping 506 matching lines @@
       }
       dtmf_payload_type_ = rtc::Optional<int>(codec.id);
       break;
     }
   }
 
   // Scan through the list to figure out the codec to use for sending, along
   // with the proper configuration for VAD, CNG, NACK and Opus-specific
   // parameters.
   // TODO(solenberg): Refactor this logic once we create AudioEncoders here.
+  SendCodecSpec send_codec_spec;
   {
-    SendCodecSpec send_codec_spec;
     send_codec_spec.nack_enabled = send_codec_spec_.nack_enabled;
 
     // Find send codec (the first non-telephone-event/CN codec).
     const AudioCodec* codec = WebRtcVoiceCodecs::GetPreferredCodec(
         codecs, &send_codec_spec.codec_inst);
     if (!codec) {
       LOG(LS_WARNING) << "Received empty list of codecs.";
       return false;
     }
 
@@ skipping 45 matching lines @@
           default:
             LOG(LS_WARNING) << "CN frequency " << codec.clockrate
                             << " not supported.";
             continue;
         }
         send_codec_spec.cng_payload_type = codec.id;
         send_codec_spec.cng_plfreq = cng_plfreq;
         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(), ch.second->rtp_parameters())) {
-      return false;
+  // Apply new settings to all streams.
+  if (send_codec_spec_ != send_codec_spec) {
+    send_codec_spec_ = std::move(send_codec_spec);
+    for (const auto& kv : send_streams_) {
+      kv.second->RecreateAudioSendStream(send_codec_spec_);
+      if (!SetSendCodecs(kv.second->channel(), kv.second->rtp_parameters())) {
+        return false;
+      }
     }
   }
 
   // Set nack status on receive channels.
   for (const auto& kv : recv_streams_) {
     SetNack(kv.second->channel(), 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_);
     }
   }
 
   send_codecs_ = codecs;
   return true;
 }
 
 // Apply current codec settings to a single voe::Channel used for sending.
 bool WebRtcVoiceMediaChannel::SetSendCodecs(
     int channel,
     const webrtc::RtpParameters& rtp_parameters) {
-  // Disable VAD, NACK and FEC unless we know the other side wants them.
+  // Disable VAD and FEC unless we know the other side wants them.
   engine()->voe()->codec()->SetVADStatus(channel, false);
-  engine()->voe()->rtp()->SetNACKStatus(channel, false, 0);
   engine()->voe()->codec()->SetFECStatus(channel, 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;
@@ skipping 228 matching lines @@
   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();
 
   WebRtcAudioSendStream* stream = new WebRtcAudioSendStream(
-      channel, audio_transport, ssrc, sp.cname, send_rtp_extensions_, call_,
-      this);
+      channel, audio_transport, ssrc, sp.cname, send_codec_spec_,
+      send_rtp_extensions_, call_, this);
   send_streams_.insert(std::make_pair(ssrc, 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, stream->rtp_parameters())) {
     RemoveSendStream(ssrc);
     return false;
   }
 
@@ skipping 578 matching lines @@
     }
   } else {
     LOG(LS_INFO) << "Stopping playout for channel #" << channel;
     engine()->voe()->base()->StopPlayout(channel);
   }
   return true;
 }
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE