// SPDX-License-Identifier: GPL-3.0-only #include "container.hpp" #include "music_fallback.hpp" #include "playback.hpp" #include #include #include #include #include #include #include namespace { #define CHECK(expr) do { if (!(expr)) { \ std::cerr << "check failed at line " << __LINE__ << ": " << #expr << '\n'; \ return 1; \ } } while (false) std::vector fixture() { // Authored format header and payload, not bytes copied from a game asset. return {'F','O','R','M', 17,0,0,0, 'A','L','P','T','R','A','U','M', 'H','E','D','R', 1,0,0,0, 42}; } std::vector sfx_fixture() { std::vector bytes(65380, 0); std::copy_n("FORM", 4, bytes.begin()); const auto put32 = [&bytes](std::size_t at, std::uint32_t value) { for (unsigned i = 0; i < 4; ++i) bytes[at + i] = static_cast(value >> (i * 8)); }; const auto put16 = [&bytes](std::size_t at, std::uint16_t value) { bytes[at] = static_cast(value); bytes[at + 1] = static_cast(value >> 8); }; put32(4, static_cast(bytes.size())); std::copy_n("ALPTRAUM", 8, bytes.begin() + 8); const auto chunk = [&bytes, &put32](std::size_t at, const char* id, std::uint32_t size) { std::copy_n(id, 4, bytes.begin() + static_cast(at)); put32(at + 4, size); }; chunk(16, "HEDR", 8); chunk(32, "SEFX", 212); bytes[42] = 7; for (std::size_t i = 7; i < 13; ++i) { const std::size_t row = 44 + i * 16; bytes[row] = static_cast(16 + i - 7); bytes[row + 1] = 9; } chunk(252, "INST", 228); chunk(488, "SAMP", 64884); const std::size_t samp = 496; put16(samp + 2, 6); const std::size_t data_at = samp + 4 + 6 * 16; for (std::size_t i = 0; i < 6; ++i) { const std::size_t row = samp + 4 + i * 16; put16(row, static_cast(i * 2048)); put16(row + 2, 2048); put16(row + 8, 11025); std::fill(bytes.begin() + static_cast(data_at + i * 2048), bytes.begin() + static_cast(data_at + (i + 1) * 2048), static_cast(128 + i)); } return bytes; } } int main(int, char**) { // (the SDL_main signature: SDL.h renames main on Windows) using namespace openbmh::audio; std::string error; Container c; auto good = fixture(); CHECK(parse_container(good, c, error)); CHECK(c.chunks.size() == 1 && c.chunks[0].id == "HEDR"); CHECK(c.chunks[0].payload_size == 1 && good[c.chunks[0].payload_offset] == 42); auto broken = good; broken[20] = 0xff; broken[21] = 0xff; broken[22] = 0xff; broken[23] = 0x7f; CHECK(!parse_container(broken, c, error)); CHECK(c.chunks.empty()); CHECK(!parse_container(std::span(good.data(), 15), c, error)); std::vector sefx(65380, 0); const char form[] = "FORM"; std::copy(form, form + 4, sefx.begin()); sefx[4] = static_cast(sefx.size()); sefx[5] = static_cast(sefx.size() >> 8); const char type[] = "ALPTRAUM"; std::copy(type, type + 8, sefx.begin() + 8); std::size_t at = 16; const auto put_chunk = [&](const char* id, std::uint32_t size, std::size_t& cursor) { std::copy(id, id + 4, sefx.begin() + static_cast(cursor)); sefx[cursor + 4] = static_cast(size); sefx[cursor + 5] = static_cast(size >> 8); cursor += 8 + size; }; put_chunk("HEDR", 8, at); put_chunk("SEFX", 212, at); sefx[42] = 7; // observed 2003 SEFX record-count field put_chunk("INST", 228, at); put_chunk("SAMP", 64884, at); CHECK(at == sefx.size()); CHECK(parse_container(sefx, c, error)); CHECK(c.chunks.size() == 4 && c.chunks[1].id == "SEFX"); auto wrong_exception = sefx; wrong_exception[32] = 'S'; wrong_exception[33] = 'O'; wrong_exception[34] = 'N'; wrong_exception[35] = 'G'; CHECK(!parse_container(wrong_exception, c, error)); auto wrong_type = good; wrong_type[8] = 'X'; CHECK(!parse_container(wrong_type, c, error)); std::vector samp(24, 0); samp[2] = 1; samp[6] = 4; samp[12] = 0x22; samp[13] = 0x56; // 22050 Hz samp[20] = 0; samp[21] = 128; samp[22] = 255; samp[23] = 128; PcmSample pcm; CHECK(decode_sample(samp, 0, pcm, error)); CHECK(pcm.sample_rate == 22050 && pcm.mono.size() == 4); CHECK(pcm.mono[0] == -32768 && pcm.mono[1] == 0 && pcm.mono[2] == 32512); samp[6] = 0xff; samp[7] = 0xff; CHECK(!decode_sample(samp, 0, pcm, error)); CHECK(!decode_sample(samp, 1, pcm, error)); auto bank = sfx_fixture(); OriginalCue original; CHECK(decode_original_cue(bank, 17, original, error)); CHECK(original.original_id == 17 && original.sefx_index == 7 && original.sample_index == 0); CHECK(original.pcm.sample_rate == 11025 && original.pcm.mono.size() == 2048); CHECK(original.pcm.mono.front() == 0); CHECK(decode_original_cue(bank, 22, original, error)); CHECK(original.sefx_index == 12 && original.sample_index == 5); CHECK(!decode_original_cue(bank, 16, original, error)); CHECK(SDL_InitSubSystem(SDL_INIT_VIDEO) == 0); Playback playback; CHECK(playback.initialize(error)); CHECK(playback.available()); CHECK(!playback.music_active() && !playback.needs_pump()); CHECK(!playback.pump(error)); // The optional music path is inactive by default. playback.set_volume(2.0F); CHECK(playback.volume() == 1.0F); playback.set_volume(-1.0F); CHECK(playback.volume() == 0.0F); playback.set_volume(1.0F); playback.set_volume(std::numeric_limits::quiet_NaN()); CHECK(playback.volume() == 1.0F); playback.set_volume(std::numeric_limits::infinity()); CHECK(playback.volume() == 1.0F); playback.set_muted(true); CHECK(playback.muted()); CHECK(playback.play_pcm(nullptr, 0, 22050, error)); // mute drops without queueing playback.set_muted(false); const std::int16_t sample[] = {0, 1000, -1000, 0}; CHECK(playback.play_pcm(sample, 4, 22050, error)); std::vector long_sample(22050, 1000); CHECK(playback.play_pcm(long_sample.data(), long_sample.size(), 22050, error)); CHECK(playback.queued_bytes() > 0); playback.set_muted(true); CHECK(playback.queued_bytes() == 0); playback.set_muted(false); CHECK(playback.play_pcm(long_sample.data(), long_sample.size(), 22050, error)); CHECK(playback.queued_bytes() > 0); playback.reset_session(7); CHECK(playback.queued_bytes() == 0); playback.reset_session(7); // same session preserves the event watermark CHECK(playback.load_original_bank(bank, error)); const CueRequest cue_a{7, 1, 17}; CHECK(playback.submit(cue_a, error) == CueStatus::queued); CHECK(playback.queued_bytes() > 0); CHECK(playback.submit(cue_a, error) == CueStatus::duplicate); CHECK(playback.submit(CueRequest{7, 2, 17}, error) == CueStatus::queued); playback.set_muted(true); const CueRequest muted{7, 3, 17}; CHECK(playback.submit(muted, error) == CueStatus::muted); playback.set_muted(false); CHECK(playback.submit(muted, error) == CueStatus::duplicate); playback.stop(); CHECK(playback.submit(cue_a, error) == CueStatus::duplicate); playback.reset_session(8); CHECK(playback.submit(CueRequest{8, 1, 17}, error) == CueStatus::queued); CHECK(playback.submit(CueRequest{7, 4, 17}, error) == CueStatus::invalid); CHECK(playback.submit(CueRequest{8, 1, 17}, error) == CueStatus::duplicate); PcmSample kickoff_pcm, goal_pcm, final_pcm; CHECK(synthesize_semantic_cue(SemanticCue::kickoff_whistle, kickoff_pcm, error)); CHECK(synthesize_semantic_cue(SemanticCue::goal, goal_pcm, error)); CHECK(synthesize_semantic_cue(SemanticCue::full_time_whistle, final_pcm, error)); CHECK(kickoff_pcm.sample_rate == 22050 && goal_pcm.sample_rate == 22050 && final_pcm.sample_rate == 22050); CHECK(!kickoff_pcm.mono.empty() && !goal_pcm.mono.empty() && !final_pcm.mono.empty()); CHECK(kickoff_pcm.mono != goal_pcm.mono && goal_pcm.mono != final_pcm.mono && kickoff_pcm.mono != final_pcm.mono); PcmSample matchday_loop, repeated_loop; CHECK(synthesize_matchday_music_loop(matchday_loop, error)); CHECK(synthesize_matchday_music_loop(repeated_loop, error)); CHECK(matchday_loop.sample_rate == 22050); CHECK(matchday_loop.mono.size() == 392000); // 8 bars, 4 beats, 108 BPM. CHECK(matchday_loop.mono == repeated_loop.mono); // deterministic, no RNG. CHECK(matchday_loop.mono.front() == 0 && matchday_loop.mono.back() == 0); CHECK(std::any_of(matchday_loop.mono.begin(), matchday_loop.mono.end(), [](std::int16_t value) { return value != 0; })); Mixer mixer; PcmSample constant_music{22050, std::vector(8, 1000)}; const std::int16_t voice_samples[] = {2000, 2000, 2000, 2000}; CHECK(mixer.start_music_loop(constant_music, 22050, error)); CHECK(mixer.add_voice(voice_samples, 22050, 22050, error)); CHECK(mixer.active_voices() == 1); std::int16_t mixed_block[2]{}; CHECK(mixer.mix_block(mixed_block, 1.0F)); CHECK(mixed_block[0] == 3000 && mixed_block[1] == 3000); // Cue overlays the loop. mixer.stop_music(); CHECK(!mixer.has_music() && mixer.active_voices() == 1); std::int16_t voice_tail[4]{}; CHECK(mixer.mix_block(voice_tail, 1.0F)); // stop_music leaves the cue voice alive. CHECK(voice_tail[0] == 2000 && voice_tail[1] == 2000 && voice_tail[2] == 0 && voice_tail[3] == 0); CHECK(!mixer.active()); mixer.clear(); CHECK(mixer.start_music_loop(constant_music, 22050, error)); for (int i = 0; i < 8; ++i) CHECK(mixer.add_voice(voice_samples, 22050, 22050, error)); CHECK(mixer.active_voices() == 8); CHECK(!mixer.add_voice(voice_samples, 22050, 22050, error)); mixer.clear(); static_assert(static_cast(SemanticCue::kickoff_whistle) == 1); static_assert(static_cast(SemanticCue::goal) == 2); static_assert(static_cast(SemanticCue::full_time_whistle) == 3); playback.reset_session(9); const SemanticCueRequest kickoff{9, 1, SemanticCue::kickoff_whistle}; CHECK(playback.submit(kickoff, error) == CueStatus::queued); CHECK(playback.queued_bytes() > 0); CHECK(playback.submit(kickoff, error) == CueStatus::duplicate); CHECK(playback.submit(SemanticCueRequest{9, 2, SemanticCue::kickoff_whistle}, error) == CueStatus::queued); playback.set_muted(true); const SemanticCueRequest muted_goal{9, 3, SemanticCue::goal}; CHECK(playback.submit(muted_goal, error) == CueStatus::muted); playback.set_muted(false); CHECK(playback.submit(muted_goal, error) == CueStatus::duplicate); CHECK(playback.submit(SemanticCueRequest{9, 4, SemanticCue::goal}, error) == CueStatus::queued); playback.reset_session(10); CHECK(playback.queued_bytes() == 0); CHECK(playback.submit(SemanticCueRequest{10, 1, SemanticCue::full_time_whistle}, error) == CueStatus::queued); CHECK(playback.queued_bytes() > 0); playback.reset_session(11); CHECK(playback.submit(CueRequest{11, 1, 17}, error) == CueStatus::queued); CHECK(playback.submit(SemanticCueRequest{11, 1, SemanticCue::goal}, error) == CueStatus::duplicate); CHECK(playback.submit(SemanticCueRequest{11, 2, SemanticCue::goal}, error) == CueStatus::queued); CHECK(playback.submit(CueRequest{11, 2, 17}, error) == CueStatus::duplicate); CHECK(playback.submit(SemanticCueRequest{10, 3, SemanticCue::goal}, error) == CueStatus::invalid); CHECK(playback.submit(CueRequest{11, 0, 17}, error) == CueStatus::invalid); CHECK(playback.submit(SemanticCueRequest{11, 3, SemanticCue::full_time_whistle}, error) == CueStatus::queued); // Optional music is explicit. Cues submitted while it is active enter the // mixer immediately; pump emits short mixed blocks, never a whole loop. playback.reset_session(12); CHECK(playback.play_pcm(long_sample.data(), long_sample.size(), 22050, error)); CHECK(playback.queued_bytes() > 0); CHECK(!playback.start_music_loop(matchday_loop, error)); // Reject >40ms legacy cue backlog. CHECK(!playback.music_active()); CHECK(playback.queued_bytes() > 0); // Existing queued cue was not discarded. playback.stop(); CHECK(!playback.needs_pump()); CHECK(playback.start_music_loop(matchday_loop, error)); CHECK(playback.pump(error)); CHECK(playback.queued_bytes() <= 40U * 22050U * 2U / 1000U); // Refill after typical 60/30 Hz app ticks. This checks the bounded refill, // not continuous audible output: the dummy backend is not a listening test. for (const unsigned delay : {17U, 33U}) { for (unsigned tick = 0; tick < 12; ++tick) { SDL_Delay(delay); CHECK(playback.pump(error)); CHECK(error.empty()); CHECK(playback.queued_bytes() > 0); CHECK(playback.queued_bytes() <= 40U * 22050U * 2U / 1000U); } } CHECK(playback.submit(CueRequest{12, 1, 17}, error) == CueStatus::queued); bool cue_pumped = false; for (unsigned attempt = 0; attempt < 5 && !cue_pumped; ++attempt) { cue_pumped = playback.pump(error); if (cue_pumped) CHECK(playback.queued_bytes() <= 40U * 22050U * 2U / 1000U); if (!cue_pumped) SDL_Delay(25); } CHECK(cue_pumped); const SemanticCueRequest music_muted_event{12, 2, SemanticCue::goal}; playback.set_muted(true); // Clears music and both queued and active voices. CHECK(!playback.music_active()); CHECK(!playback.pump(error)); CHECK(playback.submit(music_muted_event, error) == CueStatus::muted); playback.set_muted(false); CHECK(playback.submit(music_muted_event, error) == CueStatus::duplicate); CHECK(!playback.pump(error)); // A zero master volume still advances an already active voice silently. playback.reset_session(13); CHECK(playback.start_music_loop(matchday_loop, error)); const std::int16_t short_voice[] = {1000, 1000, 1000, 1000}; CHECK(playback.play_pcm(short_voice, 4, 22050, error)); playback.set_volume(0.0F); playback.stop_music(); CHECK(playback.needs_pump()); CHECK(playback.pump(error)); CHECK(!playback.needs_pump()); playback.set_volume(1.0F); CHECK(!playback.pump(error)); // No delayed replay after restoring volume. playback.reset_session(13); CHECK(!playback.music_active() && !playback.pump(error)); CHECK(playback.start_music_loop(matchday_loop, error)); CHECK(playback.needs_pump()); playback.reset_session(14); // A real session change clears music and queue. CHECK(!playback.music_active() && !playback.needs_pump() && playback.queued_bytes() == 0); CHECK(playback.start_music_loop(matchday_loop, error)); CHECK(playback.submit(CueRequest{14, 1, 17}, error) == CueStatus::queued); playback.stop_music(); CHECK(!playback.music_active()); CHECK(playback.needs_pump()); CHECK(playback.pump(error)); // Stopping music alone preserves an active cue. playback.stop(); CHECK(!playback.needs_pump()); CHECK(!playback.pump(error)); Playback unavailable; unavailable.reset_session(20); const CueRequest unavailable_event{20, 1, 17}; CHECK(!unavailable.available()); CHECK(!unavailable.start_music_loop(matchday_loop, error)); CHECK(unavailable.submit(unavailable_event, error) == CueStatus::disabled); playback.shutdown(); CHECK(unavailable.initialize(error)); CHECK(unavailable.submit(unavailable_event, error) == CueStatus::duplicate); CHECK(unavailable.queued_bytes() == 0); // A disabled event is not replayed after device recovery. unavailable.shutdown(); CHECK(playback.initialize(error)); playback.reset_session(15); CHECK(playback.start_music_loop(matchday_loop, error)); CHECK(playback.submit(CueRequest{15, 1, 17}, error) == CueStatus::queued); playback.shutdown(); // Device shutdown clears the optional track and active cue. CHECK(!playback.available() && !playback.music_active()); playback.shutdown(); CHECK(!playback.available()); CHECK((SDL_WasInit(SDL_INIT_VIDEO) & SDL_INIT_VIDEO) != 0); SDL_QuitSubSystem(SDL_INIT_VIDEO); std::cout << "checks passed: original/semantic shared event ledger; stale and zero IDs; unavailable device and no replay; deterministic eight-bar loop; PCM overlay and stop-music cue tail; fixed voice cap; mute/reset/shutdown clear music; SDL dummy lifecycle; no listening test\n"; return 0; // (explicit: main is SDL_main here, no implicit return 0) }