Remove saturation warning support from TransmitMixer.

webrtc/voice_engine/transmit_mixer.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.
  */
 
 #include "webrtc/voice_engine/transmit_mixer.h"
 
 #include <memory>
 
 #include "webrtc/audio/utility/audio_frame_operations.h"
 #include "webrtc/base/format_macros.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/system_wrappers/include/event_wrapper.h"
 #include "webrtc/system_wrappers/include/trace.h"
 #include "webrtc/voice_engine/channel.h"
 #include "webrtc/voice_engine/channel_manager.h"
 #include "webrtc/voice_engine/statistics.h"
 #include "webrtc/voice_engine/utility.h"
 #include "webrtc/voice_engine/voe_base_impl.h"
 
 namespace webrtc {
 namespace voe {
 
+#if WEBRTC_VOICE_ENGINE_TYPING_DETECTION
 // TODO(ajm): The thread safety of this is dubious...
-void
-TransmitMixer::OnPeriodicProcess()
+void TransmitMixer::OnPeriodicProcess()
 {
     WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::OnPeriodicProcess()");
 
-#if WEBRTC_VOICE_ENGINE_TYPING_DETECTION
     bool send_typing_noise_warning = false;
     bool typing_noise_detected = false;
     {
       rtc::CritScope cs(&_critSect);
       if (_typingNoiseWarningPending) {
         send_typing_noise_warning = true;
         typing_noise_detected = _typingNoiseDetected;
         _typingNoiseWarningPending = false;
       }
     }
@@ skipping 10 matching lines @@
             } else {
                 WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                              "TransmitMixer::OnPeriodicProcess() => "
                              "CallbackOnError(VE_TYPING_NOISE_OFF_WARNING)");
                 _voiceEngineObserverPtr->CallbackOnError(
                     -1,
                     VE_TYPING_NOISE_OFF_WARNING);
             }
         }
     }
+}
 #endif  // WEBRTC_VOICE_ENGINE_TYPING_DETECTION
 
-    bool saturationWarning = false;
-    {
-      // Modify |_saturationWarning| under lock to avoid conflict with write op
-      // in ProcessAudio and also ensure that we don't hold the lock during the
-      // callback.
-      rtc::CritScope cs(&_critSect);
-      saturationWarning = _saturationWarning;
-      if (_saturationWarning)
-        _saturationWarning = false;
-    }
-
-    if (saturationWarning)
-    {
-        rtc::CritScope cs(&_callbackCritSect);
-        if (_voiceEngineObserverPtr)
-        {
-            WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
-                         "TransmitMixer::OnPeriodicProcess() =>"
-                         " CallbackOnError(VE_SATURATION_WARNING)");
-            _voiceEngineObserverPtr->CallbackOnError(-1, VE_SATURATION_WARNING);
-        }
-    }
-}
-
-
 void TransmitMixer::PlayNotification(int32_t id,
                                      uint32_t durationMs)
 {
     WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::PlayNotification(id=%d, durationMs=%d)",
                  id, durationMs);
 
     // Not implement yet
 }
 
@@ skipping 65 matching lines @@
 TransmitMixer::Destroy(TransmitMixer*& mixer)
 {
     if (mixer)
     {
         delete mixer;
         mixer = NULL;
     }
 }
 
 TransmitMixer::TransmitMixer(uint32_t instanceId) :
-    _monitorModule(this),
     // Avoid conflict with other channels by adding 1024 - 1026,
     // won't use as much as 1024 channels.
     _filePlayerId(instanceId + 1024),
     _fileRecorderId(instanceId + 1025),
     _fileCallRecorderId(instanceId + 1026),
+#if WEBRTC_VOICE_ENGINE_TYPING_DETECTION
+    _monitorModule(this),
+#endif
     _instanceId(instanceId)
 {
     WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::TransmitMixer() - ctor");
 }
 
 TransmitMixer::~TransmitMixer()
 {
     WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::~TransmitMixer() - dtor");
+#if WEBRTC_VOICE_ENGINE_TYPING_DETECTION
     if (_processThreadPtr)
-    {
         _processThreadPtr->DeRegisterModule(&_monitorModule);
-    }
+#endif
     {
         rtc::CritScope cs(&_critSect);
         if (file_recorder_) {
           file_recorder_->RegisterModuleFileCallback(NULL);
           file_recorder_->StopRecording();
         }
         if (file_call_recorder_) {
           file_call_recorder_->RegisterModuleFileCallback(NULL);
           file_call_recorder_->StopRecording();
         }
         if (file_player_) {
           file_player_->RegisterModuleFileCallback(NULL);
           file_player_->StopPlayingFile();
         }
     }
 }
 
 int32_t
 TransmitMixer::SetEngineInformation(ProcessThread& processThread,
                                     Statistics& engineStatistics,
                                     ChannelManager& channelManager)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::SetEngineInformation()");
 
     _processThreadPtr = &processThread;
     _engineStatisticsPtr = &engineStatistics;
     _channelManagerPtr = &channelManager;
 
+#if WEBRTC_VOICE_ENGINE_TYPING_DETECTION
     _processThreadPtr->RegisterModule(&_monitorModule);
-
+#endif
     return 0;
 }
 
 int32_t
 TransmitMixer::RegisterVoiceEngineObserver(VoiceEngineObserver& observer)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::RegisterVoiceEngineObserver()");
     rtc::CritScope cs(&_callbackCritSect);
 
@@ skipping 830 matching lines @@
   audioproc_->set_stream_key_pressed(key_pressed);
 
   int err = audioproc_->ProcessStream(&_audioFrame);
   if (err != 0) {
     LOG(LS_ERROR) << "ProcessStream() error: " << err;
     assert(false);
   }
 
   // Store new capture level. Only updated when analog AGC is enabled.
   _captureLevel = agc->stream_analog_level();
-
-  rtc::CritScope cs(&_critSect);
-  // Triggers a callback in OnPeriodicProcess().
-  _saturationWarning |= agc->stream_is_saturated();
 }
 
 #if WEBRTC_VOICE_ENGINE_TYPING_DETECTION
 void TransmitMixer::TypingDetection(bool keyPressed)
 {
   // We let the VAD determine if we're using this feature or not.
   if (_audioFrame.vad_activity_ == AudioFrame::kVadUnknown) {
     return;
   }
 
@@ skipping 44 matching lines @@
 void TransmitMixer::EnableStereoChannelSwapping(bool enable) {
   swap_stereo_channels_ = enable;
 }
 
 bool TransmitMixer::IsStereoChannelSwappingEnabled() {
   return swap_stereo_channels_;
 }
 
 }  // namespace voe
 }  // namespace webrtc