path: root/chromium/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 "base/strings/stringprintf.h"
#include "base/time/time.h"
#include "build/build_config.h"
#include "media/audio/audio_parameters.h"
#include "media/base/audio_bus.h"
#include "media/base/channel_layout.h"
#include "media/base/fake_audio_render_callback.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace media {

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 * 32 - 1;
static const int kSampleRate = 48000;

class AudioBusTest : public testing::Test {
 public:
  AudioBusTest() {}
  virtual ~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]) << "i=" << i;
  }

  // Verify values for each channel in |result| are within |epsilon| of
  // |expected|.  If |epsilon| exactly equals 0, uses FLOAT_EQ macro.
  void VerifyBusWithEpsilon(const AudioBus* result, const AudioBus* expected,
                            float epsilon) {
    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));
        if (epsilon == 0) {
          ASSERT_FLOAT_EQ(expected->channel(ch)[i], result->channel(ch)[i]);
        } else {
          ASSERT_NEAR(expected->channel(ch)[i], result->channel(ch)[i],
                      epsilon);
        }
      }
    }
  }

  // Verify values for each channel in |result| against |expected|.
  void VerifyBus(const AudioBus* result, const AudioBus* expected) {
    VerifyBusWithEpsilon(result, expected, 0);
  }

  // Read and write to the full extent of the allocated channel data.  Also test
  // the Zero() method and verify it does as advertised.  Also test data if data
  // is 16-byte aligned as advertised (see kChannelAlignment in audio_bus.h).
  void VerifyChannelData(AudioBus* bus) {
    for (int i = 0; i < bus->channels(); ++i) {
      ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(
          bus->channel(i)) & (AudioBus::kChannelAlignment - 1));
      std::fill(bus->channel(i), bus->channel(i) + bus->frames(), i);
    }

    for (int i = 0; i < bus->channels(); ++i)
      VerifyValue(bus->channel(i), bus->frames(), i);

    bus->Zero();
    for (int i = 0; i < bus->channels(); ++i)
      VerifyValue(bus->channel(i), bus->frames(), 0);
  }

  // Verify copying to and from |bus1| and |bus2|.
  void CopyTest(AudioBus* bus1, AudioBus* bus2) {
    // Fill |bus1| with dummy data.
    for (int i = 0; i < bus1->channels(); ++i)
      std::fill(bus1->channel(i), bus1->channel(i) + bus1->frames(), i);

    // Verify copy from |bus1| to |bus2|.
    bus2->Zero();
    bus1->CopyTo(bus2);
    VerifyBus(bus1, bus2);

    // Verify copy from |bus2| to |bus1|.
    bus1->Zero();
    bus2->CopyTo(bus1);
    VerifyBus(bus2, bus1);
  }

 protected:
  std::vector<float*> data_;

  DISALLOW_COPY_AND_ASSIGN(AudioBusTest);
};

// Verify basic Create(...) method works as advertised.
TEST_F(AudioBusTest, Create) {
  scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, kFrameCount);
  VerifyParams(bus.get());
  VerifyChannelData(bus.get());
}

// Verify Create(...) using AudioParameters works as advertised.
TEST_F(AudioBusTest, CreateUsingAudioParameters) {
  scoped_ptr<AudioBus> bus = AudioBus::Create(AudioParameters(
      AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout, kSampleRate, 32,
      kFrameCount));
  VerifyParams(bus.get());
  VerifyChannelData(bus.get());
}

// Verify an AudioBus created via wrapping a vector works as advertised.
TEST_F(AudioBusTest, WrapVector) {
  data_.reserve(kChannels);
  for (int i = 0; i < kChannels; ++i) {
    data_.push_back(static_cast<float*>(base::AlignedAlloc(
        sizeof(*data_[i]) * kFrameCount, AudioBus::kChannelAlignment)));
  }

  scoped_ptr<AudioBus> bus = AudioBus::WrapVector(kFrameCount, data_);
  VerifyParams(bus.get());
  VerifyChannelData(bus.get());
}

// Verify an AudioBus created via wrapping a memory block works as advertised.
TEST_F(AudioBusTest, WrapMemory) {
  AudioParameters params(
      AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout, kSampleRate, 32,
      kFrameCount);
  int data_size = AudioBus::CalculateMemorySize(params);
  scoped_ptr_malloc<float, base::ScopedPtrAlignedFree> data(static_cast<float*>(
      base::AlignedAlloc(data_size, AudioBus::kChannelAlignment)));

  // Fill the memory with a test value we can check for after wrapping.
  static const float kTestValue = 3;
  std::fill(
      data.get(), data.get() + data_size / sizeof(*data.get()), kTestValue);

  scoped_ptr<AudioBus> bus = AudioBus::WrapMemory(params, data.get());
  // Verify the test value we filled prior to wrapping.
  for (int i = 0; i < bus->channels(); ++i)
    VerifyValue(bus->channel(i), bus->frames(), kTestValue);
  VerifyParams(bus.get());
  VerifyChannelData(bus.get());

  // Verify the channel vectors lie within the provided memory block.
  EXPECT_GE(bus->channel(0), data.get());
  EXPECT_LT(bus->channel(bus->channels() - 1) + bus->frames(),
            data.get() + data_size / sizeof(*data.get()));
}

// Simulate a shared memory transfer and verify results.
TEST_F(AudioBusTest, CopyTo) {
  // Create one bus with AudioParameters and the other through direct values to
  // test for parity between the Create() functions.
  AudioParameters params(
      AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout, kSampleRate, 32,
      kFrameCount);
  scoped_ptr<AudioBus> bus1 = AudioBus::Create(kChannels, kFrameCount);
  scoped_ptr<AudioBus> bus2 = AudioBus::Create(params);

  {
    SCOPED_TRACE("Created");
    CopyTest(bus1.get(), bus2.get());
  }
  {
    SCOPED_TRACE("Wrapped Vector");
    // Try a copy to an AudioBus wrapping a vector.
    data_.reserve(kChannels);
    for (int i = 0; i < kChannels; ++i) {
      data_.push_back(static_cast<float*>(base::AlignedAlloc(
          sizeof(*data_[i]) * kFrameCount, AudioBus::kChannelAlignment)));
    }

    bus2 = AudioBus::WrapVector(kFrameCount, data_);
    CopyTest(bus1.get(), bus2.get());
  }
  {
    SCOPED_TRACE("Wrapped Memory");
    // Try a copy to an AudioBus wrapping a memory block.
    scoped_ptr_malloc<float, base::ScopedPtrAlignedFree> data(
        static_cast<float*>(base::AlignedAlloc(
            AudioBus::CalculateMemorySize(params),
            AudioBus::kChannelAlignment)));

    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);

  // 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 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)
    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) {
    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, max / 2, min / 2, zero, max, zero, zero>.
static const int kTestVectorSize = 10;
static const uint8 kTestVectorUint8[kTestVectorSize] = {
    0, -kint8min, kuint8max, 0, kint8max / 2 + 128, kint8min / 2 + 128,
    -kint8min, kuint8max, -kint8min, -kint8min };
static const int16 kTestVectorInt16[kTestVectorSize] = {
    kint16min, 0, kint16max, kint16min, kint16max / 2, kint16min / 2,
    0, kint16max, 0, 0 };
static const int32 kTestVectorInt32[kTestVectorSize] = {
    kint32min, 0, kint32max, kint32min, kint32max / 2, kint32min / 2,
    0, kint32max, 0, 0 };

// Expected results.
static const int kTestVectorFrames = kTestVectorSize / 2;
static const float kTestVectorResult[][kTestVectorFrames] = {
    { -1, 1, 0.5, 0, 0 }, { 0, -1, -0.5, 1, 0 }};
static const int kTestVectorChannels = arraysize(kTestVectorResult);

// Verify FromInterleaved() deinterleaves audio in supported formats correctly.
TEST_F(AudioBusTest, FromInterleaved) {
  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));
    // Biased uint8 calculations have poor precision, so the epsilon here is
    // slightly more permissive than int16 and int32 calculations.
    VerifyBusWithEpsilon(bus.get(), expected.get(), 1.0f / (kuint8max - 1));
  }
  {
    SCOPED_TRACE("int16");
    bus->Zero();
    bus->FromInterleaved(
        kTestVectorInt16, kTestVectorFrames, sizeof(*kTestVectorInt16));
    VerifyBusWithEpsilon(bus.get(), expected.get(), 1.0f / (kuint16max + 1.0f));
  }
  {
    SCOPED_TRACE("int32");
    bus->Zero();
    bus->FromInterleaved(
        kTestVectorInt32, kTestVectorFrames, sizeof(*kTestVectorInt32));
    VerifyBusWithEpsilon(bus.get(), expected.get(), 1.0f / (kuint32max + 1.0f));
  }
}

// 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 < bus->channels(); ++ch) {
    memcpy(bus->channel(ch), kTestVectorResult[ch],
           kTestVectorFrames * sizeof(*bus->channel(ch)));
  }
  {
    SCOPED_TRACE("uint8");
    uint8 test_array[arraysize(kTestVectorUint8)];
    bus->ToInterleaved(bus->frames(), sizeof(*kTestVectorUint8), test_array);
    ASSERT_EQ(memcmp(
        test_array, kTestVectorUint8, sizeof(kTestVectorUint8)), 0);
  }
  {
    SCOPED_TRACE("int16");
    int16 test_array[arraysize(kTestVectorInt16)];
    bus->ToInterleaved(bus->frames(), sizeof(*kTestVectorInt16), test_array);
    ASSERT_EQ(memcmp(
        test_array, kTestVectorInt16, sizeof(kTestVectorInt16)), 0);
  }
  {
    SCOPED_TRACE("int32");
    int32 test_array[arraysize(kTestVectorInt32)];
    bus->ToInterleaved(bus->frames(), sizeof(*kTestVectorInt32), test_array);

    // Some compilers get better precision than others on the half-max test, so
    // let the test pass with an off by one check on the half-max.
    int32 fixed_test_array[arraysize(kTestVectorInt32)];
    memcpy(fixed_test_array, kTestVectorInt32, sizeof(kTestVectorInt32));
    ASSERT_EQ(fixed_test_array[4], kint32max / 2);
    fixed_test_array[4]++;

    ASSERT_TRUE(
       memcmp(test_array, kTestVectorInt32, sizeof(kTestVectorInt32)) == 0 ||
       memcmp(test_array, fixed_test_array, sizeof(fixed_test_array)) == 0);
  }
}

// Verify ToInterleavedPartial() interleaves audio correctly.
TEST_F(AudioBusTest, ToInterleavedPartial) {
  // Only interleave 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> expected = AudioBus::Create(
      kTestVectorChannels, kTestVectorFrames);
  for (int ch = 0; ch < kTestVectorChannels; ++ch) {
    memcpy(expected->channel(ch), kTestVectorResult[ch],
           kTestVectorFrames * sizeof(*expected->channel(ch)));
  }

  int16 test_array[arraysize(kTestVectorInt16)];
  expected->ToInterleavedPartial(
      kPartialStart, kPartialFrames, sizeof(*kTestVectorInt16), test_array);
  ASSERT_EQ(memcmp(
      test_array, kTestVectorInt16 + kPartialStart * kTestVectorChannels,
      kPartialFrames * sizeof(*kTestVectorInt16) * kTestVectorChannels), 0);
}

TEST_F(AudioBusTest, Scale) {
  scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, kFrameCount);

  // Fill the bus with dummy data.
  static const float kFillValue = 1;
  for (int i = 0; i < bus->channels(); ++i)
    std::fill(bus->channel(i), bus->channel(i) + bus->frames(), kFillValue);

  // Adjust by an invalid volume and ensure volume is unchanged.
  bus->Scale(-1);
  for (int i = 0; i < bus->channels(); ++i) {
    SCOPED_TRACE("Invalid Scale");
    VerifyValue(bus->channel(i), bus->frames(), kFillValue);
  }

  // Verify correct volume adjustment.
  static const float kVolume = 0.5;
  bus->Scale(kVolume);
  for (int i = 0; i < bus->channels(); ++i) {
    SCOPED_TRACE("Half Scale");
    VerifyValue(bus->channel(i), bus->frames(), kFillValue * kVolume);
  }

  // Verify zero volume case.
  bus->Scale(0);
  for (int i = 0; i < bus->channels(); ++i) {
    SCOPED_TRACE("Zero Scale");
    VerifyValue(bus->channel(i), bus->frames(), 0);
  }
}

// Benchmark the FromInterleaved() and ToInterleaved() methods.
TEST_F(AudioBusTest, DISABLED_InterleaveBench) {
  scoped_ptr<AudioBus> bus = AudioBus::Create(2, 48000 * 120);
  const int frame_size = bus->frames() * bus->channels();
  FakeAudioRenderCallback callback(0.2);
  callback.Render(bus.get(), 0);
  {
    SCOPED_TRACE("uint8");
    scoped_ptr<uint8> interleaved(new uint8[frame_size]);
    const int byte_size = sizeof(*interleaved);

    base::TimeTicks start = base::TimeTicks::HighResNow();
    bus->ToInterleaved(bus->frames(), byte_size, interleaved.get());
    double total_time_ms =
        (base::TimeTicks::HighResNow() - start).InMillisecondsF();
    printf("ToInterleaved uint8 took %.2fms.\n", total_time_ms);

    start = base::TimeTicks::HighResNow();
    bus->FromInterleaved(interleaved.get(), bus->frames(), byte_size);
    total_time_ms = (base::TimeTicks::HighResNow() - start).InMillisecondsF();
    printf("FromInterleaved uint8 took %.2fms.\n", total_time_ms);
  }
  {
    SCOPED_TRACE("int16");
    scoped_ptr<int16> interleaved(new int16[frame_size]);
    const int byte_size = sizeof(*interleaved);

    base::TimeTicks start = base::TimeTicks::HighResNow();
    bus->ToInterleaved(bus->frames(), byte_size, interleaved.get());
    double total_time_ms =
        (base::TimeTicks::HighResNow() - start).InMillisecondsF();
    printf("ToInterleaved int16 took %.2fms.\n", total_time_ms);

    start = base::TimeTicks::HighResNow();
    bus->FromInterleaved(interleaved.get(), bus->frames(), byte_size);
    total_time_ms = (base::TimeTicks::HighResNow() - start).InMillisecondsF();
    printf("FromInterleaved int16 took %.2fms.\n", total_time_ms);
  }
  {
    SCOPED_TRACE("int32");
    scoped_ptr<int32> interleaved(new int32[frame_size]);
    const int byte_size = sizeof(*interleaved);

    base::TimeTicks start = base::TimeTicks::HighResNow();
    bus->ToInterleaved(bus->frames(), byte_size, interleaved.get());
    double total_time_ms =
        (base::TimeTicks::HighResNow() - start).InMillisecondsF();
    printf("ToInterleaved int32 took %.2fms.\n", total_time_ms);

    start = base::TimeTicks::HighResNow();
    bus->FromInterleaved(interleaved.get(), bus->frames(), byte_size);
    total_time_ms = (base::TimeTicks::HighResNow() - start).InMillisecondsF();
    printf("FromInterleaved int32 took %.2fms.\n", total_time_ms);
  }
}

}  // namespace media