Restores larger output buffer size when output stream requiring smaller size is closed

media/audio/mac/audio_manager_mac.cc

Index: media/audio/mac/audio_manager_mac.cc
diff --git a/media/audio/mac/audio_manager_mac.cc b/media/audio/mac/audio_manager_mac.cc
index b0744eeaa1f10bbb1f87443686f18bd2a61e02f0..b935bee034d5f9e3bf81e2c65095120e7351695a 100644
--- a/media/audio/mac/audio_manager_mac.cc
+++ b/media/audio/mac/audio_manager_mac.cc
@@ -4,7 +4,9 @@
 
 #include "media/audio/mac/audio_manager_mac.h"
 
-#include <stdint.h>
+#include <algorithm>
+#include <map>
+#include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ -483,6 +485,7 @@ void AudioManagerMac::GetAudioOutputDeviceNames(
 
 AudioParameters AudioManagerMac::GetInputStreamParameters(
     const std::string& device_id) {
+  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
   AudioDeviceID device = GetAudioDeviceIdByUId(true, device_id);
   if (device == kAudioObjectUnknown) {
     DLOG(ERROR) << "Invalid device " << device_id;
@@ -598,12 +601,14 @@ std::string AudioManagerMac::GetAssociatedOutputDeviceID(
 
 AudioOutputStream* AudioManagerMac::MakeLinearOutputStream(
     const AudioParameters& params) {
+  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
   return MakeLowLatencyOutputStream(params, std::string());
 }
 
 AudioOutputStream* AudioManagerMac::MakeLowLatencyOutputStream(
     const AudioParameters& params,
     const std::string& device_id) {
+  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
   bool device_listener_first_init = false;
   // Lazily create the audio device listener on the first stream creation,
   // even if getting an audio device fails. Otherwise, if we have 0 audio
@@ -672,6 +677,7 @@ std::string AudioManagerMac::GetDefaultOutputDeviceID() {
 
 AudioInputStream* AudioManagerMac::MakeLinearInputStream(
     const AudioParameters& params, const std::string& device_id) {
+  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LINEAR, params.format());
   AudioInputStream* stream = new PCMQueueInAudioInputStream(this, params);
   basic_input_streams_.push_back(stream);
@@ -680,6 +686,7 @@ AudioInputStream* AudioManagerMac::MakeLinearInputStream(
 
 AudioInputStream* AudioManagerMac::MakeLowLatencyInputStream(
     const AudioParameters& params, const std::string& device_id) {
+  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LOW_LATENCY, params.format());
   // Gets the AudioDeviceID that refers to the AudioInputDevice with the device
   // unique id. This AudioDeviceID is used to set the device for Audio Unit.
@@ -696,6 +703,7 @@ AudioInputStream* AudioManagerMac::MakeLowLatencyInputStream(
 AudioParameters AudioManagerMac::GetPreferredOutputStreamParameters(
     const std::string& output_device_id,
     const AudioParameters& input_params) {
+  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
   const AudioDeviceID device = GetAudioDeviceIdByUId(false, output_device_id);
   if (device == kAudioObjectUnknown) {
     DLOG(ERROR) << "Invalid output device " << output_device_id;
@@ -917,12 +925,127 @@ bool AudioManagerMac::MaybeChangeBufferSize(AudioDeviceID device_id,
   return (result == noErr);
 }
 
+#if !defined(NDEBUG)
+void AudioManagerMac::PrintOutputBufferSizes() {
+  for (auto* stream : output_streams_) {
+    DVLOG(1) << "[id=0x" << std::hex << stream->device_id() << "] " << std::dec
+             << "requested: " << stream->requested_buffer_size() << ", "
+             << "actual: " << stream->actual_buffer_size();
+  }
+}
+#endif  // !defined(NDEBUG)
+
+bool AudioManagerMac::IncreaseIOBufferSizeIfPossible(AudioDeviceID device_id) {
+  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
+  DVLOG(1) << "IncreaseIOBufferSizeIfPossible(id=0x" << std::hex << device_id
+           << ")";
+
+  // Scan all active output streams using the specified |device_id|. Store the
+  // actual I/O buffer size once and add all requested buffer sizes to a list.
+  // In addition, build a list of output streams using |device_id|.

[o1ka, 2016/04/25 15:13:26]

It does not seem to be used - am I missing something?

[henrika (OOO until Aug 14), 2016/04/26 11:47:28]

I actually only use the first stream in the list. Will change data structure.

+  size_t actual_size = 0;
+  std::vector<size_t> requested_sizes;
+  std::list<AUHALStream*> output_streams;
+  for (auto* stream : output_streams_) {
+    if (stream->device_id() == device_id) {
+      if (actual_size == 0) {
+        // All active output streams uses the same actual I/O buffer size given
+        // a unique device ID. Hence, it is sufficient to store one value once.
+        actual_size = stream->actual_buffer_size();
+      }
+      requested_sizes.push_back(stream->requested_buffer_size());
+      output_streams.push_back(stream);
+    }
+  }
+
+  if (output_streams.empty()) {
+    DVLOG(1) << "No action since there is no active stream for given device id";
+    return false;
+  }
+
+  // Sort the list of requested buffer sizes (lowest value comes first).
+  std::sort(requested_sizes.begin(), requested_sizes.end());
+  // It is only possible to revert to a larger buffer size if the lowest
+  // requested is not in use. Example: if the actual I/O buffer size is 256 and
+  // at least one output stream has asked for 256 as its buffer size, we can't
+  // start using a larger I/O buffer size.
+  if (requested_sizes[0] == actual_size) {
+    DVLOG(1) << "No action since lowest possible size is already in use: "
+             << actual_size;
+    return false;
+  }
+
+  // Add a handy log message to track the current status before trying to make
+  // a change.
+  for (auto it = requested_sizes.begin(); it != requested_sizes.end(); ++it) {

[o1ka, 2016/04/25 15:13:26]

Do I understand it correctly that this information is important for diagnostics,
and otherwise we would just find out the minimum requested buffer size without
keeping a list and sorting it?
Can we probably just print this information at l.956 and keep there track of a
minimum requested size found so far, instead of keeping a vector? In the end it
looks like only the minimum value is used.

+    DVLOG(1) << "requested:" << *it << " actual: " << actual_size;
+  }
+
+  // It should now be safe to increase the I/O buffer size to a new (higher)
+  // value using the first value in |requested_sizes|. Doing so will save
+  // system resources. All active output streams with the same |device_id| are
+  // affected by this change but it is only required to apply the change to one
+  // of the streams. Currently the first stream in the list is utilized.
+  const size_t increased_io_buffer_frame_size = requested_sizes[0];
+  DVLOG(1) << "increased_io_buffer_frame_size: "
+           << increased_io_buffer_frame_size;
+  bool size_was_changed = false;
+  size_t io_buffer_frame_size = 0;
+  bool result = MaybeChangeBufferSize(
+      device_id, output_streams.front()->audio_unit(), 0,
+      increased_io_buffer_frame_size, &size_was_changed, &io_buffer_frame_size);
+  DCHECK_EQ(io_buffer_frame_size, increased_io_buffer_frame_size);
+
+  return result;
+}
+
+bool AudioManagerMac::AudioDeviceIsUsedForInput(AudioDeviceID device_id) {
+  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
+  if (!basic_input_streams_.empty()) {
+    // For Audio Queues and in the default case (Mac OS X), the audio comes
+    // from the system’s default audio input device as set by a user in System
+    // Preferences.
+    AudioDeviceID default_id;
+    GetDefaultDevice(&default_id, true);
+    if (default_id == device_id)
+      return true;
+  }
+
+  // Each low latency streams has its own device ID.
+  for (auto* stream : low_latency_input_streams_) {
+    if (stream->device_id() == device_id)
+      return true;
+  }
+  return false;
+}
+
 void AudioManagerMac::ReleaseOutputStream(AudioOutputStream* stream) {
+  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
+  const AudioDeviceID id = static_cast<AUHALStream*>(stream)->device_id();
+  DVLOG(1) << "Closing down output stream with id=0x" << std::hex << id;
+
+  // Start by closing down the specified output stream.
   output_streams_.remove(static_cast<AUHALStream*>(stream));
+#if !defined(NDEBUG)
+  PrintOutputBufferSizes();
+#endif  // !defined(NDEBUG)
   AudioManagerBase::ReleaseOutputStream(stream);
+
+  // Prevent attempt to alter buffer size if the released stream was the last
+  // output stream.
+  if (output_streams_.empty())
+    return;
+
+  if (!AudioDeviceIsUsedForInput(id)) {
+    // The current audio device is not used for input. See if it is possible to
+    // increase the IO buffer size (saves power) given the remaining output
+    // audio streams and their buffer size requirements.
+    IncreaseIOBufferSizeIfPossible(id);
+  }
 }
 
 void AudioManagerMac::ReleaseInputStream(AudioInputStream* stream) {
+  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
   auto stream_it = std::find(basic_input_streams_.begin(),
                              basic_input_streams_.end(),
                              stream);