Add Mac OS X synchronized audio I/O back-end

media/base/audio_bus.h

Index: media/base/audio_bus.h
===================================================================
--- media/base/audio_bus.h	(revision 156450)
+++ media/base/audio_bus.h	(working copy)
@@ -11,6 +11,10 @@
 #include "base/memory/scoped_ptr.h"
 #include "media/base/media_export.h"
 
+#if defined(OS_MACOSX)
+struct AudioBufferList;
+#endif
+
 namespace media {
 class AudioParameters;
 
@@ -25,6 +29,16 @@
   // SSE optimizations.
   enum { kChannelAlignment = 16 };
 
+  AudioBus(int channels, int frames);
+  AudioBus(int channels, int frames, float* data);
+  AudioBus(int frames, const std::vector<float*>& channel_data);
+
+#if defined(OS_MACOSX)
+  AudioBus(int channels, int frames, AudioBufferList* buffer_list);
+#endif
+
+  ~AudioBus();

[scherkus (not reviewing), 2012/09/13 13:06:03]

we'll likely have to chat about this change a bit more -- one of the motivations
behind having private ctors/dtors w/ static methods that return scoped_ptr<> was
to enforce that these objects have single owner and deletion/transfer of
ownership is forbidden:
http://codereview.chromium.org/10829183/diff/5001/media/base/audio_bus.h#newc...

We can revisit that decision but I'm curious whether it's possible to
pre-allocate the AudioBus objects you need inside of audio_synchronized_mac.cc

For example, there are snippets of code like the following:
AudioBus bus(channels_, number_of_frames, input_data_);

...both of those are member variable data and it's only the # of frames that
might change but maybe that can be handled via some other mechanism.

[DaleCurtis, 2012/09/14 09:14:00]

+1, I don't see why you made this change. You should just add a new OS_MAC
specific Create method.

That said, I don't think this is the place for the AudioBufferList change, this
class should remain platform independent. I don't think any other class will use
the AudioBufferList method. Which means this is probably better done inside a
helper method inside that class. Something like:

scoped_ptr<AudioBus> AudioSynchronizedStream::GetAudioBus(int frames, int
channels, AudioBufferList* buffer_list) {
  std::vector temp_vector()
  <convert buffer_list into temp_vector>
  return AudioBus::WrapVector(frames, channels, temp_vector);
}

[Chris Rogers, 2012/09/15 00:06:08]

Ok, I can change this part if necessary - not that big of a deal.  But two
advantages I see are:

1) Client code is much easier to read when using stack-based objects as compared
with scoped_ptr<> style.  We *do* actually have some classes which are allowed
to be stack-based.

2) It's less efficient to create objects on the heap than on the stack.  It's
(occasionally) possible to block on memory allocations which is bad for
real-time threads.  Ideally, memory allocations shouldn't happen at all on
real-time audio threads.  Unfortunately, we *do* allocate in several other
places already, but I don't like to pile on more.

[DaleCurtis, 2012/09/15 07:44:42]

This is going to result in real time allocation either way right? The AudioBus
internally will call AlignedAlloc on construction. The only case where this
might help is the wrapped methods, and even then I'm not so sure.

If you're worried about allocations we can add a resize method to audio bus
which intelligently figures out if it needs to reallocate or just adjust the
frame cap. Then you can do your allocation once on initialize with a large size
once and resize elsewhere.

What do you think? I'd prefer to keep the existing methods unless I'm missing
something.

+
   // Creates a new AudioBus and allocates |channels| of length |frames|.  Uses
   // channels() and frames_per_buffer() from AudioParameters if given.
   static scoped_ptr<AudioBus> Create(int channels, int frames);
@@ -85,12 +99,7 @@
 
  private:
   friend class scoped_ptr<AudioBus>;
-  ~AudioBus();
 
-  AudioBus(int channels, int frames);
-  AudioBus(int channels, int frames, float* data);
-  AudioBus(int frames, const std::vector<float*>& channel_data);
-
   // Helper method for building |channel_data_| from a block of memory.  |data|
   // must be at least BlockSize() bytes in size.
   void BuildChannelData(int channels, int aligned_frame, float* data);