AudioBus: Add a ToInterleavedFloat() method to AudioBus

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 <stddef.h>
 #include <stdint.h>
 
 #include <limits>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/numerics/safe_conversions.h"
 #include "media/base/audio_parameters.h"
 #include "media/base/limits.h"
 #include "media/base/vector_math.h"
 
 namespace media {
 
 static const uint8_t kUint8Bias = 128;
 
 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.
+// In order to guarantee that the memory block for each channel starts at an
+// aligned address when splitting a contiguous block of memory into one block
+// per channel, we may have to make these blocks larger than otherwise needed.
+// We do this by allocating space for potentially more frames than requested.
+// This method returns the required size for the contiguous memory block
+// in bytes and outputs the adjusted number of frames via |out_aligned_frames|.
 static int CalculateMemorySizeInternal(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.
+  // Since our internal sample format is float, we can guarantee the alignment
+  // by making the number of frames an integer multiple of
+  // AudioBus::kChannelAlignment / sizeof(float).
   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;
 }
 
@@ skipping 197 matching lines @@
       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
+  // Initialize |channel_data_| with pointers into |data|.
   channel_data_.reserve(channels);
   for (int i = 0; i < channels; ++i)
     channel_data_.push_back(data + i * aligned_frames);
 }
 
 // TODO(dalecurtis): See if intrinsic optimizations help any here.
 void AudioBus::FromInterleavedPartial(const void* source, int start_frame,
                                       int frames, int bytes_per_sample) {
   CheckOverflow(start_frame, frames, frames_);
   switch (bytes_per_sample) {
@@ skipping 31 matching lines @@
 void AudioBus::FromInterleaved(const void* source, int frames,
                                int bytes_per_sample) {
   FromInterleavedPartial(source, 0, frames, bytes_per_sample);
 }
 
 void AudioBus::ToInterleaved(int frames, int bytes_per_sample,
                              void* dest) const {
   ToInterleavedPartial(0, frames, bytes_per_sample, dest);
 }
 
+// Interleaves |audio_bus| channels() of floats into a single output linear
+// |buffer|.
+void AudioBus::ToInterleavedFloat(int source_offset,
+                                  int destination_offset,
+                                  int num_samples,

[miu, 2016/06/02 20:40:21]

s/num_samples/frames/ (for naming consistency with the rest of this class)

+                                  float* buffer) const {
+  CheckOverflow(source_offset, destination_offset, num_samples);
+  for (int ch = 0; ch < channels(); ++ch) {
+    const float* src = channel(ch) + source_offset;
+    const float* const src_end = src + num_samples;
+    float* dest = buffer + destination_offset + ch;
+    for (; src < src_end; ++src, dest += channels())
+      *dest = *src;
+  }
+}
+
 // TODO(dalecurtis): See if intrinsic optimizations help any here.
 void AudioBus::ToInterleavedPartial(int start_frame, int frames,
                                     int bytes_per_sample, void* dest) const {
   CheckOverflow(start_frame, frames, frames_);
   switch (bytes_per_sample) {
     case 1:
       ToInterleavedInternal<uint8_t, int16_t, kUint8Bias>(
           this, start_frame, frames, dest, std::numeric_limits<int8_t>::min(),
           std::numeric_limits<int8_t>::max());
       break;
@@ skipping 56 matching lines @@
   return scoped_refptr<AudioBusRefCounted>(
       new AudioBusRefCounted(channels, frames));
 }
 
 AudioBusRefCounted::AudioBusRefCounted(int channels, int frames)
     : AudioBus(channels, frames) {}
 
 AudioBusRefCounted::~AudioBusRefCounted() {}
 
 }  // namespace media