[media/audio] Convert VLOGs to DVLOGs

media/audio/win/audio_low_latency_output_win.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/audio/win/audio_low_latency_output_win.h"
 
 #include <Functiondiscoverykeys_devpkey.h>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 55 matching lines @@
       packet_size_bytes_(0),
       endpoint_buffer_size_frames_(0),
       device_id_(device_id),
       device_role_(device_role),
       share_mode_(GetShareMode()),
       num_written_frames_(0),
       source_(NULL),
       audio_bus_(AudioBus::Create(params)) {
   DCHECK(manager_);
 
-  VLOG(1) << "WASAPIAudioOutputStream::WASAPIAudioOutputStream()";
-  VLOG_IF(1, share_mode_ == AUDCLNT_SHAREMODE_EXCLUSIVE)
-      << "Core Audio (WASAPI) EXCLUSIVE MODE is enabled.";
+  DVLOG(1) << "WASAPIAudioOutputStream::WASAPIAudioOutputStream()";
+  DVLOG_IF(1, share_mode_ == AUDCLNT_SHAREMODE_EXCLUSIVE)
+       << "Core Audio (WASAPI) EXCLUSIVE MODE is enabled.";
 
   // Load the Avrt DLL if not already loaded. Required to support MMCSS.
   bool avrt_init = avrt::Initialize();
   DCHECK(avrt_init) << "Failed to load the avrt.dll";
 
   // Set up the desired render format specified by the client. We use the
   // WAVE_FORMAT_EXTENSIBLE structure to ensure that multiple channel ordering
   // and high precision data can be supported.
 
   // Begin with the WAVEFORMATEX structure that specifies the basic format.
   WAVEFORMATEX* format = &format_.Format;
   format->wFormatTag = WAVE_FORMAT_EXTENSIBLE;
   format->nChannels = params.channels();
   format->nSamplesPerSec = params.sample_rate();
   format->wBitsPerSample = params.bits_per_sample();
   format->nBlockAlign = (format->wBitsPerSample / 8) * format->nChannels;
   format->nAvgBytesPerSec = format->nSamplesPerSec * format->nBlockAlign;
   format->cbSize = sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
 
   // Add the parts which are unique to WAVE_FORMAT_EXTENSIBLE.
   format_.Samples.wValidBitsPerSample = params.bits_per_sample();
   format_.dwChannelMask = CoreAudioUtil::GetChannelConfig(device_id, eRender);
   format_.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 
   // Store size (in different units) of audio packets which we expect to
   // get from the audio endpoint device in each render event.
   packet_size_frames_ = params.frames_per_buffer();
   packet_size_bytes_ = params.GetBytesPerBuffer();
-  VLOG(1) << "Number of bytes per audio frame  : " << format->nBlockAlign;
-  VLOG(1) << "Number of audio frames per packet: " << packet_size_frames_;
-  VLOG(1) << "Number of bytes per packet       : " << packet_size_bytes_;
-  VLOG(1) << "Number of milliseconds per packet: "
+  DVLOG(1) << "Number of bytes per audio frame  : " << format->nBlockAlign;
+  DVLOG(1) << "Number of audio frames per packet: " << packet_size_frames_;
+  DVLOG(1) << "Number of bytes per packet       : " << packet_size_bytes_;
+  DVLOG(1) << "Number of milliseconds per packet: "
           << params.GetBufferDuration().InMillisecondsF();
 
   // All events are auto-reset events and non-signaled initially.
 
   // Create the event which the audio engine will signal each time
   // a buffer becomes ready to be processed by the client.
   audio_samples_render_event_.Set(CreateEvent(NULL, FALSE, FALSE, NULL));
   DCHECK(audio_samples_render_event_.IsValid());
 
   // Create the event which will be set in Stop() when capturing shall stop.
   stop_render_event_.Set(CreateEvent(NULL, FALSE, FALSE, NULL));
   DCHECK(stop_render_event_.IsValid());
 }
 
 WASAPIAudioOutputStream::~WASAPIAudioOutputStream() {
   DCHECK_EQ(GetCurrentThreadId(), creating_thread_id_);
 }
 
 bool WASAPIAudioOutputStream::Open() {
-  VLOG(1) << "WASAPIAudioOutputStream::Open()";
+  DVLOG(1) << "WASAPIAudioOutputStream::Open()";
   DCHECK_EQ(GetCurrentThreadId(), creating_thread_id_);
   if (opened_)
     return true;
 
   DCHECK(!audio_client_.get());
   DCHECK(!audio_render_client_.get());
 
   // Will be set to true if we ended up opening the default communications
   // device.
   bool communications_device = false;
@@ skipping 78 matching lines @@
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to get IAudioClock service.";
     return false;
   }
 
   opened_ = true;
   return true;
 }
 
 void WASAPIAudioOutputStream::Start(AudioSourceCallback* callback) {
-  VLOG(1) << "WASAPIAudioOutputStream::Start()";
+  DVLOG(1) << "WASAPIAudioOutputStream::Start()";
   DCHECK_EQ(GetCurrentThreadId(), creating_thread_id_);
   CHECK(callback);
   CHECK(opened_);
 
   if (render_thread_) {
     CHECK_EQ(callback, source_);
     return;
   }
 
   source_ = callback;
@@ skipping 24 matching lines @@
   // Start streaming data between the endpoint buffer and the audio engine.
   HRESULT hr = audio_client_->Start();
   if (FAILED(hr)) {
     PLOG(ERROR) << "Failed to start output streaming: " << std::hex << hr;
     StopThread();
     callback->OnError(this);
   }
 }
 
 void WASAPIAudioOutputStream::Stop() {
-  VLOG(1) << "WASAPIAudioOutputStream::Stop()";
+  DVLOG(1) << "WASAPIAudioOutputStream::Stop()";
   DCHECK_EQ(GetCurrentThreadId(), creating_thread_id_);
   if (!render_thread_)
     return;
 
   // Stop output audio streaming.
   HRESULT hr = audio_client_->Stop();
   if (FAILED(hr)) {
     PLOG(ERROR) << "Failed to stop output streaming: " << std::hex << hr;
     source_->OnError(this);
   }
@@ skipping 14 matching lines @@
   // would fail with AUDCLNT_E_BUFFER_ERROR at IAudioRenderClient::GetBuffer().
   // This check is is only needed for shared-mode streams.
   if (share_mode_ == AUDCLNT_SHAREMODE_SHARED) {
     UINT32 num_queued_frames = 0;
     audio_client_->GetCurrentPadding(&num_queued_frames);
     DCHECK_EQ(0u, num_queued_frames);
   }
 }
 
 void WASAPIAudioOutputStream::Close() {
-  VLOG(1) << "WASAPIAudioOutputStream::Close()";
+  DVLOG(1) << "WASAPIAudioOutputStream::Close()";
   DCHECK_EQ(GetCurrentThreadId(), creating_thread_id_);
 
   // It is valid to call Close() before calling open or Start().
   // It is also valid to call Close() after Start() has been called.
   Stop();
 
   // Inform the audio manager that we have been closed. This will cause our
   // destruction.
   manager_->ReleaseOutputStream(this);
 }
 
 void WASAPIAudioOutputStream::SetVolume(double volume) {
-  VLOG(1) << "SetVolume(volume=" << volume << ")";
+  DVLOG(1) << "SetVolume(volume=" << volume << ")";
   float volume_float = static_cast<float>(volume);
   if (volume_float < 0.0f || volume_float > 1.0f) {
     return;
   }
   volume_ = volume_float;
 }
 
 void WASAPIAudioOutputStream::GetVolume(double* volume) {
-  VLOG(1) << "GetVolume()";
+  DVLOG(1) << "GetVolume()";
   *volume = static_cast<double>(volume_);
 }
 
 void WASAPIAudioOutputStream::Run() {
   ScopedCOMInitializer com_init(ScopedCOMInitializer::kMTA);
 
   // Increase the thread priority.
   render_thread_->SetThreadPriority(base::kThreadPriority_RealtimeAudio);
 
   // Enable MMCSS to ensure that this thread receives prioritized access to
@@ skipping 189 matching lines @@
 
   float f = (1000.0 * packet_size_frames_) / format_.Format.nSamplesPerSec;
   REFERENCE_TIME requested_buffer_duration =
       static_cast<REFERENCE_TIME>(f * 10000.0 + 0.5);
 
   DWORD stream_flags = AUDCLNT_STREAMFLAGS_NOPERSIST;
   bool use_event = (event_handle != NULL &&
                     event_handle != INVALID_HANDLE_VALUE);
   if (use_event)
     stream_flags |= AUDCLNT_STREAMFLAGS_EVENTCALLBACK;
-  VLOG(2) << "stream_flags: 0x" << std::hex << stream_flags;
+  DVLOG(2) << "stream_flags: 0x" << std::hex << stream_flags;
 
   // Initialize the audio stream between the client and the device.
   // For an exclusive-mode stream that uses event-driven buffering, the
   // caller must specify nonzero values for hnsPeriodicity and
   // hnsBufferDuration, and the values of these two parameters must be equal.
   // The Initialize method allocates two buffers for the stream. Each buffer
   // is equal in duration to the value of the hnsBufferDuration parameter.
   // Following the Initialize call for a rendering stream, the caller should
   // fill the first of the two buffers before starting the stream.
   HRESULT hr = S_FALSE;
   hr = client->Initialize(AUDCLNT_SHAREMODE_EXCLUSIVE,
                           stream_flags,
                           requested_buffer_duration,
                           requested_buffer_duration,
                           reinterpret_cast<WAVEFORMATEX*>(&format_),
                           NULL);
   if (FAILED(hr)) {
     if (hr == AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED) {
       LOG(ERROR) << "AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED";
 
       UINT32 aligned_buffer_size = 0;
       client->GetBufferSize(&aligned_buffer_size);
-      VLOG(1) << "Use aligned buffer size instead: " << aligned_buffer_size;
+      DVLOG(1) << "Use aligned buffer size instead: " << aligned_buffer_size;
 
       // Calculate new aligned periodicity. Each unit of reference time
       // is 100 nanoseconds.
       REFERENCE_TIME aligned_buffer_duration = static_cast<REFERENCE_TIME>(
           (10000000.0 * aligned_buffer_size / format_.Format.nSamplesPerSec)
           + 0.5);
 
       // It is possible to re-activate and re-initialize the audio client
       // at this stage but we bail out with an error code instead and
       // combine it with a log message which informs about the suggested
       // aligned buffer size which should be used instead.
-      VLOG(1) << "aligned_buffer_duration: "
-              << static_cast<double>(aligned_buffer_duration / 10000.0)
-              << " [ms]";
+      DVLOG(1) << "aligned_buffer_duration: "
+               << static_cast<double>(aligned_buffer_duration / 10000.0)
+               << " [ms]";
     } else if (hr == AUDCLNT_E_INVALID_DEVICE_PERIOD) {
       // We will get this error if we try to use a smaller buffer size than
       // the minimum supported size (usually ~3ms on Windows 7).
       LOG(ERROR) << "AUDCLNT_E_INVALID_DEVICE_PERIOD";
     }
     return hr;
   }
 
   if (use_event) {
     hr = client->SetEventHandle(event_handle);
     if (FAILED(hr)) {
-      VLOG(1) << "IAudioClient::SetEventHandle: " << std::hex << hr;
+      DVLOG(1) << "IAudioClient::SetEventHandle: " << std::hex << hr;
       return hr;
     }
   }
 
   UINT32 buffer_size_in_frames = 0;
   hr = client->GetBufferSize(&buffer_size_in_frames);
   if (FAILED(hr)) {
-    VLOG(1) << "IAudioClient::GetBufferSize: " << std::hex << hr;
+    DVLOG(1) << "IAudioClient::GetBufferSize: " << std::hex << hr;
     return hr;
   }
 
   *endpoint_buffer_size = buffer_size_in_frames;
-  VLOG(2) << "endpoint buffer size: " << buffer_size_in_frames;
+  DVLOG(2) << "endpoint buffer size: " << buffer_size_in_frames;
   return hr;
 }
 
 void WASAPIAudioOutputStream::StopThread() {
   if (render_thread_ ) {
     if (render_thread_->HasBeenStarted()) {
       // Wait until the thread completes and perform cleanup.
       SetEvent(stop_render_event_.Get());
       render_thread_->Join();
     }
 
     render_thread_.reset();
 
     // Ensure that we don't quit the main thread loop immediately next
     // time Start() is called.
     ResetEvent(stop_render_event_.Get());
   }
 
   source_ = NULL;
 }
 
 }  // namespace media