From 8b111eb3e68c4afe974a10db8a4f62a99f6bbdf7 Mon Sep 17 00:00:00 2001
From: "andrew@webrtc.org"
 <andrew@webrtc.org@4adac7df-926f-26a2-2b94-8c16560cd09d>
Date: Tue, 6 Mar 2012 19:50:12 +0000
Subject: [PATCH] Reformat voe_audio_processing_impl to Goog style.

TBR=xians@webrtc.org
BUG=
TEST=voe_auto_test

Review URL: https://webrtc-codereview.appspot.com/439003

git-svn-id: http://webrtc.googlecode.com/svn/trunk@1847 4adac7df-926f-26a2-2b94-8c16560cd09d
---
 .../main/source/voe_audio_processing_impl.cc  | 1603 ++++++++---------
 .../main/source/voe_audio_processing_impl.h   |   97 +-
 2 files changed, 770 insertions(+), 930 deletions(-)

diff --git a/src/voice_engine/main/source/voe_audio_processing_impl.cc b/src/voice_engine/main/source/voe_audio_processing_impl.cc
index 3a8705c6b6..b7a705ce41 100644
--- a/src/voice_engine/main/source/voe_audio_processing_impl.cc
+++ b/src/voice_engine/main/source/voe_audio_processing_impl.cc
@@ -19,918 +19,777 @@
 
 namespace webrtc {
 
-VoEAudioProcessing* VoEAudioProcessing::GetInterface(
-    VoiceEngine* voiceEngine)
-{
+VoEAudioProcessing* VoEAudioProcessing::GetInterface(VoiceEngine* voiceEngine) {
 #ifndef WEBRTC_VOICE_ENGINE_AUDIO_PROCESSING_API
-    return NULL;
+  return NULL;
 #else
-    if (NULL == voiceEngine)
-    {
-        return NULL;
-    }
-    VoiceEngineImpl* s = reinterpret_cast<VoiceEngineImpl*> (voiceEngine);
-    VoEAudioProcessingImpl* d = s;
-    (*d)++;
-    return (d);
+  if (NULL == voiceEngine) {
+    return NULL;
+  }
+  VoiceEngineImpl* s = reinterpret_cast<VoiceEngineImpl*>(voiceEngine);
+  VoEAudioProcessingImpl* d = s;
+  (*d)++;
+  return (d);
 #endif
 }
 
 #ifdef WEBRTC_VOICE_ENGINE_AUDIO_PROCESSING_API
 VoEAudioProcessingImpl::VoEAudioProcessingImpl():
-    _isAecMode(static_cast<int>(WEBRTC_VOICE_ENGINE_EC_DEFAULT_MODE) == EcAec?
-        true : false)
-{
-    WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId,-1),
-                 "VoEAudioProcessingImpl::VoEAudioProcessingImpl() - ctor");
+  _isAecMode(static_cast<int>(WEBRTC_VOICE_ENGINE_EC_DEFAULT_MODE) == EcAec ?
+             true : false) {
+  WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, -1),
+               "VoEAudioProcessingImpl::VoEAudioProcessingImpl() - ctor");
 }
 
-VoEAudioProcessingImpl::~VoEAudioProcessingImpl()
-{
-    WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId,-1),
-                 "VoEAudioProcessingImpl::~VoEAudioProcessingImpl() - dtor");
+VoEAudioProcessingImpl::~VoEAudioProcessingImpl() {
+  WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, -1),
+               "VoEAudioProcessingImpl::~VoEAudioProcessingImpl() - dtor");
 }
 
-int VoEAudioProcessingImpl::Release()
-{
-    WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId,-1),
-                 "VoEAudioProcessing::Release()");
-    (*this)--;
-    int refCount = GetCount();
-    if (refCount < 0)
-    {
-        Reset();  // reset reference counter to zero => OK to delete VE
-        _engineStatistics.SetLastError(
-            VE_INTERFACE_NOT_FOUND, kTraceWarning);
-        return (-1);
-    }
-    WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId,-1),
-                 "VoEAudioProcessing reference counter = %d", refCount);
-    return (refCount);
+int VoEAudioProcessingImpl::Release() {
+  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
+               "VoEAudioProcessing::Release()");
+  (*this)--;
+  int refCount = GetCount();
+  if (refCount < 0) {
+    Reset();  // reset reference counter to zero => OK to delete VE
+    _engineStatistics.SetLastError(VE_INTERFACE_NOT_FOUND, kTraceWarning);
+    return (-1);
+  }
+  WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId, -1),
+               "VoEAudioProcessing reference counter = %d", refCount);
+  return (refCount);
 }
 
-int VoEAudioProcessingImpl::SetNsStatus(bool enable, NsModes mode)
-{
-    WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId,-1),
-                 "SetNsStatus(enable=%d, mode=%d)", enable, mode);
+int VoEAudioProcessingImpl::SetNsStatus(bool enable, NsModes mode) {
+  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
+               "SetNsStatus(enable=%d, mode=%d)", enable, mode);
 #ifdef WEBRTC_VOICE_ENGINE_NR
-    if (!_engineStatistics.Initialized())
-    {
-        _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
-        return -1;
-    }
+  if (!_engineStatistics.Initialized()) {
+    _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
+    return -1;
+  }
 
-    NoiseSuppression::Level nsLevel(
-        (NoiseSuppression::Level)WEBRTC_VOICE_ENGINE_NS_DEFAULT_MODE);
-    switch (mode)
-    {
+  NoiseSuppression::Level nsLevel(
+      (NoiseSuppression::Level)WEBRTC_VOICE_ENGINE_NS_DEFAULT_MODE);
+  switch (mode) {
     case kNsDefault:
-        nsLevel = (NoiseSuppression::Level)WEBRTC_VOICE_ENGINE_NS_DEFAULT_MODE;
-        break; 
+      nsLevel = (NoiseSuppression::Level)WEBRTC_VOICE_ENGINE_NS_DEFAULT_MODE;
+      break;
     case kNsUnchanged:
-        nsLevel = _audioProcessingModulePtr->noise_suppression()->level();
-        break;
+      nsLevel = _audioProcessingModulePtr->noise_suppression()->level();
+      break;
     case kNsConference:
-        nsLevel = NoiseSuppression::kHigh;
-        break;
+      nsLevel = NoiseSuppression::kHigh;
+      break;
     case kNsLowSuppression:
-        nsLevel = NoiseSuppression::kLow;
-        break;
+      nsLevel = NoiseSuppression::kLow;
+      break;
     case kNsModerateSuppression:
-        nsLevel = NoiseSuppression::kModerate;
-        break;
+      nsLevel = NoiseSuppression::kModerate;
+      break;
     case kNsHighSuppression:
-        nsLevel = NoiseSuppression::kHigh;
-        break;
+      nsLevel = NoiseSuppression::kHigh;
+      break;
     case kNsVeryHighSuppression:
-        nsLevel = NoiseSuppression::kVeryHigh;
-        break;
-    }
+      nsLevel = NoiseSuppression::kVeryHigh;
+      break;
+  }
 
-    if (_audioProcessingModulePtr->noise_suppression()->set_level(nsLevel) != 0)
-    {
-        _engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
-                                       "SetNsStatus() failed to set Ns mode");
-        return -1;
-    }
-    if (_audioProcessingModulePtr->noise_suppression()->Enable(enable) != 0)
-    {
-        _engineStatistics.SetLastError(
-            VE_APM_ERROR, kTraceError,
-            "SetNsStatus() failed to set Ns state");
-        return -1;
-    }
-
-    return 0;
-#else
-    _engineStatistics.SetLastError(
-        VE_FUNC_NOT_SUPPORTED, kTraceError,
-        "SetNsStatus() Ns is not supported");
+  if (_audioProcessingModulePtr->noise_suppression()->set_level(nsLevel) != 0) {
+    _engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
+        "SetNsStatus() failed to set Ns mode");
     return -1;
+  }
+  if (_audioProcessingModulePtr->noise_suppression()->Enable(enable) != 0) {
+    _engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
+        "SetNsStatus() failed to set Ns state");
+    return -1;
+  }
+
+  return 0;
+#else
+  _engineStatistics.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(_instanceId,-1),
-                 "GetNsStatus(enabled=?, mode=?)");
+int VoEAudioProcessingImpl::GetNsStatus(bool& enabled, NsModes& mode) {
+  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
+               "GetNsStatus(enabled=?, mode=?)");
 #ifdef WEBRTC_VOICE_ENGINE_NR
-    if (!_engineStatistics.Initialized())
-    {
-        _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
-        return -1;
-    }
-
-    bool enable(false);
-    NoiseSuppression::Level nsLevel(
-        (NoiseSuppression::Level)WEBRTC_VOICE_ENGINE_NS_DEFAULT_MODE);
-
-    enable = _audioProcessingModulePtr->noise_suppression()->is_enabled();
-    nsLevel = _audioProcessingModulePtr->noise_suppression()->level();
-
-    enabled = enable;
-
-    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(_instanceId,-1),
-                 "GetNsStatus() => enabled=% d, mode=%d",enabled, mode);
-    return 0;
-#else
-    _engineStatistics.SetLastError(
-        VE_FUNC_NOT_SUPPORTED, kTraceError,
-        "GetNsStatus() Ns is not supported");
+  if (!_engineStatistics.Initialized()) {
+    _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
+  }
+
+  bool enable(false);
+  NoiseSuppression::Level nsLevel(
+      (NoiseSuppression::Level)WEBRTC_VOICE_ENGINE_NS_DEFAULT_MODE);
+
+  enable = _audioProcessingModulePtr->noise_suppression()->is_enabled();
+  nsLevel = _audioProcessingModulePtr->noise_suppression()->level();
+
+  enabled = enable;
+
+  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(_instanceId, -1),
+               "GetNsStatus() => enabled=% d, mode=%d", enabled, mode);
+  return 0;
+#else
+  _engineStatistics.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(_instanceId,-1),
-                 "SetAgcStatus(enable=%d, mode=%d)", enable, mode);
+int VoEAudioProcessingImpl::SetAgcStatus(bool enable, AgcModes mode) {
+  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
+               "SetAgcStatus(enable=%d, mode=%d)", enable, mode);
 #ifdef WEBRTC_VOICE_ENGINE_AGC
-    if (!_engineStatistics.Initialized())
-    {
-        _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
-        return -1;
-    }
+  if (!_engineStatistics.Initialized()) {
+    _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
+    return -1;
+  }
 
 #if defined(MAC_IPHONE) || defined(ATA) || defined(WEBRTC_ANDROID)
-    if (mode == kAgcAdaptiveAnalog)
-    {
-        _engineStatistics.SetLastError(
-            VE_INVALID_ARGUMENT, kTraceError,
-            "SetAgcStatus() invalid Agc mode for mobile device");
-        return -1;
-    }
+  if (mode == kAgcAdaptiveAnalog) {
+    _engineStatistics.SetLastError(VE_INVALID_ARGUMENT, kTraceError,
+        "SetAgcStatus() invalid Agc mode for mobile device");
+    return -1;
+  }
 #endif
 
-    GainControl::Mode agcMode(
-        (GainControl::Mode)WEBRTC_VOICE_ENGINE_AGC_DEFAULT_MODE);
-    switch (mode)
-    {
+  GainControl::Mode agcMode(
+     (GainControl::Mode)WEBRTC_VOICE_ENGINE_AGC_DEFAULT_MODE);
+  switch (mode) {
     case kAgcDefault:
-        agcMode = (GainControl::Mode)WEBRTC_VOICE_ENGINE_AGC_DEFAULT_MODE;
-        break;
+      agcMode = (GainControl::Mode)WEBRTC_VOICE_ENGINE_AGC_DEFAULT_MODE;
+      break;
     case kAgcUnchanged:
-        agcMode = _audioProcessingModulePtr->gain_control()->mode();;
-        break;
+      agcMode = _audioProcessingModulePtr->gain_control()->mode();;
+      break;
     case kAgcFixedDigital:
-        agcMode = GainControl::kFixedDigital;
-        break;
+      agcMode = GainControl::kFixedDigital;
+      break;
     case kAgcAdaptiveAnalog:
-        agcMode = GainControl::kAdaptiveAnalog;
-        break;
+      agcMode = GainControl::kAdaptiveAnalog;
+      break;
     case kAgcAdaptiveDigital:
-        agcMode = GainControl::kAdaptiveDigital;
-        break;
-    }
+      agcMode = GainControl::kAdaptiveDigital;
+      break;
+  }
 
-    if (_audioProcessingModulePtr->gain_control()->set_mode(agcMode) != 0)
-    {
-        _engineStatistics.SetLastError(
-            VE_APM_ERROR, kTraceError,
-            "SetAgcStatus() failed to set Agc mode");
-        return -1;
-    }
-    if (_audioProcessingModulePtr->gain_control()->Enable(enable) != 0)
-    {
-        _engineStatistics.SetLastError(
-            VE_APM_ERROR, kTraceError,
-            "SetAgcStatus() failed to set Agc state");
-        return -1;
-    }
-
-    if (agcMode != GainControl::kFixedDigital)
-    {
-        // Set Agc state in the ADM when adaptive Agc mode has been selected.
-        // Note that we also enable the ADM Agc when Adaptive Digital mode is
-        // used since we want to be able to provide the APM with updated mic
-        // levels when the user modifies the mic level manually.
-        if (_audioDevicePtr->SetAGC(enable) != 0)
-        {
-            _engineStatistics.SetLastError(
-                VE_AUDIO_DEVICE_MODULE_ERROR, kTraceWarning,
-                "SetAgcStatus() failed to set Agc mode");
-        }
-    }
-
-    return 0;
-#else
-    _engineStatistics.SetLastError(
-        VE_FUNC_NOT_SUPPORTED, kTraceError,
-        "SetAgcStatus() Agc is not supported");
+  if (_audioProcessingModulePtr->gain_control()->set_mode(agcMode) != 0) {
+    _engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
+        "SetAgcStatus() failed to set Agc mode");
     return -1;
+  }
+  if (_audioProcessingModulePtr->gain_control()->Enable(enable) != 0) {
+    _engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
+        "SetAgcStatus() failed to set Agc state");
+    return -1;
+  }
+
+  if (agcMode != GainControl::kFixedDigital) {
+    // Set Agc state in the ADM when adaptive Agc mode has been selected.
+    // Note that we also enable the ADM Agc when Adaptive Digital mode is
+    // used since we want to be able to provide the APM with updated mic
+    // levels when the user modifies the mic level manually.
+    if (_audioDevicePtr->SetAGC(enable) != 0) {
+      _engineStatistics.SetLastError(VE_AUDIO_DEVICE_MODULE_ERROR,
+          kTraceWarning, "SetAgcStatus() failed to set Agc mode");
+    }
+  }
+
+  return 0;
+#else
+  _engineStatistics.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(_instanceId,-1),
-                 "GetAgcStatus(enabled=?, mode=?)");
+int VoEAudioProcessingImpl::GetAgcStatus(bool& enabled, AgcModes& mode) {
+  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
+               "GetAgcStatus(enabled=?, mode=?)");
 #ifdef WEBRTC_VOICE_ENGINE_AGC
-    if (!_engineStatistics.Initialized())
-    {
-        _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
-        return -1;
-    }
-
-    bool enable(false);
-    GainControl::Mode agcMode(
-        (GainControl::Mode)WEBRTC_VOICE_ENGINE_AGC_DEFAULT_MODE);
-
-    enable = _audioProcessingModulePtr->gain_control()->is_enabled();
-    agcMode = _audioProcessingModulePtr->gain_control()->mode();
-
-    enabled = enable;
-
-    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(_instanceId,-1),
-                 "GetAgcStatus() => enabled=%d, mode=%d", enabled, mode);
-    return 0;
-#else
-    _engineStatistics.SetLastError(
-        VE_FUNC_NOT_SUPPORTED, kTraceError,
-        "GetAgcStatus() Agc is not supported");
+  if (!_engineStatistics.Initialized()) {
+    _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
+  }
+
+  bool enable(false);
+  GainControl::Mode agcMode(
+    (GainControl::Mode)WEBRTC_VOICE_ENGINE_AGC_DEFAULT_MODE);
+
+  enable = _audioProcessingModulePtr->gain_control()->is_enabled();
+  agcMode = _audioProcessingModulePtr->gain_control()->mode();
+
+  enabled = enable;
+
+  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(_instanceId, -1),
+               "GetAgcStatus() => enabled=%d, mode=%d", enabled, mode);
+  return 0;
+#else
+  _engineStatistics.SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
+      "GetAgcStatus() Agc is not supported");
+  return -1;
 #endif
 }
 
-int VoEAudioProcessingImpl::SetAgcConfig(const AgcConfig config)
-{
-    WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId,-1),
-                 "SetAgcConfig()");
+int VoEAudioProcessingImpl::SetAgcConfig(const AgcConfig config) {
+  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
+               "SetAgcConfig()");
 #ifdef WEBRTC_VOICE_ENGINE_AGC
-    if (!_engineStatistics.Initialized())
-    {
-        _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
-        return -1;
-    }
-
-    if (_audioProcessingModulePtr->gain_control()->set_target_level_dbfs(
-                    config.targetLeveldBOv) != 0)
-    {
-        _engineStatistics.SetLastError(
-            VE_APM_ERROR, kTraceError,
-            "SetAgcConfig() failed to set target peak |level|"
-            " (or envelope) of the Agc");
-        return -1;
-    }
-    if (_audioProcessingModulePtr->gain_control()->set_compression_gain_db(
-        config.digitalCompressionGaindB) != 0)
-    {
-        _engineStatistics.SetLastError(
-            VE_APM_ERROR, kTraceError,
-            "SetAgcConfig() failed to set the range in |gain|"
-            "the digital compression stage may apply");
-        return -1;
-    }
-    if (_audioProcessingModulePtr->gain_control()->enable_limiter(
-        config.limiterEnable) != 0)
-    {
-        _engineStatistics.SetLastError(
-            VE_APM_ERROR, kTraceError,
-            "SetAgcConfig() failed to set hard limiter to the signal");
-        return -1;
-    }
-
-    return 0;
-#else
-    _engineStatistics.SetLastError(
-        VE_FUNC_NOT_SUPPORTED, kTraceError,
-        "SetAgcConfig() EC is not supported");
+  if (!_engineStatistics.Initialized()) {
+    _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
+  }
+
+  if (_audioProcessingModulePtr->gain_control()->set_target_level_dbfs(
+      config.targetLeveldBOv) != 0) {
+    _engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
+        "SetAgcConfig() failed to set target peak |level|"
+        " (or envelope) of the Agc");
+    return -1;
+  }
+  if (_audioProcessingModulePtr->gain_control()->set_compression_gain_db(
+        config.digitalCompressionGaindB) != 0) {
+    _engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
+        "SetAgcConfig() failed to set the range in |gain| "
+        "the digital compression stage may apply");
+    return -1;
+  }
+  if (_audioProcessingModulePtr->gain_control()->enable_limiter(
+        config.limiterEnable) != 0) {
+    _engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
+        "SetAgcConfig() failed to set hard limiter to the signal");
+    return -1;
+  }
+
+  return 0;
+#else
+  _engineStatistics.SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
+      "SetAgcConfig() EC is not supported");
+  return -1;
 #endif
 }
 
-int VoEAudioProcessingImpl::GetAgcConfig(AgcConfig &config)
-{
-    WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId,-1),
-                 "GetAgcConfig(config=?)");
+int VoEAudioProcessingImpl::GetAgcConfig(AgcConfig& config) {
+  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
+               "GetAgcConfig(config=?)");
 #ifdef WEBRTC_VOICE_ENGINE_AGC
-    if (!_engineStatistics.Initialized())
-    {
-        _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
-        return -1;
-    }
+  if (!_engineStatistics.Initialized()) {
+    _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
+    return -1;
+  }
 
-    config.targetLeveldBOv =
-        _audioProcessingModulePtr->gain_control()->target_level_dbfs();
-    config.digitalCompressionGaindB =
-        _audioProcessingModulePtr->gain_control()->compression_gain_db();
-    config.limiterEnable =
-        _audioProcessingModulePtr->gain_control()->is_limiter_enabled();
+  config.targetLeveldBOv =
+    _audioProcessingModulePtr->gain_control()->target_level_dbfs();
+  config.digitalCompressionGaindB =
+    _audioProcessingModulePtr->gain_control()->compression_gain_db();
+  config.limiterEnable =
+    _audioProcessingModulePtr->gain_control()->is_limiter_enabled();
 
-    WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId,-1),
+  WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId, -1),
                "GetAgcConfig() => targetLeveldBOv=%u, "
-               "digitalCompressionGaindB=%u, limiterEnable=%d",
-    config.targetLeveldBOv,
-    config.digitalCompressionGaindB,
-    config.limiterEnable);
+                  "digitalCompressionGaindB=%u, limiterEnable=%d",
+               config.targetLeveldBOv,
+               config.digitalCompressionGaindB,
+               config.limiterEnable);
 
-    return 0;
+  return 0;
 #else
-    _engineStatistics.SetLastError(
-        VE_FUNC_NOT_SUPPORTED, kTraceError,
-        "GetAgcConfig() EC is not supported");
-    return -1;
+  _engineStatistics.SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
+      "GetAgcConfig() EC is not supported");
+  return -1;
 #endif
 }
 
 int VoEAudioProcessingImpl::SetRxNsStatus(int channel,
                                           bool enable,
-                                          NsModes mode)
-{
-    WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId,-1),
-                 "SetRxNsStatus(channel=%d, enable=%d, mode=%d)",
-                 channel, (int)enable, (int)mode);
+                                          NsModes mode) {
+  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
+               "SetRxNsStatus(channel=%d, enable=%d, mode=%d)",
+               channel, (int)enable, (int)mode);
 #ifdef WEBRTC_VOICE_ENGINE_AGC
-    if (!_engineStatistics.Initialized())
-    {
-        _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
-        return -1;
-    }
-
-    voe::ScopedChannel sc(_channelManager, channel);
-    voe::Channel* channelPtr = sc.ChannelPtr();
-    if (channelPtr == NULL)
-    {
-        _engineStatistics.SetLastError(
-            VE_CHANNEL_NOT_VALID, kTraceError,
-            "SetRxNsStatus() failed to locate channel");
-        return -1;
-    }
-    return channelPtr->SetRxNsStatus(enable, mode);
-#else
-    _engineStatistics.SetLastError(
-        VE_FUNC_NOT_SUPPORTED, kTraceError,
-        "SetRxNsStatus() AGC is not supported");
+  if (!_engineStatistics.Initialized()) {
+    _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
+  }
+
+  voe::ScopedChannel sc(_channelManager, channel);
+  voe::Channel* channelPtr = sc.ChannelPtr();
+  if (channelPtr == NULL) {
+    _engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
+        "SetRxNsStatus() failed to locate channel");
+    return -1;
+  }
+  return channelPtr->SetRxNsStatus(enable, mode);
+#else
+  _engineStatistics.SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
+      "SetRxNsStatus() AGC is not supported");
+  return -1;
 #endif
 }
 
 int VoEAudioProcessingImpl::GetRxNsStatus(int channel,
                                           bool& enabled,
-                                          NsModes& mode)
-{
-    WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId,-1),
-                 "GetRxNsStatus(channel=%d, enable=?, mode=?)", channel);
+                                          NsModes& mode) {
+  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
+               "GetRxNsStatus(channel=%d, enable=?, mode=?)", channel);
 #ifdef WEBRTC_VOICE_ENGINE_AGC
-    if (!_engineStatistics.Initialized())
-    {
-        _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
-        return -1;
-    }
-
-    voe::ScopedChannel sc(_channelManager, channel);
-    voe::Channel* channelPtr = sc.ChannelPtr();
-    if (channelPtr == NULL)
-    {
-        _engineStatistics.SetLastError(
-            VE_CHANNEL_NOT_VALID, kTraceError,
-            "GetRxNsStatus() failed to locate channel");
-        return -1;
-    }
-    return channelPtr->GetRxNsStatus(enabled, mode);
-#else
-    _engineStatistics.SetLastError(
-        VE_FUNC_NOT_SUPPORTED, kTraceError,
-        "GetRxNsStatus() Agc is not supported");
+  if (!_engineStatistics.Initialized()) {
+    _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
+  }
+
+  voe::ScopedChannel sc(_channelManager, channel);
+  voe::Channel* channelPtr = sc.ChannelPtr();
+  if (channelPtr == NULL) {
+    _engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
+        "GetRxNsStatus() failed to locate channel");
+    return -1;
+  }
+  return channelPtr->GetRxNsStatus(enabled, mode);
+#else
+  _engineStatistics.SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
+      "GetRxNsStatus() Agc is not supported");
+  return -1;
 #endif
 }
 
 int VoEAudioProcessingImpl::SetRxAgcStatus(int channel,
                                            bool enable,
-                                           AgcModes mode)
-{
-    WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId,-1),
-                 "SetRxAgcStatus(channel=%d, enable=%d, mode=%d)",
-                 channel, (int)enable, (int)mode);
+                                           AgcModes mode) {
+  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
+               "SetRxAgcStatus(channel=%d, enable=%d, mode=%d)",
+               channel, (int)enable, (int)mode);
 #ifdef WEBRTC_VOICE_ENGINE_AGC
-    if (!_engineStatistics.Initialized())
-    {
-        _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
-        return -1;
-    }
-
-    voe::ScopedChannel sc(_channelManager, channel);
-    voe::Channel* channelPtr = sc.ChannelPtr();
-    if (channelPtr == NULL)
-    {
-        _engineStatistics.SetLastError(
-            VE_CHANNEL_NOT_VALID, kTraceError,
-            "SetRxAgcStatus() failed to locate channel");
-        return -1;
-    }
-    return channelPtr->SetRxAgcStatus(enable, mode);
-#else
-    _engineStatistics.SetLastError(
-        VE_FUNC_NOT_SUPPORTED, kTraceError,
-        "SetRxAgcStatus() Agc is not supported");
+  if (!_engineStatistics.Initialized()) {
+    _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
+  }
+
+  voe::ScopedChannel sc(_channelManager, channel);
+  voe::Channel* channelPtr = sc.ChannelPtr();
+  if (channelPtr == NULL) {
+    _engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
+        "SetRxAgcStatus() failed to locate channel");
+    return -1;
+  }
+  return channelPtr->SetRxAgcStatus(enable, mode);
+#else
+  _engineStatistics.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(_instanceId,-1),
-                 "GetRxAgcStatus(channel=%d, enable=?, mode=?)", channel);
+                                           AgcModes& mode) {
+  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
+               "GetRxAgcStatus(channel=%d, enable=?, mode=?)", channel);
 #ifdef WEBRTC_VOICE_ENGINE_AGC
-    if (!_engineStatistics.Initialized())
-    {
-        _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
-        return -1;
-    }
-
-    voe::ScopedChannel sc(_channelManager, channel);
-    voe::Channel* channelPtr = sc.ChannelPtr();
-    if (channelPtr == NULL)
-    {
-        _engineStatistics.SetLastError(
-            VE_CHANNEL_NOT_VALID, kTraceError,
-            "GetRxAgcStatus() failed to locate channel");
-        return -1;
-    }
-    return channelPtr->GetRxAgcStatus(enabled, mode);
-#else
-    _engineStatistics.SetLastError(
-        VE_FUNC_NOT_SUPPORTED, kTraceError,
-        "GetRxAgcStatus() Agc is not supported");
+  if (!_engineStatistics.Initialized()) {
+    _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
+  }
+
+  voe::ScopedChannel sc(_channelManager, channel);
+  voe::Channel* channelPtr = sc.ChannelPtr();
+  if (channelPtr == NULL) {
+    _engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
+        "GetRxAgcStatus() failed to locate channel");
+    return -1;
+  }
+  return channelPtr->GetRxAgcStatus(enabled, mode);
+#else
+  _engineStatistics.SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
+      "GetRxAgcStatus() Agc is not supported");
+  return -1;
 #endif
 }
 
-int VoEAudioProcessingImpl::SetRxAgcConfig(int channel, const AgcConfig config)
-{
-    WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId,-1),
-                 "SetRxAgcConfig(channel=%d)", channel);
+int VoEAudioProcessingImpl::SetRxAgcConfig(int channel,
+                                           const AgcConfig config) {
+  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
+               "SetRxAgcConfig(channel=%d)", channel);
 #ifdef WEBRTC_VOICE_ENGINE_AGC
-    if (!_engineStatistics.Initialized())
-    {
-        _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
-        return -1;
-    }
-
-    voe::ScopedChannel sc(_channelManager, channel);
-    voe::Channel* channelPtr = sc.ChannelPtr();
-    if (channelPtr == NULL)
-    {
-        _engineStatistics.SetLastError(
-            VE_CHANNEL_NOT_VALID, kTraceError,
-            "SetRxAgcConfig() failed to locate channel");
-        return -1;
-    }
-    return channelPtr->SetRxAgcConfig(config);
-#else
-    _engineStatistics.SetLastError(
-        VE_FUNC_NOT_SUPPORTED, kTraceError,
-        "SetRxAgcConfig() Agc is not supported");
+  if (!_engineStatistics.Initialized()) {
+    _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
+  }
+
+  voe::ScopedChannel sc(_channelManager, channel);
+  voe::Channel* channelPtr = sc.ChannelPtr();
+  if (channelPtr == NULL) {
+    _engineStatistics.SetLastError(
+      VE_CHANNEL_NOT_VALID, kTraceError,
+      "SetRxAgcConfig() failed to locate channel");
+    return -1;
+  }
+  return channelPtr->SetRxAgcConfig(config);
+#else
+  _engineStatistics.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(_instanceId,-1),
-                 "GetRxAgcConfig(channel=%d)", channel);
+int VoEAudioProcessingImpl::GetRxAgcConfig(int channel, AgcConfig& config) {
+  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
+               "GetRxAgcConfig(channel=%d)", channel);
 #ifdef WEBRTC_VOICE_ENGINE_AGC
-    if (!_engineStatistics.Initialized())
-    {
-        _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
-        return -1;
-    }
-
-    voe::ScopedChannel sc(_channelManager, channel);
-    voe::Channel* channelPtr = sc.ChannelPtr();
-    if (channelPtr == NULL)
-    {
-        _engineStatistics.SetLastError(
-            VE_CHANNEL_NOT_VALID, kTraceError,
-            "GetRxAgcConfig() failed to locate channel");
-        return -1;
-    }
-    return channelPtr->GetRxAgcConfig(config);
-#else
-    _engineStatistics.SetLastError(
-        VE_FUNC_NOT_SUPPORTED, kTraceError,
-        "GetRxAgcConfig() Agc is not supported");
+  if (!_engineStatistics.Initialized()) {
+    _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
+  }
+
+  voe::ScopedChannel sc(_channelManager, channel);
+  voe::Channel* channelPtr = sc.ChannelPtr();
+  if (channelPtr == NULL) {
+    _engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
+        "GetRxAgcConfig() failed to locate channel");
+    return -1;
+  }
+  return channelPtr->GetRxAgcConfig(config);
+#else
+  _engineStatistics.SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
+      "GetRxAgcConfig() Agc is not supported");
+  return -1;
 #endif
 }
 
-int VoEAudioProcessingImpl::SetEcStatus(bool enable, EcModes mode)
-{
-    WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId,-1),
-                 "SetEcStatus(enable=%d, mode=%d)", enable, mode);
+int VoEAudioProcessingImpl::SetEcStatus(bool enable, EcModes mode) {
+  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
+               "SetEcStatus(enable=%d, mode=%d)", enable, mode);
 #ifdef WEBRTC_VOICE_ENGINE_ECHO
-    if (!_engineStatistics.Initialized())
-    {
-        _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
-        return -1;
-    }
+  if (!_engineStatistics.Initialized()) {
+    _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
+    return -1;
+  }
 
-    // AEC mode
-    if ((mode == kEcDefault) ||
-        (mode == kEcConference) ||
-        (mode == kEcAec) ||
-        ((mode == kEcUnchanged) &&
-        (_isAecMode == true)))
-    {
-        if (enable)
-        {
-            // Disable the AECM before enable the AEC
-            if (_audioProcessingModulePtr->echo_control_mobile()->is_enabled())
-            {
-                _engineStatistics.SetLastError(
-                    VE_APM_ERROR, kTraceWarning,
-                    "SetEcStatus() disable AECM before enabling AEC");
-                if (_audioProcessingModulePtr->echo_control_mobile()->
-                    Enable(false) != 0)
-                {
-                    _engineStatistics.SetLastError(
-                        VE_APM_ERROR, kTraceError,
-                        "SetEcStatus() failed to disable AECM");
-                    return -1;
-                }
-            }
-        }
-        if (_audioProcessingModulePtr->echo_cancellation()->Enable(enable) != 0)
-        {
-            _engineStatistics.SetLastError(
-                VE_APM_ERROR, kTraceError,
-                "SetEcStatus() failed to set AEC state");
-            return -1;
-        }
-#ifdef CLOCK_SKEW_COMP
-        if (_audioProcessingModulePtr->echo_cancellation()->
-            enable_drift_compensation(true) != 0)
-        {
-            _engineStatistics.SetLastError(
-                VE_APM_ERROR, kTraceError,
-                "SetEcStatus() failed to enable drift compensation");
-            return -1;
-        }
-#else
-        if (_audioProcessingModulePtr->echo_cancellation()->
-            enable_drift_compensation(false) != 0)
-        {
-            _engineStatistics.SetLastError(
-                VE_APM_ERROR, kTraceError,
-                "SetEcStatus() failed to disable drift compensation");
-            return -1;
-        }
-#endif
-        if (mode == kEcConference)
-        {
-            if (_audioProcessingModulePtr->echo_cancellation()->
-                set_suppression_level(EchoCancellation::kHighSuppression) != 0)
-           {
-                _engineStatistics.SetLastError(
-                    VE_APM_ERROR, kTraceError,
-                    "SetEcStatus() failed to set aggressiveness to high");
-                return -1;
-            }
-        }
-        else
-        {
-           if (_audioProcessingModulePtr->echo_cancellation()->
-               set_suppression_level(
-                   EchoCancellation::kModerateSuppression) != 0)
-           {
-                _engineStatistics.SetLastError(
-                    VE_APM_ERROR, kTraceError,
-                    "SetEcStatus() failed to set aggressiveness to moderate");
-                return -1;
-           }
-        }
-
-        _isAecMode = true;
-    }
-    else if ((mode == kEcAecm) ||
-            ((mode == kEcUnchanged) &&
-            (_isAecMode == false)))
-    {
-        if (enable)
-        {
-            // Disable the AEC before enable the AECM
-            if (_audioProcessingModulePtr->echo_cancellation()->is_enabled())
-            {
-                _engineStatistics.SetLastError(
-                    VE_APM_ERROR, kTraceWarning,
-                    "SetEcStatus() disable AEC before enabling AECM");
-                if (_audioProcessingModulePtr->echo_cancellation()->
-                    Enable(false) != 0)
-                {
-                    _engineStatistics.SetLastError(
-                        VE_APM_ERROR, kTraceError,
-                        "SetEcStatus() failed to disable AEC");
-                    return -1;
-                }
-            }
-        }
+  // AEC mode
+  if ((mode == kEcDefault) ||
+      (mode == kEcConference) ||
+      (mode == kEcAec) ||
+      ((mode == kEcUnchanged) &&
+       (_isAecMode == true))) {
+    if (enable) {
+      // Disable the AECM before enable the AEC
+      if (_audioProcessingModulePtr->echo_control_mobile()->is_enabled()) {
+        _engineStatistics.SetLastError(VE_APM_ERROR, kTraceWarning,
+            "SetEcStatus() disable AECM before enabling AEC");
         if (_audioProcessingModulePtr->echo_control_mobile()->
-            Enable(enable) != 0)
-        {
-            _engineStatistics.SetLastError(
-                VE_APM_ERROR, kTraceError,
-                "SetEcStatus() failed to set AECM state");
-            return -1;
+            Enable(false) != 0) {
+          _engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
+              "SetEcStatus() failed to disable AECM");
+          return -1;
         }
-        _isAecMode = false;
+      }
     }
-    else
-    {
-        _engineStatistics.SetLastError(VE_INVALID_ARGUMENT, kTraceError,
-                                       "SetEcStatus() invalid EC mode");
-        return -1;
+    if (_audioProcessingModulePtr->echo_cancellation()->Enable(enable) != 0) {
+      _engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
+          "SetEcStatus() failed to set AEC state");
+      return -1;
+    }
+#ifdef CLOCK_SKEW_COMP
+    if (_audioProcessingModulePtr->echo_cancellation()->
+        enable_drift_compensation(true) != 0) {
+      _engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
+          "SetEcStatus() failed to enable drift compensation");
+      return -1;
     }
-
-    return 0;
 #else
-    _engineStatistics.SetLastError(
-        VE_FUNC_NOT_SUPPORTED, kTraceError,
-        "SetEcStatus() EC is not supported");
-    return -1;
+    if (_audioProcessingModulePtr->echo_cancellation()->
+        enable_drift_compensation(false) != 0) {
+      _engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
+          "SetEcStatus() failed to disable drift compensation");
+      return -1;
+    }
 #endif
-}
-
-int VoEAudioProcessingImpl::GetEcStatus(bool& enabled, EcModes& mode)
-{
-    WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId,-1),
-                 "GetEcStatus()");
-#ifdef WEBRTC_VOICE_ENGINE_ECHO
-    if (!_engineStatistics.Initialized())
-    {
-        _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
+    if (mode == kEcConference) {
+      if (_audioProcessingModulePtr->echo_cancellation()->
+          set_suppression_level(EchoCancellation::kHighSuppression) != 0) {
+        _engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
+            "SetEcStatus() failed to set aggressiveness to high");
         return -1;
-    }
-
-    if (_isAecMode == true)
-    {
-        mode = kEcAec;
-        enabled = _audioProcessingModulePtr->echo_cancellation()->is_enabled();
-    }
-    else
-    {
-        mode = kEcAecm;
-        enabled = _audioProcessingModulePtr->echo_control_mobile()->
-            is_enabled();
-    }
-
-    WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId,-1),
-                 "GetEcStatus() => enabled=%i, mode=%i",
-                 enabled, (int)mode);
-    return 0;
-#else
-    _engineStatistics.SetLastError(
-        VE_FUNC_NOT_SUPPORTED, kTraceError,
-        "GetEcStatus() EC is not supported");
-    return -1;
-#endif
-}
-
-void VoEAudioProcessingImpl::SetDelayOffsetMs(int offset)
-{
-    WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
-                 "SetDelayOffsetMs(offset = %d)", offset);
-    _audioProcessingModulePtr->set_delay_offset_ms(offset);
-}
-
-int VoEAudioProcessingImpl::DelayOffsetMs()
-{
-    WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
-                 "DelayOffsetMs()");
-    return _audioProcessingModulePtr->delay_offset_ms();
-}
-
-int VoEAudioProcessingImpl::SetAecmMode(AecmModes mode, bool enableCNG)
-{
-    WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId,-1),
-                 "SetAECMMode(mode = %d)", mode);
-#ifdef WEBRTC_VOICE_ENGINE_ECHO
-    if (!_engineStatistics.Initialized())
-    {
-        _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
+      }
+    } else {
+      if (_audioProcessingModulePtr->echo_cancellation()->
+          set_suppression_level(
+            EchoCancellation::kModerateSuppression) != 0) {
+        _engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
+            "SetEcStatus() failed to set aggressiveness to moderate");
         return -1;
+      }
     }
 
-    EchoControlMobile::RoutingMode aecmMode(
-        EchoControlMobile::kQuietEarpieceOrHeadset);
-
-    switch (mode)
-    {
-        case kAecmQuietEarpieceOrHeadset:
-            aecmMode = EchoControlMobile::kQuietEarpieceOrHeadset;
-            break;
-        case kAecmEarpiece:
-            aecmMode = EchoControlMobile::kEarpiece;
-            break;
-        case kAecmLoudEarpiece:
-            aecmMode = EchoControlMobile::kLoudEarpiece;
-            break;
-        case kAecmSpeakerphone:
-            aecmMode = EchoControlMobile::kSpeakerphone;
-            break;
-        case kAecmLoudSpeakerphone:
-            aecmMode = EchoControlMobile::kLoudSpeakerphone;
-            break;
-    }
-
-
-    if (_audioProcessingModulePtr->echo_control_mobile()->
-        set_routing_mode(aecmMode) != 0)
-    {
-        _engineStatistics.SetLastError(
-            VE_APM_ERROR, kTraceError,
-            "SetAECMMode() failed to set AECM routing mode");
-        return -1;
+    _isAecMode = true;
+  } else if ((mode == kEcAecm) ||
+             ((mode == kEcUnchanged) &&
+              (_isAecMode == false))) {
+    if (enable) {
+      // Disable the AEC before enable the AECM
+      if (_audioProcessingModulePtr->echo_cancellation()->is_enabled()) {
+        _engineStatistics.SetLastError(VE_APM_ERROR, kTraceWarning,
+            "SetEcStatus() disable AEC before enabling AECM");
+        if (_audioProcessingModulePtr->echo_cancellation()->
+            Enable(false) != 0) {
+          _engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
+              "SetEcStatus() failed to disable AEC");
+          return -1;
+        }
+      }
     }
     if (_audioProcessingModulePtr->echo_control_mobile()->
-        enable_comfort_noise(enableCNG) != 0)
-    {
-        _engineStatistics.SetLastError(
-            VE_APM_ERROR, kTraceError,
-            "SetAECMMode() failed to set comfort noise state for AECM");
-        return -1;
+        Enable(enable) != 0) {
+      _engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
+          "SetEcStatus() failed to set AECM state");
+      return -1;
     }
-
-    return 0;
-#else
-    _engineStatistics.SetLastError(
-        VE_FUNC_NOT_SUPPORTED, kTraceError,
-        "SetAECMMode() EC is not supported");
+    _isAecMode = false;
+  } else {
+    _engineStatistics.SetLastError(VE_INVALID_ARGUMENT, kTraceError,
+                                   "SetEcStatus() invalid EC mode");
     return -1;
+  }
+
+  return 0;
+#else
+  _engineStatistics.SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
+      "SetEcStatus() EC is not supported");
+  return -1;
 #endif
 }
 
-int VoEAudioProcessingImpl::GetAecmMode(AecmModes& mode, bool& enabledCNG)
-{
-    WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId,-1),
-                 "GetAECMMode(mode=?)");
+int VoEAudioProcessingImpl::GetEcStatus(bool& enabled, EcModes& mode) {
+  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
+               "GetEcStatus()");
 #ifdef WEBRTC_VOICE_ENGINE_ECHO
-    if (!_engineStatistics.Initialized())
-    {
-        _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
-        return -1;
-    }
-
-    enabledCNG = false;
-
-    EchoControlMobile::RoutingMode aecmMode =
-        _audioProcessingModulePtr->echo_control_mobile()->routing_mode();
-    enabledCNG = _audioProcessingModulePtr->echo_control_mobile()->
-        is_comfort_noise_enabled();
-
-    switch (aecmMode)
-    {
-        case EchoControlMobile::kQuietEarpieceOrHeadset:
-            mode = kAecmQuietEarpieceOrHeadset;
-            break;
-        case EchoControlMobile::kEarpiece:
-            mode = kAecmEarpiece;
-            break;
-        case EchoControlMobile::kLoudEarpiece:
-            mode = kAecmLoudEarpiece;
-            break;
-        case EchoControlMobile::kSpeakerphone:
-            mode = kAecmSpeakerphone;
-            break;
-        case EchoControlMobile::kLoudSpeakerphone:
-            mode = kAecmLoudSpeakerphone;
-            break;
-    }
-
-    return 0;
-#else
-    _engineStatistics.SetLastError(
-        VE_FUNC_NOT_SUPPORTED, kTraceError,
-        "GetAECMMode() EC is not supported");
+  if (!_engineStatistics.Initialized()) {
+    _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
+  }
+
+  if (_isAecMode == true) {
+    mode = kEcAec;
+    enabled = _audioProcessingModulePtr->echo_cancellation()->is_enabled();
+  } else {
+    mode = kEcAecm;
+    enabled = _audioProcessingModulePtr->echo_control_mobile()->
+              is_enabled();
+  }
+
+  WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId, -1),
+               "GetEcStatus() => enabled=%i, mode=%i",
+               enabled, (int)mode);
+  return 0;
+#else
+  _engineStatistics.SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
+      "GetEcStatus() EC is not supported");
+  return -1;
+#endif
+}
+
+void VoEAudioProcessingImpl::SetDelayOffsetMs(int offset) {
+  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
+               "SetDelayOffsetMs(offset = %d)", offset);
+  _audioProcessingModulePtr->set_delay_offset_ms(offset);
+}
+
+int VoEAudioProcessingImpl::DelayOffsetMs() {
+  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
+               "DelayOffsetMs()");
+  return _audioProcessingModulePtr->delay_offset_ms();
+}
+
+int VoEAudioProcessingImpl::SetAecmMode(AecmModes mode, bool enableCNG) {
+  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
+               "SetAECMMode(mode = %d)", mode);
+#ifdef WEBRTC_VOICE_ENGINE_ECHO
+  if (!_engineStatistics.Initialized()) {
+    _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
+    return -1;
+  }
+
+  EchoControlMobile::RoutingMode aecmMode(
+      EchoControlMobile::kQuietEarpieceOrHeadset);
+
+  switch (mode) {
+    case kAecmQuietEarpieceOrHeadset:
+      aecmMode = EchoControlMobile::kQuietEarpieceOrHeadset;
+      break;
+    case kAecmEarpiece:
+      aecmMode = EchoControlMobile::kEarpiece;
+      break;
+    case kAecmLoudEarpiece:
+      aecmMode = EchoControlMobile::kLoudEarpiece;
+      break;
+    case kAecmSpeakerphone:
+      aecmMode = EchoControlMobile::kSpeakerphone;
+      break;
+    case kAecmLoudSpeakerphone:
+      aecmMode = EchoControlMobile::kLoudSpeakerphone;
+      break;
+  }
+
+
+  if (_audioProcessingModulePtr->echo_control_mobile()->
+      set_routing_mode(aecmMode) != 0) {
+    _engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
+        "SetAECMMode() failed to set AECM routing mode");
+    return -1;
+  }
+  if (_audioProcessingModulePtr->echo_control_mobile()->
+      enable_comfort_noise(enableCNG) != 0) {
+    _engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
+        "SetAECMMode() failed to set comfort noise state for AECM");
+    return -1;
+  }
+
+  return 0;
+#else
+  _engineStatistics.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(_instanceId, -1),
+               "GetAECMMode(mode=?)");
+#ifdef WEBRTC_VOICE_ENGINE_ECHO
+  if (!_engineStatistics.Initialized()) {
+    _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
+    return -1;
+  }
+
+  enabledCNG = false;
+
+  EchoControlMobile::RoutingMode aecmMode =
+      _audioProcessingModulePtr->echo_control_mobile()->routing_mode();
+  enabledCNG = _audioProcessingModulePtr->echo_control_mobile()->
+      is_comfort_noise_enabled();
+
+  switch (aecmMode) {
+    case EchoControlMobile::kQuietEarpieceOrHeadset:
+      mode = kAecmQuietEarpieceOrHeadset;
+      break;
+    case EchoControlMobile::kEarpiece:
+      mode = kAecmEarpiece;
+      break;
+    case EchoControlMobile::kLoudEarpiece:
+      mode = kAecmLoudEarpiece;
+      break;
+    case EchoControlMobile::kSpeakerphone:
+      mode = kAecmSpeakerphone;
+      break;
+    case EchoControlMobile::kLoudSpeakerphone:
+      mode = kAecmLoudSpeakerphone;
+      break;
+  }
+
+  return 0;
+#else
+  _engineStatistics.SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
+      "GetAECMMode() EC is not supported");
+  return -1;
 #endif
 }
 
 int VoEAudioProcessingImpl::RegisterRxVadObserver(
-    int channel,
-    VoERxVadCallback &observer)
-{
-    WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId,-1),
-                 "RegisterRxVadObserver()");
-    ANDROID_NOT_SUPPORTED(_engineStatistics);
-    IPHONE_NOT_SUPPORTED();
+  int channel,
+  VoERxVadCallback& observer) {
+  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
+               "RegisterRxVadObserver()");
+  ANDROID_NOT_SUPPORTED(_engineStatistics);
+  IPHONE_NOT_SUPPORTED();
 
-    if (!_engineStatistics.Initialized())
-    {
-        _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
-        return -1;
-    }
-    voe::ScopedChannel sc(_channelManager, channel);
-    voe::Channel* channelPtr = sc.ChannelPtr();
-    if (channelPtr == NULL)
-    {
-        _engineStatistics.SetLastError(
-            VE_CHANNEL_NOT_VALID, kTraceError,
-            "RegisterRxVadObserver() failed to locate channel");
-        return -1;
-    }
-    return channelPtr->RegisterRxVadObserver(observer);
+  if (!_engineStatistics.Initialized()) {
+    _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
+    return -1;
+  }
+  voe::ScopedChannel sc(_channelManager, channel);
+  voe::Channel* channelPtr = sc.ChannelPtr();
+  if (channelPtr == NULL) {
+    _engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
+        "RegisterRxVadObserver() failed to locate channel");
+    return -1;
+  }
+  return channelPtr->RegisterRxVadObserver(observer);
 }
 
-int VoEAudioProcessingImpl::DeRegisterRxVadObserver(int channel)
-{
-    WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId,-1),
-                 "DeRegisterRxVadObserver()");
-    ANDROID_NOT_SUPPORTED(_engineStatistics);
-    IPHONE_NOT_SUPPORTED();
+int VoEAudioProcessingImpl::DeRegisterRxVadObserver(int channel) {
+  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
+               "DeRegisterRxVadObserver()");
+  ANDROID_NOT_SUPPORTED(_engineStatistics);
+  IPHONE_NOT_SUPPORTED();
 
-    if (!_engineStatistics.Initialized())
-    {
-        _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
-        return -1;
-    }
-    voe::ScopedChannel sc(_channelManager, channel);
-    voe::Channel* channelPtr = sc.ChannelPtr();
-    if (channelPtr == NULL)
-    {
-        _engineStatistics.SetLastError(
-            VE_CHANNEL_NOT_VALID, kTraceError,
-            "DeRegisterRxVadObserver() failed to locate channel");
-        return -1;
-    }
+  if (!_engineStatistics.Initialized()) {
+    _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
+    return -1;
+  }
+  voe::ScopedChannel sc(_channelManager, channel);
+  voe::Channel* channelPtr = sc.ChannelPtr();
+  if (channelPtr == NULL) {
+    _engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
+        "DeRegisterRxVadObserver() failed to locate channel");
+    return -1;
+  }
 
-    return channelPtr->DeRegisterRxVadObserver();
+  return channelPtr->DeRegisterRxVadObserver();
 }
 
-int VoEAudioProcessingImpl::VoiceActivityIndicator(int channel)
-{
-    WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId,-1),
-                 "VoiceActivityIndicator(channel=%d)", channel);
-    if (!_engineStatistics.Initialized())
-    {
-        _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
-        return -1;
-    }
+int VoEAudioProcessingImpl::VoiceActivityIndicator(int channel) {
+  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
+               "VoiceActivityIndicator(channel=%d)", channel);
+  if (!_engineStatistics.Initialized()) {
+    _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
+    return -1;
+  }
 
-    voe::ScopedChannel sc(_channelManager, channel);
-    voe::Channel* channelPtr = sc.ChannelPtr();
-    if (channelPtr == NULL)
-    {
-        _engineStatistics.SetLastError(
-            VE_CHANNEL_NOT_VALID, kTraceError,
-            "DeRegisterRxVadObserver() failed to locate channel");
-        return -1;
-    }
-    int activity(-1);
-    channelPtr->VoiceActivityIndicator(activity);
+  voe::ScopedChannel sc(_channelManager, channel);
+  voe::Channel* channelPtr = sc.ChannelPtr();
+  if (channelPtr == NULL) {
+    _engineStatistics.SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
+        "DeRegisterRxVadObserver() failed to locate channel");
+    return -1;
+  }
+  int activity(-1);
+  channelPtr->VoiceActivityIndicator(activity);
 
-    return activity;
+  return activity;
 }
 
 int VoEAudioProcessingImpl::SetEcMetricsStatus(bool enable) {
@@ -946,18 +805,17 @@ int VoEAudioProcessingImpl::SetEcMetricsStatus(bool enable) {
   }
 
   if ((_audioProcessingModulePtr->echo_cancellation()->enable_metrics(enable)
-      != 0) ||
+       != 0) ||
       (_audioProcessingModulePtr->echo_cancellation()->enable_delay_logging(
-          enable) != 0)) {
-    _engineStatistics.SetLastError(
-        VE_APM_ERROR, kTraceError,
+         enable) != 0)) {
+    _engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
         "SetEcMetricsStatus() unable to set EC metrics mode");
     return -1;
   }
   return 0;
 #else
-  _engineStatistics.SetLastError(
-      VE_FUNC_NOT_SUPPORTED, kTraceError, "SetEcStatus() EC is not supported");
+  _engineStatistics.SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
+      "SetEcStatus() EC is not supported");
   return -1;
 #endif
 }
@@ -980,8 +838,7 @@ int VoEAudioProcessingImpl::GetEcMetricsStatus(bool& enabled) {
     _audioProcessingModulePtr->echo_cancellation()->is_delay_logging_enabled();
 
   if (echo_mode != delay_mode) {
-    _engineStatistics.SetLastError(
-        VE_APM_ERROR, kTraceError,
+    _engineStatistics.SetLastError(VE_APM_ERROR, kTraceError,
         "GetEcMetricsStatus() delay logging and echo mode are not the same");
     return -1;
   }
@@ -992,8 +849,8 @@ int VoEAudioProcessingImpl::GetEcMetricsStatus(bool& enabled) {
                "GetEcMetricsStatus() => enabled=%d", enabled);
   return 0;
 #else
-  _engineStatistics.SetLastError(
-      VE_FUNC_NOT_SUPPORTED, kTraceError, "SetEcStatus() EC is not supported");
+  _engineStatistics.SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
+      "SetEcStatus() EC is not supported");
   return -1;
 #endif
 }
@@ -1013,17 +870,16 @@ int VoEAudioProcessingImpl::GetEchoMetrics(int& ERL,
     return -1;
   }
   if (!_audioProcessingModulePtr->echo_cancellation()->is_enabled()) {
-    _engineStatistics.SetLastError(
-        VE_APM_ERROR, kTraceWarning,
+    _engineStatistics.SetLastError(VE_APM_ERROR, kTraceWarning,
         "GetEchoMetrics() AudioProcessingModule AEC is not enabled");
     return -1;
   }
 
   // Get Echo Metrics from Audio Processing Module.
   EchoCancellation::Metrics echoMetrics;
-  if (_audioProcessingModulePtr->echo_cancellation()->GetMetrics(&echoMetrics))
-  {
-    WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId,-1),
+  if (_audioProcessingModulePtr->echo_cancellation()->GetMetrics(
+          &echoMetrics)) {
+    WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId, -1),
                  "GetEchoMetrics(), AudioProcessingModule metrics error");
     return -1;
   }
@@ -1034,13 +890,13 @@ int VoEAudioProcessingImpl::GetEchoMetrics(int& ERL,
   RERL = echoMetrics.residual_echo_return_loss.instant;
   A_NLP = echoMetrics.a_nlp.instant;
 
-  WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId,-1),
+  WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId, -1),
                "GetEchoMetrics() => ERL=%d, ERLE=%d, RERL=%d, A_NLP=%d",
                ERL, ERLE, RERL, A_NLP);
   return 0;
 #else
-  _engineStatistics.SetLastError(
-      VE_FUNC_NOT_SUPPORTED, kTraceError, "SetEcStatus() EC is not supported");
+  _engineStatistics.SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
+      "SetEcStatus() EC is not supported");
   return -1;
 #endif
 }
@@ -1058,8 +914,7 @@ int VoEAudioProcessingImpl::GetEcDelayMetrics(int& delay_median,
     return -1;
   }
   if (!_audioProcessingModulePtr->echo_cancellation()->is_enabled()) {
-    _engineStatistics.SetLastError(
-        VE_APM_ERROR, kTraceWarning,
+    _engineStatistics.SetLastError(VE_APM_ERROR, kTraceWarning,
         "GetEcDelayMetrics() AudioProcessingModule AEC is not enabled");
     return -1;
   }
@@ -1068,8 +923,8 @@ int VoEAudioProcessingImpl::GetEcDelayMetrics(int& delay_median,
   int std = 0;
   // Get delay-logging values from Audio Processing Module.
   if (_audioProcessingModulePtr->echo_cancellation()->GetDelayMetrics(
-      &median, &std)) {
-    WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId,-1),
+        &median, &std)) {
+    WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId, -1),
                  "GetEcDelayMetrics(), AudioProcessingModule delay-logging "
                  "error");
     return -1;
@@ -1079,109 +934,95 @@ int VoEAudioProcessingImpl::GetEcDelayMetrics(int& delay_median,
   delay_median = median;
   delay_std = std;
 
-  WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId,-1),
+  WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId, -1),
                "GetEcDelayMetrics() => delay_median=%d, delay_std=%d",
                delay_median, delay_std);
   return 0;
 #else
-  _engineStatistics.SetLastError(
-      VE_FUNC_NOT_SUPPORTED, kTraceError, "SetEcStatus() EC is not supported");
+  _engineStatistics.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(_instanceId,-1),
+int VoEAudioProcessingImpl::StartDebugRecording(const char* fileNameUTF8) {
+  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
                "StartDebugRecording()");
-    if (!_engineStatistics.Initialized())
-    {
-        _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
-        return -1;
-    }
-
-    return _audioProcessingModulePtr->StartDebugRecording(fileNameUTF8);
-
-}
-
-int VoEAudioProcessingImpl::StopDebugRecording()
-{
-    WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId,-1),
-                 "StopDebugRecording()");
-    if (!_engineStatistics.Initialized())
-    {
-        _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
-        return -1;
-    }
-
-    return _audioProcessingModulePtr->StopDebugRecording();
-}
-
-int VoEAudioProcessingImpl::SetTypingDetectionStatus(bool enable)
-{
-    WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId,-1),
-                 "SetTypingDetectionStatus()");
-    ANDROID_NOT_SUPPORTED(_engineStatistics);
-    IPHONE_NOT_SUPPORTED();
-#ifdef WEBRTC_VOICE_ENGINE_TYPING_DETECTION
-    if (!_engineStatistics.Initialized())
-    {
-        _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
-        return -1;
-    }
-
-    // Just use the VAD state to determine if we should enable typing detection
-    // or not
-
-    if (_audioProcessingModulePtr->voice_detection()->Enable(enable))
-    {
-        _engineStatistics.SetLastError(
-            VE_APM_ERROR, kTraceWarning,
-            "SetTypingDetectionStatus() failed to set VAD state");
-        return -1;
-    }
-    if (_audioProcessingModulePtr->voice_detection()->set_likelihood(
-        VoiceDetection::kVeryLowLikelihood))
-    {
-        _engineStatistics.SetLastError(
-            VE_APM_ERROR, kTraceWarning,
-            "SetTypingDetectionStatus() failed to set VAD likelihood to low");
-        return -1;
-    }
-
-    return 0;
-#else
-    _engineStatistics.SetLastError(
-        VE_FUNC_NOT_SUPPORTED, kTraceError,
-        "SetTypingDetectionStatus is not supported");
+  if (!_engineStatistics.Initialized()) {
+    _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
+  }
+
+  return _audioProcessingModulePtr->StartDebugRecording(fileNameUTF8);
+
+}
+
+int VoEAudioProcessingImpl::StopDebugRecording() {
+  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
+               "StopDebugRecording()");
+  if (!_engineStatistics.Initialized()) {
+    _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
+    return -1;
+  }
+
+  return _audioProcessingModulePtr->StopDebugRecording();
+}
+
+int VoEAudioProcessingImpl::SetTypingDetectionStatus(bool enable) {
+  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
+               "SetTypingDetectionStatus()");
+  ANDROID_NOT_SUPPORTED(_engineStatistics);
+  IPHONE_NOT_SUPPORTED();
+#ifdef WEBRTC_VOICE_ENGINE_TYPING_DETECTION
+  if (!_engineStatistics.Initialized()) {
+    _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
+    return -1;
+  }
+
+  // Just use the VAD state to determine if we should enable typing detection
+  // or not
+
+  if (_audioProcessingModulePtr->voice_detection()->Enable(enable)) {
+    _engineStatistics.SetLastError(VE_APM_ERROR, kTraceWarning,
+        "SetTypingDetectionStatus() failed to set VAD state");
+    return -1;
+  }
+  if (_audioProcessingModulePtr->voice_detection()->set_likelihood(
+          VoiceDetection::kVeryLowLikelihood)) {
+    _engineStatistics.SetLastError(  VE_APM_ERROR, kTraceWarning,
+        "SetTypingDetectionStatus() failed to set VAD likelihood to low");
+    return -1;
+  }
+
+  return 0;
+#else
+  _engineStatistics.SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
+      "SetTypingDetectionStatus is not supported");
+  return -1;
 #endif
 }
 
-int VoEAudioProcessingImpl::GetTypingDetectionStatus(bool& enabled)
-{
-    WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId,-1),
-                 "GetTypingDetectionStatus()");
-    ANDROID_NOT_SUPPORTED(_engineStatistics);
-    IPHONE_NOT_SUPPORTED();
+int VoEAudioProcessingImpl::GetTypingDetectionStatus(bool& enabled) {
+  WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_instanceId, -1),
+               "GetTypingDetectionStatus()");
+  ANDROID_NOT_SUPPORTED(_engineStatistics);
+  IPHONE_NOT_SUPPORTED();
 
 #ifdef WEBRTC_VOICE_ENGINE_TYPING_DETECTION
-    if (!_engineStatistics.Initialized())
-    {
-        _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
-        return -1;
-    }
-    // Just use the VAD state to determine if we should enable typing
-    // detection or not
+  if (!_engineStatistics.Initialized()) {
+    _engineStatistics.SetLastError(VE_NOT_INITED, kTraceError);
+    return -1;
+  }
+  // Just use the VAD state to determine if we should enable typing
+  // detection or not
 
-    enabled = _audioProcessingModulePtr->voice_detection()->is_enabled();
+  enabled = _audioProcessingModulePtr->voice_detection()->is_enabled();
 
-    return(0);
+  return 0;
 #else
-    _engineStatistics.SetLastError(
-        VE_FUNC_NOT_SUPPORTED, kTraceError,
-        "SetTypingDetectionStatus is not supported");
-    return(-1);
+  _engineStatistics.SetLastError(VE_FUNC_NOT_SUPPORTED, kTraceError,
+      "SetTypingDetectionStatus is not supported");
+  return -1;
 #endif
 }
 
diff --git a/src/voice_engine/main/source/voe_audio_processing_impl.h b/src/voice_engine/main/source/voe_audio_processing_impl.h
index 8146ac078e..0c49bf43be 100644
--- a/src/voice_engine/main/source/voe_audio_processing_impl.h
+++ b/src/voice_engine/main/source/voe_audio_processing_impl.h
@@ -16,89 +16,88 @@
 #include "ref_count.h"
 #include "shared_data.h"
 
-
 namespace webrtc {
 
-class VoEAudioProcessingImpl : public virtual voe::SharedData,
-                               public VoEAudioProcessing,
-                               public voe::RefCount
-{
-public:
-    virtual int Release();
+class VoEAudioProcessingImpl
+    : public virtual voe::SharedData,
+      public VoEAudioProcessing,
+      public voe::RefCount {
+ public:
+  virtual int Release();
 
-    virtual int SetNsStatus(bool enable, NsModes mode = kNsUnchanged);
+  virtual int SetNsStatus(bool enable, NsModes mode = kNsUnchanged);
 
-    virtual int GetNsStatus(bool& enabled, NsModes& mode);
+  virtual int GetNsStatus(bool& enabled, NsModes& mode);
 
-    virtual int SetAgcStatus(bool enable, AgcModes mode = kAgcUnchanged);
+  virtual int SetAgcStatus(bool enable, AgcModes mode = kAgcUnchanged);
 
-    virtual int GetAgcStatus(bool& enabled, AgcModes& mode);
+  virtual int GetAgcStatus(bool& enabled, AgcModes& mode);
 
-    virtual int SetAgcConfig(const AgcConfig config);
+  virtual int SetAgcConfig(const AgcConfig config);
 
-    virtual int GetAgcConfig(AgcConfig& config);
+  virtual int GetAgcConfig(AgcConfig& config);
 
-    virtual int SetRxNsStatus(int channel,
-                              bool enable,
-                              NsModes mode = kNsUnchanged);
+  virtual int SetRxNsStatus(int channel,
+                            bool enable,
+                            NsModes mode = kNsUnchanged);
 
-    virtual int GetRxNsStatus(int channel, bool& enabled, NsModes& mode);
+  virtual int GetRxNsStatus(int channel, bool& enabled, NsModes& mode);
 
-    virtual int SetRxAgcStatus(int channel,
-                               bool enable,
-                               AgcModes mode = kAgcUnchanged);
+  virtual int SetRxAgcStatus(int channel,
+                             bool enable,
+                             AgcModes mode = kAgcUnchanged);
 
-    virtual int GetRxAgcStatus(int channel, bool& enabled, AgcModes& mode);
+  virtual int GetRxAgcStatus(int channel, bool& enabled, AgcModes& mode);
 
-    virtual int SetRxAgcConfig(int channel, const AgcConfig config);
+  virtual int SetRxAgcConfig(int channel, const AgcConfig config);
 
-    virtual int GetRxAgcConfig(int channel, AgcConfig& config);
+  virtual int GetRxAgcConfig(int channel, AgcConfig& config);
 
-    virtual int SetEcStatus(bool enable, EcModes mode = kEcUnchanged);
+  virtual int SetEcStatus(bool enable, EcModes mode = kEcUnchanged);
 
-    virtual int GetEcStatus(bool& enabled, EcModes& mode);
+  virtual int GetEcStatus(bool& enabled, EcModes& mode);
 
-    virtual void SetDelayOffsetMs(int offset);
+  virtual void SetDelayOffsetMs(int offset);
 
-    virtual int DelayOffsetMs();
+  virtual int DelayOffsetMs();
 
-    virtual int SetAecmMode(AecmModes mode = kAecmSpeakerphone,
-                            bool enableCNG = true);
+  virtual int SetAecmMode(AecmModes mode = kAecmSpeakerphone,
+                          bool enableCNG = true);
 
-    virtual int GetAecmMode(AecmModes& mode, bool& enabledCNG);
+  virtual int GetAecmMode(AecmModes& mode, bool& enabledCNG);
 
-    virtual int RegisterRxVadObserver(int channel,
-                                      VoERxVadCallback& observer);
+  virtual int RegisterRxVadObserver(int channel,
+                                    VoERxVadCallback& observer);
 
-    virtual int DeRegisterRxVadObserver(int channel);
+  virtual int DeRegisterRxVadObserver(int channel);
 
-    virtual int VoiceActivityIndicator(int channel);
+  virtual int VoiceActivityIndicator(int channel);
 
-    virtual int SetEcMetricsStatus(bool enable);
+  virtual int SetEcMetricsStatus(bool enable);
 
-    virtual int GetEcMetricsStatus(bool& enabled);
+  virtual int GetEcMetricsStatus(bool& enabled);
 
-    virtual int GetEchoMetrics(int& ERL, int& ERLE, int& RERL, int& A_NLP);
+  virtual int GetEchoMetrics(int& ERL, int& ERLE, int& RERL, int& A_NLP);
 
-    virtual int GetEcDelayMetrics(int& delay_median, int& delay_std);
+  virtual int GetEcDelayMetrics(int& delay_median, int& delay_std);
 
-    virtual int StartDebugRecording(const char* fileNameUTF8);
+  virtual int StartDebugRecording(const char* fileNameUTF8);
 
-    virtual int StopDebugRecording();
+  virtual int StopDebugRecording();
 
-    virtual int SetTypingDetectionStatus(bool enable);
+  virtual int SetTypingDetectionStatus(bool enable);
 
-    virtual int GetTypingDetectionStatus(bool& enabled);
+  virtual int GetTypingDetectionStatus(bool& enabled);
 
-protected:
-    VoEAudioProcessingImpl();
-    virtual ~VoEAudioProcessingImpl();
+ protected:
+  VoEAudioProcessingImpl();
+  virtual ~VoEAudioProcessingImpl();
 
-private:
-    bool _isAecMode;
+ private:
+  bool _isAecMode;
 };
 
-}   //  namespace webrtc
+}  //  namespace webrtc
 
-#endif    // WEBRTC_VOICE_ENGINE_VOE_AUDIO_PROCESSING_IMPL_H
+#endif  // WEBRTC_VOICE_ENGINE_VOE_AUDIO_PROCESSING_IMPL_H