Allow audio system to handle synchronized low-latency audio I/O

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"
 #include "media/base/limits.h"
 
 namespace media {
 
 static bool IsAligned(void* ptr) {
   return (reinterpret_cast<uintptr_t>(ptr) &
           (AudioBus::kChannelAlignment - 1)) == 0U;
 }
 
-// Calculates the required size for an AudioBus with the given params, sets
-// |aligned_frames| to the actual frame length of each channel array.
-static int CalculateMemorySizeInternal(int channels, int frames,
-                                       int* aligned_frames) {
-  CHECK(aligned_frames);
-  // Choose a size such that each channel will be aligned by kChannelAlignment
-  // when stored in a contiguous block.
-  *aligned_frames =
-      ((frames * sizeof(float) + AudioBus::kChannelAlignment - 1) &
-       ~(AudioBus::kChannelAlignment - 1)) / sizeof(float);
-  return sizeof(float) * channels * (*aligned_frames);
-}
-
 // |Format| is the destination type, |Fixed| is a type larger than |Format|
 // such that operations can be made without overflowing.
 template<class Format, class Fixed>
 static void FromInterleavedInternal(const void* src, int start_frame,
                                     int frames, AudioBus* dest) {
   const Format* source = static_cast<const Format*>(src);
 
   static const Fixed kBias = std::numeric_limits<Format>::is_signed ? 0 :
       std::numeric_limits<Format>::max() / 2 + 1;
   static const float kMaxScale = 1.0f / (kBias ? kBias - 1 :
@@ skipping 56 matching lines @@
   int sum = start_frame + frames;
   CHECK_LE(sum, total_frames);
   CHECK_GE(sum, 0);
 }
 
 AudioBus::AudioBus(int channels, int frames)
     : frames_(frames) {
   ValidateConfig(channels, frames_);
 
   int aligned_frames = 0;
-  int size = CalculateMemorySizeInternal(channels, frames, &aligned_frames);
+  int size = CalculateMemorySizeFromChannels(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) {
   ValidateConfig(channels, frames_);
 
   int aligned_frames = 0;
-  CalculateMemorySizeInternal(channels, frames, &aligned_frames);
+  CalculateMemorySizeFromChannels(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) {
   ValidateConfig(channel_data_.size(), frames_);
 
   // Sanity check wrapped vector for alignment and channel count.
@@ skipping 47 matching lines @@
 }
 
 void AudioBus::ZeroFrames(int frames) {
   ZeroFramesPartial(0, frames);
 }
 
 void AudioBus::Zero() {
   ZeroFrames(frames_);
 }
 
+// Calculates the required size for an AudioBus with the given params, sets
+// |aligned_frames| to the actual frame length of each channel array.
+int AudioBus::CalculateMemorySizeFromChannels(int channels, int frames,
+                                              int* out_aligned_frames) {
+  // Choose a size such that each channel will be aligned by
+  // kChannelAlignment when stored in a contiguous block.
+  int aligned_frames =
+      ((frames * sizeof(float) + AudioBus::kChannelAlignment - 1) &
+       ~(AudioBus::kChannelAlignment - 1)) / sizeof(float);
+
+  if (out_aligned_frames)
+    *out_aligned_frames = aligned_frames;
+
+  return sizeof(float) * channels * aligned_frames;
+}
+
 int AudioBus::CalculateMemorySize(const AudioParameters& params) {
   int aligned_frames = 0;
-  return CalculateMemorySizeInternal(
+  return CalculateMemorySizeFromChannels(
       params.channels(), params.frames_per_buffer(), &aligned_frames);
 }
 
 void AudioBus::BuildChannelData(int channels, int aligned_frames, float* data) {
   DCHECK(IsAligned(data));
   DCHECK_EQ(channel_data_.size(), 0U);
   // Separate audio data out into channels for easy lookup later.  Figure out
   channel_data_.reserve(channels);
   for (int i = 0; i < channels; ++i)
     channel_data_.push_back(data + i * aligned_frames);
@@ skipping 56 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