(Relanding) 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 <limits>
+#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 339 matching lines @@
 };
 
 AudioManagerMac::AudioManagerMac(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> worker_task_runner,
     AudioLogFactory* audio_log_factory)
     : AudioManagerBase(std::move(task_runner),
                        std::move(worker_task_runner),
                        audio_log_factory),
       current_sample_rate_(0),
-      current_output_device_(kAudioDeviceUnknown) {
+      current_output_device_(kAudioDeviceUnknown),
+      device_id_used_by_closing_output_stream_(kAudioDeviceUnknown),
+      try_to_increase_io_buffer_size_(false) {
   SetMaxOutputStreamsAllowed(kMaxOutputStreams);
 
   // Task must be posted last to avoid races from handing out "this" to the
   // audio thread.  Always PostTask even if we're on the right thread since
   // AudioManager creation is on the startup path and this may be slow.
   GetTaskRunner()->PostTask(
       FROM_HERE, base::Bind(&AudioManagerMac::InitializeOnAudioThread,
                             base::Unretained(this)));
 }
 
@@ skipping 96 matching lines @@
 }
 
 void AudioManagerMac::GetAudioOutputDeviceNames(
     media::AudioDeviceNames* device_names) {
   DCHECK(device_names->empty());
   GetAudioDeviceInfo(false, device_names);
 }
 
 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;
     return AudioParameters(
         AudioParameters::AUDIO_PCM_LOW_LATENCY, CHANNEL_LAYOUT_STEREO,
         kFallbackSampleRate, 16, ChooseBufferSize(true, kFallbackSampleRate));
   }
 
   int channels = 0;
   ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
@@ skipping 95 matching lines @@
     if (default_device == *iter)
       return *iter;
   }
 
   // Failed to figure out which is the matching device, return an empty string.
   return std::string();
 }
 
 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
   // devices, the listener will never be initialized, and new valid devices
   // will never be detected.
   if (!output_device_listener_) {
     // NOTE: Use BindToCurrentLoop() to ensure the callback is always PostTask'd
     // even if OSX calls us on the right thread.  Some CoreAudio drivers will
     // fire the callbacks during stream creation, leading to re-entrancy issues
     // otherwise.  See http://crbug.com/349604
@@ skipping 48 matching lines @@
     return std::string();
 
   std::string ret(base::SysCFStringRefToUTF8(device_uid));
   CFRelease(device_uid);
 
   return ret;
 }
 
 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);
   return stream;
 }
 
 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.
   AudioDeviceID audio_device_id = GetAudioDeviceIdByUId(true, device_id);
   AUAudioInputStream* stream = NULL;
   if (audio_device_id != kAudioObjectUnknown) {
     stream = new AUAudioInputStream(this, params, audio_device_id);
     low_latency_input_streams_.push_back(stream);
   }
 
   return stream;
 }
 
 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;
     return input_params.IsValid() ? input_params : AudioParameters(
         AudioParameters::AUDIO_PCM_LOW_LATENCY, CHANNEL_LAYOUT_STEREO,
         kFallbackSampleRate, 16, ChooseBufferSize(false, kFallbackSampleRate));
   }
 
   const bool has_valid_input_params = input_params.IsValid();
   const int hardware_sample_rate = HardwareSampleRateForDevice(device);
@@ skipping 141 matching lines @@
 
   // Check if a buffer size change is required. If the caller asks for a
   // reduced size (|desired_buffer_size| < |buffer_size|), the new lower size
   // will be set. For larger buffer sizes, we have to perform some checks to
   // 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.
 
+  // Update map of actual buffer size given device id if the map is empty.
+  // Stores a base value that most likely be modified as last action in this
+  // method.
+  if (!is_input && output_io_buffer_size_map_.count(device_id) == 0)
+    output_io_buffer_size_map_[device_id] = buffer_size;

[o1ka, 2016/05/12 11:30:17]

Should we really do it here? (See my comment to l.933)

[henrika (OOO until Aug 14), 2016/05/12 13:02:08]

Nahh, you are probably correct. I must agree that storing it here does not feel
OK. Removing.

+
   if (buffer_size == desired_buffer_size)
     return true;
 
   if (desired_buffer_size > buffer_size) {

[o1ka, 2016/05/12 11:30:17]

shouldn't we just check (output_io_buffer_size_map_[device_id] <
desired_buffer_size_)  here instead of iterating through all the streams?

[henrika (OOO until Aug 14), 2016/05/12 13:02:08]

If you don't mind I would like to avoid making such a change at this stage. I
did a quick test and found that there were cased when the size would be
increased but it wasn't. Did not spend time on figuring out why.

     // Do NOT set the buffer size if there is another output stream using
     // 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 33 matching lines @@
                                 kAudioUnitScope_Global, 0, &buffer_size,
                                 sizeof(buffer_size));
   OSSTATUS_DLOG_IF(ERROR, result != noErr, result)
       << "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;
 
+  // If the size was changed, update the actual output buffer size used for the
+  // given device ID.
+  if (!is_input && (result == noErr)) {

[o1ka, 2016/05/12 11:30:17]

if (output_io_buffer_size_map_.count(device_id) == 0), but (result != noErr), it
means you updated that map at l.872 with the value which is not actually set,
isn't it?

[henrika (OOO until Aug 14), 2016/05/12 13:02:08]

Lines 868 - 873 have been  removed.

+    output_io_buffer_size_map_[device_id] = buffer_size;
+  }
+
   return (result == noErr);
 }
 
+bool AudioManagerMac::IncreaseIOBufferSizeIfPossible(AudioDeviceID device_id) {
+  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
+  DVLOG(1) << "IncreaseIOBufferSizeIfPossible(id=0x" << std::hex << device_id
+           << ")";
+  // Start by storing the actual I/O buffer size. Then scan all active output
+  // streams using the specified |device_id| and find the minimum requested
+  // buffer size. In addition, store a reference to the audio unit of the first
+  // output stream using |device_id|.
+  DCHECK(!output_io_buffer_size_map_.empty());
+  // All active output streams use the same actual I/O buffer size given
+  // a unique device ID.
+  const size_t& actual_size = output_io_buffer_size_map_[device_id];
+  AudioUnit audio_unit;
+  size_t min_requested_size = std::numeric_limits<std::size_t>::max();
+  for (auto* stream : output_streams_) {
+    if (stream->device_id() == device_id) {
+      if (min_requested_size == std::numeric_limits<std::size_t>::max()) {
+        // Store reference to the first audio unit using the specified ID.
+        audio_unit = stream->audio_unit();
+      }
+      if (stream->requested_buffer_size() < min_requested_size)
+        min_requested_size = stream->requested_buffer_size();
+      DVLOG(1) << "requested:" << stream->requested_buffer_size()
+               << " actual: " << actual_size;
+    }
+  }
+
+  if (min_requested_size == std::numeric_limits<std::size_t>::max()) {
+    DVLOG(1) << "No action since there is no active stream for given device id";
+    return false;
+  }
+
+  // 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.
+  DCHECK_GE(min_requested_size, actual_size);
+  if (min_requested_size == actual_size) {
+    DVLOG(1) << "No action since lowest possible size is already in use: "
+             << actual_size;
+    return false;
+  }
+
+  // It should now be safe to increase the I/O buffer size to a new (higher)
+  // value using the |min_requested_size|. 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.
+  DVLOG(1) << "min_requested_size: " << min_requested_size;
+  bool size_was_changed = false;
+  size_t io_buffer_frame_size = 0;
+  bool result =
+      MaybeChangeBufferSize(device_id, audio_unit, 0, min_requested_size,
+                            &size_was_changed, &io_buffer_frame_size);
+  DCHECK_EQ(io_buffer_frame_size, min_requested_size);
+  DCHECK(size_was_changed);
+  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::PrepareForAttemptToIncreaseIOBufferSize(
+    AudioDeviceID device_id) {
+  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
+  device_id_used_by_closing_output_stream_ = device_id;
+  try_to_increase_io_buffer_size_ = true;
+}
+
 void AudioManagerMac::ReleaseOutputStream(AudioOutputStream* stream) {
+  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
+  // Start by closing down the specified output stream.
   output_streams_.remove(static_cast<AUHALStream*>(stream));
   AudioManagerBase::ReleaseOutputStream(stream);
+
+  if (!try_to_increase_io_buffer_size_)
+    return;
+
+  const AudioDeviceID id = device_id_used_by_closing_output_stream_;
+  DVLOG(1) << "Closed output stream with id=0x" << std::hex << id;
+
+  // 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);
+  }
+
+  try_to_increase_io_buffer_size_ = false;
 }
 
 void AudioManagerMac::ReleaseInputStream(AudioInputStream* stream) {
+  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
   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