Initial public OpenBMH 0.1 source (by Codex)

This commit is contained in:
Codex committed 2026-10-16 19:36:32 +02:00
commit 558fbf166b
613 files changed
+168029

No files matched your search

+354
View File
@@ -0,0 +1,354 @@
// SPDX-License-Identifier: GPL-3.0-only
#include "container.hpp"
#include "music_fallback.hpp"
#include "playback.hpp"
#include <algorithm>
#include <cstdlib>
#include <cstdint>
#include <iostream>
#include <limits>
#include <string>
#include <vector>
namespace {
#define CHECK(expr) do { if (!(expr)) { \
std::cerr << "check failed at line " << __LINE__ << ": " << #expr << '\n'; \
return 1; \
} } while (false)
std::vector<std::uint8_t> 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<std::uint8_t> sfx_fixture() {
std::vector<std::uint8_t> 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<std::uint8_t>(value >> (i * 8));
};
const auto put16 = [&bytes](std::size_t at, std::uint16_t value) {
bytes[at] = static_cast<std::uint8_t>(value);
bytes[at + 1] = static_cast<std::uint8_t>(value >> 8);
};
put32(4, static_cast<std::uint32_t>(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<std::ptrdiff_t>(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<std::uint8_t>(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<std::uint16_t>(i * 2048));
put16(row + 2, 2048);
put16(row + 8, 11025);
std::fill(bytes.begin() + static_cast<std::ptrdiff_t>(data_at + i * 2048),
bytes.begin() + static_cast<std::ptrdiff_t>(data_at + (i + 1) * 2048),
static_cast<std::uint8_t>(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<const std::uint8_t>(good.data(), 15), c, error));
std::vector<std::uint8_t> sefx(65380, 0);
const char form[] = "FORM";
std::copy(form, form + 4, sefx.begin());
sefx[4] = static_cast<std::uint8_t>(sefx.size());
sefx[5] = static_cast<std::uint8_t>(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<std::ptrdiff_t>(cursor));
sefx[cursor + 4] = static_cast<std::uint8_t>(size);
sefx[cursor + 5] = static_cast<std::uint8_t>(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<std::uint8_t> 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<float>::quiet_NaN());
CHECK(playback.volume() == 1.0F);
playback.set_volume(std::numeric_limits<float>::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<std::int16_t> 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<std::int16_t>(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<std::uint8_t>(SemanticCue::kickoff_whistle) == 1);
static_assert(static_cast<std::uint8_t>(SemanticCue::goal) == 2);
static_assert(static_cast<std::uint8_t>(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)
}