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) {
   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 26 matching lines @@
 
 static void ValidateConfig(int channels, int 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());
 }
 
+static bool CheckOverflow(int start_frame, int frames, int total_frames) {
+  DCHECK_GE(start_frame, 0);
+  DCHECK_GE(frames, 0);
+  DCHECK_GT(total_frames, 0);
+  int sum = start_frame + frames;
+  DCHECK_LE(sum, total_frames);
+  DCHECK_GE(sum, 0);
+
+  return (start_frame >= 0 && frames >= 0 && total_frames > 0 &&

[vrk (LEFT CHROMIUM), 2012/08/28 20:25:12]

Remove the return bool and have this a void method like ValidateConfig? This
return statement is repeating the logic of the above DCHECKs, so
DCHECK(CheckOverflow) will never fire because one of the DCHECKs above would
have fired first.

[DaleCurtis, 2012/08/29 03:43:13]

I have it this way since I wasn't sure if those DCHECK(CheckOverflow()) should
be CHECKs instead.  Otherwise you're correct.  So, CHECK or DCHECK, wdyt?

[DaleCurtis, 2012/08/29 04:47:11]

Feels safer with CHECK, going that route.

+          sum <= total_frames && sum >= 0);
+}
+
 AudioBus::AudioBus(int channels, int frames)
     : frames_(frames) {
   ValidateConfig(channels, frames_);
 
   int aligned_frames = 0;
   int size = CalculateMemorySizeInternal(channels, frames, &aligned_frames);
 
   data_.reset(static_cast<float*>(base::AlignedAlloc(
       size, AudioBus::kChannelAlignment)));
 
@@ skipping 46 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(CheckOverflow(start_frame, frames, frames_));
+
+  if (frames > 0) {

[vrk (LEFT CHROMIUM), 2012/08/28 20:25:12]

nit: reverse test and return early

[DaleCurtis, 2012/08/29 04:47:11]

Done.

+    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(CheckOverflow(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_);
+  DCHECK(CheckOverflow(0, frames, frames_));
   switch (bytes_per_sample) {
     case 1:
       ToInterleavedInternal<uint8, int16>(this, frames, dest);
       break;
     case 2:
       ToInterleavedInternal<int16, int32>(this, frames, dest);
       break;
     case 4:
       ToInterleavedInternal<int32, int64>(this, frames, dest);
       break;
     default:
       NOTREACHED() << "Unsupported bytes per sample encountered.";
       memset(dest, 0, frames * bytes_per_sample);
       return;
   }
 }
 
 void AudioBus::CopyTo(AudioBus* dest) const {
   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