Replace WEBRTC_TRACE logging in audio_device_alsa_linux.cc

webrtc/modules/audio_device/linux/audio_device_alsa_linux.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 <assert.h>
 
 #include "webrtc/modules/audio_device/audio_device_config.h"
 #include "webrtc/modules/audio_device/linux/audio_device_alsa_linux.h"
 #include "webrtc/rtc_base/logging.h"
 
 #include "webrtc/system_wrappers/include/event_wrapper.h"
 #include "webrtc/system_wrappers/include/sleep.h"
-#include "webrtc/system_wrappers/include/trace.h"
-
 webrtc::adm_linux_alsa::AlsaSymbolTable AlsaSymbolTable;
 
 // Accesses ALSA functions through our late-binding symbol table instead of
 // directly. This way we don't have to link to libasound, which means our binary
 // will work on systems that don't have it.
 #define LATE(sym) \
   LATESYM_GET(webrtc::adm_linux_alsa::AlsaSymbolTable, &AlsaSymbolTable, sym)
 
 // Redefine these here to be able to do late-binding
 #undef snd_ctl_card_info_alloca
@@ skipping 24 matching lines @@
 static const unsigned int ALSA_CAPTURE_CH = 2;
 static const unsigned int ALSA_CAPTURE_LATENCY = 40*1000; // in us
 static const unsigned int ALSA_CAPTURE_WAIT_TIMEOUT = 5; // in ms
 
 #define FUNC_GET_NUM_OF_DEVICE 0
 #define FUNC_GET_DEVICE_NAME 1
 #define FUNC_GET_DEVICE_NAME_FOR_AN_ENUM 2
 
 AudioDeviceLinuxALSA::AudioDeviceLinuxALSA(const int32_t id) :
     _ptrAudioBuffer(NULL),
-    _id(id),
     _mixerManager(id),
     _inputDeviceIndex(0),
     _outputDeviceIndex(0),
     _inputDeviceIsSpecified(false),
     _outputDeviceIsSpecified(false),
     _handleRecord(NULL),
     _handlePlayout(NULL),
     _recordingBuffersizeInFrame(0),
     _recordingPeriodSizeInFrame(0),
     _playoutBufferSizeInFrame(0),
@@ skipping 20 matching lines @@
     _recordingDelay(0),
     _playoutDelay(0),
     _playWarning(0),
     _playError(0),
     _recWarning(0),
     _recError(0),
     _playBufDelay(80),
     _playBufDelayFixed(80)
 {
     memset(_oldKeyState, 0, sizeof(_oldKeyState));
-    WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, id,
-                 "%s created", __FUNCTION__);
+    LOG(LS_INFO) << __FUNCTION__ << " created";
 }
 
 // ----------------------------------------------------------------------------
 //  AudioDeviceLinuxALSA - dtor
 // ----------------------------------------------------------------------------
 
 AudioDeviceLinuxALSA::~AudioDeviceLinuxALSA()
 {
-    WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id,
-                 "%s destroyed", __FUNCTION__);
+    LOG(LS_INFO) << __FUNCTION__ << " destroyed";
 
     Terminate();
 
     // Clean up the recording buffer and playout buffer.
     if (_recordingBuffer)
     {
         delete [] _recordingBuffer;
         _recordingBuffer = NULL;
     }
     if (_playoutBuffer)
@@ skipping 197 matching lines @@
     volume = level;
 
     return 0;
 }
 
 
 int32_t AudioDeviceLinuxALSA::SetWaveOutVolume(uint16_t volumeLeft,
                                                uint16_t volumeRight)
 {
 
-    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-                 "  API call not supported on this platform");
+    LOG(LS_WARNING) << "API call not supported on this platform";
     return -1;
 }
 
 int32_t AudioDeviceLinuxALSA::WaveOutVolume(
     uint16_t& /*volumeLeft*/,
     uint16_t& /*volumeRight*/) const
 {
 
-    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-                 "  API call not supported on this platform");
+    LOG(LS_WARNING) << "API call not supported on this platform";
     return -1;
 }
 
 int32_t AudioDeviceLinuxALSA::MaxSpeakerVolume(
     uint32_t& maxVolume) const
 {
 
     uint32_t maxVol(0);
 
     if (_mixerManager.MaxSpeakerVolume(maxVol) == -1)
@@ skipping 390 matching lines @@
     return 0;
 }
 
 int32_t AudioDeviceLinuxALSA::MicrophoneVolume(uint32_t& volume) const
 {
 
     uint32_t level(0);
 
     if (_mixerManager.MicrophoneVolume(level) == -1)
     {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-                     "  failed to retrive current microphone level");
+        LOG(LS_WARNING) << "failed to retrive current microphone level";
         return -1;
     }
 
     volume = level;
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxALSA::MaxMicrophoneVolume(
     uint32_t& maxVolume) const
@@ skipping 51 matching lines @@
 
 int32_t AudioDeviceLinuxALSA::SetPlayoutDevice(uint16_t index)
 {
 
     if (_playIsInitialized)
     {
         return -1;
     }
 
     uint32_t nDevices = GetDevicesInfo(0, true);
-    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-                 "  number of availiable audio output devices is %u", nDevices);
+    LOG(LS_VERBOSE) << "number of available audio output devices is "
+                    << nDevices;
 
     if (index > (nDevices-1))
     {
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                     "  device index is out of range [0,%u]", (nDevices-1));
+        LOG(LS_ERROR) << "device index is out of range [0," << (nDevices-1)
+                      << "]";
         return -1;
     }
 
     _outputDeviceIndex = index;
     _outputDeviceIsSpecified = true;
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxALSA::SetPlayoutDevice(
     AudioDeviceModule::WindowsDeviceType /*device*/)
 {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "WindowsDeviceType not supported");
+    LOG(LS_ERROR) << "WindowsDeviceType not supported";
     return -1;
 }
 
 int32_t AudioDeviceLinuxALSA::PlayoutDeviceName(
     uint16_t index,
     char name[kAdmMaxDeviceNameSize],
     char guid[kAdmMaxGuidSize])
 {
 
     const uint16_t nDevices(PlayoutDevices());
@@ skipping 44 matching lines @@
 
 int32_t AudioDeviceLinuxALSA::SetRecordingDevice(uint16_t index)
 {
 
     if (_recIsInitialized)
     {
         return -1;
     }
 
     uint32_t nDevices = GetDevicesInfo(0, false);
-    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-                 "  number of availiable audio input devices is %u", nDevices);
+    LOG(LS_VERBOSE) << "number of availiable audio input devices is "
+                    << nDevices;
 
     if (index > (nDevices-1))
     {
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                     "  device index is out of range [0,%u]", (nDevices-1));
+        LOG(LS_ERROR) << "device index is out of range [0," << (nDevices-1)
+                      << "]";
         return -1;
     }
 
     _inputDeviceIndex = index;
     _inputDeviceIsSpecified = true;
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  SetRecordingDevice II (II)
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceLinuxALSA::SetRecordingDevice(
     AudioDeviceModule::WindowsDeviceType /*device*/)
 {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "WindowsDeviceType not supported");
+    LOG(LS_ERROR) << "WindowsDeviceType not supported";
     return -1;
 }
 
 int32_t AudioDeviceLinuxALSA::PlayoutIsAvailable(bool& available)
 {
 
     available = false;
 
     // Try to initialize the playout side with mono
     // Assumes that user set num channels after calling this function
@@ skipping 68 matching lines @@
         return -1;
     }
 
     if (_playIsInitialized)
     {
         return 0;
     }
     // Initialize the speaker (devices might have been added or removed)
     if (InitSpeaker() == -1)
     {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-                     "  InitSpeaker() failed");
+        LOG(LS_WARNING) << "InitSpeaker() failed";
     }
 
     // Start by closing any existing wave-output devices
     //
     if (_handlePlayout != NULL)
     {
         LATE(snd_pcm_close)(_handlePlayout);
         _handlePlayout = NULL;
         _playIsInitialized = false;
         if (errVal < 0)
         {
-            WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                         "  Error closing current playout sound device, error:"
-                         " %s", LATE(snd_strerror)(errVal));
+            LOG(LS_ERROR)
+                << "Error closing current playout sound device, error: "
+                << LATE(snd_strerror)(errVal);
         }
     }
 
     // Open PCM device for playout
     char deviceName[kAdmMaxDeviceNameSize] = {0};
     GetDevicesInfo(2, true, _outputDeviceIndex, deviceName,
                    kAdmMaxDeviceNameSize);
 
-    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-                 "  InitPlayout open (%s)", deviceName);
+    LOG(LS_VERBOSE) << "InitPlayout open (" << deviceName << ")";
 
     errVal = LATE(snd_pcm_open)
                  (&_handlePlayout,
                   deviceName,
                   SND_PCM_STREAM_PLAYBACK,
                   SND_PCM_NONBLOCK);
 
     if (errVal == -EBUSY) // Device busy - try some more!
     {
         for (int i=0; i < 5; i++)
         {
             SleepMs(1000);
             errVal = LATE(snd_pcm_open)
                          (&_handlePlayout,
                           deviceName,
                           SND_PCM_STREAM_PLAYBACK,
                           SND_PCM_NONBLOCK);
             if (errVal == 0)
             {
                 break;
             }
         }
     }
     if (errVal < 0)
     {
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                     "     unable to open playback device: %s (%d)",
-                     LATE(snd_strerror)(errVal),
-                     errVal);
+        LOG(LS_ERROR) << "unable to open playback device: "
+                      << LATE(snd_strerror)(errVal) << " (" << errVal << ")";
         _handlePlayout = NULL;
         return -1;
     }
 
     _playoutFramesIn10MS = _playoutFreq/100;
     if ((errVal = LATE(snd_pcm_set_params)( _handlePlayout,
 #if defined(WEBRTC_ARCH_BIG_ENDIAN)
         SND_PCM_FORMAT_S16_BE,
 #else
         SND_PCM_FORMAT_S16_LE, //format
 #endif
         SND_PCM_ACCESS_RW_INTERLEAVED, //access
         _playChannels, //channels
         _playoutFreq, //rate
         1, //soft_resample
         ALSA_PLAYOUT_LATENCY //40*1000 //latency required overall latency in us
     )) < 0)
     {   /* 0.5sec */
         _playoutFramesIn10MS = 0;
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                     "     unable to set playback device: %s (%d)",
-                     LATE(snd_strerror)(errVal),
-                     errVal);
+        LOG(LS_ERROR) << "unable to set playback device: "
+                      << LATE(snd_strerror)(errVal) << " (" << errVal << ")";
         ErrorRecovery(errVal, _handlePlayout);
         errVal = LATE(snd_pcm_close)(_handlePlayout);
         _handlePlayout = NULL;
         return -1;
     }
 
     errVal = LATE(snd_pcm_get_params)(_handlePlayout,
         &_playoutBufferSizeInFrame, &_playoutPeriodSizeInFrame);
     if (errVal < 0)
     {
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                     "    snd_pcm_get_params %s",
-                     LATE(snd_strerror)(errVal),
-                     errVal);
+        LOG(LS_ERROR) << "snd_pcm_get_params: " << LATE(snd_strerror)(errVal)
+                      << " (" << errVal << ")";
         _playoutBufferSizeInFrame = 0;
         _playoutPeriodSizeInFrame = 0;
     }
     else {
-        WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-                     "    playout snd_pcm_get_params "
-                     "buffer_size:%d period_size :%d",
-                     _playoutBufferSizeInFrame, _playoutPeriodSizeInFrame);
+        LOG(LS_VERBOSE) << "playout snd_pcm_get_params buffer_size:"
+                        << _playoutBufferSizeInFrame << " period_size :"
+                        << _playoutPeriodSizeInFrame;
     }
 
     if (_ptrAudioBuffer)
     {
         // Update webrtc audio buffer with the selected parameters
         _ptrAudioBuffer->SetPlayoutSampleRate(_playoutFreq);
         _ptrAudioBuffer->SetPlayoutChannels(_playChannels);
     }
 
     // Set play buffer size
@@ skipping 35 matching lines @@
     }
 
     if (_recIsInitialized)
     {
         return 0;
     }
 
     // Initialize the microphone (devices might have been added or removed)
     if (InitMicrophone() == -1)
     {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-                   "  InitMicrophone() failed");
+        LOG(LS_WARNING) << "InitMicrophone() failed";
     }
 
     // Start by closing any existing pcm-input devices
     //
     if (_handleRecord != NULL)
     {
         int errVal = LATE(snd_pcm_close)(_handleRecord);
         _handleRecord = NULL;
         _recIsInitialized = false;
         if (errVal < 0)
         {
-            WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                         "     Error closing current recording sound device,"
-                         " error: %s",
-                         LATE(snd_strerror)(errVal));
+            LOG(LS_ERROR)
+                << "Error closing current recording sound device, error: "
+                << LATE(snd_strerror)(errVal);
         }
     }
 
     // Open PCM device for recording
     // The corresponding settings for playout are made after the record settings
     char deviceName[kAdmMaxDeviceNameSize] = {0};
     GetDevicesInfo(2, false, _inputDeviceIndex, deviceName,
                    kAdmMaxDeviceNameSize);
 
-    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-                 "InitRecording open (%s)", deviceName);
+    LOG(LS_VERBOSE) << "InitRecording open (" << deviceName << ")";
     errVal = LATE(snd_pcm_open)
                  (&_handleRecord,
                   deviceName,
                   SND_PCM_STREAM_CAPTURE,
                   SND_PCM_NONBLOCK);
 
     // Available modes: 0 = blocking, SND_PCM_NONBLOCK, SND_PCM_ASYNC
     if (errVal == -EBUSY) // Device busy - try some more!
     {
         for (int i=0; i < 5; i++)
         {
             SleepMs(1000);
             errVal = LATE(snd_pcm_open)
                          (&_handleRecord,
                           deviceName,
                           SND_PCM_STREAM_CAPTURE,
                           SND_PCM_NONBLOCK);
             if (errVal == 0)
             {
                 break;
             }
         }
     }
     if (errVal < 0)
     {
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                     "    unable to open record device: %s",
-                     LATE(snd_strerror)(errVal));
+        LOG(LS_ERROR) << "unable to open record device: "
+                      << LATE(snd_strerror)(errVal);
         _handleRecord = NULL;
         return -1;
     }
 
     _recordingFramesIn10MS = _recordingFreq/100;
     if ((errVal = LATE(snd_pcm_set_params)(_handleRecord,
 #if defined(WEBRTC_ARCH_BIG_ENDIAN)
         SND_PCM_FORMAT_S16_BE, //format
 #else
         SND_PCM_FORMAT_S16_LE, //format
@@ skipping 18 matching lines @@
              SND_PCM_FORMAT_S16_LE, //format
 #endif
              SND_PCM_ACCESS_RW_INTERLEAVED, //access
              _recChannels, //channels
              _recordingFreq, //rate
              1, //soft_resample
              ALSA_CAPTURE_LATENCY //latency in us
          )) < 0)
          {
              _recordingFramesIn10MS = 0;
-             WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                          "    unable to set record settings: %s (%d)",
-                          LATE(snd_strerror)(errVal), errVal);
+             LOG(LS_ERROR) << "unable to set record settings: "
+                           << LATE(snd_strerror)(errVal) << " (" << errVal
+                           << ")";
              ErrorRecovery(errVal, _handleRecord);
              errVal = LATE(snd_pcm_close)(_handleRecord);
              _handleRecord = NULL;
              return -1;
          }
     }
 
     errVal = LATE(snd_pcm_get_params)(_handleRecord,
         &_recordingBuffersizeInFrame, &_recordingPeriodSizeInFrame);
     if (errVal < 0)
     {
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                     "    snd_pcm_get_params %s",
-                     LATE(snd_strerror)(errVal), errVal);
+        LOG(LS_ERROR) << "snd_pcm_get_params " << LATE(snd_strerror)(errVal)
+                      << " (" << errVal << ")";
         _recordingBuffersizeInFrame = 0;
         _recordingPeriodSizeInFrame = 0;
     }
     else {
-        WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-                     "    capture snd_pcm_get_params "
-                     "buffer_size:%d period_size:%d",
-                     _recordingBuffersizeInFrame, _recordingPeriodSizeInFrame);
+        LOG(LS_VERBOSE) << "capture snd_pcm_get_params, buffer_size:"
+                        << _recordingBuffersizeInFrame << ", period_size:"
+                        << _recordingPeriodSizeInFrame;
     }
 
     if (_ptrAudioBuffer)
     {
         // Update webrtc audio buffer with the selected parameters
         _ptrAudioBuffer->SetRecordingSampleRate(_recordingFreq);
         _ptrAudioBuffer->SetRecordingChannels(_recChannels);
     }
 
     // Set rec buffer size and create buffer
@@ skipping 30 matching lines @@
     _recording = true;
 
     int errVal = 0;
     _recordingFramesLeft = _recordingFramesIn10MS;
 
     // Make sure we only create the buffer once.
     if (!_recordingBuffer)
         _recordingBuffer = new int8_t[_recordingBufferSizeIn10MS];
     if (!_recordingBuffer)
     {
-        WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id,
-                     "   failed to alloc recording buffer");
+        LOG(LS_ERROR) << "failed to alloc recording buffer";
         _recording = false;
         return -1;
     }
     // RECORDING
     _ptrThreadRec.reset(new rtc::PlatformThread(
         RecThreadFunc, this, "webrtc_audio_module_capture_thread"));
 
     _ptrThreadRec->Start();
     _ptrThreadRec->SetPriority(rtc::kRealtimePriority);
 
     errVal = LATE(snd_pcm_prepare)(_handleRecord);
     if (errVal < 0)
     {
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                     "     capture snd_pcm_prepare failed (%s)\n",
-                     LATE(snd_strerror)(errVal));
+        LOG(LS_ERROR) << "capture snd_pcm_prepare failed ("
+                      << LATE(snd_strerror)(errVal) << ")\n";
         // just log error
         // if snd_pcm_open fails will return -1
     }
 
     errVal = LATE(snd_pcm_start)(_handleRecord);
     if (errVal < 0)
     {
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                     "     capture snd_pcm_start err: %s",
-                     LATE(snd_strerror)(errVal));
+        LOG(LS_ERROR) << "capture snd_pcm_start err: "
+                      << LATE(snd_strerror)(errVal);
         errVal = LATE(snd_pcm_start)(_handleRecord);
         if (errVal < 0)
         {
-            WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                         "     capture snd_pcm_start 2nd try err: %s",
-                         LATE(snd_strerror)(errVal));
+            LOG(LS_ERROR) << "capture snd_pcm_start 2nd try err: "
+                          << LATE(snd_strerror)(errVal);
             StopRecording();
             return -1;
         }
     }
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxALSA::StopRecording()
 {
@@ skipping 27 matching lines @@
     if (_recordingBuffer)
     {
         delete [] _recordingBuffer;
         _recordingBuffer = NULL;
     }
 
     // Stop and close pcm recording device.
     int errVal = LATE(snd_pcm_drop)(_handleRecord);
     if (errVal < 0)
     {
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                     "     Error stop recording: %s",
-                     LATE(snd_strerror)(errVal));
+        LOG(LS_ERROR) << "Error stop recording: " << LATE(snd_strerror)(errVal);
         return -1;
     }
 
     errVal = LATE(snd_pcm_close)(_handleRecord);
     if (errVal < 0)
     {
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                     "     Error closing record sound device, error: %s",
-                     LATE(snd_strerror)(errVal));
+        LOG(LS_ERROR) << "Error closing record sound device, error: "
+                      << LATE(snd_strerror)(errVal);
         return -1;
     }
 
     // Check if we have muted and unmute if so.
     bool muteEnabled = false;
     MicrophoneMute(muteEnabled);
     if (muteEnabled)
     {
         SetMicrophoneMute(false);
     }
@@ skipping 30 matching lines @@
         return 0;
     }
 
     _playing = true;
 
     _playoutFramesLeft = 0;
     if (!_playoutBuffer)
         _playoutBuffer = new int8_t[_playoutBufferSizeIn10MS];
     if (!_playoutBuffer)
     {
-      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                   "    failed to alloc playout buf");
+      LOG(LS_ERROR) << "failed to alloc playout buf";
       _playing = false;
       return -1;
     }
 
     // PLAYOUT
     _ptrThreadPlay.reset(new rtc::PlatformThread(
         PlayThreadFunc, this, "webrtc_audio_module_play_thread"));
     _ptrThreadPlay->Start();
     _ptrThreadPlay->SetPriority(rtc::kRealtimePriority);
 
     int errVal = LATE(snd_pcm_prepare)(_handlePlayout);
     if (errVal < 0)
     {
-        WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id,
-                     "     playout snd_pcm_prepare failed (%s)\n",
-                     LATE(snd_strerror)(errVal));
+        LOG(LS_ERROR) << "playout snd_pcm_prepare failed ("
+                      << LATE(snd_strerror)(errVal) << ")\n";
         // just log error
         // if snd_pcm_open fails will return -1
     }
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxALSA::StopPlayout()
 {
 
@@ skipping 23 matching lines @@
     rtc::CritScope lock(&_critSect);
 
     _playoutFramesLeft = 0;
     delete [] _playoutBuffer;
     _playoutBuffer = NULL;
 
     // stop and close pcm playout device
     int errVal = LATE(snd_pcm_drop)(_handlePlayout);
     if (errVal < 0)
     {
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                     "    Error stop playing: %s",
-                     LATE(snd_strerror)(errVal));
+        LOG(LS_ERROR) << "Error stop playing: " << LATE(snd_strerror)(errVal);
     }
 
     errVal = LATE(snd_pcm_close)(_handlePlayout);
      if (errVal < 0)
-         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                      "    Error closing playout sound device, error: %s",
-                      LATE(snd_strerror)(errVal));
+         LOG(LS_ERROR) << "Error closing playout sound device, error: "
+                       << LATE(snd_strerror)(errVal);
 
      // set the pcm input handle to NULL
      _playIsInitialized = false;
      _handlePlayout = NULL;
-     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-                  "  handle_playout is now set to NULL");
+     LOG(LS_VERBOSE) << "handle_playout is now set to NULL";
 
      return 0;
 }
 
 int32_t AudioDeviceLinuxALSA::PlayoutDelay(uint16_t& delayMS) const
 {
     delayMS = (uint16_t)_playoutDelay * 1000 / _playoutFreq;
     return 0;
 }
 
@@ skipping 37 matching lines @@
     {
         sizeMS = _playBufDelay;
     }
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxALSA::CPULoad(uint16_t& load) const
 {
 
-    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-               "  API call not supported on this platform");
+    LOG(LS_WARNING) << "API call not supported on this platform";
     return -1;
 }
 
 bool AudioDeviceLinuxALSA::PlayoutWarning() const
 {
     rtc::CritScope lock(&_critSect);
     return (_playWarning > 0);
 }
 
 bool AudioDeviceLinuxALSA::PlayoutError() const
@@ skipping 68 matching lines @@
     // From Chromium issue 95797
     // Loop through the sound cards to get Alsa device hints.
     // Don't use snd_device_name_hint(-1,..) since there is a access violation
     // inside this ALSA API with libasound.so.2.0.0.
     int card = -1;
     while (!(LATE(snd_card_next)(&card)) && (card >= 0) && keepSearching) {
         void **hints;
         err = LATE(snd_device_name_hint)(card, "pcm", &hints);
         if (err != 0)
         {
-            WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                         "GetDevicesInfo - device name hint error: %s",
-                         LATE(snd_strerror)(err));
+            LOG(LS_ERROR) << "GetDevicesInfo - device name hint error: "
+                          << LATE(snd_strerror)(err);
             return -1;
         }
 
         enumCount++; // default is 0
         if ((function == FUNC_GET_DEVICE_NAME ||
             function == FUNC_GET_DEVICE_NAME_FOR_AN_ENUM) && enumDeviceNo == 0)
         {
             strcpy(enumDeviceName, "default");
 
             err = LATE(snd_device_name_free_hint)(hints);
             if (err != 0)
             {
-                WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                             "GetDevicesInfo - device name free hint error: %s",
-                             LATE(snd_strerror)(err));
+                LOG(LS_ERROR)
+                    << "GetDevicesInfo - device name free hint error: "
+                    << LATE(snd_strerror)(err);
             }
 
             return 0;
         }
 
         for (void **list = hints; *list != NULL; ++list)
         {
             char *actualType = LATE(snd_device_name_get_hint)(*list, "IOID");
             if (actualType)
             {   // NULL means it's both.
                 bool wrongType = (strcmp(actualType, type) != 0);
                 free(actualType);
                 if (wrongType)
                 {
                     // Wrong type of device (i.e., input vs. output).
                     continue;
                 }
             }
 
             char *name = LATE(snd_device_name_get_hint)(*list, "NAME");
             if (!name)
             {
-                WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                             "Device has no name");
+                LOG(LS_ERROR) << "Device has no name";
                 // Skip it.
                 continue;
             }
 
             // Now check if we actually want to show this device.
             if (strcmp(name, "default") != 0 &&
                 strcmp(name, "null") != 0 &&
                 strcmp(name, "pulse") != 0 &&
                 strncmp(name, ignorePrefix, strlen(ignorePrefix)) != 0)
             {
                 // Yes, we do.
                 char *desc = LATE(snd_device_name_get_hint)(*list, "DESC");
                 if (!desc)
                 {
                     // Virtual devices don't necessarily have descriptions.
                     // Use their names instead.
                     desc = name;
                 }
 
                 if (FUNC_GET_NUM_OF_DEVICE == function)
                 {
-                    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-                                 "    Enum device %d - %s", enumCount, name);
+                    LOG(LS_VERBOSE) << "Enum device " << enumCount << " - "
+                                    << name;
 
                 }
                 if ((FUNC_GET_DEVICE_NAME == function) &&
                     (enumDeviceNo == enumCount))
                 {
                     // We have found the enum device, copy the name to buffer.
                     strncpy(enumDeviceName, desc, ednLen);
                     enumDeviceName[ednLen-1] = '\0';
                     keepSearching = false;
                     // Replace '\n' with '-'.
@@ skipping 19 matching lines @@
 
             free(name);
 
             if (!keepSearching)
                 break;
         }
 
         err = LATE(snd_device_name_free_hint)(hints);
         if (err != 0)
         {
-            WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                         "GetDevicesInfo - device name free hint error: %s",
-                         LATE(snd_strerror)(err));
+            LOG(LS_ERROR) << "GetDevicesInfo - device name free hint error: "
+                          << LATE(snd_strerror)(err);
             // Continue and return true anyway, since we did get the whole list.
         }
     }
 
     if (FUNC_GET_NUM_OF_DEVICE == function)
     {
         if (enumCount == 1) // only default?
             enumCount = 0;
         return enumCount; // Normal return point for function 0
     }
 
     if (keepSearching)
     {
         // If we get here for function 1 and 2, we didn't find the specified
         // enum device.
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                     "GetDevicesInfo - Could not find device name or numbers");
+        LOG(LS_ERROR)
+            << "GetDevicesInfo - Could not find device name or numbers";
         return -1;
     }
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxALSA::InputSanityCheckAfterUnlockedPeriod() const
 {
     if (_handleRecord == NULL)
     {
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                     "  input state has been modified during unlocked period");
+        LOG(LS_ERROR) << "input state has been modified during unlocked period";
         return -1;
     }
     return 0;
 }
 
 int32_t AudioDeviceLinuxALSA::OutputSanityCheckAfterUnlockedPeriod() const
 {
     if (_handlePlayout == NULL)
     {
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                     "  output state has been modified during unlocked period");
+        LOG(LS_ERROR)
+            << "output state has been modified during unlocked period";
         return -1;
     }
     return 0;
 }
 
 int32_t AudioDeviceLinuxALSA::ErrorRecovery(int32_t error,
                                             snd_pcm_t* deviceHandle)
 {
     int st = LATE(snd_pcm_state)(deviceHandle);
-    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-               "Trying to recover from error: %s (%d) (state %d)",
-               (LATE(snd_pcm_stream)(deviceHandle) == SND_PCM_STREAM_CAPTURE) ?
-                   "capture" : "playout", LATE(snd_strerror)(error), error, st);
+    LOG(LS_VERBOSE) << "Trying to recover from "
+         << ((LATE(snd_pcm_stream)(deviceHandle) == SND_PCM_STREAM_CAPTURE)
+         ? "capture" : "playout") << " error: " << LATE(snd_strerror)(error)
+         << " (" << error << ") (state " << st << ")";
 
     // It is recommended to use snd_pcm_recover for all errors. If that function
     // cannot handle the error, the input error code will be returned, otherwise
     // 0 is returned. From snd_pcm_recover API doc: "This functions handles
     // -EINTR (4) (interrupted system call), -EPIPE (32) (playout overrun or
     // capture underrun) and -ESTRPIPE (86) (stream is suspended) error codes
     // trying to prepare given stream for next I/O."
 
     /** Open */
     //    SND_PCM_STATE_OPEN = 0,
@@ skipping 14 matching lines @@
     //  ** Hardware is disconnected */
     //    SND_PCM_STATE_DISCONNECTED,
     //    SND_PCM_STATE_LAST = SND_PCM_STATE_DISCONNECTED
 
     // snd_pcm_recover isn't available in older alsa, e.g. on the FC4 machine
     // in Sthlm lab.
 
     int res = LATE(snd_pcm_recover)(deviceHandle, error, 1);
     if (0 == res)
     {
-        WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-                   "    Recovery - snd_pcm_recover OK");
+        LOG(LS_VERBOSE) << "Recovery - snd_pcm_recover OK";
 
         if ((error == -EPIPE || error == -ESTRPIPE) && // Buf underrun/overrun.
             _recording &&
             LATE(snd_pcm_stream)(deviceHandle) == SND_PCM_STREAM_CAPTURE)
         {
             // For capture streams we also have to repeat the explicit start()
             // to get data flowing again.
             int err = LATE(snd_pcm_start)(deviceHandle);
             if (err != 0)
             {
-                WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                             "  Recovery - snd_pcm_start error: %u", err);
+                LOG(LS_ERROR) << "Recovery - snd_pcm_start error: " << err;
                 return -1;
             }
         }
 
         if ((error == -EPIPE || error == -ESTRPIPE) &&  // Buf underrun/overrun.
             _playing &&
             LATE(snd_pcm_stream)(deviceHandle) == SND_PCM_STREAM_PLAYBACK)
         {
             // For capture streams we also have to repeat the explicit start() to get
             // data flowing again.
             int err = LATE(snd_pcm_start)(deviceHandle);
             if (err != 0)
             {
-              WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                       "    Recovery - snd_pcm_start error: %s",
-                       LATE(snd_strerror)(err));
+              LOG(LS_ERROR) << "Recovery - snd_pcm_start error: "
+                            << LATE(snd_strerror)(err);
               return -1;
             }
         }
 
         return -EPIPE == error ? 1 : 0;
     }
     else {
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                     "  Unrecoverable alsa stream error: %d", res);
+        LOG(LS_ERROR) << "Unrecoverable alsa stream error: " << res;
     }
 
     return res;
 }
 
 // ============================================================================
 //                                  Thread Methods
 // ============================================================================
 
 bool AudioDeviceLinuxALSA::PlayThreadFunc(void* pThis)
@@ skipping 13 matching lines @@
 
     int err;
     snd_pcm_sframes_t frames;
     snd_pcm_sframes_t avail_frames;
 
     Lock();
     //return a positive number of frames ready otherwise a negative error code
     avail_frames = LATE(snd_pcm_avail_update)(_handlePlayout);
     if (avail_frames < 0)
     {
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                   "playout snd_pcm_avail_update error: %s",
-                   LATE(snd_strerror)(avail_frames));
+        LOG(LS_ERROR) << "playout snd_pcm_avail_update error: "
+                      << LATE(snd_strerror)(avail_frames);
         ErrorRecovery(avail_frames, _handlePlayout);
         UnLock();
         return true;
     }
     else if (avail_frames == 0)
     {
         UnLock();
 
         //maximum tixe in milliseconds to wait, a negative value means infinity
         err = LATE(snd_pcm_wait)(_handlePlayout, 2);
         if (err == 0)
         { //timeout occured
-            WEBRTC_TRACE(kTraceStream, kTraceAudioDevice, _id,
-                         "playout snd_pcm_wait timeout");
+            LOG(LS_VERBOSE) << "playout snd_pcm_wait timeout";
         }
 
         return true;
     }
 
     if (_playoutFramesLeft <= 0)
     {
         UnLock();
         _ptrAudioBuffer->RequestPlayoutData(_playoutFramesIn10MS);
         Lock();
 
         _playoutFramesLeft = _ptrAudioBuffer->GetPlayoutData(_playoutBuffer);
         assert(_playoutFramesLeft == _playoutFramesIn10MS);
     }
 
     if (static_cast<uint32_t>(avail_frames) > _playoutFramesLeft)
         avail_frames = _playoutFramesLeft;
 
     int size = LATE(snd_pcm_frames_to_bytes)(_handlePlayout,
         _playoutFramesLeft);
     frames = LATE(snd_pcm_writei)(
         _handlePlayout,
         &_playoutBuffer[_playoutBufferSizeIn10MS - size],
         avail_frames);
 
     if (frames < 0)
     {
-        WEBRTC_TRACE(kTraceStream, kTraceAudioDevice, _id,
-                     "playout snd_pcm_writei error: %s",
-                     LATE(snd_strerror)(frames));
+        LOG(LS_VERBOSE) << "playout snd_pcm_writei error: "
+                        << LATE(snd_strerror)(frames);
         _playoutFramesLeft = 0;
         ErrorRecovery(frames, _handlePlayout);
         UnLock();
         return true;
     }
     else {
         assert(frames==avail_frames);
         _playoutFramesLeft -= frames;
     }
 
@@ skipping 10 matching lines @@
     snd_pcm_sframes_t frames;
     snd_pcm_sframes_t avail_frames;
     int8_t buffer[_recordingBufferSizeIn10MS];
 
     Lock();
 
     //return a positive number of frames ready otherwise a negative error code
     avail_frames = LATE(snd_pcm_avail_update)(_handleRecord);
     if (avail_frames < 0)
     {
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                     "capture snd_pcm_avail_update error: %s",
-                     LATE(snd_strerror)(avail_frames));
+        LOG(LS_ERROR) << "capture snd_pcm_avail_update error: "
+                      << LATE(snd_strerror)(avail_frames);
         ErrorRecovery(avail_frames, _handleRecord);
         UnLock();
         return true;
     }
     else if (avail_frames == 0)
     { // no frame is available now
         UnLock();
 
         //maximum time in milliseconds to wait, a negative value means infinity
         err = LATE(snd_pcm_wait)(_handleRecord,
             ALSA_CAPTURE_WAIT_TIMEOUT);
         if (err == 0) //timeout occured
-            WEBRTC_TRACE(kTraceStream, kTraceAudioDevice, _id,
-                         "capture snd_pcm_wait timeout");
+            LOG(LS_VERBOSE) << "capture snd_pcm_wait timeout";
 
         return true;
     }
 
     if (static_cast<uint32_t>(avail_frames) > _recordingFramesLeft)
         avail_frames = _recordingFramesLeft;
 
     frames = LATE(snd_pcm_readi)(_handleRecord,
         buffer, avail_frames); // frames to be written
     if (frames < 0)
     {
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                     "capture snd_pcm_readi error: %s",
-                     LATE(snd_strerror)(frames));
+        LOG(LS_ERROR) << "capture snd_pcm_readi error: "
+                      << LATE(snd_strerror)(frames);
         ErrorRecovery(frames, _handleRecord);
         UnLock();
         return true;
     }
     else if (frames > 0)
     {
         assert(frames == avail_frames);
 
         int left_size = LATE(snd_pcm_frames_to_bytes)(_handleRecord,
             _recordingFramesLeft);
@@ skipping 31 matching lines @@
             _playoutDelay = 0;
             _recordingDelay = 0;
             if (_handlePlayout)
             {
                 err = LATE(snd_pcm_delay)(_handlePlayout,
                     &_playoutDelay); // returned delay in frames
                 if (err < 0)
                 {
                     // TODO(xians): Shall we call ErrorRecovery() here?
                     _playoutDelay = 0;
-                    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                                 "playout snd_pcm_delay: %s",
-                                 LATE(snd_strerror)(err));
+                    LOG(LS_ERROR) << "playout snd_pcm_delay: "
+                                  << LATE(snd_strerror)(err);
                 }
             }
 
             err = LATE(snd_pcm_delay)(_handleRecord,
                 &_recordingDelay); // returned delay in frames
             if (err < 0)
             {
                 // TODO(xians): Shall we call ErrorRecovery() here?
                 _recordingDelay = 0;
-                WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                             "capture snd_pcm_delay: %s",
-                             LATE(snd_strerror)(err));
+                LOG(LS_ERROR) << "capture snd_pcm_delay: "
+                              << LATE(snd_strerror)(err);
             }
 
            // TODO(xians): Shall we add 10ms buffer delay to the record delay?
             _ptrAudioBuffer->SetVQEData(
                 _playoutDelay * 1000 / _playoutFreq,
                 _recordingDelay * 1000 / _recordingFreq, 0);
 
             _ptrAudioBuffer->SetTypingStatus(KeyPressed());
 
             // Deliver recorded samples at specified sample rate, mic level etc.
             // to the observer using callback.
             UnLock();
             _ptrAudioBuffer->DeliverRecordedData();
             Lock();
 
             if (AGC())
             {
                 newMicLevel = _ptrAudioBuffer->NewMicLevel();
                 if (newMicLevel != 0)
                 {
                     // The VQE will only deliver non-zero microphone levels when a
                     // change is needed. Set this new mic level (received from the
                     // observer as return value in the callback).
                     if (SetMicrophoneVolume(newMicLevel) == -1)
-                        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-                                     "  the required modification of the "
-                                     "microphone volume failed");
+                        LOG(LS_WARNING)
+                            << "the required modification of the microphone volume failed";
                 }
             }
         }
     }
 
     UnLock();
     return true;
 }
 
 
@@ skipping 14 matching lines @@
     state |= (szKey[i] ^ _oldKeyState[i]) & szKey[i];
 
   // Save old state
   memcpy((char*)_oldKeyState, (char*)szKey, sizeof(_oldKeyState));
   return (state != 0);
 #else
   return false;
 #endif
 }
 }  // namespace webrtc