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

media/audio/mac/audio_manager_mac.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/mac/audio_manager_mac.h"
 
-#include <stdint.h>
+#include <algorithm>
+#include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/mac/mac_logging.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/macros.h"
 #include "base/memory/free_deleter.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/power_monitor/power_observer.h"
 #include "base/strings/sys_string_conversions.h"
@@ skipping 836 matching lines @@
   // see if the size can actually be changed. If there is any other active
   // streams on the same device, either input or output, a larger size than
   // their requested buffer size can't be set. The reason is that an existing
   // stream can't handle buffer size larger than its requested buffer size.
   // See http://crbug.com/428706 for a reason why.
 
   if (buffer_size == desired_buffer_size)
     return true;
 
   if (desired_buffer_size > buffer_size) {
     // Do NOT set the buffer size if there is another output stream using

[o1ka, 2016/04/22 12:24:24]

May we probably skip those checks when called from
IncreaseIOBufferSizeIfPossible? They n^2 complexity if called for each
IncreaseIOBufferSizeIfPossible() call. (Though, n should be small so it probably
does not matter; depends on what are the requirements for ReleaseOutputStream)

[henrika (OOO until Aug 14), 2016/04/25 13:54:13]

Latest implementation only calls it once for all streams sharing the same device
id. IMO, we can keep as is. 

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

Acknowledged.

     // the same device with a smaller requested buffer size.
     // Note, for the caller stream, its requested_buffer_size() will be the same
     // as |desired_buffer_size|, so it won't return true due to comparing with
     // itself.
     for (auto* stream : output_streams_) {
       if (stream->device_id() == device_id &&
           stream->requested_buffer_size() < desired_buffer_size) {
         return true;
       }
     }
@@ skipping 35 matching lines @@
       << "AudioUnitSetProperty(kAudioDevicePropertyBufferFrameSize) failed.  "
       << "Size:: " << buffer_size;
   *size_was_changed = (result == noErr);
   DVLOG_IF(1, result == noErr) << "IO buffer size changed to: " << buffer_size;
   // Store the currently used (after a change) I/O buffer frame size.
   *io_buffer_frame_size = buffer_size;
 
   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) {

[o1ka, 2016/04/22 12:24:24]

Add a thread check for clarity?

[henrika (OOO until Aug 14), 2016/04/25 13:54:13]

Done.

+  DVLOG(1) << "IncreaseIOBufferSizeIfPossible(id=0x" << std::hex << device_id
+           << ")";
+  // Build a map of buffer sizes [requested, actual] from all existing output
+  // audio streams using the specified |device_id|.
+  std::map<size_t, size_t> size_map;
+  std::list<AUHALStream*> output_streams;
+  for (auto* stream : output_streams_) {
+    if (stream->device_id() == device_id) {
+      size_map[stream->requested_buffer_size()] = stream->actual_buffer_size();

[o1ka, 2016/04/22 12:24:24]

Shouldn't it be that all the streams have the same actual buffer size?
I really like this map trick, but I'm not sure if it is needed.

[henrika (OOO until Aug 14), 2016/04/25 13:54:13]

Now changed.

+      output_streams.push_back(stream);
+    }
+  }
+
+  if (size_map.empty()) {
+    DVLOG(1) << "No action since there is no active stream for given device id";
+    return false;
+  }
+
+  // The elements are sorted according to the key object which is the
+  // requested buffer size in this case. The associated value is the actual
+  // buffer size and if these are equal for the first pair in the lists it means
+  // that we are already using the lowest possible buffer size. Hence, it is not
+  // possible to do any increase.
+  if (size_map.begin()->first == size_map.begin()->second) {
+    DVLOG(1) << "No action since lowest possible size is already in use: "
+             << size_map.begin()->first;
+    return false;
+  }
+
+  // Add a handy log message to track the current status before trying to make
+  // a change.
+  for (auto it = size_map.begin(); it != size_map.end(); ++it) {
+    DVLOG(1) << "requested:" << it->first << " actual: " << it->second;
+  }
+
+  // First pair in the map now contains the lowest requested buffer size that
+  // is not yet in use since another stream required a smaller value. It should
+  // now be safe to increase the I/O buffer size to this new (higher) value.
+  // Doing so will save system resources.
+  const size_t increased_io_buffer_frame_size = size_map.begin()->first;
+
+  bool size_was_changed = false;
+  size_t io_buffer_frame_size = 0;
+  bool result = false;
+  for (auto* stream : output_streams) {
+    result = MaybeChangeBufferSize(device_id, stream->audio_unit(), 0,
+                                   increased_io_buffer_frame_size,
+                                   &size_was_changed, &io_buffer_frame_size);
+    DCHECK(size_was_changed);
+    DCHECK_EQ(io_buffer_frame_size, increased_io_buffer_frame_size);
+  }
+
+  return true;
+}
+
+bool AudioManagerMac::AudioDeviceIsUsedForInput(AudioDeviceID device_id) {
+  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) {

[o1ka, 2016/04/22 12:24:24]

I assume it can't race with MakeLowLatencyOutputStream(), am I correct? How is
it guaranteed? Can we have a thread check?

[henrika (OOO until Aug 14), 2016/04/25 13:54:13]

Added thread checks. 

+  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) {
   auto stream_it = std::find(basic_input_streams_.begin(),
                              basic_input_streams_.end(),
                              stream);
   if (stream_it == basic_input_streams_.end())
     low_latency_input_streams_.remove(static_cast<AUAudioInputStream*>(stream));
   else
     basic_input_streams_.erase(stream_it);
 
   AudioManagerBase::ReleaseInputStream(stream);
 }
 
 ScopedAudioManagerPtr CreateAudioManager(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> worker_task_runner,
     AudioLogFactory* audio_log_factory) {
   return ScopedAudioManagerPtr(
       new AudioManagerMac(std::move(task_runner), std::move(worker_task_runner),
                           audio_log_factory));
 }
 
 }  // namespace media