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 87 matching lines @@
 static void CheckOverflow(int start_frame, int frames, int total_frames) {
   CHECK_GE(start_frame, 0);
   CHECK_GE(frames, 0);
   CHECK_GT(total_frames, 0);
   int sum = start_frame + frames;
   CHECK_LE(sum, total_frames);
   CHECK_GE(sum, 0);
 }
 
 AudioBus::AudioBus(int channels, int frames)
-    : frames_(frames) {
+    : frames_(frames),
+      can_set_channel_data_(false) {
   ValidateConfig(channels, frames_);
 
   int aligned_frames = 0;
   int size = CalculateMemorySizeInternal(channels, frames, &aligned_frames);
 
   data_.reset(static_cast<float*>(base::AlignedAlloc(
       size, AudioBus::kChannelAlignment)));
 
   BuildChannelData(channels, aligned_frames, data_.get());
 }
 
 AudioBus::AudioBus(int channels, int frames, float* data)
-    : frames_(frames) {
+    : frames_(frames),
+      can_set_channel_data_(false) {
   ValidateConfig(channels, frames_);
 
   int aligned_frames = 0;
   CalculateMemorySizeInternal(channels, frames, &aligned_frames);
 
   BuildChannelData(channels, aligned_frames, data);
 }
 
 AudioBus::AudioBus(int frames, const std::vector<float*>& channel_data)
     : channel_data_(channel_data),
-      frames_(frames) {
+      frames_(frames),
+      can_set_channel_data_(false) {
   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),
+      can_set_channel_data_(true) {
+  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::CreateWrapper(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) {
+  CHECK(can_set_channel_data_);
+  CHECK_GE(channel, 0);
+  CHECK_LT(static_cast<size_t>(channel), channel_data_.size());
+  DCHECK(IsAligned(data));
+  channel_data_[channel] = data;
+}
+
+void AudioBus::set_frames(int frames) {
+  CHECK(can_set_channel_data_);
+  frames_ = frames;
+}
+
 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