Upgrade AudioBus to support wrapping, interleaving.

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 {
 
 // Ensure each channel is 16-byte aligned for easy SSE optimizations.
 static const int kChannelAlignment = 16;
 
 static bool IsAligned(void* ptr) {
   return (reinterpret_cast<uintptr_t>(ptr) & (kChannelAlignment - 1)) == 0U;
 }
 
-AudioBus::AudioBus(int channels, int frames)
-    : frames_(frames) {
-  CHECK_GT(frames, 0);
-  CHECK_LE(frames, limits::kMaxSamplesPerPacket);
-  CHECK_GT(channels, 0);
-  CHECK_LE(channels, limits::kMaxChannels);
-  DCHECK_LT(limits::kMaxSamplesPerPacket * limits::kMaxChannels,
-            std::numeric_limits<int>::max());
+// Calculates the expected data_size() for an AudioBus with the given params,
+// sets |aligned_frames| to the actual frame length of each channel array.
+static int ExpectedDataSizeInternal(int channels, int frames,
+                                    int* aligned_frames) {

[Chris Rogers, 2012/08/15 19:39:31]

NULL-check aligned_frames

[DaleCurtis, 2012/08/16 01:54:14]

Done.

+  // Choose a size such that each channel is aligned by kChannelAlignment.
+  *aligned_frames =
+      (frames + kChannelAlignment - 1) & ~(kChannelAlignment - 1);
+  // Include an extra kChannelAlignment bytes in case WrapBlock() needs to
+  // manually align the start of the first channel.
+  return sizeof(float) * channels * *aligned_frames + kChannelAlignment;
+}
 
-  // Choose a size such that each channel is aligned by kChannelAlignment.
-  int aligned_frames =
-      (frames_ + kChannelAlignment - 1) & ~(kChannelAlignment - 1);
-  data_size_ = sizeof(float) * channels * aligned_frames;
+AudioBus::AudioBus(int channels, int frames, int sample_rate)
+    : frames_(frames),
+      sample_rate_(sample_rate) {
+  ValidateConfig(channels, frames_, sample_rate_);
+
+  int aligned_frames = 0;
+  data_size_ = ExpectedDataSizeInternal(channels, frames, &aligned_frames);
 
   data_.reset(static_cast<float*>(base::AlignedAlloc(
       data_size_, kChannelAlignment)));

[Chris Rogers, 2012/08/15 19:39:31]

Are we now allocating more than we need to in order to be aligned since
ExpectedDataSizeInternal() is adding the extra +kChannelAlignment, on top of
whatever AlignedAlloc is doing (sorry I didn't look AlignedAlloc internals)

[DaleCurtis, 2012/08/15 20:12:54]

We're allocating more than we need since we don't require WrapBlock to be given
a 16-byte aligned address.

AlignedAlloc is in the 99% of cases using an aligned allocator method like
posix_memalign which isn't over allocating under the hood. The only time over
allocation is used is when a user manually specifies CHROME_ALLOCATOR=winheap or
winlfh.

In common desktop case we've already got a 16-byte alignment due to the
underlying allocator, so we're not even fragmenting the heap by using
AlignedAlloc.

 
-  // Separate audio data out into channels for easy lookup later.
-  channel_data_.reserve(channels);
-  for (int i = 0; i < channels; ++i)
-    channel_data_.push_back(data_.get() + i * aligned_frames);
+  BuildChannelData(channels, aligned_frames, data_.get());
+}
+
+AudioBus::AudioBus(int channels, int frames, int sample_rate, float* data)
+    : data_size_(0),
+      frames_(frames),
+      sample_rate_(sample_rate) {
+  ValidateConfig(channels, frames_, sample_rate_);
+
+  // Manually align the input pointer if it's not already aligned.  We pad the
+  // amount returned by ExpectedDataSize() just for this case.
+  uintptr_t aligned_ptr = reinterpret_cast<uintptr_t>(data);
+  if (!IsAligned(data))
+    aligned_ptr += kChannelAlignment - (aligned_ptr & (kChannelAlignment - 1));
+
+  // Don't set |data_size_| based on expected data size, since we do not own the
+  // block of memory provided for channel data.
+  int aligned_frames = 0;
+  ExpectedDataSizeInternal(channels, frames, &aligned_frames);
+
+  BuildChannelData(
+      channels, aligned_frames, reinterpret_cast<float*>(aligned_ptr));
 }
 
 AudioBus::AudioBus(int frames, const std::vector<float*>& channel_data)
     : data_size_(0),
       channel_data_(channel_data),
-      frames_(frames) {
+      frames_(frames),
+      sample_rate_(0) {
+  ValidateConfig(channel_data_.size(), frames_, sample_rate_);
+
   // 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() {}
 
 scoped_ptr<AudioBus> AudioBus::Create(int channels, int frames) {
-  return scoped_ptr<AudioBus>(new AudioBus(channels, frames));
+  return scoped_ptr<AudioBus>(new AudioBus(channels, frames, 0));
 }
 
 scoped_ptr<AudioBus> AudioBus::Create(const AudioParameters& params) {
   return scoped_ptr<AudioBus>(new AudioBus(
-      params.channels(), params.frames_per_buffer()));
+      params.channels(), params.frames_per_buffer(), params.sample_rate()));
 }
 
 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::WrapBlock(int channels, int frames, void* data) {
+  return scoped_ptr<AudioBus>(new AudioBus(
+      channels, frames, 0, static_cast<float*>(data)));
+}
+
+scoped_ptr<AudioBus> AudioBus::WrapBlock(const AudioParameters& params,
+                                         void* data) {
+  return scoped_ptr<AudioBus>(new AudioBus(
+      params.channels(), params.frames_per_buffer(), params.sample_rate(),
+      static_cast<float*>(data)));
+}
+
 void* AudioBus::data() {
   DCHECK(data_.get());
   return data_.get();
 }
 
 int AudioBus::data_size() const {
   DCHECK(data_.get());
   return data_size_;
 }
 
 void AudioBus::ZeroFrames(int frames) {
   DCHECK_LE(frames, frames_);
   for (size_t i = 0; i < channel_data_.size(); ++i)
     memset(channel_data_[i], 0, frames * sizeof(*channel_data_[i]));
 }
 
 void AudioBus::Zero() {
   ZeroFrames(frames_);
 }
 
+int AudioBus::sample_rate() const {
+  DCHECK_NE(sample_rate_, 0);
+  return sample_rate_;
+}
+
+int AudioBus::ExpectedDataSize(int channels, int frames) {
+  int aligned_frames = 0;
+  return ExpectedDataSizeInternal(channels, frames, &aligned_frames);
+}
+
+int AudioBus::ExpectedDataSize(const AudioParameters& params) {
+  int aligned_frames = 0;
+  return ExpectedDataSizeInternal(
+      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);
+}
+
+void AudioBus::ValidateConfig(int channels, int frames, int sample_rate) {
+  CHECK_GT(frames, 0);
+  CHECK_LE(frames, limits::kMaxSamplesPerPacket);
+  CHECK_GT(channels, 0);
+  CHECK_LE(channels, limits::kMaxChannels);
+  DCHECK_LT(limits::kMaxSamplesPerPacket * limits::kMaxChannels,
+            std::numeric_limits<int>::max());
+  if (sample_rate != 0)
+    DCHECK_GT(sample_rate, limits::kMinSampleRate);
+  DCHECK_LT(sample_rate, limits::kMaxSampleRate);
+}
+
+// TODO(dalecurtis): See if intrinsic optimizations help any here.
+void AudioBus::FromInterleaved(const void* source, int frames,

[henrika (OOO until Aug 14), 2012/08/15 09:59:37]

Perhaps mention that these methods are related to existing methods in
audio_util.cc.

[DaleCurtis, 2012/08/16 01:54:14]

Ideally those methods will go away and these will be the only ones, which is why
I added a "TODO" in audio_util.cc. Adding another transient comment doesn't seem
useful.

+                               int bytes_per_sample) {
+  DCHECK_LE(frames, frames_);
+
+  switch (bytes_per_sample) {
+    case 1: {
+      static const float kMinScale = 1.0f / kint8min;
+      static const float kMaxScale = 1.0f / kint8max;
+      const uint8* source8 = reinterpret_cast<const uint8*>(source);
+      for (int i = 0; i < frames; ++i) {
+        for (int ch = 0; ch < channels(); ++ch) {
+          int v = static_cast<int>(*source8++) - (-kint8min);
+          channel(ch)[i] = v * (v < 0 ? -kMinScale : kMaxScale);

[Chris Rogers, 2012/08/15 19:39:31]

It seems like it would be more efficient to reverse these two for() loops and
avoid having to call the channel()  method each time in the inner loop.  You can
instead loop through source8 with stride==channels()

Similar for other int cases below

[DaleCurtis, 2012/08/15 20:12:54]

How about iterating over i=0..frames * channels and setting channel(i % channel)
instead?

[DaleCurtis, 2012/08/16 01:54:14]

I did some basic benchmarking and the new template version is ~twice as fast as
the old one.  I'll make another pass to convert this to intrinsics in the future
and add a proper benchmark at that time.

+        }
+      }
+      break;
+    }
+
+    case 2: {
+      static const float kMinScale = 1.0f / kint16min;
+      static const float kMaxScale = 1.0f / kint16max;
+      const int16* source16 = reinterpret_cast<const int16*>(source);
+      for (int i = 0; i < frames; ++i) {
+        for (int ch = 0; ch < channels(); ++ch) {
+          float v = *source16++;

[henrika (OOO until Aug 14), 2012/08/15 09:59:37]

Is it not more clear to use static_cast<> here?

[DaleCurtis, 2012/08/16 01:54:14]

I think that would be over-verbose.

+          channel(ch)[i] = v * (v < 0 ? -kMinScale : kMaxScale);
+        }
+      }
+      break;
+    }
+
+    case 4: {
+      static const float kMinScale = 1.0f / kint32min;
+      static const float kMaxScale = 1.0f / kint32max;
+      const int32* source32 = reinterpret_cast<const int32*>(source);
+      for (int i = 0; i < frames; ++i) {
+        for (int ch = 0; ch < channels(); ++ch) {
+          float v = *source32++;
+          channel(ch)[i] = v * (v < 0 ? -kMinScale : kMaxScale);
+        }
+      }
+      break;
+    }
+
+    default:
+     CHECK(false) << "Unsupported bytes per sample encountered.";
+  }
+
+  // Zero any remaining frames.
+  int remaining_frames = (frames_ - frames);
+  if (remaining_frames) {
+    for (int ch = 0; ch < channels(); ++ch)
+      memset(channel(ch) + frames, 0, sizeof(*channel(ch)) * remaining_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 ToInterleavedInternal(const AudioBus* source, void* dest_bytes,
+                                  int frames) {
+  Format* destination = reinterpret_cast<Format*>(dest_bytes);
+  Fixed max_value = std::numeric_limits<Format>::max();
+  Fixed min_value = std::numeric_limits<Format>::min();
+
+  Format bias = 0;
+  if (!std::numeric_limits<Format>::is_signed) {
+    bias = (max_value / 2) + 1;
+    max_value = bias - 1;
+    min_value = -bias;
+  }
+
+  int channels = source->channels();
+  for (int i = 0; i < channels; ++i) {
+    const float* channel_data = source->channel(i);
+    for (int j = 0; j < frames; ++j) {
+      Fixed sample =
+          (channel_data[j] < 0 ? -min_value : max_value) * channel_data[j];
+      if (sample > max_value)
+        sample = max_value;
+      else if (sample < min_value)
+        sample = min_value;
+
+      destination[j * channels + i] = static_cast<Format>(sample) + bias;
+    }
+  }
+}
+
+// TODO(dalecurtis): See if intrinsic optimizations help any here.
+void AudioBus::ToInterleaved(void* dest, int frames, int bytes_per_sample) {
+  DCHECK_LE(frames, frames_);
+  switch (bytes_per_sample) {
+    case 1:
+      ToInterleavedInternal<uint8, int32>(this, dest, frames);
+      break;
+    case 2:
+      ToInterleavedInternal<int16, int32>(this, dest, frames);
+      break;
+    case 4:
+      ToInterleavedInternal<int32, int64>(this, dest, frames);
+      break;
+    default:
+      CHECK(false) << "Unsupported bytes per sample encountered.";
+      break;
+  }
+}
+
 }  // namespace media