// Standalone tests for reasampler::wav_trim — no REAPER, no test framework. // Builds synthetic 32-bit-float WAV byte buffers, asserts the parse geometry, the // float extraction, and the truncate-plan arithmetic (the header size-field patch). // // Covers: canonical stereo/mono 32-bit-float parse; a leading unknown chunk skipped; // format rejection (16-bit PCM, non-WAV, data-before-fmt, truncated data); frame // extraction (whole / tail window / clamp / out-of-range); truncate plan (kept #include #include #include using namespace reasampler; using namespace reasampler::capture; static int g_fail = 0; #define CHECK(cond) do { if(!(cond)) { \ std::printf("FAIL line %d: %s\n", __LINE__, #cond); ++g_fail; } } while(0) // --- Synthetic WAV builder --------------------------------------------------- static void putU16(std::vector& b, std::uint16_t v) { b.push_back(static_cast(v & 0xFF)); b.push_back(static_cast((v >> 8) & 0xFF)); } static void putU32(std::vector& b, std::uint32_t v) { b.push_back(static_cast(v & 0xFF)); b.push_back(static_cast((v >> 8) & 0xFF)); b.push_back(static_cast((v >> 16) & 0xFF)); b.push_back(static_cast((v >> 24) & 0xFF)); } static void putTag(std::vector& b, const char* t) { for (int i = 0; i < 4; ++i) b.push_back(static_cast(t[i])); } static void putFloat(std::vector& b, float f) { std::uint8_t tmp[4]; std::memcpy(tmp, &f, 4); for (int i = 0; i < 4; ++i) b.push_back(tmp[i]); } // A canonical 32-bit-float WAV: RIFF/WAVE, fmt (tag 3, 16-byte body), data holding // `frames` interleaved frames of `channels`. `leadingJunk` optionally inserts an // unknown chunk before fmt to exercise the chunk walk. Samples: frame f, channel c // = value(f,c). template static std::vector buildFloatWav(std::uint16_t channels, std::uint32_t sampleRate, std::size_t frames, Fn value, bool leadingJunk = false, std::uint16_t fmtTag = 3, std::uint16_t bits = 32) { const std::uint32_t dataBytes = static_cast(frames * channels * (bits / 8)); std::vector chunks; // everything after "WAVE" if (leadingJunk) { putTag(chunks, "LIST"); putU32(chunks, 4); putTag(chunks, "INFO"); // 4-byte body, even -> no pad } // fmt chunk (16-byte body). putTag(chunks, "fmt "); putU32(chunks, 16); putU16(chunks, fmtTag); // format tag putU16(chunks, channels); putU32(chunks, sampleRate); const std::uint32_t byteRate = sampleRate * channels * (bits / 8); putU32(chunks, byteRate); putU16(chunks, static_cast(channels * (bits / 8))); // block align putU16(chunks, bits); // data chunk. putTag(chunks, "data"); putU32(chunks, dataBytes); for (std::size_t f = 0; f < frames; ++f) for (std::uint16_t c = 0; c < channels; ++c) putFloat(chunks, value(f, c)); std::vector wav; putTag(wav, "RIFF"); putU32(wav, static_cast(4 + chunks.size())); // "WAVE" + chunks putTag(wav, "WAVE"); wav.insert(wav.end(), chunks.begin(), chunks.end()); return wav; } // Builds a WAVE_FORMAT_EXTENSIBLE (0xFFFE) WAV with a 40-byte fmt body. // `subFormatTag` is the 2-byte leading tag embedded in the SubFormat GUID: // 0x0003 = IEEE float, 0x0001 = PCM integer (and any other value to exercise rejection). // bitsPerSample and the PCM data are always 32-bit float bytes regardless of subFormatTag // (we're testing that the parser correctly rejects/accepts based on the GUID, not the data). template static std::vector buildExtensibleWav(std::uint16_t channels, std::uint32_t sampleRate, std::size_t frames, Fn value, std::uint16_t subFormatTag) { const std::uint32_t dataBytes = static_cast(frames * channels * 4u); // WAVEFORMATEXTENSIBLE fmt body (40 bytes): // [0..1] wFormatTag = 0xFFFE // [2..3] nChannels // [4..7] nSamplesPerSec // [8..11] nAvgBytesPerSec // [12..13] nBlockAlign // [14..15] wBitsPerSample = 32 // [16..17] cbSize = 22 (extension size beyond the 18-byte WAVEFORMATEX) // [18..19] wValidBitsPerSample = 32 // [20..23] dwChannelMask = 0 // [24..39] SubFormat GUID: first 2 bytes = subFormatTag (LE), rest = standard // KSDATAFORMAT_SUBTYPE base GUID {00000000-0000-0010-8000-00aa00389b71} std::vector fmt; putU16(fmt, 0xFFFE); // wFormatTag putU16(fmt, channels); // nChannels putU32(fmt, sampleRate); // nSamplesPerSec putU32(fmt, sampleRate * channels * 4u); // nAvgBytesPerSec putU16(fmt, static_cast(channels * 4)); // nBlockAlign putU16(fmt, 32); // wBitsPerSample putU16(fmt, 22); // cbSize putU16(fmt, 32); // wValidBitsPerSample putU32(fmt, 0); // dwChannelMask // SubFormat GUID (16 bytes): [subFormatTag, 0x0000, 0x00, 0x00, 0x10, 0x00, // 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71] putU16(fmt, subFormatTag); // bytes [24..25]: the effective format tag putU16(fmt, 0x0000); // bytes [26..27] fmt.push_back(0x00); fmt.push_back(0x00); // bytes [28..29] fmt.push_back(0x10); fmt.push_back(0x00); // bytes [30..31] fmt.push_back(0x80); fmt.push_back(0x00); // bytes [32..33] fmt.push_back(0x00); fmt.push_back(0xaa); // bytes [34..35] fmt.push_back(0x00); fmt.push_back(0x38); // bytes [36..37] fmt.push_back(0x9b); fmt.push_back(0x71); // bytes [38..39] std::vector chunks; putTag(chunks, "fmt "); putU32(chunks, static_cast(fmt.size())); // 40 chunks.insert(chunks.end(), fmt.begin(), fmt.end()); putTag(chunks, "data"); putU32(chunks, dataBytes); for (std::size_t f = 0; f < frames; ++f) for (std::uint16_t c = 0; c < channels; ++c) putFloat(chunks, value(f, c)); std::vector wav; putTag(wav, "RIFF"); putU32(wav, static_cast(4 + chunks.size())); putTag(wav, "WAVE"); wav.insert(wav.end(), chunks.begin(), chunks.end()); return wav; } // --- Parse tests ------------------------------------------------------------- static void testParseCanonicalStereo() { auto wav = buildFloatWav(2, 48000, 5, [](std::size_t f, std::uint16_t c) { return static_cast(f) + 0.1f * c; }); WavLayout L = parseWavLayout(wav); CHECK(L.valid); CHECK(L.channelCount == 2); CHECK(L.sampleRate == 48000); CHECK(L.dataByteLength == 5 * 2 * 4); CHECK(L.frameCount() == 5); // data body sits after RIFF(12) + fmt(8 header + 16 body) + data(8 header) = 44. CHECK(L.dataByteOffset == 44); CHECK(L.dataSizeFieldOffset == 40); // the 4 bytes before dataByteOffset CHECK(L.riffSizeFieldOffset == 4); } static void testParseMonoAndLeadingChunk() { // A leading LIST/INFO chunk before fmt must be skipped by the walk. auto wav = buildFloatWav(1, 44100, 3, [](std::size_t f, std::uint16_t) { return static_cast(f); }, /*leadingJunk=*/true); WavLayout L = parseWavLayout(wav); CHECK(L.valid); CHECK(L.channelCount == 1); CHECK(L.frameCount() == 3); // Data still parses correctly despite the leading chunk shifting its offset. auto pcm = extractFloatFrames(wav, L, 0, 3); CHECK(pcm.size() == 3); CHECK(pcm[0] == 0.0f && pcm[1] == 1.0f && pcm[2] == 2.0f); } static void testParseRejectsNon32BitAndNonWav() { // 16-bit PCM (tag 1, bits 16) -> rejected. auto pcm16 = buildFloatWav(2, 48000, 4, [](std::size_t, std::uint16_t) { return 0.0f; }, false, /*fmtTag=*/1, /*bits=*/16); CHECK(!parseWavLayout(pcm16).valid); // Not a RIFF file. std::vector junk = {'N','O','P','E', 0,0,0,0, 'W','A','V','E'}; CHECK(!parseWavLayout(junk).valid); // Too short to hold even the RIFF header. std::vector tiny = {'R','I','F','F'}; CHECK(!parseWavLayout(tiny).valid); } static void testParseRejectsLyingDataLength() { // Build a valid WAV, then inflate the `data` size field so it claims more bytes // than the buffer holds -> must be rejected (no OOB trust). auto wav = buildFloatWav(2, 48000, 4, [](std::size_t, std::uint16_t) { return 1.0f; }); WavLayout good = parseWavLayout(wav); CHECK(good.valid); // Overwrite the data size field with a huge value. wav[good.dataSizeFieldOffset + 0] = 0xFF; wav[good.dataSizeFieldOffset + 1] = 0xFF; wav[good.dataSizeFieldOffset + 2] = 0xFF; wav[good.dataSizeFieldOffset + 3] = 0x7F; CHECK(!parseWavLayout(wav).valid); } // --- Extraction tests -------------------------------------------------------- static void testExtractTailWindow() { // Stereo, 10 frames. Sample value encodes frame+channel so a mis-index is caught. auto wav = buildFloatWav(2, 48000, 10, [](std::size_t f, std::uint16_t c) { return static_cast(f) * 10.0f + c; }); WavLayout L = parseWavLayout(wav); CHECK(L.valid); // The "tail region" the realtime trim scans: frames 6..9 (start at frame 6). auto tail = extractFloatFrames(wav, L, 6, 100 /*clamps*/); CHECK(tail.size() == 4 * 2); // frames 6,7,8,9, 2 channels each CHECK(tail[0] == 60.0f && tail[1] == 61.0f); // frame 6: L=60,R=61 CHECK(tail[6] == 90.0f && tail[7] == 91.0f); // frame 9: L=90,R=91 // Out-of-range start -> empty. CHECK(extractFloatFrames(wav, L, 10, 4).empty()); CHECK(extractFloatFrames(wav, L, 99, 4).empty()); } // --- Truncate-plan tests ----------------------------------------------------- static void testTruncatePlanKeepFewer() { auto wav = buildFloatWav(2, 48000, 10, [](std::size_t, std::uint16_t) { return 0.0f; }); WavLayout L = parseWavLayout(wav); CHECK(L.valid); // Keep 4 of 10 frames. WavTruncatePlan p = planWavTruncate(L, 4); CHECK(p.valid); const std::size_t bpf = 2 * 4; // channels * 4 bytes CHECK(p.newDataSize == 4 * bpf); // 32 bytes of PCM kept CHECK(p.newFileByteLength == L.dataByteOffset + 4 * bpf); // 44 + 32 = 76 CHECK(p.newRiffSize == p.newFileByteLength - 8); CHECK(p.dataSizeFieldOffset == L.dataSizeFieldOffset); CHECK(p.riffSizeFieldOffset == 4); // Applying the plan yields a buffer that re-parses to exactly 4 frames. std::vector trimmed(wav.begin(), wav.begin() + p.newFileByteLength); // Patch the two size fields (what the shell does before truncating on disk). auto writeU32 = [](std::vector& b, std::size_t off, std::uint32_t v) { b[off + 0] = static_cast(v & 0xFF); b[off + 1] = static_cast((v >> 8) & 0xFF); b[off + 2] = static_cast((v >> 16) & 0xFF); b[off + 3] = static_cast((v >> 24) & 0xFF); }; writeU32(trimmed, p.dataSizeFieldOffset, p.newDataSize); writeU32(trimmed, p.riffSizeFieldOffset, p.newRiffSize); WavLayout L2 = parseWavLayout(trimmed); CHECK(L2.valid); CHECK(L2.frameCount() == 4); CHECK(L2.dataByteLength == 4 * bpf); } static void testTruncatePlanKeepAllIsNoOp() { auto wav = buildFloatWav(1, 48000, 6, [](std::size_t, std::uint16_t) { return 0.0f; }); WavLayout L = parseWavLayout(wav); WavTruncatePlan p = planWavTruncate(L, 6); // keep all CHECK(p.valid); CHECK(p.newFileByteLength == wav.size()); // unchanged CHECK(p.newDataSize == L.dataByteLength); } // --- Extensible format tests ------------------------------------------------- // A WAVE_FORMAT_EXTENSIBLE fmt with SubFormat tag 0x0001 (PCM integer) and // bitsPerSample==32 must be REJECTED — it is 32-bit integer, not 32-bit float. static void testExtensiblePcmIntegerRejected() { auto wav = buildExtensibleWav(2, 48000, 4, [](std::size_t, std::uint16_t) { return 0.0f; }, /*subFormatTag=*/0x0001); // PCM integer CHECK(!parseWavLayout(wav).valid); } // A WAVE_FORMAT_EXTENSIBLE fmt with SubFormat tag 0x0003 (IEEE float) and // bitsPerSample==32 must be ACCEPTED and parse + trim correctly. static void testExtensibleFloatAccepted() { auto wav = buildExtensibleWav(2, 48000, 5, [](std::size_t f, std::uint16_t c) { return static_cast(f) + 0.1f * c; }, /*subFormatTag=*/0x0003); // IEEE float WavLayout L = parseWavLayout(wav); CHECK(L.valid); CHECK(L.channelCount == 2); CHECK(L.sampleRate == 48000); CHECK(L.frameCount() == 5); // Frame extraction works correctly. auto pcm = extractFloatFrames(wav, L, 0, 2); CHECK(pcm.size() == 4); CHECK(pcm[0] == 0.0f); // frame 0, channel 0 CHECK(pcm[1] == 0.1f); // frame 0, channel 1 // Truncate plan is valid and re-parses cleanly. WavTruncatePlan p = planWavTruncate(L, 3); CHECK(p.valid); CHECK(p.newDataSize == 3 * 2 * 4u); std::vector trimmed(wav.begin(), wav.begin() + p.newFileByteLength); auto writeU32 = [](std::vector& b, std::size_t off, std::uint32_t v) { b[off + 0] = static_cast(v & 0xFF); b[off + 1] = static_cast((v >> 8) & 0xFF); b[off + 2] = static_cast((v >> 16) & 0xFF); b[off + 3] = static_cast((v >> 24) & 0xFF); }; writeU32(trimmed, p.dataSizeFieldOffset, p.newDataSize); writeU32(trimmed, p.riffSizeFieldOffset, p.newRiffSize); WavLayout L2 = parseWavLayout(trimmed); CHECK(L2.valid); CHECK(L2.frameCount() == 3); } static void testTruncatePlanKeepZeroAndGrowRejected() { auto wav = buildFloatWav(2, 48000, 5, [](std::size_t, std::uint16_t) { return 0.0f; }); WavLayout L = parseWavLayout(wav); WavTruncatePlan zero = planWavTruncate(L, 0); CHECK(zero.valid); CHECK(zero.newDataSize == 0); CHECK(zero.newFileByteLength == L.dataByteOffset); // header only // keptFrames > total -> refused (never grow a file). CHECK(!planWavTruncate(L, 6).valid); // Invalid layout -> invalid plan. WavLayout bad; CHECK(!planWavTruncate(bad, 0).valid); } int main() { testParseCanonicalStereo(); testParseMonoAndLeadingChunk(); testParseRejectsNon32BitAndNonWav(); testParseRejectsLyingDataLength(); testExtractTailWindow(); testTruncatePlanKeepFewer(); testTruncatePlanKeepAllIsNoOp(); testTruncatePlanKeepZeroAndGrowRejected(); testExtensiblePcmIntegerRejected(); testExtensibleFloatAccepted(); if (g_fail == 0) std::printf("All tests passed.\n"); return g_fail ? 1 : 0; }