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 =
+                                       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);
-  return sizeof(float) * channels * (*aligned_frames);
+
+  if (out_aligned_frames)
+    *out_aligned_frames = aligned_frames;
+
+  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 :
@@ skipping 140 matching lines @@
 
 void AudioBus::ZeroFrames(int frames) {
   ZeroFramesPartial(0, frames);
 }
 
 void AudioBus::Zero() {
   ZeroFrames(frames_);
 }
 
 int AudioBus::CalculateMemorySize(const AudioParameters& params) {
-  int aligned_frames = 0;
   return CalculateMemorySizeInternal(
-      params.channels(), params.frames_per_buffer(), &aligned_frames);
+      params.channels(), params.frames_per_buffer(), NULL);
+}
+
+int AudioBus::CalculateMemorySize(int channels, int frames) {
+  return CalculateMemorySizeInternal(channels, frames, NULL);
 }
 
 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 55 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