Convert WebAudio file handlers to use 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 <limits>
 
 #include "base/logging.h"
 #include "media/audio/audio_parameters.h"
@@ skipping 15 matching lines @@
   // 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 frames,
-                                    AudioBus* dest) {
+static void FromInterleavedInternal(const void* src, int start_frame,
+                                    int frames, AudioBus* dest) {

[Chris Rogers, 2012/08/24 20:49:28]

how about some DCHECKS, including negative values for start_frame and frames.

[DaleCurtis, 2012/08/24 22:23:22]

Not here, the DCHECKS are in the class methods.  Eventually I'll add a benchmark
for this and having DCHECKs in here hurts performance unless built with
branding=Chrome (since local Release builds leave DCHECKS in, just disabled for
use with --enable-dcheck).

   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 :
       std::numeric_limits<Format>::max());
   static const float kMinScale = 1.0f / (kBias ? kBias :
       -static_cast<Fixed>(std::numeric_limits<Format>::min()));
 
   int channels = dest->channels();
   for (int ch = 0; ch < channels; ++ch) {
     float* channel_data = dest->channel(ch);
-    for (int i = 0, offset = ch; i < frames; ++i, offset += channels) {
+    for (int i = start_frame, offset = ch; i < start_frame + frames;
+         ++i, offset += channels) {
       Fixed v = static_cast<Fixed>(source[offset]) - kBias;
       channel_data[i] = v * (v < 0 ? kMinScale : kMaxScale);
     }
   }
 }
 
 // |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, int frames,
@@ skipping 92 matching lines @@
 
 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::ZeroFramesPartial(int start_frame, int frames) {
+  DCHECK_LE(start_frame + frames, frames_);

[Chris Rogers, 2012/08/24 20:49:28]

What about checking for start_frame < 0 or frames < 0?

This is why I don't like using signed integers for things which should be
unsigned...

[DaleCurtis, 2012/08/24 22:23:22]

Yeah, it's a bit weird, but is Chrome style. I've add DCHECK(CheckOverflow()),
although maybe it should be a CHECK?

+  if (frames > 0) {
+    for (size_t i = 0; i < channel_data_.size(); ++i) {
+      memset(channel_data_[i] + start_frame, 0,
+             frames * sizeof(*channel_data_[i]));
+    }
+  }
+}
+
 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]));
+  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);
 }
 
 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);
 }
 
 // TODO(dalecurtis): See if intrinsic optimizations help any here.
-void AudioBus::FromInterleaved(const void* source, int frames,
-                               int bytes_per_sample) {
-  DCHECK_LE(frames, frames_);
+void AudioBus::FromInterleavedPartial(const void* source, int start_frame,
+                                      int frames, int bytes_per_sample) {
+  DCHECK_LE(start_frame + frames, frames_);
   switch (bytes_per_sample) {
     case 1:
-      FromInterleavedInternal<uint8, int16>(source, frames, this);
+      FromInterleavedInternal<uint8, int16>(source, start_frame, frames, this);
       break;
     case 2:
-      FromInterleavedInternal<int16, int32>(source, frames, this);
+      FromInterleavedInternal<int16, int32>(source, start_frame, frames, this);
       break;
     case 4:
-      FromInterleavedInternal<int32, int64>(source, frames, this);
+      FromInterleavedInternal<int32, int64>(source, start_frame, frames, this);
       break;
     default:
       NOTREACHED() << "Unsupported bytes per sample encountered.";
-      Zero();
+      ZeroFramesPartial(start_frame, frames);
       return;
   }
 
-  // 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);
+  // Don't clear remaining frames if this is a partial deinterleave.
+  if (!start_frame) {
+    // Zero any remaining frames.
+    ZeroFramesPartial(frames, frames_ - frames);
   }
 }
 
+void AudioBus::FromInterleaved(const void* source, int frames,
+                               int bytes_per_sample) {
+  FromInterleavedPartial(source, 0, frames, bytes_per_sample);
+}
+
 // TODO(dalecurtis): See if intrinsic optimizations help any here.
 void AudioBus::ToInterleaved(int frames, int bytes_per_sample,
                              void* dest) const {
   DCHECK_LE(frames, frames_);
   switch (bytes_per_sample) {
     case 1:
       ToInterleavedInternal<uint8, int16>(this, frames, dest);
       break;
     case 2:
       ToInterleavedInternal<int16, int32>(this, frames, dest);
@@ skipping 12 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