Convert WebAudio file handlers to use AudioBus.

media/base/audio_bus_unittest.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 <limits>
 
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "media/audio/audio_parameters.h"
 #include "media/base/audio_bus.h"
 #include "media/base/channel_layout.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 static const int kChannels = 6;
 static const ChannelLayout kChannelLayout = CHANNEL_LAYOUT_5_1;
 // Use a buffer size which is intentionally not a multiple of kChannelAlignment.
-static const int kFrameCount = media::AudioBus::kChannelAlignment * 128 - 1;
+static const int kFrameCount = media::AudioBus::kChannelAlignment * 32 - 1;
 static const int kSampleRate = 48000;
 
 namespace media {
 
 class AudioBusTest : public testing::Test {
  public:
   AudioBusTest() {}
   ~AudioBusTest() {
     for (size_t i = 0; i < data_.size(); ++i)
       base::AlignedFree(data_[i]);
   }
 
   // Validate parameters returned by AudioBus v.s. the constructed parameters.
   void VerifyParams(AudioBus* bus) {
     EXPECT_EQ(kChannels, bus->channels());
     EXPECT_EQ(kFrameCount, bus->frames());
   }
 
   void VerifyValue(const float data[], int size, float value) {
     for (int i = 0; i < size; ++i)
-      ASSERT_FLOAT_EQ(value, data[i]);
+      ASSERT_FLOAT_EQ(value, data[i]) << "i=" << i;
   }
 
   // Verify values for each channel in |result| against |expected|.
   void VerifyBus(const AudioBus* result, const AudioBus* expected) {
     ASSERT_EQ(expected->channels(), result->channels());
     ASSERT_EQ(expected->frames(), result->frames());
     for (int ch = 0; ch < result->channels(); ++ch) {
       for (int i = 0; i < result->frames(); ++i) {
         SCOPED_TRACE(base::StringPrintf("ch=%d, i=%d", ch, i));
         ASSERT_FLOAT_EQ(expected->channel(ch)[i], result->channel(ch)[i]);
@@ skipping 134 matching lines @@
 
     bus2 = AudioBus::WrapMemory(params, data.get());
     CopyTest(bus1.get(), bus2.get());
   }
 }
 
 // Verify Zero() and ZeroFrames(...) utility methods work as advertised.
 TEST_F(AudioBusTest, Zero) {
   scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, kFrameCount);
 
-  // First fill the bus with dummy data.
+  // Fill the bus with dummy data.
   for (int i = 0; i < bus->channels(); ++i)
     std::fill(bus->channel(i), bus->channel(i) + bus->frames(), i + 1);
 
-  // Zero half the frames of each channel.
+  // Zero first half the frames of each channel.
   bus->ZeroFrames(kFrameCount / 2);
+  for (int i = 0; i < bus->channels(); ++i) {
+    SCOPED_TRACE("First Half Zero");
+    VerifyValue(bus->channel(i), kFrameCount / 2, 0);
+    VerifyValue(bus->channel(i) + kFrameCount / 2,
+                kFrameCount - kFrameCount / 2, i + 1);
+  }
+
+  // Fill the bus with dummy data.
   for (int i = 0; i < bus->channels(); ++i)
-    VerifyValue(bus->channel(i), kFrameCount / 2, 0);
+    std::fill(bus->channel(i), bus->channel(i) + bus->frames(), i + 1);
+
+  // Zero the last half of the frames.
+  bus->ZeroFramesPartial(kFrameCount / 2, kFrameCount - kFrameCount / 2);
+  for (int i = 0; i < bus->channels(); ++i) {
+    SCOPED_TRACE("Last Half Zero");
+    VerifyValue(bus->channel(i) + kFrameCount / 2,
+                kFrameCount - kFrameCount / 2, 0);
+    VerifyValue(bus->channel(i), kFrameCount / 2, i + 1);
+  }
+
+  // Fill the bus with dummy data.
+  for (int i = 0; i < bus->channels(); ++i)
+    std::fill(bus->channel(i), bus->channel(i) + bus->frames(), i + 1);
 
   // Zero all the frames of each channel.
   bus->Zero();
-  for (int i = 0; i < bus->channels(); ++i)
+  for (int i = 0; i < bus->channels(); ++i) {
+    SCOPED_TRACE("All Zero");
     VerifyValue(bus->channel(i), bus->frames(), 0);
+  }
 }
 
 // Each test vector represents two channels of data in the following arbitrary
 // layout: <min, zero, max, min, zero, max, zero, zero>.
 static const int kTestVectorSize = 8;
 static const uint8 kTestVectorUint8[kTestVectorSize] = {
     0, -kint8min, kuint8max, 0, -kint8min, kuint8max, -kint8min, -kint8min };
 static const int16 kTestVectorInt16[kTestVectorSize] = {
     kint16min, 0, kint16max, kint16min, 0, kint16max, 0, 0 };
 static const int32 kTestVectorInt32[kTestVectorSize] = {
@@ skipping 10 matching lines @@
   scoped_ptr<AudioBus> bus = AudioBus::Create(
       kTestVectorChannels, kTestVectorFrames);
   scoped_ptr<AudioBus> expected = AudioBus::Create(
       kTestVectorChannels, kTestVectorFrames);
   for (int ch = 0; ch < kTestVectorChannels; ++ch) {
     memcpy(expected->channel(ch), kTestVectorResult[ch],
            kTestVectorFrames * sizeof(*expected->channel(ch)));
   }
   {
     SCOPED_TRACE("uint8");
+    bus->Zero();
     bus->FromInterleaved(
         kTestVectorUint8, kTestVectorFrames, sizeof(*kTestVectorUint8));
     VerifyBus(bus.get(), expected.get());
   }
   {
     SCOPED_TRACE("int16");
+    bus->Zero();
     bus->FromInterleaved(
         kTestVectorInt16, kTestVectorFrames, sizeof(*kTestVectorInt16));
     VerifyBus(bus.get(), expected.get());
   }
   {
     SCOPED_TRACE("int32");
+    bus->Zero();
     bus->FromInterleaved(
         kTestVectorInt32, kTestVectorFrames, sizeof(*kTestVectorInt32));
     VerifyBus(bus.get(), expected.get());
   }
 }
 
+// Verify FromInterleavedPartial() deinterleaves audio correctly.
+TEST_F(AudioBusTest, FromInterleavedPartial) {
+  // Only deinterleave the middle two frames in each channel.
+  static const int kPartialStart = 1;
+  static const int kPartialFrames = 2;
+  ASSERT_LE(kPartialStart + kPartialFrames, kTestVectorFrames);
+
+  scoped_ptr<AudioBus> bus = AudioBus::Create(
+      kTestVectorChannels, kTestVectorFrames);
+  scoped_ptr<AudioBus> expected = AudioBus::Create(
+      kTestVectorChannels, kTestVectorFrames);
+  expected->Zero();
+  for (int ch = 0; ch < kTestVectorChannels; ++ch) {
+    memcpy(expected->channel(ch) + kPartialStart,
+           kTestVectorResult[ch] + kPartialStart,
+           kPartialFrames * sizeof(*expected->channel(ch)));
+  }
+
+  bus->Zero();
+  bus->FromInterleavedPartial(
+      kTestVectorInt32 + kPartialStart * bus->channels(), kPartialStart,
+      kPartialFrames, sizeof(*kTestVectorInt32));
+  VerifyBus(bus.get(), expected.get());
+}
+
 // Verify ToInterleaved() interleaves audio in suported formats correctly.
 TEST_F(AudioBusTest, ToInterleaved) {
   scoped_ptr<AudioBus> bus = AudioBus::Create(
       kTestVectorChannels, kTestVectorFrames);
   // Fill the bus with our test vector.
   for (int ch = 0; ch < kTestVectorChannels; ++ch) {
     memcpy(bus->channel(ch), kTestVectorResult[ch],
            kTestVectorFrames * sizeof(*bus->channel(ch)));
   }
   {
@@ skipping 13 matching lines @@
   {
     SCOPED_TRACE("int32");
     int32 test_array[arraysize(kTestVectorInt32)];
     bus->ToInterleaved(bus->frames(), sizeof(*kTestVectorInt32), test_array);
     ASSERT_EQ(memcmp(
         test_array, kTestVectorInt32, arraysize(kTestVectorInt32)), 0);
   }
 }
 
 }  // namespace media