Using AudioOption to enable audio network adaptor.

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 168 matching lines @@
   auto it = std::unique(payload_types.begin(), payload_types.end());
   return it == payload_types.end();
 }
 
 // Return true if codec.params[feature] == "1", false otherwise.
 bool IsCodecFeatureEnabled(const AudioCodec& codec, const char* feature) {
   int value;
   return codec.GetParam(feature, &value) && value == 1;
 }
 
+// Returns integer parameter params[feature] if it is defined. Returns
+// |default_value| otherwise.
+int GetCodecFeatureInt(const AudioCodec& codec,
+                       const char* feature,
+                       int default_value) {
+  int value;
+  if (codec.GetParam(feature, &value)) {
+    return value;
+  }
+  return default_value;
+}
+
 // 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.
 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;
@@ skipping 15 matching lines @@
     std::string rate_source =
         use_param ? "Codec parameter \"maxaveragebitrate\"" :
             "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.
-int GetOpusMaxPlaybackRate(const AudioCodec& codec) {
-  int value;
-  if (codec.GetParam(kCodecParamMaxPlaybackRate, &value)) {
-    return value;
-  }
-  return kOpusDefaultMaxPlaybackRate;
-}
-
-void GetOpusConfig(const AudioCodec& codec, webrtc::CodecInst* voe_codec,
-                          bool* enable_codec_fec, int* max_playback_rate,
-                          bool* enable_codec_dtx) {
+void GetOpusConfig(const AudioCodec& codec,
+                   webrtc::CodecInst* voe_codec,
+                   bool* enable_codec_fec,
+                   int* max_playback_rate,
+                   bool* enable_codec_dtx,
+                   int* min_ptime_ms,
+                   int* max_ptime_ms) {
   *enable_codec_fec = IsCodecFeatureEnabled(codec, kCodecParamUseInbandFec);
   *enable_codec_dtx = IsCodecFeatureEnabled(codec, kCodecParamUseDtx);
-  *max_playback_rate = GetOpusMaxPlaybackRate(codec);
+  *max_playback_rate = GetCodecFeatureInt(codec, kCodecParamMaxPlaybackRate,
+                                          kOpusDefaultMaxPlaybackRate);
+  *max_ptime_ms =
+      GetCodecFeatureInt(codec, kCodecParamMaxPTime, kOpusDefaultMaxPTime);
+  *min_ptime_ms =
+      GetCodecFeatureInt(codec, kCodecParamMinPTime, kOpusDefaultMinPTime);
 
   // 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);
 }
 
 webrtc::AudioState::Config MakeAudioStateConfig(VoEWrapper* voe_wrapper) {
   webrtc::AudioState::Config config;
   config.voice_engine = voe_wrapper->engine();
   return config;
 }
 
@@ skipping 564 matching lines @@
     }
   }
 
   if (options.adjust_agc_delta) {
     LOG(LS_INFO) << "Adjust agc delta is " << *options.adjust_agc_delta;
     if (!AdjustAgcLevel(*options.adjust_agc_delta)) {
       return false;
     }
   }
 
+  if (options.audio_network_adaptor_config) {
+    channel_config_.acm_config.audio_network_adaptor_enabled = true;
+    channel_config_.acm_config.audio_network_adaptor_config =
+        *options.audio_network_adaptor_config;
+  }
+
   webrtc::Config config;
 
   if (options.delay_agnostic_aec)
     delay_agnostic_aec_ = options.delay_agnostic_aec;
   if (delay_agnostic_aec_) {
     LOG(LS_INFO) << "Delay agnostic aec is enabled? " << *delay_agnostic_aec_;
     config.Set<webrtc::DelayAgnostic>(
         new webrtc::DelayAgnostic(*delay_agnostic_aec_));
   }
 
@@ skipping 456 matching lines @@
     return rtp_parameters_;
   }
 
   void SetRtpParameters(const webrtc::RtpParameters& parameters) {
     RTC_CHECK_EQ(1UL, parameters.encodings.size());
     rtp_parameters_ = parameters;
     // parameters.encodings[0].active could have changed.
     UpdateSendState();
   }
 
+  bool EnableAudioNetworkAdaptor(const std::string& config_string) {
+    RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(stream_);
+    return stream_->EnableAudioNetworkAdaptor(config_string);
+  }
+
+  void DisableAudioNetworkAdaptor() {
+    RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(stream_);
+    stream_->DisableAudioNetworkAdaptor();
+  }
+
+  void SetReceiverFrameLengthRange(int min_frame_length_ms,

[michaelt, 2016/10/19 13:32:55]

Will you add a interface for ana_dump as well ?

+                                   int max_frame_length_ms) {
+    RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(stream_);
+    stream_->SetReceiverFrameLengthRange(min_frame_length_ms,
+                                         max_frame_length_ms);
+  }
+
  private:
   void UpdateSendState() {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     RTC_DCHECK(stream_);
     RTC_DCHECK_EQ(1UL, rtp_parameters_.encodings.size());
     if (send_ && source_ != nullptr && rtp_parameters_.encodings[0].active) {
       stream_->Start();
     } else {  // !send || source_ = nullptr
       stream_->Stop();
     }
@@ skipping 462 matching lines @@
 
     send_codec_spec.transport_cc_enabled = HasTransportCc(*codec);
     send_codec_spec.nack_enabled = HasNack(*codec);
 
     // For Opus as the send codec, we are to determine inband FEC, maximum
     // playback rate, and opus internal dtx.
     if (IsCodec(*codec, kOpusCodecName)) {
       GetOpusConfig(*codec, &send_codec_spec.codec_inst,
                     &send_codec_spec.enable_codec_fec,
                     &send_codec_spec.opus_max_playback_rate,
-                    &send_codec_spec.enable_opus_dtx);
+                    &send_codec_spec.enable_opus_dtx,
+                    &send_codec_spec.min_ptime_ms,
+                    &send_codec_spec.max_ptime_ms);
     }
 
     // Set packet size if the AudioCodec param kCodecParamPTime is set.
     int ptime_ms = 0;
     if (codec->GetParam(kCodecParamPTime, &ptime_ms)) {
       if (!WebRtcVoiceCodecs::SetPTimeAsPacketSize(
           &send_codec_spec.codec_inst, ptime_ms)) {
         LOG(LS_WARNING) << "Failed to set packet size for codec "
                         << send_codec_spec.codec_inst.plname;
         return false;
@@ skipping 32 matching lines @@
         break;
       }
     }
   }
 
   // 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())) {
+      if (!SetSendCodecs(kv.first, kv.second->rtp_parameters())) {
         return false;
       }
     }
   }
 
   // Check if the transport cc feedback or NACK status 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 ||
       recv_nack_enabled_ != send_codec_spec_.nack_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;
     recv_nack_enabled_ = send_codec_spec_.nack_enabled;
     for (auto& kv : recv_streams_) {
       kv.second->RecreateAudioReceiveStream(recv_transport_cc_enabled_,
                                             recv_nack_enabled_);
     }
   }
 
   send_codecs_ = codecs;
   return true;
 }
 
 // Apply current codec settings to a single voe::Channel used for sending.
 bool WebRtcVoiceMediaChannel::SetSendCodecs(
-    int channel,
+    uint32_t ssrc,
     const webrtc::RtpParameters& rtp_parameters) {
+  int channel = GetSendChannelId(ssrc);
+
   // Disable VAD and FEC unless we know the other side wants them.
   engine()->voe()->codec()->SetVADStatus(channel, false);
   engine()->voe()->codec()->SetFECStatus(channel, false);
 
   // 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;
   }
 
@@ skipping 79 matching lines @@
         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;
       }
     }
   }
+
+  auto it = send_streams_.find(ssrc);
+  RTC_CHECK(it != send_streams_.end());
+  const auto acm_config = engine()->channel_config_.acm_config;
+  if (acm_config.audio_network_adaptor_enabled) {
+    if (IsCodec(send_codec_spec_.codec_inst, kOpusCodecName)) {
+      // Audio network adaptor is only allowed for Opus currently.
+      if (it->second->EnableAudioNetworkAdaptor(

[michaelt, 2016/10/19 13:32:55]

You will have to change the order of Enable and set frame length when
"Simplifying audio network adaptor by moving receiver frame length range to
ctor." is landed.   

+              acm_config.audio_network_adaptor_config)) {

[the sun, 2016/10/06 08:03:46]

If this information is already propagated to the Channel's ACM, why do you need
to act on it here as well?

+        LOG(LS_ERROR) << "Audio network adaptor cannot be enabled on SSRC "
+                      << ssrc;
+        return false;
+      }
+      LOG(LS_INFO) << "Audio network adaptor enabled on SSRC " << ssrc;
+      it->second->SetReceiverFrameLengthRange(send_codec_spec_.min_ptime_ms,
+                                              send_codec_spec_.max_ptime_ms);
+    }
+  } else {
+    it->second->DisableAudioNetworkAdaptor();
+  }
   return true;
 }
 
 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 &&
@@ skipping 117 matching lines @@
       engine()->voe()->base()->audio_transport();
 
   WebRtcAudioSendStream* stream = new WebRtcAudioSendStream(
       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())) {
+  if (HasSendCodec() && !SetSendCodecs(ssrc, stream->rtp_parameters())) {
     RemoveSendStream(ssrc);
     return false;
   }
 
   // At this point the stream's local SSRC has been updated. If it is the first
   // send stream, make sure that all the receive streams are updated with the
   // same SSRC in order to send receiver reports.
   if (send_streams_.size() == 1) {
     receiver_reports_ssrc_ = ssrc;
     for (const auto& kv : recv_streams_) {
@@ skipping 544 matching lines @@
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   const auto it = send_streams_.find(ssrc);
   if (it != send_streams_.end()) {
     return it->second->channel();
   }
   return -1;
 }
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE