Avoids irregular OnMoreData callbacks on Windows using Core Audio

media/audio/win/audio_unified_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_unified_win.h"
 
 #include <Functiondiscoverykeys_devpkey.h>
 
 #include "base/debug/trace_event.h"
 #include "base/time.h"
 #include "base/win/scoped_com_initializer.h"
+#include "media/audio/audio_util.h"
 #include "media/audio/win/audio_manager_win.h"
 #include "media/audio/win/avrt_wrapper_win.h"
 #include "media/audio/win/core_audio_util_win.h"
 
 using base::win::ScopedComPtr;
 using base::win::ScopedCOMInitializer;
 using base::win::ScopedCoMem;
 
 // Time in milliseconds between two successive delay measurements.
 // We save resources by not updating the delay estimates for each capture
@@ skipping 47 matching lines @@
 
 namespace media {
 
 WASAPIUnifiedStream::WASAPIUnifiedStream(AudioManagerWin* manager,
                                          const AudioParameters& params)
     : creating_thread_id_(base::PlatformThread::CurrentId()),
       manager_(manager),
       share_mode_(CoreAudioUtil::GetShareMode()),
       audio_io_thread_(NULL),
       opened_(false),
+      volume_(1.0),
       endpoint_render_buffer_size_frames_(0),
       endpoint_capture_buffer_size_frames_(0),
       num_written_frames_(0),
       total_delay_ms_(0.0),
       source_(NULL),
       capture_bus_(AudioBus::Create(params)),
       render_bus_(AudioBus::Create(params)) {
   DCHECK(manager_);
 
   DVLOG_IF(1, !HasUnifiedDefaultIO()) << "Unified audio I/O is not supported.";
@@ skipping 150 matching lines @@
   }
 
   // Start input streaming data between the endpoint buffer and the audio
   // engine.
   HRESULT hr = audio_input_client_->Start();
   if (FAILED(hr)) {
     StopAndJoinThread(hr);
     return;
   }
 
-  // Reset the counter for number of rendered frames taking into account the
-  // fact that we always initialize the render side with silence.
-  UINT32 num_queued_frames = 0;
-  audio_output_client_->GetCurrentPadding(&num_queued_frames);
-  DCHECK_EQ(num_queued_frames, endpoint_render_buffer_size_frames_);
-  num_written_frames_ = num_queued_frames;
+  // Ensure that the endpoint buffer is prepared with silence.
+  if (share_mode_ == AUDCLNT_SHAREMODE_SHARED) {
+    if (!CoreAudioUtil::FillRenderEndpointBufferWithSilence(
+             audio_output_client_, audio_render_client_)) {
+      DLOG(WARNING) << "Failed to prepare endpoint buffers with silence.";
+      return;
+    }
+  }
+  num_written_frames_ = endpoint_render_buffer_size_frames_;
 
   // Start output streaming data between the endpoint buffer and the audio
   // engine.
   hr = audio_output_client_->Start();
   if (FAILED(hr)) {
     StopAndJoinThread(hr);
     return;
   }
 }
 
@@ skipping 56 matching lines @@
   // 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 WASAPIUnifiedStream::SetVolume(double volume) {
-  NOTIMPLEMENTED();
+  DVLOG(1) << "SetVolume(volume=" << volume << ")";
+  if (volume < 0 || volume > 1)
+    return;
+  volume_ = volume;
 }
 
 void WASAPIUnifiedStream::GetVolume(double* volume) {
-  NOTIMPLEMENTED();
+  DVLOG(1) << "GetVolume()";
+  *volume = static_cast<double>(volume_);
 }
 
 // static
 bool WASAPIUnifiedStream::HasUnifiedDefaultIO() {
   AudioParameters in_params;
   HRESULT hr = CoreAudioUtil::GetPreferredAudioParameters(eCapture, eConsole,
                                                           &in_params);
   if (FAILED(hr))
     return false;
 
@@ skipping 170 matching lines @@
           if (FAILED(hr)) {
             DLOG(ERROR) << "Failed to access render buffer";
             continue;
           }
 
           // Convert the audio bus content to interleaved integer data using
           // |audio_data| as destination.
           render_bus_->ToInterleaved(
               packet_size_frames_, bytes_per_sample, audio_data);
 
+          // Perform in-place, software-volume adjustments.
+          media::AdjustVolume(audio_data,
+                              frames_filled * format_.Format.nBlockAlign,
+                              render_bus_->channels(),
+                              bytes_per_sample,
+                              volume_);
+
           // Release the buffer space acquired in the GetBuffer() call.
           audio_render_client_->ReleaseBuffer(packet_size_frames_, 0);
           DLOG_IF(ERROR, FAILED(hr)) << "Failed to release render buffer";
         }
         break;
       default:
         error = true;
         break;
     }
   }
@@ skipping 24 matching lines @@
 void WASAPIUnifiedStream::StopAndJoinThread(HRESULT err) {
   CHECK(GetCurrentThreadId() == creating_thread_id_);
   DCHECK(audio_io_thread_.get());
   SetEvent(stop_streaming_event_.Get());
   audio_io_thread_->Join();
   audio_io_thread_.reset();
   HandleError(err);
 }
 
 }  // namespace media