oysteikt/mpd
0
0
Fork 0
Code Issues Pull Requests Releases Activity

pcm/*: use std::span instead of ConstBuffer

Browse Source
This commit is contained in:
Max Kellermann
2022-07-04 15:27:03 +02:00
parent d89136b09c
commit 4ce1dae673
58 changed files with 572 additions and 595 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
test/RunMixRampAnalyzer.cxx
View File

@@ -20,7 +20,6 @@
#include "ReadFrames.hxx"
#include "pcm/MixRampAnalyzer.hxx"
#include "io/FileDescriptor.hxx"
#include "util/ConstBuffer.hxx"
#include "util/PrintException.hxx"
#include <array>

1
test/RunReplayGainAnalyzer.cxx
View File

@@ -21,7 +21,6 @@
#include "pcm/ReplayGainAnalyzer.hxx"
#include "io/FileDescriptor.hxx"
#include "system/Error.hxx"
#include "util/ConstBuffer.hxx"
#include "util/PrintException.hxx"
#include <array>

9
test/run_convert.cxx
View File

@@ -30,7 +30,6 @@
#include "fs/Path.hxx"
#include "fs/NarrowPath.hxx"
#include "io/FileDescriptor.hxx"
#include "util/ConstBuffer.hxx"
#include "util/StaticFifoBuffer.hxx"
#include "util/OptionDef.hxx"
#include "util/OptionParser.hxx"
@@ -132,16 +131,16 @@ RunConvert(PcmConvert &convert, size_t in_frame_size,
buffer.Consume(src.size());
auto output = convert.Convert({src.data(), src.size()});
out_fd.FullWrite(output.data, output.size);
auto output = convert.Convert(src);
out_fd.FullWrite(output.data(), output.size());
}
while (true) {
auto output = convert.Flush();
if (output.IsNull())
if (output.data() == nullptr)
break;
out_fd.FullWrite(output.data, output.size);
out_fd.FullWrite(output.data(), output.size());
}
}

5
test/software_volume.cxx
View File

@@ -26,7 +26,6 @@
#include "pcm/Volume.hxx"
#include "pcm/AudioParser.hxx"
#include "pcm/AudioFormat.hxx"
#include "util/ConstBuffer.hxx"
#include "util/PrintException.hxx"
#include <stdio.h>
@@ -37,7 +36,7 @@
int
main(int argc, char **argv)
try {
static char buffer[4096];
static std::byte buffer[4096];
ssize_t nbytes;
if (argc > 2) {
@@ -58,7 +57,7 @@ try {
while ((nbytes = read(0, buffer, sizeof(buffer))) > 0) {
auto dest = pv.Apply({buffer, size_t(nbytes)});
[[maybe_unused]] ssize_t ignored = write(1, dest.data, dest.size);
[[maybe_unused]] ssize_t ignored = write(1, dest.data(), dest.size());
}
pv.Close();

37
test/test_pcm_channels.cxx
View File

@@ -20,7 +20,6 @@
#include "test_pcm_util.hxx"
#include "pcm/PcmChannels.hxx"
#include "pcm/Buffer.hxx"
#include "util/ConstBuffer.hxx"
#include <gtest/gtest.h>
@@ -33,18 +32,18 @@ TEST(PcmTest, Channels16)
/* stereo to mono */
auto dest = pcm_convert_channels_16(buffer, 1, 2, { src, N * 2 });
EXPECT_FALSE(dest.IsNull());
EXPECT_EQ(N, dest.size);
auto dest = pcm_convert_channels_16(buffer, 1, 2, src);
EXPECT_NE(dest.data(), nullptr);
EXPECT_EQ(N, dest.size());
for (unsigned i = 0; i < N; ++i)
EXPECT_EQ(int16_t((src[i * 2] + src[i * 2 + 1]) / 2),
dest[i]);
/* mono to stereo */
dest = pcm_convert_channels_16(buffer, 2, 1, { src, N * 2 });
EXPECT_FALSE(dest.IsNull());
EXPECT_EQ(N * 4, dest.size);
dest = pcm_convert_channels_16(buffer, 2, 1, src);
EXPECT_NE(dest.data(), nullptr);
EXPECT_EQ(N * 4, dest.size());
for (unsigned i = 0; i < N; ++i) {
EXPECT_EQ(src[i], dest[i * 2]);
EXPECT_EQ(src[i], dest[i * 2 + 1]);
@@ -52,9 +51,9 @@ TEST(PcmTest, Channels16)
/* stereo to 5.1 */
dest = pcm_convert_channels_16(buffer, 6, 2, { src, N * 2 });
EXPECT_FALSE(dest.IsNull());
EXPECT_EQ(N * 6, dest.size);
dest = pcm_convert_channels_16(buffer, 6, 2, src);
EXPECT_NE(dest.data(), nullptr);
EXPECT_EQ(N * 6, dest.size());
constexpr int16_t silence = 0;
for (unsigned i = 0; i < N; ++i) {
EXPECT_EQ(src[i * 2], dest[i * 6]);
@@ -75,18 +74,18 @@ TEST(PcmTest, Channels32)
/* stereo to mono */
auto dest = pcm_convert_channels_32(buffer, 1, 2, { src, N * 2 });
EXPECT_FALSE(dest.IsNull());
EXPECT_EQ(N, dest.size);
auto dest = pcm_convert_channels_32(buffer, 1, 2, src);
EXPECT_NE(dest.data(), nullptr);
EXPECT_EQ(N, dest.size());
for (unsigned i = 0; i < N; ++i)
EXPECT_EQ(int32_t(((int64_t)src[i * 2] + (int64_t)src[i * 2 + 1]) / 2),
dest[i]);
/* mono to stereo */
dest = pcm_convert_channels_32(buffer, 2, 1, { src, N * 2 });
EXPECT_FALSE(dest.IsNull());
EXPECT_EQ(N * 4, dest.size);
dest = pcm_convert_channels_32(buffer, 2, 1, src);
EXPECT_NE(dest.data(), nullptr);
EXPECT_EQ(N * 4, dest.size());
for (unsigned i = 0; i < N; ++i) {
EXPECT_EQ(src[i], dest[i * 2]);
EXPECT_EQ(src[i], dest[i * 2 + 1]);
@@ -94,9 +93,9 @@ TEST(PcmTest, Channels32)
/* stereo to 5.1 */
dest = pcm_convert_channels_32(buffer, 6, 2, { src, N * 2 });
EXPECT_FALSE(dest.IsNull());
EXPECT_EQ(N * 6, dest.size);
dest = pcm_convert_channels_32(buffer, 6, 2, src);
EXPECT_NE(dest.data(), nullptr);
EXPECT_EQ(N * 6, dest.size());
constexpr int32_t silence = 0;
for (unsigned i = 0; i < N; ++i) {
EXPECT_EQ(src[i * 2], dest[i * 6]);

139
test/test_pcm_export.cxx
View File

@@ -21,7 +21,6 @@
#include "pcm/Export.hxx"
#include "pcm/Traits.hxx"
#include "util/ByteOrder.hxx"
#include "util/ConstBuffer.hxx"
#include <gtest/gtest.h>
@@ -46,14 +45,14 @@ TEST(PcmTest, ExportShift8)
EXPECT_EQ(e.GetInputBlockSize(), 8u);
EXPECT_EQ(e.GetOutputBlockSize(), 8u);
auto dest = e.Export({src, sizeof(src)});
EXPECT_EQ(sizeof(expected), dest.size);
EXPECT_TRUE(memcmp(dest.data, expected, dest.size) == 0);
auto dest = e.Export(std::as_bytes(std::span{src}));
EXPECT_EQ(sizeof(expected), dest.size());
EXPECT_TRUE(memcmp(dest.data(), expected, dest.size()) == 0);
const auto silence = e.GetSilence();
constexpr uint8_t expected_silence[8]{};
EXPECT_EQ(silence.size, sizeof(expected_silence));
EXPECT_EQ(memcmp(silence.data, expected_silence,
EXPECT_EQ(silence.size(), sizeof(expected_silence));
EXPECT_EQ(memcmp(silence.data(), expected_silence,
sizeof(expected_silence)), 0);
}
@@ -95,14 +94,14 @@ TEST(PcmTest, ExportPack24)
EXPECT_EQ(e.GetInputBlockSize(), 8u);
EXPECT_EQ(e.GetOutputBlockSize(), 6u);
auto dest = e.Export({src, sizeof(src)});
EXPECT_EQ(expected_size, dest.size);
EXPECT_TRUE(memcmp(dest.data, expected, dest.size) == 0);
auto dest = e.Export(std::as_bytes(std::span{src}));
EXPECT_EQ(expected_size, dest.size());
EXPECT_TRUE(memcmp(dest.data(), expected, dest.size()) == 0);
const auto silence = e.GetSilence();
constexpr uint8_t expected_silence[6]{};
EXPECT_EQ(silence.size, sizeof(expected_silence));
EXPECT_EQ(memcmp(silence.data, expected_silence,
EXPECT_EQ(silence.size(), sizeof(expected_silence));
EXPECT_EQ(memcmp(silence.data(), expected_silence,
sizeof(expected_silence)), 0);
}
@@ -134,9 +133,9 @@ TEST(PcmTest, ExportReverseEndian)
EXPECT_EQ(e.GetInputBlockSize(), 2u);
EXPECT_EQ(e.GetOutputBlockSize(), 2u);
auto dest = e.Export({src, sizeof(src)});
EXPECT_EQ(sizeof(src), dest.size);
EXPECT_TRUE(memcmp(dest.data, src, dest.size) == 0);
auto dest = e.Export(std::as_bytes(std::span{src}));
EXPECT_EQ(sizeof(src), dest.size());
EXPECT_TRUE(memcmp(dest.data(), src, dest.size()) == 0);
e.Open(SampleFormat::S16, 2, params);
@@ -145,9 +144,9 @@ TEST(PcmTest, ExportReverseEndian)
EXPECT_EQ(e.GetInputBlockSize(), 4u);
EXPECT_EQ(e.GetOutputBlockSize(), 4u);
dest = e.Export({src, sizeof(src)});
EXPECT_EQ(sizeof(expected2), dest.size);
EXPECT_TRUE(memcmp(dest.data, expected2, dest.size) == 0);
dest = e.Export(std::as_bytes(std::span{src}));
EXPECT_EQ(sizeof(expected2), dest.size());
EXPECT_TRUE(memcmp(dest.data(), expected2, dest.size()) == 0);
e.Open(SampleFormat::S32, 2, params);
@@ -156,14 +155,14 @@ TEST(PcmTest, ExportReverseEndian)
EXPECT_EQ(e.GetInputBlockSize(), 8u);
EXPECT_EQ(e.GetOutputBlockSize(), 8u);
dest = e.Export({src, sizeof(src)});
EXPECT_EQ(sizeof(expected4), dest.size);
EXPECT_TRUE(memcmp(dest.data, expected4, dest.size) == 0);
dest = e.Export(std::as_bytes(std::span{src}));
EXPECT_EQ(sizeof(expected4), dest.size());
EXPECT_TRUE(memcmp(dest.data(), expected4, dest.size()) == 0);
const auto silence = e.GetSilence();
constexpr uint8_t expected_silence[8]{};
EXPECT_EQ(silence.size, sizeof(expected_silence));
EXPECT_EQ(memcmp(silence.data, expected_silence,
EXPECT_EQ(silence.size(), sizeof(expected_silence));
EXPECT_EQ(memcmp(silence.data(), expected_silence,
sizeof(expected_silence)), 0);
}
@@ -199,33 +198,33 @@ TEST(PcmTest, ExportDsdU16)
EXPECT_EQ(e.GetInputBlockSize(), 4u);
EXPECT_EQ(e.GetOutputBlockSize(), 4u);
auto dest = e.Export({src, sizeof(src)});
EXPECT_EQ(sizeof(expected), dest.size);
EXPECT_TRUE(memcmp(dest.data, expected, dest.size) == 0);
auto dest = e.Export(std::as_bytes(std::span{src}));
EXPECT_EQ(sizeof(expected), dest.size());
EXPECT_TRUE(memcmp(dest.data(), expected, dest.size()) == 0);
/* no output, 2/4 remains */
static constexpr uint8_t src2[] = { 0x11, 0x22 };
dest = e.Export({src2, sizeof(src2)});
dest = e.Export(std::as_bytes(std::span{src2}));
EXPECT_TRUE(dest.empty());
/* one full frame and 2/4 remains */
static constexpr uint8_t src3[] = { 0x33, 0x44, 0x55, 0x66 };
static constexpr uint16_t expected3[] = { 0x1133, 0x2244 };
dest = e.Export({src3, sizeof(src3)});
EXPECT_EQ(sizeof(expected3), dest.size);
EXPECT_TRUE(memcmp(dest.data, expected3, dest.size) == 0);
dest = e.Export(std::as_bytes(std::span{src3}));
EXPECT_EQ(sizeof(expected3), dest.size());
EXPECT_TRUE(memcmp(dest.data(), expected3, dest.size()) == 0);
/* two full frames and 2/4 remains again */
static constexpr uint8_t src4[] = { 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee };
static constexpr uint16_t expected4[] = { 0x5577, 0x6688, 0x99bb, 0xaacc };
dest = e.Export({src4, sizeof(src4)});
EXPECT_EQ(sizeof(expected4), dest.size);
EXPECT_TRUE(memcmp(dest.data, expected4, dest.size) == 0);
dest = e.Export(std::as_bytes(std::span{src4}));
EXPECT_EQ(sizeof(expected4), dest.size());
EXPECT_TRUE(memcmp(dest.data(), expected4, dest.size()) == 0);
const auto silence = e.GetSilence();
constexpr uint8_t expected_silence[]{0x69, 0x69, 0x69, 0x69};
EXPECT_EQ(silence.size, sizeof(expected_silence));
EXPECT_EQ(memcmp(silence.data, expected_silence,
EXPECT_EQ(silence.size(), sizeof(expected_silence));
EXPECT_EQ(memcmp(silence.data(), expected_silence,
sizeof(expected_silence)), 0);
}
@@ -259,33 +258,33 @@ TEST(PcmTest, ExportDsdU32)
EXPECT_EQ(e.GetInputBlockSize(), 8u);
EXPECT_EQ(e.GetOutputBlockSize(), 8u);
auto dest = e.Export({src, sizeof(src)});
EXPECT_EQ(sizeof(expected), dest.size);
EXPECT_TRUE(memcmp(dest.data, expected, dest.size) == 0);
auto dest = e.Export(std::as_bytes(std::span{src}));
EXPECT_EQ(sizeof(expected), dest.size());
EXPECT_TRUE(memcmp(dest.data(), expected, dest.size()) == 0);
/* no output, 4/8 remains */
static constexpr uint8_t src2[] = { 0x11, 0x22, 0x33, 0x44 };
dest = e.Export({src2, sizeof(src2)});
dest = e.Export(std::as_bytes(std::span{src2}));
EXPECT_TRUE(dest.empty());
/* one full frame and 4/8 remains */
static constexpr uint8_t src3[] = { 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc };
static constexpr uint32_t expected3[] = { 0x11335577, 0x22446688 };
dest = e.Export({src3, sizeof(src3)});
EXPECT_EQ(sizeof(expected3), dest.size);
EXPECT_TRUE(memcmp(dest.data, expected3, dest.size) == 0);
dest = e.Export(std::as_bytes(std::span{src3}));
EXPECT_EQ(sizeof(expected3), dest.size());
EXPECT_TRUE(memcmp(dest.data(), expected3, dest.size()) == 0);
/* two full frames and 2/4 remains again */
static constexpr uint8_t src4[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
static constexpr uint32_t expected4[] = { 0x99bb0103, 0xaacc0204 };
dest = e.Export({src4, sizeof(src4)});
EXPECT_EQ(sizeof(expected4), dest.size);
EXPECT_TRUE(memcmp(dest.data, expected4, dest.size) == 0);
dest = e.Export(std::as_bytes(std::span{src4}));
EXPECT_EQ(sizeof(expected4), dest.size());
EXPECT_TRUE(memcmp(dest.data(), expected4, dest.size()) == 0);
const auto silence = e.GetSilence();
constexpr uint8_t expected_silence[]{0x69, 0x69, 0x69, 0x69, 0x69, 0x69, 0x69, 0x69};
EXPECT_EQ(silence.size, sizeof(expected_silence));
EXPECT_EQ(memcmp(silence.data, expected_silence,
EXPECT_EQ(silence.size(), sizeof(expected_silence));
EXPECT_EQ(memcmp(silence.data(), expected_silence,
sizeof(expected_silence)), 0);
}
@@ -317,43 +316,43 @@ TEST(PcmTest, ExportDop)
EXPECT_EQ(e.GetInputBlockSize(), 8u);
EXPECT_EQ(e.GetOutputBlockSize(), 16u);
auto dest = e.Export({src, sizeof(src)});
EXPECT_EQ(sizeof(expected), dest.size);
EXPECT_TRUE(memcmp(dest.data, expected, dest.size) == 0);
auto dest = e.Export(std::as_bytes(std::span{src}));
EXPECT_EQ(sizeof(expected), dest.size());
EXPECT_TRUE(memcmp(dest.data(), expected, dest.size()) == 0);
/* not enough data: 2/8 */
static constexpr uint8_t src2[] = { 0x12, 0x34 };
dest = e.Export({src2, sizeof(src2)});
ASSERT_EQ(dest.size, 0u);
dest = e.Export(std::as_bytes(std::span{src2}));
ASSERT_EQ(dest.size(), 0u);
/* not enough data: 6/8 */
static constexpr uint8_t src3[] = { 0x56, 0x78, 0x9a, 0xbc };
dest = e.Export({src3, sizeof(src3)});
ASSERT_EQ(dest.size, 0u);
dest = e.Export(std::as_bytes(std::span{src3}));
ASSERT_EQ(dest.size(), 0u);
/* just enough data: 8/8 */
static constexpr uint8_t src4[] = { 0xde, 0xf0 };
static constexpr uint32_t expected4[] = { 0xff051256, 0xff053478, 0xfffa9ade, 0xfffabcf0 };
dest = e.Export({src4, sizeof(src4)});
ASSERT_EQ(sizeof(expected4), dest.size);
ASSERT_TRUE(memcmp(dest.data, expected4, dest.size) == 0);
dest = e.Export(std::as_bytes(std::span{src4}));
ASSERT_EQ(sizeof(expected4), dest.size());
ASSERT_TRUE(memcmp(dest.data(), expected4, dest.size()) == 0);
/* not enough data: 6/8 */
static constexpr uint8_t src5[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 };
dest = e.Export({src5, sizeof(src5)});
dest = e.Export(std::as_bytes(std::span{src5}));
ASSERT_TRUE(dest.empty());
/* two quads returned, not enough data for more: 2/8 */
static constexpr uint8_t src6[] = { 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x00, 0x10, 0x20 };
static constexpr uint32_t expected6[] = { 0xff051133, 0xff052244, 0xfffa5577, 0xfffa6688, 0xff0599bb, 0xff05aacc, 0xfffaddff, 0xfffaee00 };
dest = e.Export({src6, sizeof(src6)});
ASSERT_EQ(sizeof(expected6), dest.size);
ASSERT_TRUE(memcmp(dest.data, expected6, dest.size) == 0);
dest = e.Export(std::as_bytes(std::span{src6}));
ASSERT_EQ(sizeof(expected6), dest.size());
ASSERT_TRUE(memcmp(dest.data(), expected6, dest.size()) == 0);
const auto silence = e.GetSilence();
constexpr uint32_t expected_silence[]{0xff056969, 0xff056969, 0xfffa6969, 0xfffa6969};
EXPECT_EQ(silence.size, sizeof(expected_silence));
EXPECT_EQ(memcmp(silence.data, expected_silence,
EXPECT_EQ(silence.size(), sizeof(expected_silence));
EXPECT_EQ(memcmp(silence.data(), expected_silence,
sizeof(expected_silence)), 0);
}
@@ -384,9 +383,9 @@ TestAlsaChannelOrder51()
PcmExport e;
e.Open(F, 6, params);
auto dest = e.Export({src, sizeof(src)});
EXPECT_EQ(sizeof(expected), dest.size);
EXPECT_TRUE(memcmp(dest.data, expected, dest.size) == 0);
auto dest = e.Export(std::as_bytes(std::span{src}));
EXPECT_EQ(sizeof(expected), dest.size());
EXPECT_TRUE(memcmp(dest.data(), expected, dest.size()) == 0);
}
template<SampleFormat F, class Traits=SampleTraits<F>>
@@ -414,14 +413,14 @@ TestAlsaChannelOrder71()
PcmExport e;
e.Open(F, 8, params);
auto dest = e.Export({src, sizeof(src)});
EXPECT_EQ(sizeof(expected), dest.size);
EXPECT_TRUE(memcmp(dest.data, expected, dest.size) == 0);
auto dest = e.Export(std::as_bytes(std::span{src}));
EXPECT_EQ(sizeof(expected), dest.size());
EXPECT_TRUE(memcmp(dest.data(), expected, dest.size()) == 0);
const auto silence = e.GetSilence();
constexpr value_type expected_silence[8]{};
EXPECT_EQ(silence.size, sizeof(expected_silence));
EXPECT_EQ(memcmp(silence.data, expected_silence,
EXPECT_EQ(silence.size(), sizeof(expected_silence));
EXPECT_EQ(memcmp(silence.data(), expected_silence,
sizeof(expected_silence)), 0);
}

34
test/test_pcm_format.cxx
View File

@@ -34,7 +34,7 @@ TEST(PcmTest, Format8To16)
PcmDither dither;
auto d = pcm_convert_to_16(buffer, dither, SampleFormat::S8, src);
EXPECT_EQ(N, d.size);
EXPECT_EQ(N, d.size());
for (size_t i = 0; i < N; ++i)
EXPECT_EQ(int(src[i]), d[i] >> 8);
@@ -48,7 +48,7 @@ TEST(PcmTest, Format16To24)
PcmBuffer buffer;
auto d = pcm_convert_to_24(buffer, SampleFormat::S16, src);
EXPECT_EQ(N, d.size);
EXPECT_EQ(N, d.size());
for (size_t i = 0; i < N; ++i)
EXPECT_EQ(int(src[i]), d[i] >> 8);
@@ -62,7 +62,7 @@ TEST(PcmTest, Format16To32)
PcmBuffer buffer;
auto d = pcm_convert_to_32(buffer, SampleFormat::S16, src);
EXPECT_EQ(N, d.size);
EXPECT_EQ(N, d.size());
for (size_t i = 0; i < N; ++i)
EXPECT_EQ(int(src[i]), d[i] >> 16);
@@ -76,9 +76,9 @@ TEST(PcmTest, FormatFloat16)
PcmBuffer buffer1, buffer2;
auto f = pcm_convert_to_float(buffer1, SampleFormat::S16, src);
EXPECT_EQ(N, f.size);
EXPECT_EQ(N, f.size());
for (size_t i = 0; i != f.size; ++i) {
for (size_t i = 0; i != f.size(); ++i) {
EXPECT_GE(f[i], -1.f);
EXPECT_LE(f[i], 1.f);
}
@@ -87,14 +87,14 @@ TEST(PcmTest, FormatFloat16)
auto d = pcm_convert_to_16(buffer2, dither,
SampleFormat::FLOAT,
f.ToVoid());
EXPECT_EQ(N, d.size);
std::as_bytes(f));
EXPECT_EQ(N, d.size());
for (size_t i = 0; i < N; ++i)
EXPECT_EQ(src[i], d[i]);
/* check if clamping works */
auto *writable = const_cast<float *>(f.data);
auto *writable = const_cast<float *>(f.data());
*writable++ = 1.01;
*writable++ = 10;
*writable++ = -1.01;
@@ -102,8 +102,8 @@ TEST(PcmTest, FormatFloat16)
d = pcm_convert_to_16(buffer2, dither,
SampleFormat::FLOAT,
f.ToVoid());
EXPECT_EQ(N, d.size);
std::as_bytes(f));
EXPECT_EQ(N, d.size());
EXPECT_EQ(32767, int(d[0]));
EXPECT_EQ(32767, int(d[1]));
@@ -122,17 +122,17 @@ TEST(PcmTest, FormatFloat32)
PcmBuffer buffer1, buffer2;
auto f = pcm_convert_to_float(buffer1, SampleFormat::S32, src);
EXPECT_EQ(N, f.size);
EXPECT_EQ(N, f.size());
for (size_t i = 0; i != f.size; ++i) {
for (size_t i = 0; i != f.size(); ++i) {
EXPECT_GE(f[i], -1.f);
EXPECT_LE(f[i], 1.f);
}
auto d = pcm_convert_to_32(buffer2,
SampleFormat::FLOAT,
f.ToVoid());
EXPECT_EQ(N, d.size);
std::as_bytes(f));
EXPECT_EQ(N, d.size());
constexpr int error = 64;
@@ -140,7 +140,7 @@ TEST(PcmTest, FormatFloat32)
EXPECT_NEAR(src[i], d[i], error);
/* check if clamping works */
auto *writable = const_cast<float *>(f.data);
auto *writable = const_cast<float *>(f.data());
*writable++ = 1.01;
*writable++ = 10;
*writable++ = -1.01;
@@ -148,8 +148,8 @@ TEST(PcmTest, FormatFloat32)
d = pcm_convert_to_32(buffer2,
SampleFormat::FLOAT,
f.ToVoid());
EXPECT_EQ(N, d.size);
std::as_bytes(f));
EXPECT_EQ(N, d.size());
EXPECT_EQ(2147483647, int(d[0]));
EXPECT_EQ(2147483647, int(d[1]));

12
test/test_pcm_interleave.cxx
View File

@@ -35,8 +35,10 @@ TestInterleaveN()
static constexpr size_t n_frames = std::size(src1);
static constexpr unsigned channels = std::size(src_all);
static const ConstBuffer<const void *> src((const void *const*)src_all,
channels);
static const std::span<const void *const> src{
(const void *const*)src_all,
channels,
};
static constexpr T poison = T(0xdeadbeef);
T dest[n_frames * channels + 1];
@@ -77,8 +79,10 @@ TEST(PcmTest, Interleave24)
static constexpr size_t n_frames = std::size(src1) / 3;
static constexpr unsigned channels = std::size(src_all);
static const ConstBuffer<const void *> src((const void *const*)src_all,
channels);
static const std::span<const void *const> src{
(const void *const*)src_all,
channels,
};
static constexpr T poison = 0xff;
T dest[n_frames * channels * 3 + 1];

9
test/test_pcm_util.hxx
View File

@@ -17,12 +17,11 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "util/ConstBuffer.hxx"
#include <gtest/gtest.h>
#include <array>
#include <random>
#include <span>
#include <stddef.h>
#include <stdint.h>
@@ -81,12 +80,12 @@ public:
return begin();
}
operator ConstBuffer<T>() const {
operator std::span<const T>() const {
return { begin(), size() };
}
operator ConstBuffer<void>() const {
return { begin(), size() * sizeof(T) };
operator std::span<const std::byte>() const {
return { (const std::byte *)begin(), size() * sizeof(T) };
}
};

48
test/test_pcm_volume.cxx
View File

@@ -19,7 +19,7 @@
#include "pcm/Volume.hxx"
#include "pcm/Traits.hxx"
#include "util/ConstBuffer.hxx"
#include "util/SpanCast.hxx"
#include "test_pcm_util.hxx"
#include <gtest/gtest.h>
@@ -41,23 +41,23 @@ TestVolume(G g=G())
constexpr size_t N = 509;
static value_type zero[N];
const auto _src = TestDataBuffer<value_type, N>(g);
const ConstBuffer<void> src(_src, sizeof(_src));
const std::span<const std::byte> src = _src;
pv.SetVolume(0);
auto dest = pv.Apply(src);
EXPECT_EQ(src.size, dest.size);
EXPECT_EQ(0, memcmp(dest.data, zero, sizeof(zero)));
EXPECT_EQ(src.size(), dest.size());
EXPECT_EQ(0, memcmp(dest.data(), zero, sizeof(zero)));
pv.SetVolume(PCM_VOLUME_1);
dest = pv.Apply(src);
EXPECT_EQ(src.size, dest.size);
EXPECT_EQ(0, memcmp(dest.data, src.data, src.size));
EXPECT_EQ(src.size(), dest.size());
EXPECT_EQ(0, memcmp(dest.data(), src.data(), src.size()));
pv.SetVolume(PCM_VOLUME_1 / 2);
dest = pv.Apply(src);
EXPECT_EQ(src.size, dest.size);
EXPECT_EQ(src.size(), dest.size());
const auto _dest = ConstBuffer<value_type>::FromVoid(dest);
const auto _dest = FromBytesStrict<const value_type>(dest);
for (unsigned i = 0; i < N; ++i) {
const auto expected = (_src[i] + 1) / 2;
EXPECT_GE(_dest[i], expected - 4);
@@ -89,27 +89,27 @@ TEST(PcmTest, Volume16to32)
constexpr size_t N = 509;
static value_type zero[N];
const auto _src = TestDataBuffer<value_type, N>(g);
const ConstBuffer<void> src(_src, sizeof(_src));
const std::span<const std::byte> src = _src;
pv.SetVolume(0);
auto dest = pv.Apply(src);
EXPECT_EQ(src.size * 2, dest.size);
EXPECT_EQ(0, memcmp(dest.data, zero, sizeof(zero)));
EXPECT_EQ(src.size() * 2, dest.size());
EXPECT_EQ(0, memcmp(dest.data(), zero, sizeof(zero)));
pv.SetVolume(PCM_VOLUME_1);
dest = pv.Apply(src);
EXPECT_EQ(src.size * 2, dest.size);
auto s = ConstBuffer<int16_t>::FromVoid(src);
auto d = ConstBuffer<int32_t>::FromVoid(dest);
EXPECT_EQ(src.size() * 2, dest.size());
auto s = FromBytesStrict<const int16_t>(src);
auto d = FromBytesStrict<const int32_t>(dest);
for (size_t i = 0; i < N; ++i)
EXPECT_EQ(d[i], s[i] << 8);
pv.SetVolume(PCM_VOLUME_1 / 2);
dest = pv.Apply(src);
EXPECT_EQ(src.size * 2, dest.size);
EXPECT_EQ(src.size() * 2, dest.size());
s = ConstBuffer<int16_t>::FromVoid(src);
d = ConstBuffer<int32_t>::FromVoid(dest);
s = FromBytesStrict<const int16_t>(src);
d = FromBytesStrict<const int32_t>(dest);
for (unsigned i = 0; i < N; ++i) {
const int32_t expected = (s[i] << 8) / 2;
EXPECT_EQ(d[i], expected);
@@ -136,23 +136,23 @@ TEST(PcmTest, VolumeFloat)
constexpr size_t N = 509;
static float zero[N];
const auto _src = TestDataBuffer<float, N>(RandomFloat());
const ConstBuffer<void> src(_src, sizeof(_src));
const std::span<const std::byte> src = _src;
pv.SetVolume(0);
auto dest = pv.Apply(src);
EXPECT_EQ(src.size, dest.size);
EXPECT_EQ(0, memcmp(dest.data, zero, sizeof(zero)));
EXPECT_EQ(src.size(), dest.size());
EXPECT_EQ(0, memcmp(dest.data(), zero, sizeof(zero)));
pv.SetVolume(PCM_VOLUME_1);
dest = pv.Apply(src);
EXPECT_EQ(src.size, dest.size);
EXPECT_EQ(0, memcmp(dest.data, src.data, src.size));
EXPECT_EQ(src.size(), dest.size());
EXPECT_EQ(0, memcmp(dest.data(), src.data(), src.size()));
pv.SetVolume(PCM_VOLUME_1 / 2);
dest = pv.Apply(src);
EXPECT_EQ(src.size, dest.size);
EXPECT_EQ(src.size(), dest.size());
const auto _dest = ConstBuffer<float>::FromVoid(dest);
const auto _dest = FromBytesStrict<const float>(dest);
for (unsigned i = 0; i < N; ++i)
EXPECT_NEAR((double)_src[i] / 2., (double)_dest[i], 1.);