// Unit tests for the engine's self-contained parts: no test data files, no // reference implementation, no external framework. Run with `ctest` or directly. #include #include #include #include #include #include #include #include #include #include #include "adm/adm_metadata.h" #include "adm/adm_tracks.h" #include "binaural/multichannel_layout.h" #include "binaural/pcm_resampler.h" #include "eac3_transport/eac3_reader.h" #include "eac3joc_core.h" #include "foundation/bit_reader.h" #include "foundation/fs_utf8.h" #include "foundation/geometry.h" #include "hrtf/jochrtf.h" #include "hrtf/rosella_model.h" #include "hrtf/rosella_renderer.h" #include "joc_bitstream/joc_huffman_tables.h" #include "joc_bitstream/joc_parser.h" #include "foundation/mini_json.h" #include "foundation/sha256.h" #include "io/inflate.h" #include "io/hdf5.h" #include "io/npy_writer.h" #include "io/npy.h" #include "io/process.h" #include "io/wav_writer.h" #include "io/zip_reader.h" #include "oamd/oamd_parser.h" #include "speaker/speaker_layout_lookup.h" #include "speaker/speaker_trim.h" #include "stream/stream.h" #include "task/task.h" #include "timeline/position_timeline.h" namespace { int g_failures = 0; int g_checks = 0; void check(bool condition, const char* expression, const char* file, int line) { ++g_checks; if (!condition) { ++g_failures; std::printf("FAIL %s:%d %s\n", file, line, expression); } } #define CHECK(expression) check((expression), #expression, __FILE__, __LINE__) std::vector from_hex(const char* text) { auto digit = [](char c) { return static_cast(c <= '9' ? c - '0' : (c | 0x20) - 'a' + 10); }; std::vector out; for (std::size_t i = 0; text[i] != '\0' && text[i + 1] != '\0'; i += 2) { out.push_back(static_cast((digit(text[i]) << 4) | digit(text[i + 1]))); } return out; } std::string bytes_to_string(const std::vector& bytes) { return std::string(reinterpret_cast(bytes.data()), bytes.size()); } ejoc_speaker_controls speaker_controls(std::uint32_t warp, std::uint32_t trim_mode) { ejoc_speaker_controls controls{}; controls.struct_size = sizeof(controls); controls.struct_version = EJOC_SPEAKER_CONTROLS_VERSION; controls.warp_mode = warp; controls.trim_mode = trim_mode; return controls; } // Gain vector of one object, in standard output-channel order. The object sits // at (u, v, z) Q15 and contributes a single unit sample so the value read back // from sample 0 is the target gain. std::vector speaker_gains(const joc::speaker::LayoutInfo& layout, const ejoc_speaker_controls& controls, std::uint16_t u, std::uint16_t v, std::uint16_t z, bool bypass_object = false) { std::vector gains(layout.channel_count, 0.0); ejoc_speaker_renderer_handle handle = ejoc_speaker_renderer_create(layout.speaker_bitfield); CHECK(handle != nullptr); if (handle == nullptr) { return gains; } std::vector input(static_cast(EJOC_SPEAKER_BLOCK_SAMPLES) * JOC_OUTPUT_CHANNELS, 0.0f); input[1] = 1.0f; // object slot 1, sample 0 std::uint16_t positions[joc::oamd::kObjects][3] = {}; positions[0][0] = u; positions[0][1] = v; positions[0][2] = z; const std::uint32_t offset = 0; const std::uint32_t ramp = 0; ejoc_speaker_controls applied = controls; if (bypass_object) { applied.trim_bypass[1] = 1; } std::vector output(static_cast(EJOC_SPEAKER_BLOCK_SAMPLES) * layout.channel_count, 0.0); const int result = ejoc_speaker_renderer_process( handle, input.data(), EJOC_SPEAKER_BLOCK_SAMPLES, 1, &offset, &ramp, &positions[0][0], nullptr, nullptr, nullptr, &applied, output.data()); CHECK(result == 0); for (std::uint32_t channel = 0; channel < layout.channel_count; ++channel) { gains[channel] = output[channel]; } ejoc_speaker_renderer_destroy(handle); return gains; } void check_gains(const std::vector& actual, const std::vector& expected) { CHECK(actual.size() == expected.size()); if (actual.size() != expected.size()) { return; } for (std::size_t channel = 0; channel < actual.size(); ++channel) { if (std::fabs(actual[channel] - expected[channel]) > 1e-13) { std::printf(" channel %zu actual %.17g expected %.17g\n", channel, actual[channel], expected[channel]); } CHECK(std::fabs(actual[channel] - expected[channel]) <= 1e-13); } } void test_sha256() { CHECK(joc::crypto::sha256_hex("", 0) == "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"); CHECK(joc::crypto::sha256_hex("abc", 3) == "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"); const char* two_block = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"; CHECK(joc::crypto::sha256_hex(two_block, std::strlen(two_block)) == "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1"); std::vector million(1000000, 'a'); CHECK(joc::crypto::sha256_hex(million.data(), million.size()) == "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0"); // Incremental updates must equal a single-shot hash. joc::crypto::Sha256 incremental; incremental.update("ab", 2); incremental.update("c", 1); CHECK(incremental.finish_hex() == joc::crypto::sha256_hex("abc", 3)); } void test_crc32_and_inflate() { CHECK(joc::io::crc32_of(reinterpret_cast("123456789"), 9) == 0xCBF43926u); // One stored DEFLATE block: BFINAL=1, BTYPE=00, LEN=3, NLEN=~LEN, "abc". const std::uint8_t stored[] = {0x01, 0x03, 0x00, 0xFC, 0xFF, 'a', 'b', 'c'}; std::vector out; CHECK(joc::io::inflate_raw(stored, sizeof(stored), &out)); CHECK(out.size() == 3 && std::memcmp(out.data(), "abc", 3) == 0); const std::uint8_t truncated[] = {0x01, 0x10, 0x00, 0xEF, 0xFF, 'a'}; CHECK(!joc::io::inflate_raw(truncated, sizeof(truncated), &out)); } void test_bit_reader() { const std::uint8_t data[] = {0xB2, 0x5D}; // 1011 0010 0101 1101 joc::bits::BitReader reader(data, sizeof(data)); CHECK(reader.read(3) == 0x5); CHECK(reader.read(5) == 0x12); CHECK(reader.read(8) == 0x5D); CHECK(reader.position() == 16); CHECK(!reader.failed()); joc::bits::BitReader short_read(data, 1); CHECK(short_read.read(9) == 0); CHECK(short_read.failed()); CHECK(short_read.error() == JOC_ERR_BITSTREAM_TRUNCATED); CHECK(short_read.position() == 0); joc::bits::BitReader limited(data, sizeof(data)); limited.set_limit_bits(4); CHECK(limited.read(4) == 0xB); CHECK(limited.read(1) == 0 && limited.failed()); } // Writes MSB-first bits; used only to build test vectors. class BitWriter { public: void write(std::uint32_t value, unsigned count) { for (unsigned i = count; i-- > 0;) { const std::uint8_t bit = static_cast((value >> i) & 1u); if (used_ == 0) { bytes_.push_back(0); } bytes_.back() |= static_cast(bit << (7u - used_)); used_ = (used_ + 1u) % 8u; } } const std::vector& bytes() const { return bytes_; } private: std::vector bytes_; unsigned used_ = 0; }; void test_variable_bits() { // 300 with width 8 is two groups: 0 (continue) then 44 (stop). BitWriter writer; writer.write(0, 8); writer.write(1, 1); writer.write(44, 8); writer.write(0, 1); joc::bits::BitReader reader(writer.bytes().data(), writer.bytes().size()); std::uint32_t value = 0; CHECK(joc::bits::variable_bits(reader, 8, 8, &value)); CHECK(value == 300); // Eight continuation groups exceed the limit and must fail, not loop. BitWriter endless; for (int group = 0; group < 8; ++group) { endless.write(0, 8); endless.write(1, 1); } joc::bits::BitReader endless_reader(endless.bytes().data(), endless.bytes().size()); CHECK(!joc::bits::variable_bits(endless_reader, 8, 8, &value)); CHECK(endless_reader.error() == JOC_ERR_EMDF_SYNTAX); } void test_eac3_frame_bytes() { std::vector frame(3072, 0); frame[0] = 0x0B; frame[1] = 0x77; frame[2] = 0x05; frame[3] = 0xFF; // frmsiz words = 1536 -> 3072 bytes frame[5] = 0x80; // bsid (bits 40..44) = 16 marks E-AC-3 std::size_t size = 0; CHECK(joc::eac3::FrameReader::frame_bytes(frame.data(), frame.size(), 0, &size) == JOC_OK); CHECK(size == 3072); CHECK(joc::eac3::FrameReader::frame_bytes(frame.data(), 100, 0, &size) == JOC_ERR_BITSTREAM_TRUNCATED); frame[1] = 0x78; CHECK(joc::eac3::FrameReader::frame_bytes(frame.data(), frame.size(), 0, &size) == JOC_ERR_EAC3_SYNCFRAME); // bsid <= 8 is AC-3: the frame length comes from fscod/frmsizecod instead. std::vector ac3(2560, 0); ac3[0] = 0x0B; ac3[1] = 0x77; ac3[4] = 0x24; // fscod = 0, frmsizecod = 36 -> 1280 words -> 2560 bytes ac3[5] = 0x30; // bsid = 6 CHECK(joc::eac3::FrameReader::frame_bytes(ac3.data(), ac3.size(), 0, &size) == JOC_OK); CHECK(size == 2560); CHECK(joc::eac3::FrameReader::frame_bytes(ac3.data(), ac3.size() - 1, 0, &size) == JOC_ERR_BITSTREAM_TRUNCATED); } void test_mini_json() { const std::string text = R"({"a":1,"b":"x\ny","c":{"d":true},"e":-2.5})"; std::vector members; std::string error; CHECK(joc::json::parse_object(text, &members, &error)); double number = 0.0; CHECK(joc::json::as_number(*joc::json::find(members, "a"), &number) && number == 1.0); CHECK(joc::json::as_number(*joc::json::find(members, "e"), &number) && number == -2.5); std::string value; CHECK(joc::json::as_string(*joc::json::find(members, "b"), &value) && value == "x\ny"); CHECK(joc::json::find(members, "c")->raw == R"({"d":true})"); std::vector duplicate; CHECK(!joc::json::parse_object(R"({"a":1,"a":2})", &duplicate, &error)); CHECK(!joc::json::parse_object("[1,2]", &duplicate, &error)); } void test_json_text() { // Escaping matches json.dumps(..., ensure_ascii=False): the named escapes, // \u00XX for the other control characters, UTF-8 bytes passed through. CHECK(joc::json::quote("") == "\"\""); CHECK(joc::json::quote("a\"b\\c") == "\"a\\\"b\\\\c\""); CHECK(joc::json::quote("x\ny\tz") == "\"x\\ny\\tz\""); CHECK(joc::json::quote(std::string("\b\f", 2u)) == "\"\\b\\f\""); CHECK(joc::json::quote("\x01") == "\"\\u0001\""); CHECK(joc::json::quote("月と私") == "\"月と私\""); // Two-space indentation, one member per line, no trailing newline. CHECK(joc::json::pretty_object({}) == "{}"); const std::string document = joc::json::pretty_object({ {"status", "0"}, {"message", joc::json::quote("cannot open C:\\out\\a.wav")}, }); CHECK(document == "{\n \"status\": 0,\n \"message\": " "\"cannot open C:\\\\out\\\\a.wav\"\n}"); std::vector members; std::string error; CHECK(joc::json::parse_object(document, &members, &error)); std::string message; CHECK(joc::json::as_string(*joc::json::find(members, "message"), &message) && message == "cannot open C:\\out\\a.wav"); } void test_task_result_json() { joc_task_result result{}; result.struct_size = sizeof(result); result.status = JOC_TASK_FAILED; result.error_code = JOC_ERR_OUTPUT_OPEN; std::snprintf(result.error_stage, sizeof(result.error_stage), "%s", "output"); // A Windows path and a quote in the message: the document has to stay valid. std::snprintf(result.error_message, sizeof(result.error_message), "%s", "cannot write \"C:\\out\\a.wav\""); result.output_peak = 1.5; result.t_total = 6.355818; std::string text; CHECK(joc::task::result_to_json(result, &text).ok()); CHECK(text.find("\n \"error_message\": ") != std::string::npos); std::vector members; std::string error; CHECK(joc::json::parse_object(text, &members, &error)); std::string message; CHECK(joc::json::as_string(*joc::json::find(members, "error_message"), &message) && message == "cannot write \"C:\\out\\a.wav\""); double number = 0.0; CHECK(joc::json::as_number(*joc::json::find(members, "output_peak"), &number) && number == 1.5); CHECK(joc::json::as_number(*joc::json::find(members, "t_total"), &number) && number == 6.355818); } void test_npy() { // Build a minimal image; const char magic[6] = {'\x93', 'N', 'U', 'M', 'P', 'Y'}; image.insert(image.end(), magic, magic + 6); image.push_back(1); image.push_back(0); image.push_back(static_cast(header.size() & 0xFFu)); image.push_back(static_cast(header.size() >> 8)); image.insert(image.end(), header.begin(), header.end()); const double values[2] = {1.5, -0.25}; const std::uint8_t* raw = reinterpret_cast(values); image.insert(image.end(), raw, raw + sizeof(values)); joc::io::NpyArray array; std::string error; CHECK(joc::io::parse_npy(image.data(), image.size(), &array, &error)); CHECK(array.descr == " loaded; CHECK(joc::io::npy_to_double(array, &loaded, &error)); CHECK(loaded.size() == 2 && loaded[0] == 1.5 && loaded[1] == -0.25); } void test_oamd_and_adm_helpers() { CHECK(joc::oamd::q_of(0, 62) == 0); CHECK(joc::oamd::q_of(62, 62) == 32767); CHECK(joc::oamd::q_of(31, 62) == 16384); CHECK(joc::oamd::q_of(15, 15) == 32767); CHECK(joc::adm::ts(0.0) == "00:00:00.00000"); CHECK(joc::adm::ts(1.5) == "00:00:01.50000"); CHECK(joc::adm::ts(3661.25) == "01:01:01.25000"); // 0.999999 s rounds to the next second, not to 100000 microseconds. CHECK(joc::adm::ts(0.999999) == "00:00:01.00000"); double x = 0.0; double y = 0.0; double z = 0.0; joc::geometry::q_to_adm_xyz(0, 32767, 0, &x, &y, &z); CHECK(x == -1.0 && y == -1.0 && z == 0.0); joc::geometry::q_to_adm_xyz(32767, 0, 0, &x, &y, &z); CHECK(x == 1.0 && y == 1.0 && z == 0.0); } // DBMD segment 10: the nine configuration trims must default to automatic (bit 0 // of each trim's first byte), and every other field of the block must keep the // layout the writer has always produced. void test_dbmd_auto_trim() { std::string dbmd; CHECK(joc::adm::build_dbmd(25, joc::adm::BinauralMode::Mid, &dbmd).ok()); std::string segment10; std::size_t offset = 4; while (offset + 2 < dbmd.size() && static_cast(dbmd[offset]) != 0) { const std::size_t size = static_cast(static_cast(dbmd[offset + 1])) | (static_cast(static_cast(dbmd[offset + 2])) << 8); const std::size_t start = offset + 3; CHECK(start + size + 1 <= dbmd.size()); unsigned sum = static_cast(size); for (std::size_t i = 0; i < size; ++i) { sum += static_cast(dbmd[start + i]); } sum += static_cast(dbmd[start + size]); CHECK((sum & 0xFFu) == 0u); if (static_cast(dbmd[offset]) == 10) { segment10 = dbmd.substr(start, size); } offset = start + size + 1; } CHECK(segment10.size() == 292); CHECK(static_cast(segment10[0]) == 0xBD); CHECK(static_cast(segment10[1]) == 0x6F); CHECK(static_cast(segment10[2]) == 0x72); CHECK(static_cast(segment10[3]) == 0xF8); CHECK(static_cast(segment10[4]) == 25); CHECK(static_cast(segment10[5]) == 0); CHECK(static_cast(segment10[6]) == 0); // Nine 15-byte configuration trims: automatic, payload untouched. for (std::size_t layout = 0; layout < 9; ++layout) { const std::size_t flag = 7 + 15 * layout; CHECK(static_cast(segment10[flag]) == 0x01); for (std::size_t i = 1; i < 15; ++i) { CHECK(static_cast(segment10[flag + i]) == 0); } } // One trim-bypass byte per track stays clear. for (std::size_t i = 7 + 9 * 15; i < 7 + 9 * 15 + 25; ++i) { CHECK(static_cast(segment10[i]) == 0); } // Headphone modes: bed tracks clear, the object slots carry the mode value. for (std::size_t i = 0; i < 25; ++i) { const unsigned char expected = i < 10 ? 0x00 : 0x03; CHECK(static_cast(segment10[7 + 9 * 15 + 25 + i]) == expected); } // Nothing between the mode array and the trailing template fill changed. for (std::size_t i = 7 + 9 * 15 + 2 * 25; i < 5 + 262; ++i) { CHECK(static_cast(segment10[i]) == 0); } for (std::size_t i = 5 + 262; i < segment10.size(); ++i) { CHECK(static_cast(segment10[i]) == 0x84); } } // OAMD trim element parsing: warp mode, global trim mode, the nine // configuration records and the per-object bypass flags. The payloads are // generated by the reference parser's own bit layout. void test_oamd_trim_parse() { // warp 2, global trim mode 2; config 0 default, 1 disabled, 2 explicit // (centre 6 dB, surround -15 dB, height -36 dB, balance +1 / -0.5), the // rest default; objects 1 and 5 bypassed. const std::vector explicit_payload = from_hex("1f049c8a9f0eff9ffa2000"); joc::oamd::OamdTrim trim; bool present = false; CHECK(joc::oamd::parse_trim(explicit_payload.data(), explicit_payload.size(), &trim, &present) .ok()); CHECK(present); CHECK(trim.warp_mode == 2); CHECK(trim.global_trim_mode == 2); CHECK(trim.object_count == 16); CHECK(trim.configs[0].kind == joc::oamd::TrimConfigKind::kDefault); CHECK(trim.configs[1].kind == joc::oamd::TrimConfigKind::kDisabled); CHECK(trim.configs[2].kind == joc::oamd::TrimConfigKind::kExplicit); CHECK(trim.configs[2].presence == 0x1F); CHECK(trim.configs[2].centre == 6.0); CHECK(trim.configs[2].surround == -15.0); CHECK(trim.configs[2].height == -36.0); CHECK(trim.configs[2].balance_overhead == 1.0); CHECK(trim.configs[2].balance_listener == -0.5); CHECK(trim.configs[3].kind == joc::oamd::TrimConfigKind::kDefault); CHECK(trim.configs[8].kind == joc::oamd::TrimConfigKind::kDefault); CHECK(trim.disable_per_object[1]); CHECK(trim.disable_per_object[5]); CHECK(!trim.disable_per_object[0]); CHECK(!trim.disable_per_object[2]); // warp 1, automatic trim, no configuration records and no bypass table. const std::vector auto_payload = from_hex("1f048040"); CHECK(joc::oamd::parse_trim(auto_payload.data(), auto_payload.size(), &trim, &present) .ok()); CHECK(present); CHECK(trim.warp_mode == 1); CHECK(trim.global_trim_mode == 0); for (int index = 0; index < joc::oamd::kTrimConfigs; ++index) { CHECK(trim.configs[index].kind == joc::oamd::TrimConfigKind::kAbsent); } for (int slot = 0; slot < joc::oamd::kMaxSlots; ++slot) { CHECK(!trim.disable_per_object[slot]); } } void test_speaker_trim_parameters() { joc::speaker::LayoutInfo layout51{}; joc::speaker::LayoutInfo layout71{}; joc::speaker::LayoutInfo layout40{}; joc::speaker::LayoutInfo layout20{}; joc::speaker::LayoutInfo layout512{}; joc::speaker::LayoutInfo layout514{}; joc::speaker::LayoutInfo layout714{}; CHECK(joc::speaker::layout_by_name("5.1", &layout51)); CHECK(joc::speaker::layout_by_name("7.1", &layout71)); CHECK(joc::speaker::layout_by_name("4.0", &layout40)); CHECK(joc::speaker::layout_by_name("2.0", &layout20)); CHECK(joc::speaker::layout_by_name("5.1.2", &layout512)); CHECK(joc::speaker::layout_by_name("5.1.4", &layout514)); CHECK(joc::speaker::layout_by_name("7.1.4", &layout714)); CHECK(joc::speaker::trim_config_index(layout20) == 0); CHECK(joc::speaker::trim_config_index(layout40) == 1); CHECK(joc::speaker::trim_config_index(layout51) == 1); CHECK(joc::speaker::trim_config_index(layout71) == 2); CHECK(joc::speaker::trim_config_index(layout512) == 4); CHECK(joc::speaker::trim_config_index(layout514) == 7); ejoc_speaker_controls controls{}; CHECK(joc::speaker::parameters_from_oamd(nullptr, layout51, &controls).ok()); CHECK(controls.warp_mode == 0); CHECK(controls.trim_mode == EJOC_SPEAKER_TRIM_AUTOMATIC); CHECK(joc::speaker::parameters_from_oamd(nullptr, layout714, &controls).ok()); CHECK(controls.trim_mode == EJOC_SPEAKER_TRIM_DISABLED); joc::oamd::OamdTrim trim{}; trim.warp_mode = 1; trim.global_trim_mode = 1; CHECK(joc::speaker::parameters_from_oamd(&trim, layout51, &controls).ok()); CHECK(controls.warp_mode == 1); CHECK(controls.trim_mode == EJOC_SPEAKER_TRIM_DISABLED); trim = joc::oamd::OamdTrim{}; trim.global_trim_mode = 2; trim.configs[1].kind = joc::oamd::TrimConfigKind::kDefault; CHECK(joc::speaker::parameters_from_oamd(&trim, layout51, &controls).ok()); CHECK(controls.trim_mode == EJOC_SPEAKER_TRIM_AUTOMATIC); trim.configs[1].kind = joc::oamd::TrimConfigKind::kDisabled; CHECK(joc::speaker::parameters_from_oamd(&trim, layout51, &controls).ok()); CHECK(controls.trim_mode == EJOC_SPEAKER_TRIM_DISABLED); trim.configs[1].kind = joc::oamd::TrimConfigKind::kExplicit; trim.configs[1].centre = 1.5; trim.configs[1].surround = 3.0; trim.configs[1].height = -6.0; trim.configs[1].balance_listener = -0.5; trim.configs[1].balance_overhead = 0.25; trim.disable_per_object[1] = true; CHECK(joc::speaker::parameters_from_oamd(&trim, layout51, &controls).ok()); CHECK(controls.trim_mode == EJOC_SPEAKER_TRIM_EXPLICIT); CHECK(controls.centre_db == 1.5); CHECK(controls.surround_db == 0.0); CHECK(controls.height_db == -6.0); CHECK(controls.listener_balance == -0.5); CHECK(controls.overhead_balance == 0.25); CHECK(controls.trim_bypass[1] == 1); CHECK(controls.trim_bypass[2] == 0); trim.configs[1].balance_listener = 1.5; CHECK(!joc::speaker::parameters_from_oamd(&trim, layout51, &controls).ok()); trim.configs[1].balance_listener = -0.5; trim.configs[1].centre = std::numeric_limits::quiet_NaN(); CHECK(!joc::speaker::parameters_from_oamd(&trim, layout51, &controls).ok()); trim.configs[1].centre = 1.5; trim.warp_mode = 2; CHECK(joc::speaker::parameters_from_oamd(&trim, layout51, &controls).ok()); CHECK(controls.warp_mode == 2); trim.warp_mode = 3; CHECK(joc::speaker::parameters_from_oamd(&trim, layout714, &controls).ok()); CHECK(controls.warp_mode == 3); CHECK(controls.trim_mode == EJOC_SPEAKER_TRIM_DISABLED); trim.warp_mode = 4; CHECK(joc::speaker::parameters_from_oamd(&trim, layout51, &controls).code() == JOC_ERR_INVALID_ARGUMENT); trim.warp_mode = 0; trim.global_trim_mode = 3; CHECK(!joc::speaker::parameters_from_oamd(&trim, layout51, &controls).ok()); // A layout without trim semantics settles on disabled before the reserved // global mode is looked at. CHECK(joc::speaker::parameters_from_oamd(&trim, layout714, &controls).ok()); CHECK(controls.trim_mode == EJOC_SPEAKER_TRIM_DISABLED); } void test_speaker_warp_and_trim() { joc::speaker::LayoutInfo layout51{}; joc::speaker::LayoutInfo layout514{}; CHECK(joc::speaker::layout_by_name("5.1", &layout51)); CHECK(joc::speaker::layout_by_name("5.1.4", &layout514)); ejoc_speaker_controls automatic51{}; CHECK(joc::speaker::parameters_from_oamd(nullptr, layout51, &automatic51).ok()); ejoc_speaker_controls automatic514{}; CHECK(joc::speaker::parameters_from_oamd(nullptr, layout514, &automatic514).ok()); // Warp 0 leaves the floor Y alone; warp 1 doubles it before the clamp. const std::vector warp0 = {0.85973646214220434, 0, 0, 0, 0.35611450268596406, 0}; const std::vector warp1 = {0.65801380052399572, 0, 0, 0, 0.65801380052399572, 0}; const std::vector clamped = {0, 0, 0, 0, 0.70794578438413791, 0}; check_gains(speaker_gains(layout51, automatic51, 0, 4096, 0), warp0); ejoc_speaker_controls warped = automatic51; warped.warp_mode = 1; check_gains(speaker_gains(layout51, warped, 0, 4096, 0), warp1); check_gains(speaker_gains(layout51, warped, 0, 24576, 0), clamped); // The height layer is not warped. const std::vector height_top = {0, 0, 0, 0, 0, 0, 0.84139514164519513, 0, 0, 0}; const std::vector height_warp0 = speaker_gains(layout514, automatic514, 0, 4096, 32767); ejoc_speaker_controls warped514 = automatic514; warped514.warp_mode = 1; check_gains(height_warp0, height_top); check_gains(speaker_gains(layout514, warped514, 0, 4096, 32767), height_top); // Explicit trim with balance: warp then balance for the floor, balance on // the original Y for the trim evaluation. ejoc_speaker_controls explicit_controls = speaker_controls( 1, EJOC_SPEAKER_TRIM_EXPLICIT); explicit_controls.surround_db = -6.0; explicit_controls.listener_balance = 9.0 / 16.0; explicit_controls.overhead_balance = -9.0 / 16.0; const std::vector trimmed = {0.36269933962647599, 0, 0, 0, 0.71183753429070229, 0}; check_gains(speaker_gains(layout51, explicit_controls, 0, 4096, 0), trimmed); // Per-object bypass keeps warp but drops balance and trim. const std::vector bypassed = {0.70710678118654757, 0, 0, 0, 0.70710678118654757, 0}; check_gains(speaker_gains(layout51, explicit_controls, 0, 4096, 0, true), bypassed); // Centre trim is local to the front-centre region; height trim scales with Z. ejoc_speaker_controls centre_controls = speaker_controls(0, EJOC_SPEAKER_TRIM_EXPLICIT); centre_controls.centre_db = -6.0; const std::vector centre = {3.0688867071757785e-17, 0, 0.50118723362727224, 0, 0, 0}; check_gains(speaker_gains(layout51, centre_controls, 16384, 0, 0), centre); ejoc_speaker_controls height_controls = speaker_controls(0, EJOC_SPEAKER_TRIM_EXPLICIT); height_controls.height_db = -6.0; const std::vector height_half = {0.50059326485045341, 0, 0, 0, 0, 0, 0.50059326485045341, 0, 0, 0}; check_gains(speaker_gains(layout514, height_controls, 0, 0, 16384), height_half); // LFE passes straight through, untouched by warp, trim or balance. ejoc_speaker_renderer_handle handle = ejoc_speaker_renderer_create(layout51.speaker_bitfield); CHECK(handle != nullptr); if (handle != nullptr) { std::vector input(static_cast(EJOC_SPEAKER_BLOCK_SAMPLES) * JOC_OUTPUT_CHANNELS, 0.0f); for (std::uint32_t sample = 0; sample < EJOC_SPEAKER_BLOCK_SAMPLES; ++sample) { input[sample * JOC_OUTPUT_CHANNELS] = 0.25f; } std::vector output(static_cast(EJOC_SPEAKER_BLOCK_SAMPLES) * layout51.channel_count, 0.0); CHECK(ejoc_speaker_renderer_process(handle, input.data(), EJOC_SPEAKER_BLOCK_SAMPLES, 0, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, &explicit_controls, output.data()) == 0); for (std::uint32_t sample = 0; sample < EJOC_SPEAKER_BLOCK_SAMPLES; ++sample) { for (std::uint32_t channel = 0; channel < layout51.channel_count; ++channel) { const double value = output[sample * layout51.channel_count + channel]; CHECK(channel == 3 ? std::fabs(value - 0.25) <= 1e-15 : value == 0.0); } } // Warp modes above the two-bit OAMD field are rejected. ejoc_speaker_controls reserved = speaker_controls(4, EJOC_SPEAKER_TRIM_DISABLED); CHECK(ejoc_speaker_renderer_process(handle, input.data(), EJOC_SPEAKER_BLOCK_SAMPLES, 0, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, &reserved, output.data()) != 0); ejoc_speaker_renderer_destroy(handle); } } // Warp 2/3 render the 5.1-family and 4.0 layouts through an expanded surround // layout and fold the rear pair back; calibration stays on the target layout. void test_speaker_surround_fold() { joc::speaker::LayoutInfo layout20{}; joc::speaker::LayoutInfo layout40{}; joc::speaker::LayoutInfo layout51{}; joc::speaker::LayoutInfo layout512{}; joc::speaker::LayoutInfo layout514{}; joc::speaker::LayoutInfo layout71{}; CHECK(joc::speaker::layout_by_name("2.0", &layout20)); CHECK(joc::speaker::layout_by_name("4.0", &layout40)); CHECK(joc::speaker::layout_by_name("5.1", &layout51)); CHECK(joc::speaker::layout_by_name("5.1.2", &layout512)); CHECK(joc::speaker::layout_by_name("5.1.4", &layout514)); CHECK(joc::speaker::layout_by_name("7.1", &layout71)); ejoc_speaker_controls pl2x{}; CHECK(joc::speaker::parameters_from_oamd(nullptr, layout51, &pl2x).ok()); pl2x.warp_mode = 2; ejoc_speaker_controls loro = pl2x; loro.warp_mode = 3; // PLIIx spreads the rear object into both surrounds; Lo/Ro keeps it on the // same side. Nothing is normalized after the fold. const std::vector pl2x_mid = {0, 0, 0, 0, 0.88868654605257746, 0.13546740014942704}; const std::vector loro_mid = {0, 0, 0, 0, 0.92498492652336017, 0}; const std::vector pl2x_back = {0, 0, 0, 0, 0.93411653293116492, 0.25030863131451864}; const std::vector loro_back = {0, 0, 0, 0, 1.0011865285504298, 0}; check_gains(speaker_gains(layout51, pl2x, 0, 20480, 0), pl2x_mid); check_gains(speaker_gains(layout51, loro, 0, 20480, 0), loro_mid); check_gains(speaker_gains(layout51, pl2x, 0, 24576, 0), pl2x_back); check_gains(speaker_gains(layout51, loro, 0, 24576, 0), loro_back); // 4.0 adds a rear pair without adding centre or LFE. const std::vector pl2x_40 = {0, 0, 0.93411653293116492, 0.25030863131451864}; const std::vector loro_40 = {0, 0, 1.0011865285504298, 0}; const std::vector loro_40_front = {0.85973646214220434, 0, 0.35611450268596406, 0}; check_gains(speaker_gains(layout40, pl2x, 0, 24576, 0), pl2x_40); check_gains(speaker_gains(layout40, loro, 0, 24576, 0), loro_40); check_gains(speaker_gains(layout40, loro, 0, 4096, 0), loro_40_front); // The height layer and the 5.1.4/5.1.2 geometry come from the 7.1 family. const std::vector pl2x_512 = {0, 0, 0, 0, 0.64546952862797569, 0.25210606107018951, 0.54573901433240524, 0}; const std::vector loro_512 = {0, 0, 0, 0, 0.7130211440987243, 0, 0.54573901433240524, 0}; const std::vector pl2x_514 = {0, 0, 0, 0, 0.70368087041735738, 0.27484211821501858, 0, 0, 0.59495621031473322, 0}; check_gains(speaker_gains(layout512, pl2x, 0, 28672, 16384), pl2x_512); check_gains(speaker_gains(layout512, loro, 0, 28672, 16384), loro_512); check_gains(speaker_gains(layout514, pl2x, 0, 28672, 16384), pl2x_514); // Calibration is selected for the final target, not the intermediate // layout: an explicit surround trim on 5.1 applies before the fold. ejoc_speaker_controls trimmed = pl2x; trimmed.trim_mode = EJOC_SPEAKER_TRIM_EXPLICIT; trimmed.surround_db = -6.0; const std::vector pl2x_trim = {0, 0, 0, 0, 0.66130386161214494, 0.17720494033407685}; check_gains(speaker_gains(layout51, trimmed, 0, 24576, 0), pl2x_trim); // Per-object bypass drops balance and trim but keeps the fold. const std::vector pl2x_bypass = {0, 0, 0, 0, 1.319474673818108, 0.35357033947489241}; check_gains(speaker_gains(layout51, trimmed, 0, 24576, 0, true), pl2x_bypass); // Layouts with both surround pairs, or none, render directly. ejoc_speaker_controls direct71{}; CHECK(joc::speaker::parameters_from_oamd(nullptr, layout71, &direct71).ok()); ejoc_speaker_controls pl2x71 = direct71; pl2x71.warp_mode = 2; check_gains(speaker_gains(layout71, pl2x71, 0, 24576, 0), speaker_gains(layout71, direct71, 0, 24576, 0)); ejoc_speaker_controls direct20{}; CHECK(joc::speaker::parameters_from_oamd(nullptr, layout20, &direct20).ok()); ejoc_speaker_controls pl2x20 = direct20; pl2x20.warp_mode = 2; check_gains(speaker_gains(layout20, pl2x20, 0, 24576, 0), speaker_gains(layout20, direct20, 0, 24576, 0)); // LFE passes through the folded output untouched. ejoc_speaker_renderer_handle handle = ejoc_speaker_renderer_create(layout51.speaker_bitfield); CHECK(handle != nullptr); if (handle != nullptr) { std::vector input(static_cast(EJOC_SPEAKER_BLOCK_SAMPLES) * JOC_OUTPUT_CHANNELS, 0.0f); for (std::uint32_t sample = 0; sample < EJOC_SPEAKER_BLOCK_SAMPLES; ++sample) { input[sample * JOC_OUTPUT_CHANNELS] = 0.25f; } std::vector output(static_cast(EJOC_SPEAKER_BLOCK_SAMPLES) * layout51.channel_count, 0.0); CHECK(ejoc_speaker_renderer_process(handle, input.data(), EJOC_SPEAKER_BLOCK_SAMPLES, 0, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, &pl2x, output.data()) == 0); for (std::uint32_t sample = 0; sample < EJOC_SPEAKER_BLOCK_SAMPLES; ++sample) { for (std::uint32_t channel = 0; channel < layout51.channel_count; ++channel) { const double value = output[sample * layout51.channel_count + channel]; CHECK(channel == 3 ? std::fabs(value - 0.25) <= 1e-15 : value == 0.0); } } ejoc_speaker_renderer_destroy(handle); } } // The speaker step takes the OAMD trim element from each payload; a payload // without it keeps the previous controls. void test_speaker_step_trim_events() { joc::speaker::SpeakerStep step; CHECK(joc::speaker::layout_by_name("5.1", &step.layout)); step.handle = ejoc_speaker_renderer_create(step.layout.speaker_bitfield); CHECK(step.handle != nullptr); if (step.handle == nullptr) { return; } std::vector frame(static_cast(JOC_FRAME_SAMPLES) * JOC_OUTPUT_CHANNELS, 0.0f); for (std::uint32_t sample = 0; sample < JOC_FRAME_SAMPLES; ++sample) { frame[1u * JOC_FRAME_SAMPLES + sample] = 1.0f; } std::string error; const std::size_t read = 1472u * step.layout.channel_count; joc::oamd::OamdUpdate update; update.slots[1].q2 = 4096; update.has_trim = true; update.trim.warp_mode = 1; update.trim.global_trim_mode = 0; update.trim.object_count = 16; CHECK(joc::speaker::step(&step, frame, &update, &error).ok()); const std::vector warp1 = {0.65801380052399572, 0, 0, 0, 0.65801380052399572, 0}; std::vector gains(step.layout.channel_count); for (std::uint32_t channel = 0; channel < step.layout.channel_count; ++channel) { gains[channel] = step.output[read + channel]; } check_gains(gains, warp1); // No trim element: warp 1 and automatic trim stay in effect. update = joc::oamd::OamdUpdate{}; update.slots[1].q2 = 2048; CHECK(joc::speaker::step(&step, frame, &update, &error).ok()); for (std::uint32_t channel = 0; channel < step.layout.channel_count; ++channel) { gains[channel] = step.output[read + channel]; } const std::vector half_warp1 = {0.89123112643513935, 0, 0, 0, 0.36916001977848539, 0}; check_gains(gains, half_warp1); // A new trim element switches the controls back to warp 0. update = joc::oamd::OamdUpdate{}; update.slots[1].q2 = 2048; update.has_trim = true; update.trim.warp_mode = 0; update.trim.global_trim_mode = 0; update.trim.object_count = 16; CHECK(joc::speaker::step(&step, frame, &update, &error).ok()); for (std::uint32_t channel = 0; channel < step.layout.channel_count; ++channel) { gains[channel] = step.output[read + channel]; } const std::vector half_warp0 = {0.94612591737884011, 0, 0, 0, 0.18819614606507579, 0}; check_gains(gains, half_warp0); // A warp 2 element renders through the expanded layout and folds. update = joc::oamd::OamdUpdate{}; update.slots[1].q2 = 24576; update.has_trim = true; update.trim.warp_mode = 2; update.trim.global_trim_mode = 0; update.trim.object_count = 16; CHECK(joc::speaker::step(&step, frame, &update, &error).ok()); for (std::uint32_t channel = 0; channel < step.layout.channel_count; ++channel) { gains[channel] = step.output[read + channel]; } const std::vector fold_back = {0, 0, 0, 0, 0.93411653293116492, 0.25030863131451864}; check_gains(gains, fold_back); ejoc_speaker_renderer_destroy(step.handle); } void test_dbmd_and_axml_trim() { joc::oamd::OamdTrim trim{}; trim.warp_mode = 2; trim.global_trim_mode = 2; trim.object_count = 16; trim.configs[0].kind = joc::oamd::TrimConfigKind::kDefault; trim.configs[1].kind = joc::oamd::TrimConfigKind::kDisabled; trim.configs[2].kind = joc::oamd::TrimConfigKind::kExplicit; trim.configs[2].presence = 0x1F; trim.configs[2].centre = 6.0; trim.configs[2].surround = -15.0; trim.configs[2].height = -36.0; trim.configs[2].balance_overhead = 1.0; trim.configs[2].balance_listener = -0.5; for (int index = 3; index < joc::oamd::kTrimConfigs; ++index) { trim.configs[index].kind = joc::oamd::TrimConfigKind::kDefault; } std::string dbmd; CHECK(joc::adm::build_dbmd(25, joc::adm::BinauralMode::Mid, &dbmd, &trim).ok()); std::string segment9; std::string segment10; std::size_t offset = 4; while (offset + 2 < dbmd.size() && static_cast(dbmd[offset]) != 0) { const std::size_t size = static_cast(static_cast(dbmd[offset + 1])) | (static_cast(static_cast(dbmd[offset + 2])) << 8); const std::size_t start = offset + 3; unsigned sum = static_cast(size); for (std::size_t i = 0; i < size; ++i) { sum += static_cast(dbmd[start + i]); } sum += static_cast(dbmd[start + size]); CHECK((sum & 0xFFu) == 0u); const unsigned id = static_cast(dbmd[offset]); if (id == 9u) { segment9 = dbmd.substr(start, size); } else if (id == 10u) { segment10 = dbmd.substr(start, size); } offset = start + size + 1; } CHECK(segment9.size() == 248); CHECK(static_cast(segment9[152]) == 2); CHECK(segment10.size() == 292); const std::string expected_configs = bytes_to_string(from_hex( "010000000000000000000000000000" "000000000000000000000000000000" "000000c040000070c1000010c27fc0" "010000000000000000000000000000" "010000000000000000000000000000" "010000000000000000000000000000" "010000000000000000000000000000" "010000000000000000000000000000" "010000000000000000000000000000")); CHECK(segment10.substr(7, 135) == expected_configs); // The bypass table and headphone modes stay untouched. for (std::size_t i = 7 + 9 * 15; i < 7 + 9 * 15 + 2 * 25; ++i) { const unsigned char expected = (i >= 7 + 9 * 15 + 25 + 10) ? 0x03u : 0x00u; CHECK(static_cast(segment10[i]) == expected); } // Without a trim element the warp field keeps the template's zero. std::string plain; CHECK(joc::adm::build_dbmd(25, joc::adm::BinauralMode::Mid, &plain).ok()); CHECK(plain.size() > 4); std::string plain_segment9; offset = 4; while (offset + 2 < plain.size() && static_cast(plain[offset]) != 0) { const std::size_t size = static_cast(static_cast(plain[offset + 1])) | (static_cast(static_cast(plain[offset + 2])) << 8); const std::size_t start = offset + 3; if (static_cast(plain[offset]) == 9u) { plain_segment9 = plain.substr(start, size); } offset = start + size + 1; } CHECK(plain_segment9.size() == 248); CHECK(static_cast(plain_segment9[152]) == 0u); std::vector tracks(15); for (std::size_t i = 0; i < tracks.size(); ++i) { tracks[i].name = "obj" + std::to_string(i); } const std::string axml = joc::adm::build_axml(tracks, 1.0, 48000, &trim); const std::string expected_block = "2" "" "0" "10.000000" "0.0000000.000000" "0.000000" "0.000000" "26.000000" "-15.000000-36.000000" "1.000000" "-0.500000" "34" "56" "78" "2"; const std::size_t found = axml.find(expected_block); CHECK(found != std::string::npos); CHECK(found < axml.find("")); const std::string plain_axml = joc::adm::build_axml(tracks, 1.0, 48000); CHECK(plain_axml.find("") == std::string::npos); } void test_adm_object_metadata() { std::vector tracks(15); for (std::size_t i = 0; i < tracks.size(); ++i) { tracks[i].name = "obj" + std::to_string(i); } joc::adm::Keyframe block; block.duration_samples = 48000; block.meta.gain = 0.5; block.meta.size[0] = 0.516155; block.meta.size[1] = 0.516155; block.meta.size[2] = 0.516155; block.meta.divergence = 0.25; tracks[1].blocks.push_back(block); const std::string axml = joc::adm::build_axml(tracks, 1.0, 48000); CHECK(axml.find("0.5161550.5161550.516155") != std::string::npos); CHECK(axml.find("0.500000") != std::string::npos); CHECK(axml.find("") != std::string::npos); // Default metadata writes no fields. tracks[1].blocks[0].meta = joc::adm::ObjectMetadata{}; const std::string plain = joc::adm::build_axml(tracks, 1.0, 48000); CHECK(plain.find("") == std::string::npos); CHECK(plain.find(" trajectory; CHECK(builder.build(96000, joc::adm::TrajectoryMode::Compact, &trajectory).ok()); CHECK(trajectory[1].blocks.size() >= 2); CHECK(std::fabs(trajectory[1].blocks.front().meta.gain - 0.5) < 1e-12); CHECK(trajectory[1].blocks.back().meta.divergence == 0.0); } void test_multichannel_binaural_helpers() { const joc::multichannel::Layout* layout = joc::multichannel::find_layout("5.1"); CHECK(layout != nullptr); CHECK(layout->channels == 6); double positions[15][3] = {}; CHECK(joc::multichannel::object_positions(*layout, positions).ok()); CHECK(positions[0][0] == -1.0 && positions[0][1] == 1.0); CHECK(positions[2][0] == 0.0 && positions[2][1] == 1.0); CHECK(positions[3][0] == -1.0 && positions[3][1] == -1.0); const joc::multichannel::Layout* surround = joc::multichannel::detect_layout(8); CHECK(surround != nullptr && std::string(surround->name) == "7.1"); std::vector pcm(12); for (int index = 0; index < 12; ++index) { pcm[static_cast(index)] = 0.01f * index; } std::vector objects(16 * 2, 0.0f); CHECK(joc::multichannel::pcm_to_objects16(pcm.data(), 2, *layout, objects.data()).ok()); CHECK(objects[0 * 2 + 0] == pcm[3]); CHECK(objects[1 * 2 + 0] == pcm[0]); CHECK(objects[3 * 2 + 0] == pcm[2]); CHECK(objects[4 * 2 + 1] == pcm[10]); CHECK(objects[6 * 2 + 0] == 0.0f); std::vector dc(200, 0.5f); std::vector up; CHECK(joc::multichannel::resample_interleaved(dc.data(), 100, 2, 48000, 96000, &up).ok()); CHECK(up.size() == 400); CHECK(std::fabs(up[100] - 0.5f) < 1.0e-3f); std::vector down; CHECK(joc::multichannel::resample_interleaved(up.data(), 200, 2, 96000, 48000, &down).ok()); CHECK(down.size() == 200); CHECK(std::fabs(down[100] - 0.5f) < 1.0e-3f); for (const std::uint32_t rate : {44100u, 88200u, 176400u, 48000u, 96000u, 192000u}) { std::vector input(200, 0.5f); std::vector output; CHECK(joc::multichannel::resample_interleaved( input.data(), 100, 2, rate, 48000, &output) .ok()); const std::size_t expected = static_cast( std::llround(100.0 * 48000.0 / static_cast(rate))); CHECK(output.size() == expected * 2); CHECK(std::fabs(output[output.size() / 2] - 0.5f) < 1.0e-3f); } } void test_int24_packing() { // Interleaved (L,R) for two frames: 0.0, +1.0, -1.0, +2.0 (clips). const float values[4] = {0.0f, 1.0f, -1.0f, 2.0f}; std::string packed; joc::io::pack_int24(values, 2, 2, &packed); CHECK(packed.size() == 12); auto byte = [&](std::size_t index) { return static_cast(packed[index]); }; CHECK(byte(0) == 0x00 && byte(1) == 0x00 && byte(2) == 0x00); // 0.0 CHECK(byte(3) == 0xFF && byte(4) == 0xFF && byte(5) == 0x7F); // +1.0 CHECK(byte(6) == 0x01 && byte(7) == 0x00 && byte(8) == 0x80); // -1.0 CHECK(byte(9) == 0xFF && byte(10) == 0xFF && byte(11) == 0x7F); // +2.0 clips } void test_utf8_paths() { // Non-ASCII paths must survive the OS boundary on every platform: this is the // regression guard for the ANSI-code-page bug class (a Japanese path used to // reach ffmpeg as mojibake on Windows). const std::string directory = joc::fs_utf8::temp_directory(); CHECK(!directory.empty()); const std::string path = joc::fs_utf8::from_path( joc::fs_utf8::to_path(directory) / joc::fs_utf8::to_path("joc_テスト_須田景凪_测试.bin")); CHECK(joc::fs_utf8::from_path(joc::fs_utf8::to_path(path)) == path); std::FILE* file = joc::fs_utf8::fopen(path, "wb"); CHECK(file != nullptr); if (file != nullptr) { const char payload[] = "joc-utf8"; CHECK(std::fwrite(payload, 1, sizeof(payload) - 1u, file) == sizeof(payload) - 1u); std::fclose(file); } CHECK(joc::fs_utf8::exists(path)); std::error_code error; CHECK(joc::fs_utf8::file_size(path, error) == sizeof("joc-utf8") - 1u); std::ifstream input = joc::fs_utf8::open_input(path); CHECK(input.good()); std::string content(sizeof("joc-utf8") - 1u, '\0'); input.read(content.data(), static_cast(content.size())); CHECK(content == "joc-utf8"); input.close(); std::ofstream output = joc::fs_utf8::open_output(path + ".copy"); CHECK(output.good()); output << content; output.close(); CHECK(joc::fs_utf8::exists(path + ".copy")); CHECK(joc::fs_utf8::remove(path) == 0); CHECK(joc::fs_utf8::remove(path + ".copy") == 0); CHECK(!joc::fs_utf8::exists(path)); } void test_process_runner() { // The ffmpeg boundary must surface both the exit code and the child's stderr. #if defined(_WIN32) const std::vector command = {"cmd.exe", "/c", "echo boom 1>&2 & exit 3"}; #else const std::vector command = {"/bin/sh", "-c", "echo boom 1>&2; exit 3"}; #endif joc::io::ProcessResult result; const joc::Status status = joc::io::run_process(command, &result); CHECK(!status.ok()); CHECK(result.exit_code == 3u); CHECK(result.output.find("boom") != std::string::npos); } void test_find_executable() { // An executable reference has to become a concrete path: that is what turns the // default "ffmpeg" into something a child process starts without a PATH search of // its own, on both platforms. const std::string bare = #if defined(_WIN32) "cmd"; #else "sh"; #endif const std::string resolved = joc::fs_utf8::find_executable(bare); CHECK(!resolved.empty()); CHECK(resolved.find_first_of("/\\") != std::string::npos); CHECK(joc::fs_utf8::exists(resolved)); // An already concrete path is kept verbatim instead of being searched for again. CHECK(joc::fs_utf8::find_executable(resolved) == resolved); CHECK(joc::fs_utf8::find_executable("").empty()); CHECK(joc::fs_utf8::find_executable("joc_no_such_program_9f2c").empty()); // A reference with a directory separator names a location, so it is never answered // by a same-named program found somewhere else. CHECK(joc::fs_utf8::find_executable("joc_no_such_dir/joc_no_such_program_9f2c").empty()); #if !defined(_WIN32) // Without the execute bit the kernel refuses the file, so it is not a match. const std::string plain = joc::fs_utf8::from_path( joc::fs_utf8::to_path(joc::fs_utf8::temp_directory()) / joc::fs_utf8::to_path("joc_not_executable_9f2c")); std::FILE* file = joc::fs_utf8::fopen(plain, "wb"); CHECK(file != nullptr); if (file != nullptr) { std::fclose(file); } CHECK(joc::fs_utf8::find_executable(plain).empty()); CHECK(joc::fs_utf8::remove(plain) == 0); #endif } void test_npy_and_zip_writers() { using joc::io::NpyMember; // Python's repr, which is what json.dumps writes into the cache metadata. CHECK(joc::io::python_float_repr(48000.0) == "48000.0"); CHECK(joc::io::python_float_repr(1.0) == "1.0"); CHECK(joc::io::python_float_repr(0.001) == "0.001"); CHECK(joc::io::python_float_repr(1.0e-5) == "1e-05"); CHECK(joc::io::python_float_repr(1.5) == "1.5"); CHECK(joc::io::python_float_repr(-2.25) == "-2.25"); CHECK(joc::io::python_float_repr(1.0e16) == "1e+16"); CHECK(joc::io::python_float_repr(1234567890123456.0) == "1234567890123456.0"); // An NPY image must round-trip through the reader that loads the cache. const std::vector values = {1.5, -2.25, 3.75, 4.0, 0.5, 0.25}; std::vector payload(values.size() * sizeof(double)); std::memcpy(payload.data(), values.data(), payload.size()); const std::vector image = joc::io::npy_image(" restored; CHECK(joc::io::npy_to_double(array, &restored, &error)); CHECK(restored.size() == values.size()); bool same = restored.size() == values.size(); for (std::size_t index = 0; index < restored.size() && same; ++index) { same = restored[index] == values[index]; } CHECK(same); // A Unicode scalar string member, as the cache stores its metadata. const std::string text = "{\"k\":\"v\"}"; const std::vector unicode = joc::io::utf8_to_utf32le(text); CHECK(unicode.size() == text.size() * 4u); CHECK(unicode[0] == static_cast('{') && unicode[1] == 0u && unicode[3] == 0u); const std::vector text_image = joc::io::npy_image(" members; NpyMember member; member.name = "band_center_frequencies_hz"; member.descr = " read_back; CHECK(archive.read_member("band_center_frequencies_hz.npy", &read_back, &error)); CHECK(read_back.size() == image.size()); CHECK(read_back.size() == image.size() && std::memcmp(read_back.data(), image.data(), image.size()) == 0); CHECK(joc::fs_utf8::remove(path) == 0); } // --------------------------------------------------------------------------- // HRTF import and compile path. // // Everything below builds its input in memory, so the suite reads no external // files; the parts that need one are exercised through their error paths. // --------------------------------------------------------------------------- constexpr double kPi = 3.14159265358979323846; // A SimpleFreeFieldHRIR set with `measurements` directions on one 1 m shell and // `taps` decaying taps per ear. The values are closed-form placeholders; what // the canonicaliser and the spherical-harmonic fit actually read is the // geometry and the shape. void test_rosella_model_errors() { // A real model is proprietary user data and is not part of this repository. // What can be checked without one is that every malformed input is reported // instead of being half-loaded. joc::hrtf::RosellaModel model; const std::string missing = joc::fs_utf8::temp_directory() + "/joc_absent.headphone"; CHECK(!joc::hrtf::load_personalized_headphone(missing, &model).ok()); CHECK(!joc::hrtf::load_personalized_headphone(missing, nullptr).ok()); const std::string raw = joc::fs_utf8::temp_directory() + "/joc_raw.headphone"; { std::ofstream stream = joc::fs_utf8::open_output(raw); stream << "rp binary model, not JSON"; } const joc::Status raw_status = joc::hrtf::load_personalized_headphone(raw, &model); CHECK(!raw_status.ok()); CHECK(raw_status.message().find("JSON") != std::string::npos); CHECK(joc::fs_utf8::remove(raw) == 0); const std::string empty = joc::fs_utf8::temp_directory() + "/joc_empty.headphone"; { std::ofstream stream = joc::fs_utf8::open_output(empty); stream << "{}"; } CHECK(!joc::hrtf::load_personalized_headphone(empty, &model).ok()); CHECK(joc::fs_utf8::remove(empty) == 0); const std::string no_coefficients = joc::fs_utf8::temp_directory() + "/joc_no_coeff.headphone"; { std::ofstream stream = joc::fs_utf8::open_output(no_coefficients); stream << "{\"personalized_hrtf\":{\"virtualizer_parameters\":{}}}"; } const joc::Status status = joc::hrtf::load_personalized_headphone(no_coefficients, &model); CHECK(!status.ok()); CHECK(status.message().find("rosella_coefficients") != std::string::npos); CHECK(joc::fs_utf8::remove(no_coefficients) == 0); } void test_builtin_kernel_tables() { // The filterbank tables are compiled in, and their content must stay identical // to the standard-defined archive the file loader accepts. The hashes below are // the SHA-256 of each member's C-order bytes. const joc::hrtf::Kernels& kernels = joc::hrtf::builtin_kernels(); CHECK(kernels.qmf_analysis.size() == 640); CHECK(kernels.hybrid_low.size() == 2496); CHECK(kernels.hybrid_indices.size() == 616); CHECK(kernels.hybrid_values.size() == 154); CHECK(kernels.qmf_basis.size() == 32768); CHECK(kernels.qmf_taps.size() == 2560); CHECK(kernels.hybrid_count == 154); auto hash_floats = [](const std::vector& values, bool narrow) { joc::crypto::Sha256 hash; if (narrow) { std::vector raw(values.size()); for (std::size_t i = 0; i < values.size(); ++i) { raw[i] = static_cast(values[i]); } hash.update(raw.data(), raw.size() * sizeof(float)); } else { hash.update(values.data(), values.size() * sizeof(double)); } return hash.finish_hex(); }; CHECK(hash_floats(kernels.qmf_analysis, true) == "aeff6c7117d41664b9c4bf03bbf563f5319ec1b8c551f171adbb90cf19d9d306"); CHECK(hash_floats(kernels.hybrid_low, true) == "d00d36133b81ba699a7630c4df1be203fa1b7e371e595eaaebbe8957db322627"); CHECK(hash_floats(kernels.hybrid_values, true) == "99409fdd9d20d1d7c2be16bbc1e2159c8042487227c72160850745164c9cee7f"); CHECK(hash_floats(kernels.qmf_basis, false) == "a0c4a55385f6d6c7c92d7615c83ad5fbda51046d9ef785cac0b9ac9a760dc527"); CHECK(hash_floats(kernels.qmf_taps, false) == "cd7756d060d51fbf02f44c1ce53cb6225b221099505c94c3f58d3bee6f428150"); joc::crypto::Sha256 indices; indices.update(kernels.hybrid_indices.data(), kernels.hybrid_indices.size() * sizeof(std::int16_t)); CHECK(indices.finish_hex() == "f5beb3220e4530fcf28e7f4da7f07e821074265d118c911d61a590e00753a573"); } // Drives one objects16 stream over `block` and returns what it renders. With // `frame_at_a_time` each push carries a single frame; otherwise the whole batch // goes in at once. `peak` reports the largest backlog a push left behind. std::vector drive_objects16_stream(const std::vector& block, std::size_t frames, bool frame_at_a_time, std::size_t* peak) { constexpr std::size_t kFrameValues = JOC_OUTPUT_CHANNELS * JOC_FRAME_SAMPLES; joc::stream::Stream stream; joc::stream::Config config; config.input = JOC_STREAM_IN_PCM_OBJECTS16; config.output = JOC_STREAM_OUT_SPEAKER; config.layout = "5.1"; const joc::Status created = stream.create(config); CHECK(created.ok()); if (!created.ok()) { return {}; } const std::size_t channels = stream.info().output_channels; CHECK(channels != 0u); std::vector pulled(4096u * channels); std::vector rendered; const auto drain = [&] { for (;;) { std::size_t produced = 0; const joc::Status status = stream.pull(pulled.data(), 4096u, &produced); CHECK(status.ok()); if (!status.ok() || produced == 0u) { return; } rendered.insert(rendered.end(), pulled.begin(), pulled.begin() + static_cast(produced * channels)); } }; std::size_t consumed = 0; while (consumed < frames) { const std::size_t count = frame_at_a_time ? 1u : frames - consumed; std::size_t taken = 0; const joc::Status pushed = stream.push_objects16( block.data() + consumed * kFrameValues, count * JOC_FRAME_SAMPLES, &taken); CHECK(pushed.ok()); if (!pushed.ok()) { return rendered; } // A push takes everything it is given; only the rendering is bounded. CHECK(taken == count * JOC_FRAME_SAMPLES); *peak = std::max(*peak, stream.buffered_samples()); consumed += taken / JOC_FRAME_SAMPLES; drain(); } CHECK(stream.flush().ok()); drain(); return rendered; } void test_rosella_filterbank_config() { // validate() reports a selector it cannot honour instead of ignoring it: the // captured bank needs the Rosella model, and any other value is out of range. const auto reported = [](std::uint32_t selector, const char* personalized) { joc_task_config config{}; config.struct_size = sizeof(config); config.struct_version = JOC_TASK_CONFIG_VERSION; config.input_path = "input.eac3"; config.output_path = "output.wav"; config.operation = JOC_OP_BINAURAL; config.binaural_mode = JOC_BINAURAL_MID; config.personalized_headphone_path = personalized; config.hrtf_path = personalized == nullptr ? "cache.jochrtf" : nullptr; config.rosella_filterbank = selector; std::vector issues; std::uint32_t errors = 0; joc::task::validate(config, &issues, &errors); for (const joc_validation_issue& issue : issues) { if (std::string(issue.field) == "rosella_filterbank") { return true; } } return false; }; CHECK(!reported(JOC_ROSELLA_FILTERBANK_PUBLIC, "model.personalized_headphone")); CHECK(!reported(JOC_ROSELLA_FILTERBANK_CAPTURED, "model.personalized_headphone")); CHECK(reported(3u, "model.personalized_headphone")); CHECK(reported(JOC_ROSELLA_FILTERBANK_CAPTURED, nullptr)); } // A push renders every frame it makes ready, so the stream bounds how far ahead of // the caller it renders. A batch pushed at once must therefore leave a bounded // backlog, and it must render the same samples as pushing one frame at a time. void test_stream_render_ahead() { constexpr std::size_t kFrames = 32; constexpr std::size_t kFrameValues = JOC_OUTPUT_CHANNELS * JOC_FRAME_SAMPLES; std::vector block(kFrames * kFrameValues); for (std::size_t index = 0; index < block.size(); ++index) { block[index] = static_cast(std::sin(static_cast(index) * 0.0007) * 0.25); } std::size_t frame_peak = 0; const std::vector reference = drive_objects16_stream(block, kFrames, true, &frame_peak); std::size_t batch_peak = 0; const std::vector batched = drive_objects16_stream(block, kFrames, false, &batch_peak); CHECK(!reference.empty()); CHECK(batched == reference); // The batch is larger than the bound, so it cannot all be rendered at once. CHECK(batch_peak < kFrames * JOC_FRAME_SAMPLES / 2u); } } // namespace // The JOC clipgain is the analysis-side scalar's per-frame factor: it scales the // frame that carries it, ramps over that frame's first 256 samples, starts from // the frame's own value after a reset, and never reaches LFE. struct ClipGainInputs { std::vector bed; std::vector lfe; std::vector n_bands; std::vector n_dpoints; std::vector slope; std::vector offsets; std::vector dq; ClipGainInputs() : bed(EJOC_CORE_CHANNELS * EJOC_FRAME_SAMPLES, 0.0f), lfe(EJOC_FRAME_SAMPLES, 0.0f), n_bands(EJOC_MAX_OBJECTS, 0), n_dpoints(EJOC_MAX_OBJECTS, 0), slope(EJOC_MAX_OBJECTS, 0), offsets(EJOC_MAX_OBJECTS * EJOC_MAX_DPOINTS, 0), dq(static_cast(EJOC_MAX_OBJECTS) * EJOC_MAX_DPOINTS * EJOC_MAX_CORE_CHANNELS * EJOC_MAX_PARAMETER_BANDS, 0.0) { const double two_pi = 6.283185307179586476925286766559; for (int sample = 0; sample < EJOC_FRAME_SAMPLES; ++sample) { const double t = static_cast(sample) / 48000.0; bed[sample] = static_cast(0.05 * std::sin(two_pi * 440.0 * t)); lfe[sample] = static_cast(0.02 * std::sin(two_pi * 55.0 * t)); } // Object 0 passes the first core channel through one parameter band. n_bands[0] = 1; n_dpoints[0] = 1; dq[0] = 1.0; } }; bool clipgain_process(ejoc_renderer_handle handle, const ClipGainInputs& in, double clipgain, std::vector* out) { out->assign(static_cast(EJOC_OUTPUT_CHANNELS) * EJOC_FRAME_SAMPLES, 0.0f); return ejoc_renderer_process(handle, in.bed.data(), in.lfe.data(), EJOC_CORE_CHANNELS, 0u, 1u, in.n_bands.data(), in.n_dpoints.data(), in.slope.data(), in.offsets.data(), in.dq.data(), clipgain, 0.0625f, 1.0f, out->data()) == 0; } // The status struct only grows by appending fields: both the current size and // the size that ended at `ended` are accepted, and an unrelated size is rejected. void test_stream_status_struct_sizes() { joc_stream_config config{}; config.struct_size = sizeof(config); config.struct_version = 1; config.input = JOC_STREAM_IN_EAC3; config.output = JOC_STREAM_OUT_SPEAKER; config.speaker_layout_name = "7.1"; joc_stream* stream = nullptr; CHECK(joc_stream_create(&config, &stream) == JOC_OK); CHECK(stream != nullptr); if (stream == nullptr) { return; } joc_stream_status_info legacy{}; legacy.struct_size = static_cast(offsetof(joc_stream_status_info, truncated_joc_frames)); legacy.struct_version = 1; CHECK(joc_stream_status(stream, &legacy) == JOC_OK); CHECK(legacy.output_channels == 8u); CHECK(legacy.truncated_joc_frames == 0u); joc_stream_status_info current{}; current.struct_size = sizeof(current); current.struct_version = 1; CHECK(joc_stream_status(stream, ¤t) == JOC_OK); CHECK(current.output_channels == 8u); CHECK(current.truncated_joc_frames == 0u); joc_stream_status_info rejected{}; rejected.struct_size = 64; rejected.struct_version = 1; CHECK(joc_stream_status(stream, &rejected) == JOC_ERR_INVALID_ARGUMENT); CHECK(joc_stream_destroy(stream) == JOC_OK); } void test_clipgain_first_frame_uses_its_own_gain() { const ClipGainInputs in; std::vector unity; std::vector doubled; auto render = [&in](double clipgain, std::vector* out) { ejoc_renderer_handle handle = ejoc_renderer_create(); ejoc_renderer_set_threads(handle, 1); const bool ok = clipgain_process(handle, in, clipgain, out); ejoc_renderer_destroy(handle); return ok; }; CHECK(render(1.0, &unity)); CHECK(render(2.0, &doubled)); float peak = 0.0f; bool scaled = true; for (int sample = 0; sample < EJOC_FRAME_SAMPLES; ++sample) { const float value = unity[EJOC_FRAME_SAMPLES + sample]; // object 0 is channel 1 peak = std::max(peak, std::fabs(value)); if (doubled[EJOC_FRAME_SAMPLES + sample] != 2.0f * value) { scaled = false; } } // A fresh handle takes the current gain with no transition. CHECK(peak > 1.0e-3f); CHECK(scaled); // The LFE now carries the same full clipgain: a fresh ring starts with 1217 // zero samples and the rest scales by the frame's gain (2x is exact). bool lfe_scaled = true; for (int sample = 0; sample < EJOC_FRAME_SAMPLES; ++sample) { if (doubled[static_cast(sample)] != 2.0f * unity[static_cast(sample)]) { lfe_scaled = false; break; } } CHECK(lfe_scaled); for (int sample = 0; sample < JOC_LFE_DELAY_SAMPLES; ++sample) { CHECK(unity[static_cast(sample)] == 0.0f); } } void test_clipgain_change_applies_to_the_current_frame() { const ClipGainInputs in; std::vector changed; std::vector held; auto run = [&in](double second_gain, std::vector* out) { ejoc_renderer_handle handle = ejoc_renderer_create(); ejoc_renderer_set_threads(handle, 1); std::vector first; const bool ok = clipgain_process(handle, in, 1.0, &first) && clipgain_process(handle, in, second_gain, out); ejoc_renderer_destroy(handle); return ok; }; CHECK(run(2.0, &changed)); CHECK(run(1.0, &held)); // The change has to land in the frame carrying it; a one-frame-late gain // would make these two frames identical. double difference = 0.0; double energy = 0.0; for (int object = 1; object < EJOC_OUTPUT_CHANNELS; ++object) { for (int sample = 0; sample < EJOC_FRAME_SAMPLES; ++sample) { const std::size_t index = static_cast(object) * EJOC_FRAME_SAMPLES + sample; difference += std::fabs(static_cast(changed[index]) - held[index]); energy += std::fabs(static_cast(held[index])); } } CHECK(difference > 0.05 * energy); // The analysis delay lines and the QMF windows hold the new gain back by // about 1400 samples, so the start of the frame still carries the old value // and the end is scaled by the new one. bool head_intact = true; for (int sample = 0; sample < 256; ++sample) { const std::size_t index = static_cast(EJOC_FRAME_SAMPLES) + sample; if (changed[index] != held[index]) { head_intact = false; } } CHECK(head_intact); double tail = 0.0; for (int sample = 1504; sample < EJOC_FRAME_SAMPLES; ++sample) { const std::size_t index = static_cast(EJOC_FRAME_SAMPLES) + sample; tail = std::max(tail, std::fabs(static_cast(changed[index]) - 2.0 * static_cast(held[index]))); } CHECK(tail < 1.0e-4); } void test_clipgain_reset_clears_the_previous_gain() { const ClipGainInputs in; std::vector scratch; std::vector after_reset; std::vector fresh; ejoc_renderer_handle handle = ejoc_renderer_create(); ejoc_renderer_set_threads(handle, 1); CHECK(clipgain_process(handle, in, 3.0, &scratch)); CHECK(clipgain_process(handle, in, 3.0, &scratch)); CHECK(ejoc_renderer_reset(handle) == 0); CHECK(clipgain_process(handle, in, 1.0, &after_reset)); ejoc_renderer_destroy(handle); ejoc_renderer_handle pristine = ejoc_renderer_create(); ejoc_renderer_set_threads(pristine, 1); CHECK(clipgain_process(pristine, in, 1.0, &fresh)); ejoc_renderer_destroy(pristine); // No gain state may survive the reset: the first frame must match a fresh // renderer instead of ramping down from the previous 3x. CHECK(after_reset.size() == fresh.size()); CHECK(std::memcmp(after_reset.data(), fresh.data(), sizeof(float) * after_reset.size()) == 0); } // --------------------------------------------------------------------------- // JOC frame-level core: clipgain formula, frame status, offset_ts validation, // LFE clipgain ramp, 8-plane passthrough, seq state machine and the // no-previous-state interpolation rules. // --------------------------------------------------------------------------- struct JocBitWriter { std::vector bytes; std::size_t bit_count = 0; void write(std::uint32_t value, int count) { for (int index = count - 1; index >= 0; --index) { if ((bit_count & 7u) == 0u) { bytes.push_back(0u); } if (((value >> index) & 1u) != 0u) { bytes.back() |= static_cast(1u << (7u - (bit_count & 7u))); } ++bit_count; } } }; bool huffman_path(const int (*nodes)[2], int count, int value, std::vector* path) { struct Entry { int node; std::vector path; }; std::vector queue; queue.push_back({0, {}}); for (std::size_t index = 0; index < queue.size() && index < 4096u; ++index) { const int node = queue[index].node; if (node < 0) { if (-node - 1 == value) { *path = queue[index].path; return true; } continue; } if (node >= count) { continue; } std::vector left = queue[index].path; left.push_back(0); queue.push_back({nodes[node][0], std::move(left)}); std::vector right = queue[index].path; right.push_back(1); queue.push_back({nodes[node][1], std::move(right)}); } return false; } void write_huffman_symbol(JocBitWriter* writer, const int (*nodes)[2], int count, int value) { std::vector path; CHECK(huffman_path(nodes, count, value, &path)); for (const int bit : path) { writer->write(static_cast(bit), 1); } } // One synthetic ID14 payload with at most one present object (object 0), one // parameter band, dense syntax and 5 core channels. struct Id14Spec { std::uint8_t dmx_config_idx = 3; std::uint32_t num_objects_bits = 0; // declares one object std::uint8_t ext_config_idx = 0; std::uint8_t clipgain_x = 4; std::uint8_t clipgain_y = 0; std::uint32_t seq = 1; bool present = false; std::uint8_t n_bands_idx = 0; // one parameter band std::uint8_t sparse = 0; std::uint8_t quant = 0; std::uint8_t slope = 0; bool two_data_points = false; std::uint8_t offset0 = 0; std::uint8_t offset1 = 0; bool trailing = false; }; std::vector make_id14_payload(const Id14Spec& spec) { JocBitWriter writer; writer.write(spec.dmx_config_idx, 3); writer.write(spec.num_objects_bits, 6); writer.write(spec.ext_config_idx, 3); writer.write(spec.clipgain_x, 3); writer.write(spec.clipgain_y, 5); writer.write(spec.seq, 10); const std::uint32_t declared = spec.num_objects_bits + 1u; const std::uint32_t objects = declared > 15u ? 15u : declared; for (std::uint32_t object = 0; object < objects; ++object) { const bool present = object == 0u && spec.present; writer.write(present ? 1u : 0u, 1); if (!present) { continue; } writer.write(spec.n_bands_idx, 3); writer.write(spec.sparse, 1); writer.write(spec.quant, 1); writer.write(spec.slope, 1); writer.write(spec.two_data_points ? 1u : 0u, 1); if (spec.slope == 1u) { writer.write(spec.offset0, 5); if (spec.two_data_points) { writer.write(spec.offset1, 5); } } } if (spec.present && spec.sparse == 0u) { constexpr int kCount = static_cast(sizeof(joc_huff_code_coarse_generic) / sizeof(joc_huff_code_coarse_generic[0])); const int points = spec.two_data_points ? 2 : 1; for (int point = 0; point < points; ++point) { for (int channel = 0; channel < 5; ++channel) { write_huffman_symbol(&writer, joc_huff_code_coarse_generic, kCount, 0); } } } while ((writer.bit_count & 7u) != 0u) { writer.write(0u, 1); } if (spec.trailing) { writer.bytes.push_back(0u); writer.bytes.push_back(0u); } return writer.bytes; } void test_joc_clipgain_formula() { struct Case { std::uint8_t x; std::uint8_t y; double expected; }; const Case cases[] = { {0, 0, 0.0625}, {2, 8, 0.3125}, {3, 0, 0.5}, {4, 0, 1.0}, {4, 16, 1.5}, {5, 16, 3.0}, {7, 31, 15.75}, }; for (const Case& item : cases) { Id14Spec spec; spec.clipgain_x = item.x; spec.clipgain_y = item.y; spec.seq = 7; const std::vector payload = make_id14_payload(spec); joc_frame_params params{}; CHECK(joc::joc::parse_id14(payload.data(), payload.size(), ¶ms, nullptr).ok()); CHECK(params.status == JOC_FRAME_STATUS_OK); CHECK(params.clipgain == item.expected); CHECK(params.seq_count == 7u); CHECK(params.n_channels == 5u); } } void test_joc_parse_status_and_offset_ts() { // Unsupported downmix configuration: status 2, and the object syntax is not // expanded because the core channel count is unknown. { Id14Spec spec; spec.dmx_config_idx = 5; const std::vector payload = make_id14_payload(spec); joc_frame_params params{}; CHECK(joc::joc::parse_id14(payload.data(), payload.size(), ¶ms, nullptr).ok()); CHECK(params.status == JOC_FRAME_STATUS_UNSUPPORTED_DMX); CHECK(params.n_channels == 0u); CHECK(params.n_objects == 0u); } // More than 15 declared objects: the count is clamped and the // corresponding frame status is reported, while the frame still parses. { Id14Spec spec; spec.num_objects_bits = 15; // declares 16 objects const std::vector payload = make_id14_payload(spec); joc_frame_params params{}; CHECK(joc::joc::parse_id14(payload.data(), payload.size(), ¶ms, nullptr).ok()); CHECK(params.status == JOC_FRAME_STATUS_OBJECTS_CLAMPED); CHECK(params.objects_clamped == 1u); CHECK(params.n_objects == 15u); CHECK(params.n_channels == 5u); } // Legal raw 5-bit offset_ts values stay as coded (no +1). { Id14Spec spec; spec.present = true; spec.slope = 1; spec.two_data_points = true; spec.offset0 = 5; spec.offset1 = 10; const std::vector payload = make_id14_payload(spec); joc_frame_params params{}; CHECK(joc::joc::parse_id14(payload.data(), payload.size(), ¶ms, nullptr).ok()); CHECK(params.status == JOC_FRAME_STATUS_OK); CHECK(params.objects[0].offset_ts[0] == 5u); CHECK(params.objects[0].offset_ts[1] == 10u); CHECK(params.objects[0].n_dpoints == 2u); CHECK((params.present_mask & 1u) != 0u); } // offset_ts outside 0..23 -> status 5. { Id14Spec spec; spec.present = true; spec.slope = 1; spec.two_data_points = true; spec.offset0 = 24; spec.offset1 = 25; const std::vector payload = make_id14_payload(spec); joc_frame_params params{}; CHECK(joc::joc::parse_id14(payload.data(), payload.size(), ¶ms, nullptr).ok()); CHECK(params.status == JOC_FRAME_STATUS_BAD_OFFSET_TS); CHECK(params.objects[0].offset_ts[0] == 24u); } // Non-increasing offset_ts -> status 5. { Id14Spec spec; spec.present = true; spec.slope = 1; spec.two_data_points = true; spec.offset0 = 10; spec.offset1 = 10; const std::vector payload = make_id14_payload(spec); joc_frame_params params{}; CHECK(joc::joc::parse_id14(payload.data(), payload.size(), ¶ms, nullptr).ok()); CHECK(params.status == JOC_FRAME_STATUS_BAD_OFFSET_TS); } // Data after the byte alignment of joc_data -> status 6. { Id14Spec spec; spec.present = true; spec.trailing = true; const std::vector payload = make_id14_payload(spec); joc_frame_params params{}; CHECK(joc::joc::parse_id14(payload.data(), payload.size(), ¶ms, nullptr).ok()); CHECK(params.status == JOC_FRAME_STATUS_TRAILING_DATA); CHECK(params.trailing_bits > 0u); } // The same payload without the extra bytes is a normal frame. { Id14Spec spec; spec.present = true; const std::vector payload = make_id14_payload(spec); joc_frame_params params{}; CHECK(joc::joc::parse_id14(payload.data(), payload.size(), ¶ms, nullptr).ok()); CHECK(params.status == JOC_FRAME_STATUS_OK); CHECK(params.objects[0].n_bands == 1u); CHECK(params.present_mask == 1u); } } // Helpers for the truncated-payload tests. The container is byte aligned and // carries one ID11 and one ID14 payload, the shape a JOC syncframe carries; the // bytes are not a real E-AC-3 frame because the container scan only needs the // EMDF syncword. std::vector make_joc_emdf_container(const std::vector& oamd, const std::vector& joc) { JocBitWriter body; body.write(0, 2); // emdf_version body.write(0, 3); // key_id for (int index = 0; index < 2; ++index) { const bool first = index == 0; const std::vector& payload = first ? oamd : joc; body.write(first ? 11u : 14u, 5); body.write(0, 1); // has_sample_offset body.write(0, 1); // has_duration body.write(1, 1); // has_group_id body.write(0, 2); // group_id, one variable_bits(2) group body.write(0, 1); // end of the variable_bits chain body.write(0, 1); // has_codec_data body.write(0, 1); // discard_unknown_payload body.write(1, 1); // payload_frame_aligned body.write(0, 2); // alignment padding body.write(0, 7); // alignment padding // The test payloads are shorter than 256 bytes: one variable_bits group. body.write(static_cast(payload.size()), 8); body.write(0, 1); for (const std::uint8_t byte : payload) { body.write(byte, 8); } } body.write(0, 5); // payload id 0 terminates the container std::vector out; out.push_back(0x58); out.push_back(0x38); const std::size_t length = (body.bit_count + 7u) / 8u; out.push_back(static_cast((length >> 8) & 0xFFu)); out.push_back(static_cast(length & 0xFFu)); out.insert(out.end(), body.bytes.begin(), body.bytes.end()); return out; } // A JOC payload that ends inside joc_data is a damaged frame, not a transport // error: the header and object parameters stay available, so the frame keeps // its classification and the renderer can hold the previous matrices. A // payload too short to hold the joc_header is not classifiable. void test_joc_truncated_payload_status() { Id14Spec spec; spec.present = true; const std::vector full = make_id14_payload(spec); joc_frame_params parsed{}; CHECK(joc::joc::parse_id14(full.data(), full.size(), &parsed, nullptr).ok()); CHECK(parsed.status == JOC_FRAME_STATUS_OK); // Drop the last byte: object 0's five dense MTX symbols no longer fit. std::vector cut(full.begin(), full.end() - 1); joc_frame_params params{}; CHECK(joc::joc::parse_id14(cut.data(), cut.size(), ¶ms, nullptr).ok()); CHECK(params.status == JOC_FRAME_STATUS_TRUNCATED); CHECK(params.dmx_config_idx == 3u); CHECK(params.n_channels == 5u); CHECK(params.n_objects == 1u); CHECK(params.objects[0].present == 1u); CHECK(params.objects[0].n_bands == 1u); CHECK(params.objects[0].n_dpoints == 1u); CHECK(params.present_mask == 1u); CHECK(params.data_end_bits == cut.size() * 8u); // One byte cannot even hold the 12-bit joc_header, so the payload stays an // unclassifiable transport error. std::vector headerless(full.begin(), full.begin() + 1); joc_frame_params headerless_params{}; CHECK(joc::joc::parse_id14(headerless.data(), headerless.size(), &headerless_params, nullptr) .code() == JOC_ERR_BITSTREAM_TRUNCATED); // The strict padding verifier keeps reporting the truncation. std::uint32_t trailing = 0; CHECK(joc::joc::check_id14_padding(cut.data(), cut.size(), &trailing).code() == JOC_ERR_BITSTREAM_TRUNCATED); } // The container layer passes a truncated ID14 payload up as a frame status while // a broken container transport stays fatal. void test_eac3_frame_truncated_joc_payload() { Id14Spec spec; spec.present = true; const std::vector oamd(8, 0); std::vector joc = make_id14_payload(spec); { const std::vector frame = make_joc_emdf_container(oamd, joc); joc_frame_params params{}; CHECK(joc::joc::parse_eac3_frame(frame.data(), frame.size(), ¶ms, nullptr, nullptr) .ok()); CHECK(params.status == JOC_FRAME_STATUS_OK); } { joc.pop_back(); const std::vector frame = make_joc_emdf_container(oamd, joc); joc_frame_params params{}; joc::emdf::Container container; CHECK(joc::joc::parse_eac3_frame(frame.data(), frame.size(), ¶ms, &container, nullptr) .ok()); CHECK(params.status == JOC_FRAME_STATUS_TRUNCATED); CHECK(params.present_mask == 1u); CHECK(container.find(joc::emdf::kIdJoc) != nullptr); CHECK(container.find(joc::emdf::kIdOamd) != nullptr); } { // The same container with a declared length past the buffer is still a // transport error, not a frame status. joc = make_id14_payload(spec); std::vector frame = make_joc_emdf_container(oamd, joc); frame[2] = 0x7F; frame[3] = 0xFF; joc_frame_params params{}; const joc::Status status = joc::joc::parse_eac3_frame(frame.data(), frame.size(), ¶ms, nullptr, nullptr); CHECK(!status.ok()); CHECK(status.code() == JOC_ERR_EMDF_TRANSPORT); } } // Synthetic audio frames driven through the frame-level kernel. struct FrameCase { ejoc_renderer_handle handle = nullptr; std::vector bed; std::vector lfe; std::uint8_t n_bands[EJOC_MAX_OBJECTS] = {}; std::uint8_t n_dpoints[EJOC_MAX_OBJECTS] = {}; std::uint8_t slope[EJOC_MAX_OBJECTS] = {}; std::uint8_t offsets[EJOC_MAX_OBJECTS * EJOC_MAX_DPOINTS] = {}; std::vector dq; std::vector out; FrameCase() : bed(static_cast(EJOC_MAX_CORE_CHANNELS) * EJOC_FRAME_SAMPLES, 0.0f), lfe(EJOC_FRAME_SAMPLES, 0.0f), dq(static_cast(EJOC_MAX_OBJECTS) * EJOC_MAX_DPOINTS * EJOC_MAX_CORE_CHANNELS * EJOC_MAX_PARAMETER_BANDS, 0.0), out(static_cast(EJOC_OUTPUT_CHANNELS) * EJOC_FRAME_SAMPLES, 0.0f) {} ~FrameCase() { if (handle != nullptr) { ejoc_renderer_destroy(handle); } } void create() { handle = ejoc_renderer_create(); ejoc_renderer_set_threads(handle, 1); } static std::size_t dq_index(int object, int point, int channel, int band) { return static_cast( (((object * EJOC_MAX_DPOINTS + point) * EJOC_MAX_CORE_CHANNELS + channel) * EJOC_MAX_PARAMETER_BANDS) + band); } float at(int channel, int sample) const { return out[static_cast(channel) * EJOC_FRAME_SAMPLES + sample]; } bool silent_slots(int first_channel, int last_channel) const { for (int channel = first_channel; channel <= last_channel; ++channel) { for (int sample = 0; sample < EJOC_FRAME_SAMPLES; ++sample) { if (at(channel, sample) != 0.0f) { return false; } } } return true; } bool render(std::uint32_t core_channels, std::uint32_t declared_channels, std::uint32_t status, std::uint32_t seq, bool has_metadata, std::uint32_t object_mask, double clipgain) { ejoc_frame_input input{}; input.struct_size = sizeof(input); input.struct_version = EJOC_FRAME_INPUT_VERSION; input.bed_planar = bed.data(); input.lfe = lfe.data(); input.core_channel_count = core_channels; input.declared_core_channels = declared_channels; input.phase_shift = 0u; input.phase_shift_valid = 1u; input.frame_status = status; input.seq = seq; input.has_metadata = has_metadata ? 1u : 0u; input.object_mask = object_mask; input.n_bands = n_bands; input.n_dpoints = n_dpoints; input.slope_idx = slope; input.offset_ts = offsets; input.dq = dq.data(); input.clipgain = clipgain; input.output_scale = 1.0f; input.output16_planar = out.data(); std::fill(out.begin(), out.end(), 0.0f); return ejoc_renderer_render_frame(handle, &input) == 0; } }; void fill_frame_bed(FrameCase* frame, float step, float lfe_value) { for (std::uint32_t channel = 0; channel < EJOC_MAX_CORE_CHANNELS; ++channel) { for (int sample = 0; sample < EJOC_FRAME_SAMPLES; ++sample) { frame->bed[static_cast(channel) * EJOC_FRAME_SAMPLES + sample] = step * static_cast(channel + 1u); } } for (int sample = 0; sample < EJOC_FRAME_SAMPLES; ++sample) { frame->lfe[sample] = lfe_value; } } bool near(float value, float expected, float tolerance) { return std::fabs(value - expected) <= tolerance; } void test_joc_lfe_clipgain_ramp() { FrameCase frame; frame.create(); fill_frame_bed(&frame, 0.01f, 0.1f); // First frame: gain 1, the delay ring is empty. CHECK(frame.render(EJOC_CORE_CHANNELS, EJOC_CORE_CHANNELS, 0u, 1u, true, 0u, 1.0)); for (int sample = 0; sample < JOC_LFE_DELAY_SAMPLES; ++sample) { CHECK(frame.at(0, sample) == 0.0f); } for (int sample = JOC_LFE_DELAY_SAMPLES; sample < EJOC_FRAME_SAMPLES; ++sample) { CHECK(frame.at(0, sample) == 0.1f); } // Second frame: gain 2 ramps over the frame-local first 256 samples before the // delay; the read-out of the first frame is untouched by the new gain. frame.lfe.assign(EJOC_FRAME_SAMPLES, 0.2f); CHECK(frame.render(EJOC_CORE_CHANNELS, EJOC_CORE_CHANNELS, 0u, 2u, true, 0u, 2.0)); for (int sample = 0; sample < JOC_LFE_DELAY_SAMPLES; ++sample) { CHECK(frame.at(0, sample) == 0.1f); } for (int input = 0; input < static_cast(EJOC_FRAME_SAMPLES) - static_cast(JOC_LFE_DELAY_SAMPLES); ++input) { const double gain = input < 256 ? 1.0 + static_cast(input) * ((2.0 - 1.0) / 256.0) : 2.0; const double scaled = static_cast(frame.lfe[static_cast(input)]) * gain; const double clipped = scaled < -1.0 ? -1.0 : (scaled > 1.0 ? 1.0 : scaled); CHECK(frame.at(0, JOC_LFE_DELAY_SAMPLES + input) == static_cast(clipped)); } // A held frame (invalid status while normal) reuses the held clipgain: the // analysis scalar was 1/16*2, so the LFE gain stays 2 with no new ramp. frame.lfe.assign(EJOC_FRAME_SAMPLES, 0.3f); CHECK(frame.render(EJOC_CORE_CHANNELS, EJOC_CORE_CHANNELS, 5u, 3u, true, 0u, 2.0)); for (int sample = 0; sample < JOC_LFE_DELAY_SAMPLES; ++sample) { CHECK(frame.at(0, sample) == 0.4f); } for (int sample = JOC_LFE_DELAY_SAMPLES; sample < EJOC_FRAME_SAMPLES; ++sample) { CHECK(frame.at(0, sample) == 0.6f); } } void test_joc_passthrough_8_plane_layout() { // 5-channel core: slots 0..5 = L,R,C,LFE,Ls,Rs and slots 6..7 stay zero. { FrameCase frame; frame.create(); fill_frame_bed(&frame, 0.1f, 0.25f); CHECK(frame.render(EJOC_CORE_CHANNELS, 0u, EJOC_FRAME_STATUS_NO_METADATA, 0u, false, 0u, 1.0)); float expected[8] = {}; for (int channel = 0; channel < 3; ++channel) { expected[channel] = frame.bed[static_cast(channel) * EJOC_FRAME_SAMPLES]; } expected[3] = frame.lfe[0]; for (int index = 0; index < 2; ++index) { expected[4 + index] = frame.bed[static_cast(3 + index) * EJOC_FRAME_SAMPLES]; } for (int channel = 0; channel < 8; ++channel) { for (int sample = 0; sample < JOC_LFE_DELAY_SAMPLES; ++sample) { CHECK(frame.at(channel, sample) == 0.0f); } for (int sample = JOC_LFE_DELAY_SAMPLES; sample < EJOC_FRAME_SAMPLES; ++sample) { CHECK(frame.at(channel, sample) == expected[channel]); } } CHECK(frame.silent_slots(8, EJOC_OUTPUT_CHANNELS - 1)); // The 8-plane history is kept every frame: the next passthrough frame // reads the previous frame's last 1217 samples. fill_frame_bed(&frame, 0.05f, 0.125f); CHECK(frame.render(EJOC_CORE_CHANNELS, 0u, EJOC_FRAME_STATUS_NO_METADATA, 0u, false, 0u, 1.0)); float previous[8] = {}; float current[8] = {}; for (int channel = 0; channel < 3; ++channel) { current[channel] = frame.bed[static_cast(channel) * EJOC_FRAME_SAMPLES]; } current[3] = frame.lfe[0]; for (int index = 0; index < 2; ++index) { current[4 + index] = frame.bed[static_cast(3 + index) * EJOC_FRAME_SAMPLES]; } previous[0] = 0.1f; previous[1] = 0.2f; previous[2] = 0.3f; previous[3] = 0.25f; previous[4] = 0.4f; previous[5] = 0.5f; for (int channel = 0; channel < 8; ++channel) { for (int sample = 0; sample < JOC_LFE_DELAY_SAMPLES; ++sample) { CHECK(frame.at(channel, sample) == previous[channel]); } for (int sample = JOC_LFE_DELAY_SAMPLES; sample < EJOC_FRAME_SAMPLES; ++sample) { CHECK(frame.at(channel, sample) == current[channel]); } } } // 7-channel core: the extra pair is written to slots 6 and 7. { FrameCase frame; frame.create(); fill_frame_bed(&frame, 0.01f, 0.07f); CHECK(frame.render(EJOC_MAX_CORE_CHANNELS, 0u, EJOC_FRAME_STATUS_NO_METADATA, 0u, false, 0u, 1.0)); float expected[8] = {}; for (int channel = 0; channel < 3; ++channel) { expected[channel] = frame.bed[static_cast(channel) * EJOC_FRAME_SAMPLES]; } expected[3] = frame.lfe[0]; for (int index = 0; index < 4; ++index) { expected[4 + index] = frame.bed[static_cast(3 + index) * EJOC_FRAME_SAMPLES]; } for (int channel = 0; channel < 8; ++channel) { for (int sample = JOC_LFE_DELAY_SAMPLES; sample < EJOC_FRAME_SAMPLES; ++sample) { CHECK(frame.at(channel, sample) == expected[channel]); } } CHECK(frame.silent_slots(8, EJOC_OUTPUT_CHANNELS - 1)); } } // One present object that passes core channel 0 through with an all-ones matrix, // so normal rendering produces a non-zero object slot and every other mode does // not. void configure_passthrough_object(FrameCase* frame) { frame->n_bands[0] = 1; frame->n_dpoints[0] = 1; frame->dq[FrameCase::dq_index(0, 0, 0, 0)] = 1.0; } float object_peak(const FrameCase& frame, int object_channel) { float peak = 0.0f; for (int sample = 0; sample < EJOC_FRAME_SAMPLES; ++sample) { peak = std::max(peak, std::fabs(frame.at(object_channel, sample))); } return peak; } void test_joc_no_metadata_midstream_holds() { // A frame without JOC metadata in the middle of a JOC stream is a damaged // frame, not "no objects": it holds the previous matrices instead of // publishing the core planes. Before the compatibility change every such // frame went through Passthrough, which produced a step at the frame // boundary and a second one when the metadata came back. { FrameCase frame; frame.create(); for (int sample = 0; sample < EJOC_FRAME_SAMPLES; ++sample) { frame.bed[static_cast(sample)] = static_cast(0.2 * std::sin(static_cast(sample) * 0.05)); } configure_passthrough_object(&frame); CHECK(frame.render(EJOC_CORE_CHANNELS, EJOC_CORE_CHANNELS, 0u, 0u, true, 1u, 1.0)); CHECK(object_peak(frame, 1) > 1.0e-3f); CHECK(frame.render(EJOC_CORE_CHANNELS, 0u, EJOC_FRAME_STATUS_NO_METADATA, 0u, false, 0u, 1.0)); // Held: the object slot keeps rendering from the previous matrix. CHECK(object_peak(frame, 1) > 1.0e-3f); // The next valid frame resumes normally. CHECK(frame.render(EJOC_CORE_CHANNELS, EJOC_CORE_CHANNELS, 0u, 1u, true, 1u, 1.0)); CHECK(object_peak(frame, 1) > 1.0e-3f); } // A stream that has not rendered a valid frame yet keeps the passthrough: // the core planes are all there is (plain E-AC-3, or a late first JOC frame). { FrameCase frame; frame.create(); fill_frame_bed(&frame, 0.1f, 0.25f); CHECK(frame.render(EJOC_CORE_CHANNELS, 0u, EJOC_FRAME_STATUS_NO_METADATA, 0u, false, 0u, 1.0)); CHECK(frame.silent_slots(8, EJOC_OUTPUT_CHANNELS - 1)); CHECK(!frame.silent_slots(0, 7)); } } void test_joc_frame_state_machine() { // seq 0 on the first frame is not a hard cut, and a mismatch later is. { FrameCase frame; frame.create(); for (int sample = 0; sample < EJOC_FRAME_SAMPLES; ++sample) { frame.bed[static_cast(sample)] = static_cast(0.2 * std::sin(static_cast(sample) * 0.05)); } configure_passthrough_object(&frame); CHECK(frame.render(EJOC_CORE_CHANNELS, EJOC_CORE_CHANNELS, 0u, 0u, true, 1u, 1.0)); CHECK(object_peak(frame, 1) > 1.0e-3f); // Expected seq becomes 1; seq 2 is a mismatch -> hard cut publishes zeros. CHECK(frame.render(EJOC_CORE_CHANNELS, EJOC_CORE_CHANNELS, 0u, 2u, true, 1u, 1.0)); CHECK(frame.silent_slots(0, EJOC_OUTPUT_CHANNELS - 1)); // The next valid frame resyncs and renders normally again. CHECK(frame.render(EJOC_CORE_CHANNELS, EJOC_CORE_CHANNELS, 0u, 3u, true, 1u, 1.0)); CHECK(object_peak(frame, 1) > 1.0e-3f); // A seq that restarts at 0 is a hard cut as well. CHECK(frame.render(EJOC_CORE_CHANNELS, EJOC_CORE_CHANNELS, 0u, 0u, true, 1u, 1.0)); CHECK(frame.silent_slots(0, EJOC_OUTPUT_CHANNELS - 1)); } // A frame without JOC metadata always passes the core through, even while // the renderer is in its normal state. { FrameCase frame; frame.create(); fill_frame_bed(&frame, 0.1f, 0.2f); configure_passthrough_object(&frame); CHECK(frame.render(EJOC_CORE_CHANNELS, EJOC_CORE_CHANNELS, 0u, 1u, true, 1u, 1.0)); CHECK(object_peak(frame, 1) > 1.0e-3f); CHECK(frame.render(EJOC_CORE_CHANNELS, 0u, EJOC_FRAME_STATUS_NO_METADATA, 0u, false, 1u, 1.0)); CHECK(frame.silent_slots(8, EJOC_OUTPUT_CHANNELS - 1)); CHECK(frame.at(0, EJOC_FRAME_SAMPLES - 1) != 0.0f); } // Invalid frames hold the previous matrices; after six of them the state // machine stays in hold and a valid frame still resyncs. { FrameCase frame; frame.create(); for (int sample = 0; sample < EJOC_FRAME_SAMPLES; ++sample) { frame.bed[static_cast(sample)] = static_cast(0.2 * std::sin(static_cast(sample) * 0.05)); } configure_passthrough_object(&frame); CHECK(frame.render(EJOC_CORE_CHANNELS, EJOC_CORE_CHANNELS, 0u, 1u, true, 1u, 1.0)); CHECK(object_peak(frame, 1) > 1.0e-3f); for (int invalid = 0; invalid < 6; ++invalid) { CHECK(frame.render(EJOC_CORE_CHANNELS, EJOC_CORE_CHANNELS, 5u, 2u, true, 1u, 1.0)); CHECK(object_peak(frame, 1) > 1.0e-3f); } CHECK(frame.render(EJOC_CORE_CHANNELS, EJOC_CORE_CHANNELS, 0u, 100u, true, 1u, 1.0)); CHECK(object_peak(frame, 1) > 1.0e-3f); } // A declared core-channel-count change is a hard cut that clears the LFE // ring: the next frame reads only the samples written after the change. { FrameCase frame; frame.create(); fill_frame_bed(&frame, 0.1f, 0.1f); configure_passthrough_object(&frame); CHECK(frame.render(EJOC_CORE_CHANNELS, EJOC_CORE_CHANNELS, 0u, 1u, true, 1u, 1.0)); frame.lfe.assign(EJOC_FRAME_SAMPLES, 0.5f); // The frame that declares the change keeps its own clipgain (2.0) even // though it renders as a hard cut: it clears the LFE ring and refills it // with the new gain before the next frame reads it out. CHECK(frame.render(EJOC_MAX_CORE_CHANNELS, EJOC_MAX_CORE_CHANNELS, 0u, 2u, true, 1u, 2.0)); CHECK(frame.silent_slots(0, EJOC_OUTPUT_CHANNELS - 1)); CHECK(frame.render(EJOC_MAX_CORE_CHANNELS, EJOC_MAX_CORE_CHANNELS, 0u, 3u, true, 1u, 1.0)); CHECK(near(frame.at(0, 0), 1.0f, 1.0e-6f)); CHECK(near(frame.at(0, JOC_LFE_DELAY_SAMPLES), 1.0f, 1.0e-6f)); // Samples past the 256-sample ramp use the frame's own gain again. CHECK(near(frame.at(0, JOC_LFE_DELAY_SAMPLES + 300), 0.5f, 1.0e-6f)); } } // The truncated-frame status is a JOC parse status, so the kernel accepts it and // renders through the invalid-frame path: the previous matrices are held, the // frame produces its 1536 samples, and the next valid frame resynchronises. void test_joc_truncated_frame_holds_previous_matrix() { FrameCase frame; frame.create(); for (int sample = 0; sample < EJOC_FRAME_SAMPLES; ++sample) { frame.bed[static_cast(sample)] = static_cast(0.2 * std::sin(static_cast(sample) * 0.05)); } configure_passthrough_object(&frame); CHECK(frame.render(EJOC_CORE_CHANNELS, EJOC_CORE_CHANNELS, 0u, 1u, true, 1u, 1.0)); CHECK(object_peak(frame, 1) > 1.0e-3f); CHECK(frame.render(EJOC_CORE_CHANNELS, EJOC_CORE_CHANNELS, JOC_FRAME_STATUS_TRUNCATED, 2u, true, 1u, 1.0)); CHECK(object_peak(frame, 1) > 1.0e-3f); CHECK(frame.render(EJOC_CORE_CHANNELS, EJOC_CORE_CHANNELS, 0u, 3u, true, 1u, 1.0)); CHECK(object_peak(frame, 1) > 1.0e-3f); } void test_joc_no_previous_interpolation() { auto prepare = [](FrameCase* frame) { frame->create(); for (int sample = 0; sample < EJOC_FRAME_SAMPLES; ++sample) { frame->bed[static_cast(sample)] = static_cast(0.2 * std::sin(static_cast(sample) * 0.05)); } frame->n_bands[0] = 1; frame->dq[FrameCase::dq_index(0, 0, 0, 0)] = 0.0; }; // A two-data-point frame without previous state keeps dp0 in the first half // and still interpolates dp0 -> dp1 in the second half, exactly like the // same frame with a previous state equal to dp0. { FrameCase with_previous; prepare(&with_previous); with_previous.n_dpoints[0] = 1; CHECK(with_previous.render(EJOC_CORE_CHANNELS, EJOC_CORE_CHANNELS, 0u, 1u, true, 1u, 1.0)); FrameCase without_previous; prepare(&without_previous); CHECK(without_previous.render(EJOC_CORE_CHANNELS, 0u, EJOC_FRAME_STATUS_NO_METADATA, 0u, false, 1u, 1.0)); for (FrameCase* frame : {&with_previous, &without_previous}) { frame->n_dpoints[0] = 2; frame->dq[FrameCase::dq_index(0, 0, 0, 0)] = 0.0; frame->dq[FrameCase::dq_index(0, 1, 0, 0)] = 1.0; CHECK(frame->render(EJOC_CORE_CHANNELS, EJOC_CORE_CHANNELS, 0u, 2u, true, 1u, 1.0)); } CHECK(with_previous.out == without_previous.out); } // A single data point without previous state is a hard cut, not a fade from // zero: the same target with a previous state of zero ramps instead. { FrameCase with_previous; prepare(&with_previous); with_previous.n_dpoints[0] = 1; CHECK(with_previous.render(EJOC_CORE_CHANNELS, EJOC_CORE_CHANNELS, 0u, 1u, true, 1u, 1.0)); FrameCase without_previous; prepare(&without_previous); CHECK(without_previous.render(EJOC_CORE_CHANNELS, 0u, EJOC_FRAME_STATUS_NO_METADATA, 0u, false, 1u, 1.0)); for (FrameCase* frame : {&with_previous, &without_previous}) { frame->n_dpoints[0] = 1; frame->dq[FrameCase::dq_index(0, 0, 0, 0)] = 1.0; CHECK(frame->render(EJOC_CORE_CHANNELS, EJOC_CORE_CHANNELS, 0u, 2u, true, 1u, 1.0)); } CHECK(with_previous.out != without_previous.out); } // An object that disappears keeps being published as an all-zero matrix: // the synthesis state still advances, so only the window tail of the // preceding frame is left in the object slot. { FrameCase frame; frame.create(); fill_frame_bed(&frame, 0.1f, 0.1f); configure_passthrough_object(&frame); CHECK(frame.render(EJOC_CORE_CHANNELS, EJOC_CORE_CHANNELS, 0u, 1u, true, 1u, 1.0)); CHECK(object_peak(frame, 1) > 1.0e-3f); CHECK(frame.render(EJOC_CORE_CHANNELS, EJOC_CORE_CHANNELS, 0u, 2u, true, 0u, 1.0)); for (int sample = 640; sample < EJOC_FRAME_SAMPLES; ++sample) { CHECK(frame.at(1, sample) == 0.0f); } } } // The binaural position timeline consumes the full OAMD frame state: multi-block // payloads and programmes past the 16-slot legacy view are scheduled instead of // being rejected, and a renderer with a different source count can read more // tracks than the fifteen JOC object sources. void test_binaural_timeline_full_frame_state() { // Two position blocks in one object element: the legacy frame_update() view // rejects this, the full frame state schedules both blocks. const std::vector multiblock = from_hex("0104600800450132831d6a00"); joc::oamd::OamdUpdate update; CHECK(joc::oamd::parse_id11_state(multiblock.data(), multiblock.size(), &update).ok()); CHECK(update.has_frame_state); CHECK(update.frame_state.block_count == 2); joc::timeline::OamdPositionTimeline timeline; CHECK(timeline.submit_update(update, 0, 0, 1473, 0).ok()); CHECK(timeline.initialized()); CHECK(timeline.payload_count() == 1); double positions[joc::timeline::kTimelineObjects][3] = {}; CHECK(timeline.positions_at(0, &positions[0][0], joc::timeline::kTimelineObjects).ok()); // Seventeen declared objects: the timeline grows one track per object instead // of stopping at the 16-slot legacy view. const char* many_objects_hex = "21044E600022A29808054530100A8A60201514C0402A29808054530100A8A60201514C040" "2A29808054530100A8A60201514C0402A29808054530100A8A60201514C0402A2980800"; const std::vector many_objects = from_hex(many_objects_hex); joc::oamd::OamdUpdate many; CHECK(joc::oamd::parse_id11_state(many_objects.data(), many_objects.size(), &many).ok()); CHECK(many.frame_state.object_count == 17); joc::timeline::OamdPositionTimeline wide; CHECK(wide.submit_update(many, 0, 0, 1473, 0).ok()); CHECK(wide.object_count() == 16); double wide_positions[16][3] = {}; CHECK(wide.positions_at(0, &wide_positions[0][0], 16).ok()); CHECK(wide.positions_at(0, &wide_positions[0][0], 17).code() == JOC_ERR_INVALID_ARGUMENT); // The legacy slot view still works and matches the frame-state path for a // single-block payload. const std::vector single = from_hex("0304680004545313880D45301000"); joc::oamd::OamdUpdate parsed; CHECK(joc::oamd::parse_id11_state(single.data(), single.size(), &parsed).ok()); joc::timeline::OamdPositionTimeline full; joc::timeline::OamdPositionTimeline legacy; CHECK(full.submit_update(parsed, 0, 0, 1473, 0).ok()); joc::oamd::OamdUpdate slot_view = parsed; slot_view.has_frame_state = false; CHECK(legacy.submit_update(slot_view, 0, 0, 1473, 0).ok()); double frame_position[3] = {}; double slot_position[3] = {}; CHECK(full.positions_at(0, frame_position, 1).ok()); CHECK(legacy.positions_at(0, slot_position, 1).ok()); CHECK(frame_position[0] == slot_position[0] && frame_position[1] == slot_position[1] && frame_position[2] == slot_position[2]); } int main() { test_sha256(); test_crc32_and_inflate(); test_bit_reader(); test_variable_bits(); test_eac3_frame_bytes(); test_mini_json(); test_json_text(); test_task_result_json(); test_npy(); test_oamd_and_adm_helpers(); test_dbmd_auto_trim(); test_oamd_trim_parse(); test_speaker_trim_parameters(); test_speaker_warp_and_trim(); test_speaker_surround_fold(); test_speaker_step_trim_events(); test_dbmd_and_axml_trim(); test_adm_object_metadata(); test_multichannel_binaural_helpers(); test_int24_packing(); test_utf8_paths(); test_process_runner(); test_find_executable(); test_builtin_kernel_tables(); test_npy_and_zip_writers(); test_rosella_model_errors(); test_rosella_filterbank_config(); test_stream_render_ahead(); test_stream_status_struct_sizes(); test_clipgain_first_frame_uses_its_own_gain(); test_clipgain_change_applies_to_the_current_frame(); test_clipgain_reset_clears_the_previous_gain(); test_joc_clipgain_formula(); test_joc_parse_status_and_offset_ts(); test_joc_truncated_payload_status(); test_eac3_frame_truncated_joc_payload(); test_joc_lfe_clipgain_ramp(); test_joc_passthrough_8_plane_layout(); test_joc_no_metadata_midstream_holds(); test_joc_frame_state_machine(); test_joc_truncated_frame_holds_previous_matrix(); test_joc_no_previous_interpolation(); test_binaural_timeline_full_frame_state(); std::printf("%d checks, %d failure(s)\n", g_checks, g_failures); return g_failures == 0 ? 0 : 1; }