Reduce LS_INFO spam from voice_engine/.

webrtc/voice_engine/voe_audio_processing_impl.cc

 /*
  *  Copyright (c) 2012 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 106 matching lines @@
 
   return 0;
 #else
   _shared->SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
                         "SetNsStatus() Ns is not supported");
   return -1;
 #endif
 }
 
 int VoEAudioProcessingImpl::GetNsStatus(bool& enabled, NsModes& mode) {
-  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
-               "GetNsStatus(enabled=?, mode=?)");
 #ifdef WEBRTC_VOICE_ENGINE_NR
   if (!_shared->statistics().Initialized()) {
     _shared->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
 
   enabled = _shared->audio_processing()->noise_suppression()->is_enabled();
   NoiseSuppression::Level nsLevel =
       _shared->audio_processing()->noise_suppression()->level();
 
   switch (nsLevel) {
     case NoiseSuppression::kLow:
       mode = kNsLowSuppression;
       break;
     case NoiseSuppression::kModerate:
       mode = kNsModerateSuppression;
       break;
     case NoiseSuppression::kHigh:
       mode = kNsHighSuppression;
       break;
     case NoiseSuppression::kVeryHigh:
       mode = kNsVeryHighSuppression;
       break;
   }
-
-  WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_shared->instance_id(), -1),
-               "GetNsStatus() => enabled=% d, mode=%d", enabled, mode);
   return 0;
 #else
   _shared->SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
                         "GetNsStatus() Ns is not supported");
   return -1;
 #endif
 }
 
 int VoEAudioProcessingImpl::SetAgcStatus(bool enable, AgcModes mode) {
   WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
@@ skipping 55 matching lines @@
 
   return 0;
 #else
   _shared->SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
                         "SetAgcStatus() Agc is not supported");
   return -1;
 #endif
 }
 
 int VoEAudioProcessingImpl::GetAgcStatus(bool& enabled, AgcModes& mode) {
-  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
-               "GetAgcStatus(enabled=?, mode=?)");
 #ifdef WEBRTC_VOICE_ENGINE_AGC
   if (!_shared->statistics().Initialized()) {
     _shared->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
 
   enabled = _shared->audio_processing()->gain_control()->is_enabled();
   GainControl::Mode agcMode =
       _shared->audio_processing()->gain_control()->mode();
 
   switch (agcMode) {
     case GainControl::kFixedDigital:
       mode = kAgcFixedDigital;
       break;
     case GainControl::kAdaptiveAnalog:
       mode = kAgcAdaptiveAnalog;
       break;
     case GainControl::kAdaptiveDigital:
       mode = kAgcAdaptiveDigital;
       break;
   }
 
-  WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_shared->instance_id(), -1),
-               "GetAgcStatus() => enabled=%d, mode=%d", enabled, mode);
   return 0;
 #else
   _shared->SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
                         "GetAgcStatus() Agc is not supported");
   return -1;
 #endif
 }
 
 int VoEAudioProcessingImpl::SetAgcConfig(AgcConfig config) {
   WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
@@ skipping 28 matching lines @@
 
   return 0;
 #else
   _shared->SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
                         "SetAgcConfig() EC is not supported");
   return -1;
 #endif
 }
 
 int VoEAudioProcessingImpl::GetAgcConfig(AgcConfig& config) {
-  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
-               "GetAgcConfig(config=?)");
 #ifdef WEBRTC_VOICE_ENGINE_AGC
   if (!_shared->statistics().Initialized()) {
     _shared->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
 
   config.targetLeveldBOv =
       _shared->audio_processing()->gain_control()->target_level_dbfs();
   config.digitalCompressionGaindB =
       _shared->audio_processing()->gain_control()->compression_gain_db();
   config.limiterEnable =
       _shared->audio_processing()->gain_control()->is_limiter_enabled();
 
-  WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_shared->instance_id(), -1),
-               "GetAgcConfig() => targetLeveldBOv=%u, "
-               "digitalCompressionGaindB=%u, limiterEnable=%d",
-               config.targetLeveldBOv, config.digitalCompressionGaindB,
-               config.limiterEnable);
-
   return 0;
 #else
   _shared->SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
                         "GetAgcConfig() EC is not supported");
   return -1;
 #endif
 }
 
 int VoEAudioProcessingImpl::SetRxNsStatus(int channel,
                                           bool enable,
@@ skipping 16 matching lines @@
 #else
   _shared->SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
                         "SetRxNsStatus() NS is not supported");
   return -1;
 #endif
 }
 
 int VoEAudioProcessingImpl::GetRxNsStatus(int channel,
                                           bool& enabled,
                                           NsModes& mode) {
-  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
-               "GetRxNsStatus(channel=%d, enable=?, mode=?)", channel);
 #ifdef WEBRTC_VOICE_ENGINE_NR
   if (!_shared->statistics().Initialized()) {
     _shared->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
 
   voe::ChannelOwner ch = _shared->channel_manager().GetChannel(channel);
   voe::Channel* channelPtr = ch.channel();
   if (channelPtr == NULL) {
     _shared->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
@@ skipping 31 matching lines @@
 #else
   _shared->SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
                         "SetRxAgcStatus() Agc is not supported");
   return -1;
 #endif
 }
 
 int VoEAudioProcessingImpl::GetRxAgcStatus(int channel,
                                            bool& enabled,
                                            AgcModes& mode) {
-  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
-               "GetRxAgcStatus(channel=%d, enable=?, mode=?)", channel);
 #ifdef WEBRTC_VOICE_ENGINE_AGC
   if (!_shared->statistics().Initialized()) {
     _shared->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
 
   voe::ChannelOwner ch = _shared->channel_manager().GetChannel(channel);
   voe::Channel* channelPtr = ch.channel();
   if (channelPtr == NULL) {
     _shared->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
@@ skipping 26 matching lines @@
   }
   return channelPtr->SetRxAgcConfig(config);
 #else
   _shared->SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
                         "SetRxAgcConfig() Agc is not supported");
   return -1;
 #endif
 }
 
 int VoEAudioProcessingImpl::GetRxAgcConfig(int channel, AgcConfig& config) {
-  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
-               "GetRxAgcConfig(channel=%d)", channel);
 #ifdef WEBRTC_VOICE_ENGINE_AGC
   if (!_shared->statistics().Initialized()) {
     _shared->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
 
   voe::ChannelOwner ch = _shared->channel_manager().GetChannel(channel);
   voe::Channel* channelPtr = ch.channel();
   if (channelPtr == NULL) {
     _shared->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
@@ skipping 127 matching lines @@
 
   return 0;
 #else
   _shared->SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
                         "SetEcStatus() EC is not supported");
   return -1;
 #endif
 }
 
 int VoEAudioProcessingImpl::GetEcStatus(bool& enabled, EcModes& mode) {
-  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
-               "GetEcStatus()");
 #ifdef WEBRTC_VOICE_ENGINE_ECHO
   if (!_shared->statistics().Initialized()) {
     _shared->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
 
   if (_isAecMode == true) {
     mode = kEcAec;
     enabled = _shared->audio_processing()->echo_cancellation()->is_enabled();
   } else {
     mode = kEcAecm;
     enabled = _shared->audio_processing()->echo_control_mobile()->is_enabled();
   }
 
-  WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_shared->instance_id(), -1),
-               "GetEcStatus() => enabled=%i, mode=%i", enabled, (int)mode);
   return 0;
 #else
   _shared->SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
                         "GetEcStatus() EC is not supported");
   return -1;
 #endif
 }
 
 void VoEAudioProcessingImpl::SetDelayOffsetMs(int offset) {
   WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
                "SetDelayOffsetMs(offset = %d)", offset);
   _shared->audio_processing()->set_delay_offset_ms(offset);
 }
 
 int VoEAudioProcessingImpl::DelayOffsetMs() {
-  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
-               "DelayOffsetMs()");
   return _shared->audio_processing()->delay_offset_ms();
 }
 
 int VoEAudioProcessingImpl::SetAecmMode(AecmModes mode, bool enableCNG) {
   WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
                "SetAECMMode(mode = %d)", mode);
 #ifdef WEBRTC_VOICE_ENGINE_ECHO
   if (!_shared->statistics().Initialized()) {
     _shared->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
@@ skipping 36 matching lines @@
 
   return 0;
 #else
   _shared->SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
                         "SetAECMMode() EC is not supported");
   return -1;
 #endif
 }
 
 int VoEAudioProcessingImpl::GetAecmMode(AecmModes& mode, bool& enabledCNG) {
-  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
-               "GetAECMMode(mode=?)");
 #ifdef WEBRTC_VOICE_ENGINE_ECHO
   if (!_shared->statistics().Initialized()) {
     _shared->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
 
   enabledCNG = false;
 
   EchoControlMobile::RoutingMode aecmMode =
       _shared->audio_processing()->echo_control_mobile()->routing_mode();
@@ skipping 34 matching lines @@
       AudioProcessing::kNoError) {
     _shared->SetLastError(VE_APM_ERROR, kTraceError,
                           "HighPassFilter::Enable() failed.");
     return -1;
   }
 
   return 0;
 }
 
 bool VoEAudioProcessingImpl::IsHighPassFilterEnabled() {
-  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
-               "IsHighPassFilterEnabled()");
   return _shared->audio_processing()->high_pass_filter()->is_enabled();
 }
 
 int VoEAudioProcessingImpl::RegisterRxVadObserver(int channel,
                                                   VoERxVadCallback& observer) {
   WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
                "RegisterRxVadObserver()");
   if (!_shared->statistics().Initialized()) {
     _shared->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
@@ skipping 66 matching lines @@
   }
   return 0;
 #else
   _shared->SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
                         "SetEcStatus() EC is not supported");
   return -1;
 #endif
 }
 
 int VoEAudioProcessingImpl::GetEcMetricsStatus(bool& enabled) {
-  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
-               "GetEcMetricsStatus(enabled=?)");
 #ifdef WEBRTC_VOICE_ENGINE_ECHO
   if (!_shared->statistics().Initialized()) {
     _shared->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
 
   bool echo_mode =
       _shared->audio_processing()->echo_cancellation()->are_metrics_enabled();
   bool delay_mode = _shared->audio_processing()
                         ->echo_cancellation()
                         ->is_delay_logging_enabled();
 
   if (echo_mode != delay_mode) {
     _shared->SetLastError(
         VE_APM_ERROR, kTraceError,
         "GetEcMetricsStatus() delay logging and echo mode are not the same");
     return -1;
   }
 
   enabled = echo_mode;
 
-  WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_shared->instance_id(), -1),
-               "GetEcMetricsStatus() => enabled=%d", enabled);
   return 0;
 #else
   _shared->SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
                         "SetEcStatus() EC is not supported");
   return -1;
 #endif
 }
 
 int VoEAudioProcessingImpl::GetEchoMetrics(int& ERL,
                                            int& ERLE,
                                            int& RERL,
                                            int& A_NLP) {
-  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
-               "GetEchoMetrics(ERL=?, ERLE=?, RERL=?, A_NLP=?)");
 #ifdef WEBRTC_VOICE_ENGINE_ECHO
   if (!_shared->statistics().Initialized()) {
     _shared->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
   if (!_shared->audio_processing()->echo_cancellation()->is_enabled()) {
     _shared->SetLastError(
         VE_APM_ERROR, kTraceWarning,
         "GetEchoMetrics() AudioProcessingModule AEC is not enabled");
     return -1;
   }
 
   // Get Echo Metrics from Audio Processing Module.
   EchoCancellation::Metrics echoMetrics;
   if (_shared->audio_processing()->echo_cancellation()->GetMetrics(
           &echoMetrics)) {
     WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_shared->instance_id(), -1),
                  "GetEchoMetrics(), AudioProcessingModule metrics error");
     return -1;
   }
 
   // Echo quality metrics.
   ERL = echoMetrics.echo_return_loss.instant;
   ERLE = echoMetrics.echo_return_loss_enhancement.instant;
   RERL = echoMetrics.residual_echo_return_loss.instant;
   A_NLP = echoMetrics.a_nlp.instant;
 
-  WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_shared->instance_id(), -1),
-               "GetEchoMetrics() => ERL=%d, ERLE=%d, RERL=%d, A_NLP=%d", ERL,
-               ERLE, RERL, A_NLP);
   return 0;
 #else
   _shared->SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
                         "SetEcStatus() EC is not supported");
   return -1;
 #endif
 }
 
 int VoEAudioProcessingImpl::GetEcDelayMetrics(int& delay_median,
                                               int& delay_std,
                                               float& fraction_poor_delays) {
-  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
-               "GetEcDelayMetrics(median=?, std=?, fraction_poor_delays=?)");
 #ifdef WEBRTC_VOICE_ENGINE_ECHO
   if (!_shared->statistics().Initialized()) {
     _shared->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
   if (!_shared->audio_processing()->echo_cancellation()->is_enabled()) {
     _shared->SetLastError(
         VE_APM_ERROR, kTraceWarning,
         "GetEcDelayMetrics() AudioProcessingModule AEC is not enabled");
     return -1;
   }
 
   int median = 0;
   int std = 0;
   float poor_fraction = 0;
   // Get delay-logging values from Audio Processing Module.
   if (_shared->audio_processing()->echo_cancellation()->GetDelayMetrics(
           &median, &std, &poor_fraction)) {
     WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_shared->instance_id(), -1),
                  "GetEcDelayMetrics(), AudioProcessingModule delay-logging "
                  "error");
     return -1;
   }
 
   // EC delay-logging metrics
   delay_median = median;
   delay_std = std;
   fraction_poor_delays = poor_fraction;
 
-  WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_shared->instance_id(), -1),
-               "GetEcDelayMetrics() => delay_median=%d, delay_std=%d, "
-               "fraction_poor_delays=%f",
-               delay_median, delay_std, fraction_poor_delays);
   return 0;
 #else
   _shared->SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
                         "SetEcStatus() EC is not supported");
   return -1;
 #endif
 }
 
 int VoEAudioProcessingImpl::StartDebugRecording(const char* fileNameUTF8) {
   WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
@@ skipping 53 matching lines @@
         VE_APM_ERROR, kTraceWarning,
         "SetTypingDetectionStatus() failed to set VAD likelihood to low");
     return -1;
   }
 
   return 0;
 #endif
 }
 
 int VoEAudioProcessingImpl::GetTypingDetectionStatus(bool& enabled) {
-  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
-               "GetTypingDetectionStatus()");
   if (!_shared->statistics().Initialized()) {
     _shared->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
   // Just use the VAD state to determine if we should enable typing
   // detection or not
 
   enabled = _shared->audio_processing()->voice_detection()->is_enabled();
 
   return 0;
 }
 
 int VoEAudioProcessingImpl::TimeSinceLastTyping(int& seconds) {
-  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
-               "TimeSinceLastTyping()");
 #if !defined(WEBRTC_VOICE_ENGINE_TYPING_DETECTION)
   NOT_SUPPORTED(_shared->statistics());
 #else
   if (!_shared->statistics().Initialized()) {
     _shared->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
   // Check if typing detection is enabled
   bool enabled = _shared->audio_processing()->voice_detection()->is_enabled();
   if (enabled) {
@@ skipping 33 matching lines @@
 }
 
 bool VoEAudioProcessingImpl::IsStereoChannelSwappingEnabled() {
   LOG_API0();
   return _shared->transmit_mixer()->IsStereoChannelSwappingEnabled();
 }
 
 #endif  // #ifdef WEBRTC_VOICE_ENGINE_AUDIO_PROCESSING_API
 
 }  // namespace webrtc