Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(318)

Unified Diff: media/base/audio_bus_unittest.cc

Issue 2024993004: AudioBus: Add a ToInterleavedFloat() method to AudioBus (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Removed a todo Created 4 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « media/base/audio_bus.cc ('k') | media/base/audio_sample_types.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: media/base/audio_bus_unittest.cc
diff --git a/media/base/audio_bus_unittest.cc b/media/base/audio_bus_unittest.cc
index 02809db72379db083e913e5fe79b29a32a399e96..66585b2a9a195c4c00789eb68290d3493fcdfc6e 100644
--- a/media/base/audio_bus_unittest.cc
+++ b/media/base/audio_bus_unittest.cc
@@ -14,6 +14,7 @@
#include "build/build_config.h"
#include "media/base/audio_bus.h"
#include "media/base/audio_parameters.h"
+#include "media/base/audio_sample_types.h"
#include "media/base/channel_layout.h"
#include "media/base/fake_audio_render_callback.h"
#include "testing/gtest/include/gtest/gtest.h"
@@ -34,26 +35,27 @@ class AudioBusTest : public testing::Test {
base::AlignedFree(data_[i]);
}
- // Validate parameters returned by AudioBus v.s. the constructed parameters.
- void VerifyParams(AudioBus* bus) {
+ void VerifyChannelAndFrameCount(AudioBus* bus) {
EXPECT_EQ(kChannels, bus->channels());
EXPECT_EQ(kFrameCount, bus->frames());
}
- void VerifyValue(const float data[], int size, float value) {
+ void VerifyArrayIsFilledWithValue(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) {
+ void VerifyAreEqualWithEpsilon(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 {
@@ -65,26 +67,30 @@ class AudioBusTest : public testing::Test {
}
// Verify values for each channel in |result| against |expected|.
- void VerifyBus(const AudioBus* result, const AudioBus* expected) {
- VerifyBusWithEpsilon(result, expected, 0);
+ void VerifyAreEqual(const AudioBus* result, const AudioBus* expected) {
+ VerifyAreEqualWithEpsilon(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) {
+ void VerifyReadWriteAndAlignment(AudioBus* bus) {
for (int i = 0; i < bus->channels(); ++i) {
+ // Verify that the address returned by channel(i) is a multiple of
+ // AudioBus::kChannelAlignment.
ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(
bus->channel(i)) & (AudioBus::kChannelAlignment - 1));
+
+ // Write into the channel buffer.
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);
+ VerifyArrayIsFilledWithValue(bus->channel(i), bus->frames(), i);
bus->Zero();
for (int i = 0; i < bus->channels(); ++i)
- VerifyValue(bus->channel(i), bus->frames(), 0);
+ VerifyArrayIsFilledWithValue(bus->channel(i), bus->frames(), 0);
}
// Verify copying to and from |bus1| and |bus2|.
@@ -96,12 +102,12 @@ class AudioBusTest : public testing::Test {
// Verify copy from |bus1| to |bus2|.
bus2->Zero();
bus1->CopyTo(bus2);
- VerifyBus(bus1, bus2);
+ VerifyAreEqual(bus1, bus2);
// Verify copy from |bus2| to |bus1|.
bus1->Zero();
bus2->CopyTo(bus1);
- VerifyBus(bus2, bus1);
+ VerifyAreEqual(bus2, bus1);
}
protected:
@@ -113,8 +119,8 @@ class AudioBusTest : public testing::Test {
// Verify basic Create(...) method works as advertised.
TEST_F(AudioBusTest, Create) {
std::unique_ptr<AudioBus> bus = AudioBus::Create(kChannels, kFrameCount);
- VerifyParams(bus.get());
- VerifyChannelData(bus.get());
+ VerifyChannelAndFrameCount(bus.get());
+ VerifyReadWriteAndAlignment(bus.get());
}
// Verify Create(...) using AudioParameters works as advertised.
@@ -122,8 +128,8 @@ TEST_F(AudioBusTest, CreateUsingAudioParameters) {
std::unique_ptr<AudioBus> bus = AudioBus::Create(
AudioParameters(AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout,
kSampleRate, 32, kFrameCount));
- VerifyParams(bus.get());
- VerifyChannelData(bus.get());
+ VerifyChannelAndFrameCount(bus.get());
+ VerifyReadWriteAndAlignment(bus.get());
}
// Verify an AudioBus created via wrapping a vector works as advertised.
@@ -135,8 +141,8 @@ TEST_F(AudioBusTest, WrapVector) {
}
std::unique_ptr<AudioBus> bus = AudioBus::WrapVector(kFrameCount, data_);
- VerifyParams(bus.get());
- VerifyChannelData(bus.get());
+ VerifyChannelAndFrameCount(bus.get());
+ VerifyReadWriteAndAlignment(bus.get());
}
// Verify an AudioBus created via wrapping a memory block works as advertised.
@@ -156,9 +162,9 @@ TEST_F(AudioBusTest, WrapMemory) {
std::unique_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());
+ VerifyArrayIsFilledWithValue(bus->channel(i), bus->frames(), kTestValue);
+ VerifyChannelAndFrameCount(bus.get());
+ VerifyReadWriteAndAlignment(bus.get());
// Verify the channel vectors lie within the provided memory block.
EXPECT_GE(bus->channel(0), data.get());
@@ -217,9 +223,9 @@ TEST_F(AudioBusTest, Zero) {
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);
+ VerifyArrayIsFilledWithValue(bus->channel(i), kFrameCount / 2, 0);
+ VerifyArrayIsFilledWithValue(bus->channel(i) + kFrameCount / 2,
+ kFrameCount - kFrameCount / 2, i + 1);
}
EXPECT_FALSE(bus->AreFramesZero());
@@ -231,9 +237,9 @@ TEST_F(AudioBusTest, Zero) {
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);
+ VerifyArrayIsFilledWithValue(bus->channel(i) + kFrameCount / 2,
+ kFrameCount - kFrameCount / 2, 0);
+ VerifyArrayIsFilledWithValue(bus->channel(i), kFrameCount / 2, i + 1);
}
EXPECT_FALSE(bus->AreFramesZero());
@@ -245,7 +251,7 @@ TEST_F(AudioBusTest, Zero) {
bus->Zero();
for (int i = 0; i < bus->channels(); ++i) {
SCOPED_TRACE("All Zero");
- VerifyValue(bus->channel(i), bus->frames(), 0);
+ VerifyArrayIsFilledWithValue(bus->channel(i), bus->frames(), 0);
}
EXPECT_TRUE(bus->AreFramesZero());
}
@@ -264,48 +270,95 @@ static const int16_t kTestVectorInt16[kTestVectorSize] = {
static const int32_t kTestVectorInt32[kTestVectorSize] = {
INT32_MIN, 0, INT32_MAX, INT32_MIN, INT32_MAX / 2,
INT32_MIN / 2, 0, INT32_MAX, 0, 0};
+static const float kTestVectorFloat32[kTestVectorSize] = {
+ -1.0f, 0.0f, 1.0f, -1.0f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f};
// 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);
+static const int kTestVectorFrameCount = kTestVectorSize / 2;
+static const float kTestVectorResult[][kTestVectorFrameCount] = {
+ {-1.0f, 1.0f, 0.5f, 0.0f, 0.0f},
+ {0.0f, -1.0f, -0.5f, 1.0f, 0.0f}};
+static const int kTestVectorChannelCount = arraysize(kTestVectorResult);
// Verify FromInterleaved() deinterleaves audio in supported formats correctly.
TEST_F(AudioBusTest, FromInterleaved) {
std::unique_ptr<AudioBus> bus =
- AudioBus::Create(kTestVectorChannels, kTestVectorFrames);
+ AudioBus::Create(kTestVectorChannelCount, kTestVectorFrameCount);
std::unique_ptr<AudioBus> expected =
- AudioBus::Create(kTestVectorChannels, kTestVectorFrames);
- for (int ch = 0; ch < kTestVectorChannels; ++ch) {
+ AudioBus::Create(kTestVectorChannelCount, kTestVectorFrameCount);
+ for (int ch = 0; ch < kTestVectorChannelCount; ++ch) {
memcpy(expected->channel(ch), kTestVectorResult[ch],
- kTestVectorFrames * sizeof(*expected->channel(ch)));
+ kTestVectorFrameCount * sizeof(*expected->channel(ch)));
}
+
+ // Test deprecated version that takes |bytes_per_sample| as an input.
{
SCOPED_TRACE("uint8_t");
bus->Zero();
- bus->FromInterleaved(
- kTestVectorUint8, kTestVectorFrames, sizeof(*kTestVectorUint8));
+ bus->FromInterleaved(kTestVectorUint8, kTestVectorFrameCount,
+ sizeof(*kTestVectorUint8));
+
// Biased uint8_t calculations have poor precision, so the epsilon here is
// slightly more permissive than int16_t and int32_t calculations.
- VerifyBusWithEpsilon(bus.get(), expected.get(),
- 1.0f / (std::numeric_limits<uint8_t>::max() - 1));
+ VerifyAreEqualWithEpsilon(bus.get(), expected.get(),
+ 1.0f / (std::numeric_limits<uint8_t>::max() - 1));
}
{
SCOPED_TRACE("int16_t");
bus->Zero();
- bus->FromInterleaved(
- kTestVectorInt16, kTestVectorFrames, sizeof(*kTestVectorInt16));
- VerifyBusWithEpsilon(bus.get(), expected.get(),
- 1.0f / (std::numeric_limits<uint16_t>::max() + 1.0f));
+ bus->FromInterleaved(kTestVectorInt16, kTestVectorFrameCount,
+ sizeof(*kTestVectorInt16));
+ VerifyAreEqualWithEpsilon(
+ bus.get(), expected.get(),
+ 1.0f / (std::numeric_limits<uint16_t>::max() + 1.0f));
}
{
SCOPED_TRACE("int32_t");
bus->Zero();
- bus->FromInterleaved(
- kTestVectorInt32, kTestVectorFrames, sizeof(*kTestVectorInt32));
- VerifyBusWithEpsilon(bus.get(), expected.get(),
- 1.0f / (std::numeric_limits<uint32_t>::max() + 1.0f));
+ bus->FromInterleaved(kTestVectorInt32, kTestVectorFrameCount,
+ sizeof(*kTestVectorInt32));
+
+ VerifyAreEqualWithEpsilon(
+ bus.get(), expected.get(),
+ 1.0f / (std::numeric_limits<uint32_t>::max() + 1.0f));
+ }
+
+ // Test non-deprecated version that takes SampleTypeTraits as a template
+ // parameter.
+ {
+ SCOPED_TRACE("UnsignedInt8SampleTypeTraits");
+ bus->Zero();
+ bus->FromInterleaved<UnsignedInt8SampleTypeTraits>(kTestVectorUint8,
+ kTestVectorFrameCount);
+ // Biased uint8_t calculations have poor precision, so the epsilon here is
+ // slightly more permissive than int16_t and int32_t calculations.
+ VerifyAreEqualWithEpsilon(bus.get(), expected.get(),
+ 1.0f / (std::numeric_limits<uint8_t>::max() - 1));
+ }
+ {
+ SCOPED_TRACE("SignedInt16SampleTypeTraits");
+ bus->Zero();
+ bus->FromInterleaved<SignedInt16SampleTypeTraits>(kTestVectorInt16,
+ kTestVectorFrameCount);
+ VerifyAreEqualWithEpsilon(
+ bus.get(), expected.get(),
+ 1.0f / (std::numeric_limits<uint16_t>::max() + 1.0f));
+ }
+ {
+ SCOPED_TRACE("SignedInt32SampleTypeTraits");
+ bus->Zero();
+ bus->FromInterleaved<SignedInt32SampleTypeTraits>(kTestVectorInt32,
+ kTestVectorFrameCount);
+ VerifyAreEqualWithEpsilon(
+ bus.get(), expected.get(),
+ 1.0f / (std::numeric_limits<uint32_t>::max() + 1.0f));
+ }
+ {
+ SCOPED_TRACE("Float32SampleTypeTraits");
+ bus->Zero();
+ bus->FromInterleaved<Float32SampleTypeTraits>(kTestVectorFloat32,
+ kTestVectorFrameCount);
+ VerifyAreEqual(bus.get(), expected.get());
}
}
@@ -314,48 +367,65 @@ 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);
+ ASSERT_LE(kPartialStart + kPartialFrames, kTestVectorFrameCount);
std::unique_ptr<AudioBus> bus =
- AudioBus::Create(kTestVectorChannels, kTestVectorFrames);
+ AudioBus::Create(kTestVectorChannelCount, kTestVectorFrameCount);
std::unique_ptr<AudioBus> expected =
- AudioBus::Create(kTestVectorChannels, kTestVectorFrames);
+ AudioBus::Create(kTestVectorChannelCount, kTestVectorFrameCount);
expected->Zero();
- for (int ch = 0; ch < kTestVectorChannels; ++ch) {
+ for (int ch = 0; ch < kTestVectorChannelCount; ++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());
+ // Test deprecated version that takes |bytes_per_sample| as an input.
+ {
+ SCOPED_TRACE("int32_t");
+ bus->Zero();
+ bus->FromInterleavedPartial(
+ kTestVectorInt32 + kPartialStart * bus->channels(), kPartialStart,
+ kPartialFrames, sizeof(*kTestVectorInt32));
+ VerifyAreEqual(bus.get(), expected.get());
+ }
+
+ // Test non-deprecated version that takes SampleTypeTraits as a template
+ // parameter.
+ {
+ SCOPED_TRACE("SignedInt32SampleTypeTraits");
+ bus->Zero();
+ bus->FromInterleavedPartial<SignedInt32SampleTypeTraits>(
+ kTestVectorInt32 + kPartialStart * bus->channels(), kPartialStart,
+ kPartialFrames);
+ VerifyAreEqual(bus.get(), expected.get());
+ }
}
// Verify ToInterleaved() interleaves audio in suported formats correctly.
TEST_F(AudioBusTest, ToInterleaved) {
std::unique_ptr<AudioBus> bus =
- AudioBus::Create(kTestVectorChannels, kTestVectorFrames);
+ AudioBus::Create(kTestVectorChannelCount, kTestVectorFrameCount);
// 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)));
+ kTestVectorFrameCount * sizeof(*bus->channel(ch)));
}
+
+ // Test deprecated version that takes |bytes_per_sample| as an input.
{
SCOPED_TRACE("uint8_t");
uint8_t test_array[arraysize(kTestVectorUint8)];
bus->ToInterleaved(bus->frames(), sizeof(*kTestVectorUint8), test_array);
- ASSERT_EQ(memcmp(
- test_array, kTestVectorUint8, sizeof(kTestVectorUint8)), 0);
+ ASSERT_EQ(0,
+ memcmp(test_array, kTestVectorUint8, sizeof(kTestVectorUint8)));
}
{
SCOPED_TRACE("int16_t");
int16_t test_array[arraysize(kTestVectorInt16)];
bus->ToInterleaved(bus->frames(), sizeof(*kTestVectorInt16), test_array);
- ASSERT_EQ(memcmp(
- test_array, kTestVectorInt16, sizeof(kTestVectorInt16)), 0);
+ ASSERT_EQ(0,
+ memcmp(test_array, kTestVectorInt16, sizeof(kTestVectorInt16)));
}
{
SCOPED_TRACE("int32_t");
@@ -364,14 +434,60 @@ TEST_F(AudioBusTest, ToInterleaved) {
// 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_t fixed_test_array[arraysize(kTestVectorInt32)];
- memcpy(fixed_test_array, kTestVectorInt32, sizeof(kTestVectorInt32));
- ASSERT_EQ(fixed_test_array[4], std::numeric_limits<int32_t>::max() / 2);
- fixed_test_array[4]++;
+ int32_t alternative_acceptable_result[arraysize(kTestVectorInt32)];
+ memcpy(alternative_acceptable_result, kTestVectorInt32,
+ sizeof(kTestVectorInt32));
+ ASSERT_EQ(alternative_acceptable_result[4],
+ std::numeric_limits<int32_t>::max() / 2);
+ alternative_acceptable_result[4]++;
ASSERT_TRUE(
- memcmp(test_array, kTestVectorInt32, sizeof(kTestVectorInt32)) == 0 ||
- memcmp(test_array, fixed_test_array, sizeof(fixed_test_array)) == 0);
+ memcmp(test_array, kTestVectorInt32, sizeof(kTestVectorInt32)) == 0 ||
+ memcmp(test_array, alternative_acceptable_result,
+ sizeof(alternative_acceptable_result)) == 0);
+ }
+
+ // Test non-deprecated version that takes SampleTypeTraits as a template
+ // parameter.
+ {
+ SCOPED_TRACE("UnsignedInt8SampleTypeTraits");
+ uint8_t test_array[arraysize(kTestVectorUint8)];
+ bus->ToInterleaved<UnsignedInt8SampleTypeTraits>(bus->frames(), test_array);
+ ASSERT_EQ(0,
+ memcmp(test_array, kTestVectorUint8, sizeof(kTestVectorUint8)));
+ }
+ {
+ SCOPED_TRACE("SignedInt16SampleTypeTraits");
+ int16_t test_array[arraysize(kTestVectorInt16)];
+ bus->ToInterleaved<SignedInt16SampleTypeTraits>(bus->frames(), test_array);
+ ASSERT_EQ(0,
+ memcmp(test_array, kTestVectorInt16, sizeof(kTestVectorInt16)));
+ }
+ {
+ SCOPED_TRACE("SignedInt32SampleTypeTraits");
+ int32_t test_array[arraysize(kTestVectorInt32)];
+ bus->ToInterleaved<SignedInt32SampleTypeTraits>(bus->frames(), 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_t alternative_acceptable_result[arraysize(kTestVectorInt32)];
+ memcpy(alternative_acceptable_result, kTestVectorInt32,
+ sizeof(kTestVectorInt32));
+ ASSERT_EQ(alternative_acceptable_result[4],
+ std::numeric_limits<int32_t>::max() / 2);
+ alternative_acceptable_result[4]++;
+
+ ASSERT_TRUE(
+ memcmp(test_array, kTestVectorInt32, sizeof(kTestVectorInt32)) == 0 ||
+ memcmp(test_array, alternative_acceptable_result,
+ sizeof(alternative_acceptable_result)) == 0);
+ }
+ {
+ SCOPED_TRACE("Float32SampleTypeTraits");
+ float test_array[arraysize(kTestVectorFloat32)];
+ bus->ToInterleaved<Float32SampleTypeTraits>(bus->frames(), test_array);
+ ASSERT_EQ(
+ 0, memcmp(test_array, kTestVectorFloat32, sizeof(kTestVectorFloat32)));
}
}
@@ -380,21 +496,141 @@ 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);
+ ASSERT_LE(kPartialStart + kPartialFrames, kTestVectorFrameCount);
std::unique_ptr<AudioBus> expected =
- AudioBus::Create(kTestVectorChannels, kTestVectorFrames);
- for (int ch = 0; ch < kTestVectorChannels; ++ch) {
+ AudioBus::Create(kTestVectorChannelCount, kTestVectorFrameCount);
+ for (int ch = 0; ch < kTestVectorChannelCount; ++ch) {
memcpy(expected->channel(ch), kTestVectorResult[ch],
- kTestVectorFrames * sizeof(*expected->channel(ch)));
+ kTestVectorFrameCount * sizeof(*expected->channel(ch)));
+ }
+
+ // Test deprecated version that takes |bytes_per_sample| as an input.
+ {
+ SCOPED_TRACE("int16_t");
+ int16_t test_array[arraysize(kTestVectorInt16)];
+ expected->ToInterleavedPartial(kPartialStart, kPartialFrames,
+ sizeof(*kTestVectorInt16), test_array);
+ ASSERT_EQ(0, memcmp(test_array, kTestVectorInt16 +
+ kPartialStart * kTestVectorChannelCount,
+ kPartialFrames * sizeof(*kTestVectorInt16) *
+ kTestVectorChannelCount));
+ }
+
+ // Test non-deprecated version that takes SampleTypeTraits as a template
+ // parameter.
+ {
+ SCOPED_TRACE("Float32SampleTypeTraits");
+ float test_array[arraysize(kTestVectorFloat32)];
+ expected->ToInterleavedPartial<Float32SampleTypeTraits>(
+ kPartialStart, kPartialFrames, test_array);
+ ASSERT_EQ(0, memcmp(test_array, kTestVectorFloat32 +
+ kPartialStart * kTestVectorChannelCount,
+ kPartialFrames * sizeof(*kTestVectorFloat32) *
+ kTestVectorChannelCount));
+ }
+}
+
+struct ZeroingOutTestData {
+ static constexpr int kChannelCount = 2;
+ static constexpr int kFrameCount = 10;
+ static constexpr int kInterleavedFrameCount = 3;
+
+ std::unique_ptr<AudioBus> bus_under_test;
+ std::vector<float> interleaved_dummy_frames;
+
+ ZeroingOutTestData() {
+ // Create a bus and fill each channel with a test pattern of form
+ // [1.0, 2.0, 3.0, ...]
+ bus_under_test = AudioBus::Create(kChannelCount, kFrameCount);
+ for (int ch = 0; ch < kChannelCount; ++ch) {
+ auto sample_array_for_current_channel = bus_under_test->channel(ch);
+ for (int frame_index = 0; frame_index < kFrameCount; frame_index++) {
+ sample_array_for_current_channel[frame_index] =
+ static_cast<float>(frame_index + 1);
+ }
+ }
+
+ // Create a vector containing dummy interleaved samples.
+ static const float kDummySampleValue = 0.123f;
+ interleaved_dummy_frames.resize(kChannelCount * kInterleavedFrameCount);
+ std::fill(interleaved_dummy_frames.begin(), interleaved_dummy_frames.end(),
+ kDummySampleValue);
+ }
+};
+
+TEST_F(AudioBusTest, FromInterleavedZerosOutUntouchedFrames) {
+ ZeroingOutTestData test_data;
+
+ // Exercise
+ test_data.bus_under_test->FromInterleaved<Float32SampleTypeTraits>(
+ &test_data.interleaved_dummy_frames[0], test_data.kInterleavedFrameCount);
+
+ // Verification
+ for (int ch = 0; ch < test_data.kChannelCount; ++ch) {
+ auto sample_array_for_current_channel =
+ test_data.bus_under_test->channel(ch);
+ for (int frame_index = test_data.kInterleavedFrameCount;
+ frame_index < test_data.kFrameCount; frame_index++) {
+ ASSERT_EQ(0.0f, sample_array_for_current_channel[frame_index]);
+ }
}
+}
- int16_t 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, FromInterleavedPartialDoesNotZeroOutUntouchedFrames) {
+ {
+ SCOPED_TRACE("Zero write offset");
+
+ ZeroingOutTestData test_data;
+ static const int kWriteOffsetInFrames = 0;
+
+ // Exercise
+ test_data.bus_under_test->FromInterleavedPartial<Float32SampleTypeTraits>(
+ &test_data.interleaved_dummy_frames[0], kWriteOffsetInFrames,
+ test_data.kInterleavedFrameCount);
+
+ // Verification
+ for (int ch = 0; ch < test_data.kChannelCount; ++ch) {
+ auto sample_array_for_current_channel =
+ test_data.bus_under_test->channel(ch);
+ for (int frame_index =
+ test_data.kInterleavedFrameCount + kWriteOffsetInFrames;
+ frame_index < test_data.kFrameCount; frame_index++) {
+ ASSERT_EQ(frame_index + 1,
+ sample_array_for_current_channel[frame_index]);
+ }
+ }
+ }
+ {
+ SCOPED_TRACE("Positive write offset");
+
+ ZeroingOutTestData test_data;
+ static const int kWriteOffsetInFrames = 2;
+
+ // Exercise
+ test_data.bus_under_test->FromInterleavedPartial<Float32SampleTypeTraits>(
+ &test_data.interleaved_dummy_frames[0], kWriteOffsetInFrames,
+ test_data.kInterleavedFrameCount);
+
+ // Verification
+ for (int ch = 0; ch < test_data.kChannelCount; ++ch) {
+ auto sample_array_for_current_channel =
+ test_data.bus_under_test->channel(ch);
+ // Check untouched frames before write offset
+ for (int frame_index = 0; frame_index < kWriteOffsetInFrames;
+ frame_index++) {
+ ASSERT_EQ(frame_index + 1,
+ sample_array_for_current_channel[frame_index]);
+ }
+ // Check untouched frames after write
+ for (int frame_index =
+ test_data.kInterleavedFrameCount + kWriteOffsetInFrames;
+ frame_index < test_data.kFrameCount; frame_index++) {
+ ASSERT_EQ(frame_index + 1,
+ sample_array_for_current_channel[frame_index]);
+ }
+ }
+ }
}
TEST_F(AudioBusTest, Scale) {
@@ -409,7 +645,7 @@ TEST_F(AudioBusTest, Scale) {
bus->Scale(-1);
for (int i = 0; i < bus->channels(); ++i) {
SCOPED_TRACE("Invalid Scale");
- VerifyValue(bus->channel(i), bus->frames(), kFillValue);
+ VerifyArrayIsFilledWithValue(bus->channel(i), bus->frames(), kFillValue);
}
// Verify correct volume adjustment.
@@ -417,14 +653,15 @@ TEST_F(AudioBusTest, Scale) {
bus->Scale(kVolume);
for (int i = 0; i < bus->channels(); ++i) {
SCOPED_TRACE("Half Scale");
- VerifyValue(bus->channel(i), bus->frames(), kFillValue * kVolume);
+ VerifyArrayIsFilledWithValue(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);
+ VerifyArrayIsFilledWithValue(bus->channel(i), bus->frames(), 0);
}
}
« no previous file with comments | « media/base/audio_bus.cc ('k') | media/base/audio_sample_types.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698