| // Copyright 2020 The Fuchsia 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 <lib/syslog/cpp/macros.h> |
| |
| #include <gtest/gtest.h> |
| |
| #include "src/media/sounds/soundplayer/wav_reader.h" |
| |
| namespace soundplayer { |
| namespace test { |
| |
| class TestDiscardableSound : public DiscardableSound { |
| public: |
| const zx::vmo& LockForRead() { |
| auto& result = DiscardableSound::LockForRead(); |
| Restore(); |
| return result; |
| } |
| }; |
| |
| bool VmoMatches(const zx::vmo& vmo, const uint8_t* data, size_t size) { |
| auto buffer = std::vector<uint8_t>(size); |
| zx_status_t status = vmo.read(buffer.data(), 0, size); |
| if (status != ZX_OK) { |
| FX_PLOGS(ERROR, status) << "Failed to read " << size << " bytes from vmo"; |
| return false; |
| } |
| |
| return memcmp(data, buffer.data(), size) == 0; |
| } |
| |
| TEST(WavReaderTests, Successful) { |
| std::vector<uint8_t> test_data{ |
| 0x52, 0x49, 0x46, 0x46, // 'RIFF' |
| 0x00, 0x00, 0x00, 0x00, // RIFF chunk size (ignored) |
| 0x57, 0x41, 0x56, 0x45, // 'WAVE' |
| 0x66, 0x6d, 0x74, 0x20, // 'fmt ' |
| 0x10, 0x00, 0x00, 0x00, // fmt chunk size (16 bytes) |
| 0x01, 0x00, // encoding (1 = pcm) |
| 0x02, 0x00, // channel count (2) |
| 0x44, 0xac, 0x00, 0x00, // frames/second (44100) |
| 0x10, 0xb1, 0x02, 0x00, // byte rate (44100 * 4) |
| 0x04, 0x00, // block alignment (4) |
| 0x10, 0x00, // bits/sample (16) |
| 0x64, 0x61, 0x74, 0x61, // 'data' |
| 0x04, 0x00, 0x00, 0x00, // data chunk size (4) |
| 0x01, 0x02, 0x03, 0x04, // frames |
| }; |
| |
| WavReader under_test; |
| DiscardableSound sound; |
| zx_status_t status = under_test.Process(sound, test_data.data(), test_data.size()); |
| EXPECT_EQ(ZX_OK, status); |
| EXPECT_EQ(4u, sound.size()); |
| EXPECT_EQ(fuchsia::media::AudioSampleFormat::SIGNED_16, sound.stream_type().sample_format); |
| EXPECT_EQ(2u, sound.stream_type().channels); |
| EXPECT_EQ(44100u, sound.stream_type().frames_per_second); |
| auto& vmo = sound.LockForRead(); |
| EXPECT_TRUE(VmoMatches(vmo, test_data.data() + (test_data.size() - sound.size()), sound.size())); |
| sound.Unlock(); |
| } |
| |
| TEST(WavReaderTests, OneExtraByte) { |
| std::vector<uint8_t> test_data{ |
| 0x52, 0x49, 0x46, 0x46, // 'RIFF' |
| 0x00, 0x00, 0x00, 0x00, // RIFF chunk size (ignored) |
| 0x57, 0x41, 0x56, 0x45, // 'WAVE' |
| 0x66, 0x6d, 0x74, 0x20, // 'fmt ' |
| 0x10, 0x00, 0x00, 0x00, // fmt chunk size (16 bytes) |
| 0x01, 0x00, // encoding (1 = pcm) |
| 0x02, 0x00, // channel count (2) |
| 0x44, 0xac, 0x00, 0x00, // frames/second (44100) |
| 0x10, 0xb1, 0x02, 0x00, // byte rate (44100 * 4) |
| 0x04, 0x00, // block alignment (4) |
| 0x10, 0x00, // bits/sample (16) |
| 0x64, 0x61, 0x74, 0x61, // 'data' |
| 0x04, 0x00, 0x00, 0x00, // data chunk size (4) |
| 0x01, 0x02, 0x03, 0x04, // frames |
| 0x00, // extra |
| }; |
| |
| WavReader under_test; |
| DiscardableSound sound; |
| zx_status_t status = under_test.Process(sound, test_data.data(), test_data.size()); |
| EXPECT_EQ(ZX_OK, status); |
| EXPECT_EQ(4u, sound.size()); |
| EXPECT_EQ(fuchsia::media::AudioSampleFormat::SIGNED_16, sound.stream_type().sample_format); |
| EXPECT_EQ(2u, sound.stream_type().channels); |
| EXPECT_EQ(44100u, sound.stream_type().frames_per_second); |
| auto& vmo = sound.LockForRead(); |
| EXPECT_TRUE( |
| VmoMatches(vmo, test_data.data() + (test_data.size() - sound.size() - 1), sound.size())); |
| sound.Unlock(); |
| } |
| |
| TEST(WavReaderTests, TwoExtraBytes) { |
| std::vector<uint8_t> test_data{ |
| 0x52, 0x49, 0x46, 0x46, // 'RIFF' |
| 0x00, 0x00, 0x00, 0x00, // RIFF chunk size (ignored) |
| 0x57, 0x41, 0x56, 0x45, // 'WAVE' |
| 0x66, 0x6d, 0x74, 0x20, // 'fmt ' |
| 0x10, 0x00, 0x00, 0x00, // fmt chunk size (16 bytes) |
| 0x01, 0x00, // encoding (1 = pcm) |
| 0x02, 0x00, // channel count (2) |
| 0x44, 0xac, 0x00, 0x00, // frames/second (44100) |
| 0x10, 0xb1, 0x02, 0x00, // byte rate (44100 * 4) |
| 0x04, 0x00, // block alignment (4) |
| 0x10, 0x00, // bits/sample (16) |
| 0x64, 0x61, 0x74, 0x61, // 'data' |
| 0x04, 0x00, 0x00, 0x00, // data chunk size (4) |
| 0x01, 0x02, 0x03, 0x04, // frames |
| 0x00, 0x01, // extra |
| }; |
| |
| WavReader under_test; |
| DiscardableSound sound; |
| zx_status_t status = under_test.Process(sound, test_data.data(), test_data.size()); |
| EXPECT_EQ(ZX_OK, status); |
| EXPECT_EQ(4u, sound.size()); |
| EXPECT_EQ(fuchsia::media::AudioSampleFormat::SIGNED_16, sound.stream_type().sample_format); |
| EXPECT_EQ(2u, sound.stream_type().channels); |
| EXPECT_EQ(44100u, sound.stream_type().frames_per_second); |
| auto& vmo = sound.LockForRead(); |
| EXPECT_TRUE( |
| VmoMatches(vmo, test_data.data() + (test_data.size() - sound.size() - 2), sound.size())); |
| sound.Unlock(); |
| } |
| |
| TEST(WavReaderTests, ThreeExtraBytes) { |
| std::vector<uint8_t> test_data{ |
| 0x52, 0x49, 0x46, 0x46, // 'RIFF' |
| 0x00, 0x00, 0x00, 0x00, // RIFF chunk size (ignored) |
| 0x57, 0x41, 0x56, 0x45, // 'WAVE' |
| 0x66, 0x6d, 0x74, 0x20, // 'fmt ' |
| 0x10, 0x00, 0x00, 0x00, // fmt chunk size (16 bytes) |
| 0x01, 0x00, // encoding (1 = pcm) |
| 0x02, 0x00, // channel count (2) |
| 0x44, 0xac, 0x00, 0x00, // frames/second (44100) |
| 0x10, 0xb1, 0x02, 0x00, // byte rate (44100 * 4) |
| 0x04, 0x00, // block alignment (4) |
| 0x10, 0x00, // bits/sample (16) |
| 0x64, 0x61, 0x74, 0x61, // 'data' |
| 0x04, 0x00, 0x00, 0x00, // data chunk size (4) |
| 0x01, 0x02, 0x03, 0x04, // frames |
| 0x00, 0x01, 0x02, // extra |
| }; |
| |
| WavReader under_test; |
| DiscardableSound sound; |
| zx_status_t status = under_test.Process(sound, test_data.data(), test_data.size()); |
| EXPECT_EQ(ZX_OK, status); |
| EXPECT_EQ(4u, sound.size()); |
| EXPECT_EQ(fuchsia::media::AudioSampleFormat::SIGNED_16, sound.stream_type().sample_format); |
| EXPECT_EQ(2u, sound.stream_type().channels); |
| EXPECT_EQ(44100u, sound.stream_type().frames_per_second); |
| auto& vmo = sound.LockForRead(); |
| EXPECT_TRUE( |
| VmoMatches(vmo, test_data.data() + (test_data.size() - sound.size() - 3), sound.size())); |
| sound.Unlock(); |
| } |
| |
| TEST(WavReaderTests, LongFmtChunk) { |
| std::vector<uint8_t> test_data{ |
| 0x52, 0x49, 0x46, 0x46, // 'RIFF' |
| 0x00, 0x00, 0x00, 0x00, // RIFF chunk size (ignored) |
| 0x57, 0x41, 0x56, 0x45, // 'WAVE' |
| 0x66, 0x6d, 0x74, 0x20, // 'fmt ' |
| 0x14, 0x00, 0x00, 0x00, // fmt chunk size (20 bytes) |
| 0x01, 0x00, // encoding (1 = pcm) |
| 0x02, 0x00, // channel count (2) |
| 0x44, 0xac, 0x00, 0x00, // frames/second (44100) |
| 0x10, 0xb1, 0x02, 0x00, // byte rate (44100 * 4) |
| 0x04, 0x00, // block alignment (4) |
| 0x10, 0x00, // bits/sample (16) |
| 0x00, 0x00, 0x00, 0x00, // extra fmt stuff |
| 0x64, 0x61, 0x74, 0x61, // 'data' |
| 0x04, 0x00, 0x00, 0x00, // data chunk size (4) |
| 0x01, 0x02, 0x03, 0x04, // frames |
| }; |
| |
| WavReader under_test; |
| DiscardableSound sound; |
| zx_status_t status = under_test.Process(sound, test_data.data(), test_data.size()); |
| EXPECT_EQ(ZX_OK, status); |
| EXPECT_EQ(4u, sound.size()); |
| EXPECT_EQ(fuchsia::media::AudioSampleFormat::SIGNED_16, sound.stream_type().sample_format); |
| EXPECT_EQ(2u, sound.stream_type().channels); |
| EXPECT_EQ(44100u, sound.stream_type().frames_per_second); |
| auto& vmo = sound.LockForRead(); |
| EXPECT_TRUE(VmoMatches(vmo, test_data.data() + (test_data.size() - sound.size()), sound.size())); |
| sound.Unlock(); |
| } |
| |
| TEST(WavReaderTests, NoRiffHeader) { |
| std::vector<uint8_t> test_data{ |
| 0x52, 0x41, 0x46, 0x46, // 'RAFF' |
| 0x00, 0x00, 0x00, 0x00, // RIFF chunk size (ignored) |
| 0x57, 0x41, 0x56, 0x45, // 'WAVE' |
| 0x66, 0x6d, 0x74, 0x20, // 'fmt ' |
| 0x10, 0x00, 0x00, 0x00, // fmt chunk size (16 bytes) |
| 0x01, 0x00, // encoding (1 = pcm) |
| 0x02, 0x00, // channel count (2) |
| 0x44, 0xac, 0x00, 0x00, // frames/second (44100) |
| 0x10, 0xb1, 0x02, 0x00, // byte rate (44100 * 4) |
| 0x04, 0x00, // block alignment (4) |
| 0x10, 0x00, // bits/sample (16) |
| 0x64, 0x61, 0x74, 0x61, // 'data' |
| 0x04, 0x00, 0x00, 0x00, // data chunk size (4) |
| 0x00, 0x00, 0x00, 0x00, // frames |
| }; |
| |
| WavReader under_test; |
| DiscardableSound sound; |
| zx_status_t status = under_test.Process(sound, test_data.data(), test_data.size()); |
| EXPECT_NE(ZX_OK, status); |
| } |
| |
| TEST(WavReaderTests, NoWave) { |
| std::vector<uint8_t> test_data{ |
| 0x52, 0x49, 0x46, 0x46, // 'RIFF' |
| 0x00, 0x00, 0x00, 0x00, // RIFF chunk size (ignored) |
| 0x57, 0x4f, 0x56, 0x45, // 'WOVE' |
| 0x66, 0x6d, 0x74, 0x20, // 'fmt ' |
| 0x10, 0x00, 0x00, 0x00, // fmt chunk size (16 bytes) |
| 0x01, 0x00, // encoding (1 = pcm) |
| 0x02, 0x00, // channel count (2) |
| 0x44, 0xac, 0x00, 0x00, // frames/second (44100) |
| 0x10, 0xb1, 0x02, 0x00, // byte rate (44100 * 4) |
| 0x04, 0x00, // block alignment (4) |
| 0x10, 0x00, // bits/sample (16) |
| 0x64, 0x61, 0x74, 0x61, // 'data' |
| 0x04, 0x00, 0x00, 0x00, // data chunk size (4) |
| 0x00, 0x00, 0x00, 0x00, // frames |
| }; |
| |
| WavReader under_test; |
| DiscardableSound sound; |
| zx_status_t status = under_test.Process(sound, test_data.data(), test_data.size()); |
| EXPECT_NE(ZX_OK, status); |
| } |
| |
| TEST(WavReaderTests, NoFmt) { |
| std::vector<uint8_t> test_data{ |
| 0x52, 0x49, 0x46, 0x46, // 'RIFF' |
| 0x00, 0x00, 0x00, 0x00, // RIFF chunk size (ignored) |
| 0x57, 0x41, 0x56, 0x45, // 'WAVE' |
| 0x66, 0x6d, 0x74, 0x74, // 'fmtt' |
| 0x10, 0x00, 0x00, 0x00, // fmt chunk size (16 bytes) |
| 0x01, 0x00, // encoding (1 = pcm) |
| 0x02, 0x00, // channel count (2) |
| 0x44, 0xac, 0x00, 0x00, // frames/second (44100) |
| 0x10, 0xb1, 0x02, 0x00, // byte rate (44100 * 4) |
| 0x04, 0x00, // block alignment (4) |
| 0x10, 0x00, // bits/sample (16) |
| 0x64, 0x61, 0x74, 0x61, // 'data' |
| 0x04, 0x00, 0x00, 0x00, // data chunk size (4) |
| 0x00, 0x00, 0x00, 0x00, // frames |
| }; |
| |
| WavReader under_test; |
| DiscardableSound sound; |
| zx_status_t status = under_test.Process(sound, test_data.data(), test_data.size()); |
| EXPECT_NE(ZX_OK, status); |
| } |
| |
| TEST(WavReaderTests, ShortFmt) { |
| std::vector<uint8_t> test_data{ |
| 0x52, 0x49, 0x46, 0x46, // 'RIFF' |
| 0x00, 0x00, 0x00, 0x00, // RIFF chunk size (ignored) |
| 0x57, 0x41, 0x56, 0x45, // 'WAVE' |
| 0x66, 0x6d, 0x74, 0x20, // 'fmt ' |
| 0x0e, 0x00, 0x00, 0x00, // fmt chunk size (14 bytes) |
| 0x01, 0x00, // encoding (1 = pcm) |
| 0x02, 0x00, // channel count (2) |
| 0x44, 0xac, 0x00, 0x00, // frames/second (44100) |
| 0x10, 0xb1, 0x02, 0x00, // byte rate (44100 * 4) |
| 0x04, 0x00, // block alignment (4) |
| 0x64, 0x61, 0x74, 0x61, // 'data' |
| 0x04, 0x00, 0x00, 0x00, // data chunk size (4) |
| 0x00, 0x00, 0x00, 0x00, // frames |
| }; |
| |
| WavReader under_test; |
| DiscardableSound sound; |
| zx_status_t status = under_test.Process(sound, test_data.data(), test_data.size()); |
| EXPECT_NE(ZX_OK, status); |
| } |
| |
| TEST(WavReaderTests, BadEncoding) { |
| std::vector<uint8_t> test_data{ |
| 0x52, 0x49, 0x46, 0x46, // 'RIFF' |
| 0x00, 0x00, 0x00, 0x00, // RIFF chunk size (ignored) |
| 0x57, 0x41, 0x56, 0x45, // 'WAVE' |
| 0x66, 0x6d, 0x74, 0x20, // 'fmt ' |
| 0x10, 0x00, 0x00, 0x00, // fmt chunk size (16 bytes) |
| 0x02, 0x00, // encoding (2 = bad) |
| 0x02, 0x00, // channel count (2) |
| 0x44, 0xac, 0x00, 0x00, // frames/second (44100) |
| 0x10, 0xb1, 0x02, 0x00, // byte rate (44100 * 4) |
| 0x04, 0x00, // block alignment (4) |
| 0x10, 0x00, // bits/sample (16) |
| 0x64, 0x61, 0x74, 0x61, // 'data' |
| 0x04, 0x00, 0x00, 0x00, // data chunk size (4) |
| 0x00, 0x00, 0x00, 0x00, // frames |
| }; |
| |
| WavReader under_test; |
| DiscardableSound sound; |
| zx_status_t status = under_test.Process(sound, test_data.data(), test_data.size()); |
| EXPECT_NE(ZX_OK, status); |
| } |
| |
| TEST(WavReaderTests, ZeroChannels) { |
| std::vector<uint8_t> test_data{ |
| 0x52, 0x49, 0x46, 0x46, // 'RIFF' |
| 0x00, 0x00, 0x00, 0x00, // RIFF chunk size (ignored) |
| 0x57, 0x41, 0x56, 0x45, // 'WAVE' |
| 0x66, 0x6d, 0x74, 0x20, // 'fmt ' |
| 0x10, 0x00, 0x00, 0x00, // fmt chunk size (16 bytes) |
| 0x01, 0x00, // encoding (1 = pcm) |
| 0x00, 0x00, // channel count (0) |
| 0x44, 0xac, 0x00, 0x00, // frames/second (44100) |
| 0x10, 0xb1, 0x02, 0x00, // byte rate (44100 * 4) |
| 0x04, 0x00, // block alignment (4) |
| 0x10, 0x00, // bits/sample (16) |
| 0x64, 0x61, 0x74, 0x61, // 'data' |
| 0x04, 0x00, 0x00, 0x00, // data chunk size (4) |
| 0x00, 0x00, 0x00, 0x00, // frames |
| }; |
| |
| WavReader under_test; |
| DiscardableSound sound; |
| zx_status_t status = under_test.Process(sound, test_data.data(), test_data.size()); |
| EXPECT_NE(ZX_OK, status); |
| } |
| |
| TEST(WavReaderTests, ThreeChannels) { |
| std::vector<uint8_t> test_data{ |
| 0x52, 0x49, 0x46, 0x46, // 'RIFF' |
| 0x00, 0x00, 0x00, 0x00, // RIFF chunk size (ignored) |
| 0x57, 0x41, 0x56, 0x45, // 'WAVE' |
| 0x66, 0x6d, 0x74, 0x20, // 'fmt ' |
| 0x10, 0x00, 0x00, 0x00, // fmt chunk size (16 bytes) |
| 0x01, 0x00, // encoding (1 = pcm) |
| 0x03, 0x00, // channel count (3) |
| 0x44, 0xac, 0x00, 0x00, // frames/second (44100) |
| 0x10, 0xb1, 0x02, 0x00, // byte rate (44100 * 4) |
| 0x04, 0x00, // block alignment (4) |
| 0x10, 0x00, // bits/sample (16) |
| 0x64, 0x61, 0x74, 0x61, // 'data' |
| 0x04, 0x00, 0x00, 0x00, // data chunk size (4) |
| 0x00, 0x00, 0x00, 0x00, // frames |
| }; |
| |
| WavReader under_test; |
| DiscardableSound sound; |
| zx_status_t status = under_test.Process(sound, test_data.data(), test_data.size()); |
| EXPECT_NE(ZX_OK, status); |
| } |
| |
| TEST(WavReaderTests, NoData) { |
| std::vector<uint8_t> test_data{ |
| 0x52, 0x49, 0x46, 0x46, // 'RIFF' |
| 0x00, 0x00, 0x00, 0x00, // RIFF chunk size (ignored) |
| 0x57, 0x41, 0x56, 0x45, // 'WAVE' |
| 0x66, 0x6d, 0x74, 0x20, // 'fmt ' |
| 0x10, 0x00, 0x00, 0x00, // fmt chunk size (16 bytes) |
| 0x01, 0x00, // encoding (1 = pcm) |
| 0x02, 0x00, // channel count (2) |
| 0x44, 0xac, 0x00, 0x00, // frames/second (44100) |
| 0x10, 0xb1, 0x02, 0x00, // byte rate (44100 * 4) |
| 0x04, 0x00, // block alignment (4) |
| 0x10, 0x00, // bits/sample (16) |
| 0x64, 0x61, 0x74, 0x65, // 'date' |
| 0x04, 0x00, 0x00, 0x00, // data chunk size (4) |
| 0x00, 0x00, 0x00, 0x00, // frames |
| }; |
| |
| WavReader under_test; |
| DiscardableSound sound; |
| zx_status_t status = under_test.Process(sound, test_data.data(), test_data.size()); |
| EXPECT_NE(ZX_OK, status); |
| } |
| |
| TEST(WavReaderTests, Truncated) { |
| std::vector<uint8_t> test_data{ |
| 0x52, 0x49, 0x46, 0x46, // 'RIFF' |
| 0x00, 0x00, 0x00, 0x00, // RIFF chunk size (ignored) |
| 0x57, 0x41, 0x56, 0x45, // 'WAVE' |
| 0x66, 0x6d, 0x74, 0x20, // 'fmt ' |
| 0x10, 0x00, 0x00, 0x00, // fmt chunk size (16 bytes) |
| 0x01, 0x00, // encoding (1 = pcm) |
| 0x02, 0x00, // channel count (2) |
| 0x44, 0xac, 0x00, 0x00, // frames/second (44100) |
| 0x10, 0xb1, 0x02, 0x00, // byte rate (44100 * 4) |
| 0x04, 0x00, // block alignment (4) |
| 0x10, 0x00, // bits/sample (16) |
| 0x64, 0x61, 0x74, 0x61, // 'data' |
| 0x04, 0x00, 0x00, 0x00, // data chunk size (4) |
| 0x00, 0x00, 0x00, 0x00, // frames |
| }; |
| |
| for (size_t i = 1; i < 44; ++i) { |
| WavReader under_test; |
| DiscardableSound sound; |
| zx_status_t status = under_test.Process(sound, test_data.data(), test_data.size() - i); |
| EXPECT_NE(ZX_OK, status); |
| } |
| } |
| |
| TEST(WavReaderTests, Packed24) { |
| std::vector<uint8_t> test_data{ |
| 0x52, 0x49, 0x46, 0x46, // 'RIFF' |
| 0x00, 0x00, 0x00, 0x00, // RIFF chunk size (ignored) |
| 0x57, 0x41, 0x56, 0x45, // 'WAVE' |
| 0x66, 0x6d, 0x74, 0x20, // 'fmt ' |
| 0x12, 0x00, 0x00, 0x00, // fmt chunk size (18 bytes) |
| 0x01, 0x00, // encoding (1 = pcm) |
| 0x02, 0x00, // channel count (2) |
| 0x44, 0xac, 0x00, 0x00, // frames/second (44100) |
| 0x98, 0x09, 0x04, 0x00, // byte rate (44100 * 6) |
| 0x06, 0x00, // block alignment (6) |
| 0x18, 0x00, // bits/sample (24) |
| 0x00, 0x00, // extra param size (0) |
| 0x64, 0x61, 0x74, 0x61, // 'data' |
| 0x0c, 0x00, 0x00, 0x00, // data chunk size (12) |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, // frame |
| 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, // frame |
| }; |
| std::vector<uint8_t> expected{ |
| 0x00, 0x01, 0x02, 0x03, 0x00, 0x04, 0x05, 0x06, |
| 0x00, 0x07, 0x08, 0x09, 0x00, 0x0a, 0x0b, 0x0c, |
| }; |
| |
| WavReader under_test; |
| DiscardableSound sound; |
| zx_status_t status = under_test.Process(sound, test_data.data(), test_data.size()); |
| EXPECT_EQ(ZX_OK, status); |
| EXPECT_EQ(16u, sound.size()); |
| EXPECT_EQ(fuchsia::media::AudioSampleFormat::SIGNED_24_IN_32, sound.stream_type().sample_format); |
| EXPECT_EQ(2u, sound.stream_type().channels); |
| EXPECT_EQ(44100u, sound.stream_type().frames_per_second); |
| auto& vmo = sound.LockForRead(); |
| EXPECT_TRUE(VmoMatches(vmo, expected.data(), expected.size())); |
| sound.Unlock(); |
| } |
| |
| TEST(WavReaderTests, Float) { |
| std::vector<uint8_t> test_data{ |
| 0x52, 0x49, 0x46, 0x46, // 'RIFF' |
| 0x00, 0x00, 0x00, 0x00, // RIFF chunk size (ignored) |
| 0x57, 0x41, 0x56, 0x45, // 'WAVE' |
| 0x66, 0x6d, 0x74, 0x20, // 'fmt ' |
| 0x10, 0x00, 0x00, 0x00, // fmt chunk size (16 bytes) |
| 0x03, 0x00, // encoding (3 = pcm float) |
| 0x02, 0x00, // channel count (2) |
| 0x44, 0xac, 0x00, 0x00, // frames/second (44100) |
| 0x98, 0x09, 0x04, 0x00, // byte rate (44100 * 6) |
| 0x06, 0x00, // block alignment (6) |
| 0x20, 0x00, // bits/sample (32) |
| 0x64, 0x61, 0x74, 0x61, // 'data' |
| 0x08, 0x00, 0x00, 0x00, // data chunk size (8) |
| 0x01, 0x02, 0x03, 0x04, // frame |
| 0x05, 0x06, 0x07, 0x08, // frame |
| }; |
| |
| WavReader under_test; |
| DiscardableSound sound; |
| zx_status_t status = under_test.Process(sound, test_data.data(), test_data.size()); |
| EXPECT_EQ(ZX_OK, status); |
| EXPECT_EQ(8u, sound.size()); |
| EXPECT_EQ(fuchsia::media::AudioSampleFormat::FLOAT, sound.stream_type().sample_format); |
| EXPECT_EQ(2u, sound.stream_type().channels); |
| EXPECT_EQ(44100u, sound.stream_type().frames_per_second); |
| auto& vmo = sound.LockForRead(); |
| EXPECT_TRUE(VmoMatches(vmo, test_data.data() + (test_data.size() - sound.size()), sound.size())); |
| sound.Unlock(); |
| } |
| |
| TEST(WavReaderTests, Restore) { |
| std::vector<uint8_t> test_data{ |
| 0x52, 0x49, 0x46, 0x46, // 'RIFF' |
| 0x00, 0x00, 0x00, 0x00, // RIFF chunk size (ignored) |
| 0x57, 0x41, 0x56, 0x45, // 'WAVE' |
| 0x66, 0x6d, 0x74, 0x20, // 'fmt ' |
| 0x10, 0x00, 0x00, 0x00, // fmt chunk size (16 bytes) |
| 0x01, 0x00, // encoding (1 = pcm) |
| 0x02, 0x00, // channel count (2) |
| 0x44, 0xac, 0x00, 0x00, // frames/second (44100) |
| 0x10, 0xb1, 0x02, 0x00, // byte rate (44100 * 4) |
| 0x04, 0x00, // block alignment (4) |
| 0x10, 0x00, // bits/sample (16) |
| 0x64, 0x61, 0x74, 0x61, // 'data' |
| 0x04, 0x00, 0x00, 0x00, // data chunk size (4) |
| 0x01, 0x02, 0x03, 0x04, // frames |
| }; |
| |
| WavReader under_test; |
| // |TestDiscardableSound| always restores on |LockForRead|. |
| TestDiscardableSound sound; |
| zx_status_t status = under_test.Process(sound, test_data.data(), test_data.size()); |
| EXPECT_EQ(ZX_OK, status); |
| EXPECT_EQ(4u, sound.size()); |
| EXPECT_EQ(fuchsia::media::AudioSampleFormat::SIGNED_16, sound.stream_type().sample_format); |
| EXPECT_EQ(2u, sound.stream_type().channels); |
| EXPECT_EQ(44100u, sound.stream_type().frames_per_second); |
| auto& vmo = sound.LockForRead(); |
| EXPECT_TRUE(VmoMatches(vmo, test_data.data() + (test_data.size() - sound.size()), sound.size())); |
| sound.Unlock(); |
| } |
| |
| } // namespace test |
| } // namespace soundplayer |
