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

media/base/audio_bus.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/base/audio_bus.h"
 
 #include <limits>
 
 #include "base/logging.h"
 #include "media/audio/audio_parameters.h"
@@ skipping 119 matching lines @@
 AudioBus::AudioBus(int frames, const std::vector<float*>& channel_data)
     : channel_data_(channel_data),
       frames_(frames) {
   ValidateConfig(channel_data_.size(), frames_);
 
   // Sanity check wrapped vector for alignment and channel count.
   for (size_t i = 0; i < channel_data_.size(); ++i)
     DCHECK(IsAligned(channel_data_[i]));
 }
 
+AudioBus::AudioBus(int channels)
+    : channel_data_(channels),
+      frames_(0) {
+  for (size_t i = 0; i < channel_data_.size(); ++i)
+    channel_data_[i] = NULL;
+}
+
 AudioBus::~AudioBus() {}
 
 scoped_ptr<AudioBus> AudioBus::Create(int channels, int frames) {
   return scoped_ptr<AudioBus>(new AudioBus(channels, frames));
 }
 
 scoped_ptr<AudioBus> AudioBus::Create(const AudioParameters& params) {
   return scoped_ptr<AudioBus>(new AudioBus(
       params.channels(), params.frames_per_buffer()));
 }
 
+scoped_ptr<AudioBus> AudioBus::Create(int channels) {
+  return scoped_ptr<AudioBus>(new AudioBus(channels));
+}
+
 scoped_ptr<AudioBus> AudioBus::WrapVector(
     int frames, const std::vector<float*>& channel_data) {
   return scoped_ptr<AudioBus>(new AudioBus(frames, channel_data));
 }
 
 scoped_ptr<AudioBus> AudioBus::WrapMemory(int channels, int frames,
                                           void* data) {
   // |data| must be aligned by AudioBus::kChannelAlignment.
   CHECK(IsAligned(data));
   return scoped_ptr<AudioBus>(new AudioBus(
       channels, frames, static_cast<float*>(data)));
 }
 
 scoped_ptr<AudioBus> AudioBus::WrapMemory(const AudioParameters& params,
                                           void* data) {
   // |data| must be aligned by AudioBus::kChannelAlignment.
   CHECK(IsAligned(data));
   return scoped_ptr<AudioBus>(new AudioBus(
       params.channels(), params.frames_per_buffer(),
       static_cast<float*>(data)));
 }
 
+void AudioBus::SetChannelData(int channel, float* data) {

[DaleCurtis, 2012/09/17 21:17:36]

This can lead to some pretty confusing situations:
1. WrapMemory(<some contiguous block>)
2. SetChannelData(0, <some channel data>)

Now the wrapped bus isn't writing all of its data to the wrapped memory region.

Maybe we should prevent usage of this method with WrapMemory and WrapVector
objects? If so the constructor above should set <some flag> and
DCHECK(data_.get() || <some flag>);

[Chris Rogers, 2012/09/17 22:00:42]

We can discuss offline...

+  CHECK_GE(channel, 0);
+  CHECK_LT(static_cast<size_t>(channel), channel_data_.size());
+  DCHECK(IsAligned(data));
+  channel_data_[channel] = data;
+}
+
 void AudioBus::ZeroFramesPartial(int start_frame, int frames) {
   CheckOverflow(start_frame, frames, frames_);
 
   if (frames <= 0)
     return;
 
   for (size_t i = 0; i < channel_data_.size(); ++i) {
     memset(channel_data_[i] + start_frame, 0,
            frames * sizeof(*channel_data_[i]));
   }
@@ skipping 82 matching lines @@
   DCHECK_EQ(channels(), dest->channels());
   DCHECK_EQ(frames(), dest->frames());
 
   // Since we don't know if the other AudioBus is wrapped or not (and we don't
   // want to care), just copy using the public channel() accessors.
   for (int i = 0; i < channels(); ++i)
     memcpy(dest->channel(i), channel(i), sizeof(*channel(i)) * frames());
 }
 
 }  // namespace media