The JOC bitstream reports a per-frame parse status instead of treating every anomaly as an exception: an unsupported downmix configuration, a clamped object count, an unknown parameter-band count, bad offset_ts values and trailing bytes each get their own status. The raw 5-bit offset_ts values are kept as coded and validated to be strictly increasing per object, and the clipgain uses 2^(x-4) * (1 + y/32). The JOC core gains a frame-level state machine. It keeps the per-object previous matrix and its presence marker, the seq counter, the 8-plane passthrough history, the LFE clipgain ramp start and the previous actual core-channel count. Normal, hold, hard-cut and passthrough frames are distinguished: a frame without a previous state interpolates per the data-point rules, an object that disappears keeps publishing a zero matrix, a frame without metadata passes the 8 core planes through to slots 0..7 with the 1217-sample delay, and a declared core-channel-count change hard-cuts and clears the LFE ring while the clipgain ramp state is kept. The core LFE applies the full clipgain as a sample-wise ramp before its delay. The OAMD parser exposes the full frame state: every object's state in every position block, the programme assignment and the trim element, with multiple blocks and up to 30 declared objects accepted. The speaker renderer applies this state: per-block gain/inactive, zone/elevation, the size kernel, snap, divergence, element 5 refinement, the priority size budget, ISF basis matrices and bed channel distribution, scheduled on the 32-sample metadata grid with block alignment and gain ramps. The size kernel, ISF basis assembly, bed routing and compensation are computed in oamd_math from the speaker layout geometry; bed labels and reference positions derive from the layout tables. The six ISF configurations and twelve layout descriptors are compiled in as static tables (oamd/isf_tables.h); the JSON loader and the configure-time embedding are gone. The layout tables gain 6.0, and the layout lookup, bed map and trim probe follow. The binaural position timeline consumes the full frame state as well: every position block is scheduled at its own offset and ramp, and its track list grows with the declared object count, so multi-block and over-16-object programmes are rendered instead of rejected. The JOC binaural input stays one LFE plus fifteen object sources; the extra tracks are followed but not panned. The file task and the stream parse the full state for speaker and binaural, while the ADM export keeps the 15-track single-block view. The public headers carry the new status values, the frame-level entry point and the raw offset_ts description; the internal ABI versions go to 6 (joc_core), 2 (frame params and EMDF info) and 4 (eac3joc). ctest covers the frame-level core (clipgain formula and LFE ramp, offset_ts validation, frame statuses, the 8-plane passthrough, the seq state machine and the no-previous-state interpolation), the OAMD parser state, the compiled-in ISF tables and the binaural timeline. The READMEs and the mathematical notes describe the 6.0 layout, the frame state machine, the metadata application and the ISF lookup tables.
2230 lines
97 KiB
C++
2230 lines
97 KiB
C++
// 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 <algorithm>
|
|
#include <cmath>
|
|
#include <filesystem>
|
|
#include <cstdint>
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
#include <limits>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "adm/adm_metadata.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<std::uint8_t> from_hex(const char* text) {
|
|
auto digit = [](char c) {
|
|
return static_cast<std::uint8_t>(c <= '9' ? c - '0' : (c | 0x20) - 'a' + 10);
|
|
};
|
|
std::vector<std::uint8_t> out;
|
|
for (std::size_t i = 0; text[i] != '\0' && text[i + 1] != '\0'; i += 2) {
|
|
out.push_back(static_cast<std::uint8_t>((digit(text[i]) << 4) | digit(text[i + 1])));
|
|
}
|
|
return out;
|
|
}
|
|
|
|
std::string bytes_to_string(const std::vector<std::uint8_t>& bytes) {
|
|
return std::string(reinterpret_cast<const char*>(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<double> 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<double> 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<float> input(static_cast<std::size_t>(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<double> output(static_cast<std::size_t>(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<double>& actual, const std::vector<double>& 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<char> 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<const std::uint8_t*>("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<std::uint8_t> 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<std::uint8_t>((value >> i) & 1u);
|
|
if (used_ == 0) {
|
|
bytes_.push_back(0);
|
|
}
|
|
bytes_.back() |= static_cast<std::uint8_t>(bit << (7u - used_));
|
|
used_ = (used_ + 1u) % 8u;
|
|
}
|
|
}
|
|
const std::vector<std::uint8_t>& bytes() const { return bytes_; }
|
|
|
|
private:
|
|
std::vector<std::uint8_t> 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<std::uint8_t> 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<std::uint8_t> 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<joc::json::Member> 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<joc::json::Member> 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<joc::json::Member> 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<joc::json::Member> 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 <f8 (2,) image in memory, padded the way NumPy pads it.
|
|
std::string header = "{'descr': '<f8', 'fortran_order': False, 'shape': (2,), }";
|
|
const std::size_t prefix = 10; // magic + version + uint16 header length
|
|
while ((prefix + header.size() + 1) % 64 != 0) {
|
|
header.push_back(' ');
|
|
}
|
|
header.push_back('\n');
|
|
std::vector<std::uint8_t> 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<std::uint8_t>(header.size() & 0xFFu));
|
|
image.push_back(static_cast<std::uint8_t>(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<const std::uint8_t*>(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 == "<f8");
|
|
CHECK(array.shape.size() == 1 && array.shape[0] == 2);
|
|
CHECK(!array.fortran_order);
|
|
std::vector<double> 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<unsigned char>(dbmd[offset]) != 0) {
|
|
const std::size_t size =
|
|
static_cast<std::size_t>(static_cast<unsigned char>(dbmd[offset + 1])) |
|
|
(static_cast<std::size_t>(static_cast<unsigned char>(dbmd[offset + 2])) << 8);
|
|
const std::size_t start = offset + 3;
|
|
CHECK(start + size + 1 <= dbmd.size());
|
|
unsigned sum = static_cast<unsigned>(size);
|
|
for (std::size_t i = 0; i < size; ++i) {
|
|
sum += static_cast<unsigned char>(dbmd[start + i]);
|
|
}
|
|
sum += static_cast<unsigned char>(dbmd[start + size]);
|
|
CHECK((sum & 0xFFu) == 0u);
|
|
if (static_cast<unsigned char>(dbmd[offset]) == 10) {
|
|
segment10 = dbmd.substr(start, size);
|
|
}
|
|
offset = start + size + 1;
|
|
}
|
|
|
|
CHECK(segment10.size() == 292);
|
|
CHECK(static_cast<unsigned char>(segment10[0]) == 0xBD);
|
|
CHECK(static_cast<unsigned char>(segment10[1]) == 0x6F);
|
|
CHECK(static_cast<unsigned char>(segment10[2]) == 0x72);
|
|
CHECK(static_cast<unsigned char>(segment10[3]) == 0xF8);
|
|
CHECK(static_cast<unsigned char>(segment10[4]) == 25);
|
|
CHECK(static_cast<unsigned char>(segment10[5]) == 0);
|
|
CHECK(static_cast<unsigned char>(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<unsigned char>(segment10[flag]) == 0x01);
|
|
for (std::size_t i = 1; i < 15; ++i) {
|
|
CHECK(static_cast<unsigned char>(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<unsigned char>(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<unsigned char>(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<unsigned char>(segment10[i]) == 0);
|
|
}
|
|
for (std::size_t i = 5 + 262; i < segment10.size(); ++i) {
|
|
CHECK(static_cast<unsigned char>(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<std::uint8_t> 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<std::uint8_t> 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<double>::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<double> warp0 = {0.85973646214220434, 0, 0, 0, 0.35611450268596406, 0};
|
|
const std::vector<double> warp1 = {0.65801380052399572, 0, 0, 0, 0.65801380052399572, 0};
|
|
const std::vector<double> 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<double> height_top = {0, 0, 0, 0, 0, 0, 0.84139514164519513, 0, 0, 0};
|
|
const std::vector<double> 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<double> 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<double> 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<double> 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<double> 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<float> input(static_cast<std::size_t>(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<double> output(static_cast<std::size_t>(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<double> pl2x_mid = {0, 0, 0, 0, 0.88868654605257746,
|
|
0.13546740014942704};
|
|
const std::vector<double> loro_mid = {0, 0, 0, 0, 0.92498492652336017, 0};
|
|
const std::vector<double> pl2x_back = {0, 0, 0, 0, 0.93411653293116492,
|
|
0.25030863131451864};
|
|
const std::vector<double> 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<double> pl2x_40 = {0, 0, 0.93411653293116492, 0.25030863131451864};
|
|
const std::vector<double> loro_40 = {0, 0, 1.0011865285504298, 0};
|
|
const std::vector<double> 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<double> pl2x_512 = {0, 0, 0, 0, 0.64546952862797569,
|
|
0.25210606107018951, 0.54573901433240524, 0};
|
|
const std::vector<double> loro_512 = {0, 0, 0, 0, 0.7130211440987243, 0,
|
|
0.54573901433240524, 0};
|
|
const std::vector<double> 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<double> 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<double> 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<float> input(static_cast<std::size_t>(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<double> output(static_cast<std::size_t>(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<float> frame(static_cast<std::size_t>(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<double> warp1 = {0.65801380052399572, 0, 0, 0, 0.65801380052399572, 0};
|
|
std::vector<double> 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<double> 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<double> 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<double> 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<unsigned char>(dbmd[offset]) != 0) {
|
|
const std::size_t size =
|
|
static_cast<std::size_t>(static_cast<unsigned char>(dbmd[offset + 1])) |
|
|
(static_cast<std::size_t>(static_cast<unsigned char>(dbmd[offset + 2])) << 8);
|
|
const std::size_t start = offset + 3;
|
|
unsigned sum = static_cast<unsigned>(size);
|
|
for (std::size_t i = 0; i < size; ++i) {
|
|
sum += static_cast<unsigned char>(dbmd[start + i]);
|
|
}
|
|
sum += static_cast<unsigned char>(dbmd[start + size]);
|
|
CHECK((sum & 0xFFu) == 0u);
|
|
const unsigned id = static_cast<unsigned char>(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<unsigned char>(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<unsigned char>(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<unsigned char>(plain[offset]) != 0) {
|
|
const std::size_t size =
|
|
static_cast<std::size_t>(static_cast<unsigned char>(plain[offset + 1])) |
|
|
(static_cast<std::size_t>(static_cast<unsigned char>(plain[offset + 2])) << 8);
|
|
const std::size_t start = offset + 3;
|
|
if (static_cast<unsigned char>(plain[offset]) == 9u) {
|
|
plain_segment9 = plain.substr(start, size);
|
|
}
|
|
offset = start + size + 1;
|
|
}
|
|
CHECK(plain_segment9.size() == 248);
|
|
CHECK(static_cast<unsigned char>(plain_segment9[152]) == 0u);
|
|
|
|
std::vector<joc::adm::Track> 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 =
|
|
"<DolbyAtmosMasterFile><DolbyMasterContentInfo><render_warp_mode>2</render_warp_mode>"
|
|
"</DolbyMasterContentInfo><DolbyTrimModeSetup>"
|
|
"<records><type>0</type></records>"
|
|
"<records><type>1</type><centerTrim>0.000000</centerTrim>"
|
|
"<surroundTrim>0.000000</surroundTrim><heightTrim>0.000000</heightTrim>"
|
|
"<balanceOverhead>0.000000</balanceOverhead>"
|
|
"<balanceListener>0.000000</balanceListener></records>"
|
|
"<records><type>2</type><centerTrim>6.000000</centerTrim>"
|
|
"<surroundTrim>-15.000000</surroundTrim><heightTrim>-36.000000</heightTrim>"
|
|
"<balanceOverhead>1.000000</balanceOverhead>"
|
|
"<balanceListener>-0.500000</balanceListener></records>"
|
|
"<records><type>3</type></records><records><type>4</type></records>"
|
|
"<records><type>5</type></records><records><type>6</type></records>"
|
|
"<records><type>7</type></records><records><type>8</type></records>"
|
|
"</DolbyTrimModeSetup><DolbyWarpMode>2</DolbyWarpMode></DolbyAtmosMasterFile>";
|
|
const std::size_t found = axml.find(expected_block);
|
|
CHECK(found != std::string::npos);
|
|
CHECK(found < axml.find("</audioFormatExtended>"));
|
|
const std::string plain_axml = joc::adm::build_axml(tracks, 1.0, 48000);
|
|
CHECK(plain_axml.find("<DolbyAtmosMasterFile>") == std::string::npos);
|
|
}
|
|
|
|
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<std::uint8_t>(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<std::streamsize>(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<std::string> command = {"cmd.exe", "/c", "echo boom 1>&2 & exit 3"};
|
|
#else
|
|
const std::vector<std::string> 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<double> values = {1.5, -2.25, 3.75, 4.0, 0.5, 0.25};
|
|
std::vector<std::uint8_t> payload(values.size() * sizeof(double));
|
|
std::memcpy(payload.data(), values.data(), payload.size());
|
|
const std::vector<std::uint8_t> image = joc::io::npy_image("<f8", {2u, 3u}, payload);
|
|
joc::io::NpyArray array;
|
|
std::string error;
|
|
CHECK(joc::io::parse_npy(image.data(), image.size(), &array, &error));
|
|
CHECK(array.descr == "<f8");
|
|
CHECK(joc::io::npy_shape_is(array, {2, 3}));
|
|
std::vector<double> 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<std::uint8_t> unicode = joc::io::utf8_to_utf32le(text);
|
|
CHECK(unicode.size() == text.size() * 4u);
|
|
CHECK(unicode[0] == static_cast<std::uint8_t>('{') && unicode[1] == 0u &&
|
|
unicode[3] == 0u);
|
|
const std::vector<std::uint8_t> text_image =
|
|
joc::io::npy_image("<U" + std::to_string(text.size()), {}, unicode);
|
|
CHECK(joc::io::parse_npy(text_image.data(), text_image.size(), &array, &error));
|
|
std::string decoded;
|
|
CHECK(joc::io::npy_unicode_to_utf8(array, &decoded, &error));
|
|
CHECK(decoded == text);
|
|
|
|
// The ZIP container round-trips through the archive reader.
|
|
const std::string path = joc::fs_utf8::temp_directory() + "/joc_writer_test.jochrtf";
|
|
std::vector<NpyMember> members;
|
|
NpyMember member;
|
|
member.name = "band_center_frequencies_hz";
|
|
member.descr = "<f8";
|
|
member.shape = {2u, 3u};
|
|
member.data = payload;
|
|
members.push_back(member);
|
|
CHECK(joc::io::write_zip(path, members, &error));
|
|
joc::io::ZipArchive archive;
|
|
CHECK(archive.open(path, &error));
|
|
CHECK(archive.entries().size() == 1u);
|
|
std::vector<std::uint8_t> 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<double>& values, bool narrow) {
|
|
joc::crypto::Sha256 hash;
|
|
if (narrow) {
|
|
std::vector<float> raw(values.size());
|
|
for (std::size_t i = 0; i < values.size(); ++i) {
|
|
raw[i] = static_cast<float>(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<float> drive_objects16_stream(const std::vector<float>& 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<float> pulled(4096u * channels);
|
|
std::vector<float> 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<std::ptrdiff_t>(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<joc_validation_issue> 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<float> block(kFrames * kFrameValues);
|
|
for (std::size_t index = 0; index < block.size(); ++index) {
|
|
block[index] = static_cast<float>(std::sin(static_cast<double>(index) * 0.0007) * 0.25);
|
|
}
|
|
|
|
std::size_t frame_peak = 0;
|
|
const std::vector<float> reference =
|
|
drive_objects16_stream(block, kFrames, true, &frame_peak);
|
|
std::size_t batch_peak = 0;
|
|
const std::vector<float> 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<float> bed;
|
|
std::vector<float> lfe;
|
|
std::vector<std::uint8_t> n_bands;
|
|
std::vector<std::uint8_t> n_dpoints;
|
|
std::vector<std::uint8_t> slope;
|
|
std::vector<std::uint8_t> offsets;
|
|
std::vector<double> 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<std::size_t>(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<double>(sample) / 48000.0;
|
|
bed[sample] = static_cast<float>(0.05 * std::sin(two_pi * 440.0 * t));
|
|
lfe[sample] = static_cast<float>(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<float>* out) {
|
|
out->assign(static_cast<std::size_t>(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;
|
|
}
|
|
|
|
void test_clipgain_first_frame_uses_its_own_gain() {
|
|
const ClipGainInputs in;
|
|
std::vector<float> unity;
|
|
std::vector<float> doubled;
|
|
auto render = [&in](double clipgain, std::vector<float>* 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<std::size_t>(sample)] !=
|
|
2.0f * unity[static_cast<std::size_t>(sample)]) {
|
|
lfe_scaled = false;
|
|
break;
|
|
}
|
|
}
|
|
CHECK(lfe_scaled);
|
|
for (int sample = 0; sample < JOC_LFE_DELAY_SAMPLES; ++sample) {
|
|
CHECK(unity[static_cast<std::size_t>(sample)] == 0.0f);
|
|
}
|
|
}
|
|
|
|
void test_clipgain_change_applies_to_the_current_frame() {
|
|
const ClipGainInputs in;
|
|
std::vector<float> changed;
|
|
std::vector<float> held;
|
|
auto run = [&in](double second_gain, std::vector<float>* out) {
|
|
ejoc_renderer_handle handle = ejoc_renderer_create();
|
|
ejoc_renderer_set_threads(handle, 1);
|
|
std::vector<float> 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<std::size_t>(object) * EJOC_FRAME_SAMPLES + sample;
|
|
difference += std::fabs(static_cast<double>(changed[index]) - held[index]);
|
|
energy += std::fabs(static_cast<double>(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<std::size_t>(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<std::size_t>(EJOC_FRAME_SAMPLES) + sample;
|
|
tail = std::max(tail, std::fabs(static_cast<double>(changed[index]) -
|
|
2.0 * static_cast<double>(held[index])));
|
|
}
|
|
CHECK(tail < 1.0e-4);
|
|
}
|
|
|
|
void test_clipgain_reset_clears_the_previous_gain() {
|
|
const ClipGainInputs in;
|
|
std::vector<float> scratch;
|
|
std::vector<float> after_reset;
|
|
std::vector<float> 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<std::uint8_t> 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<std::uint8_t>(1u << (7u - (bit_count & 7u)));
|
|
}
|
|
++bit_count;
|
|
}
|
|
}
|
|
};
|
|
|
|
bool huffman_path(const int (*nodes)[2], int count, int value, std::vector<int>* path) {
|
|
struct Entry {
|
|
int node;
|
|
std::vector<int> path;
|
|
};
|
|
std::vector<Entry> 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<int> left = queue[index].path;
|
|
left.push_back(0);
|
|
queue.push_back({nodes[node][0], std::move(left)});
|
|
std::vector<int> 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<int> path;
|
|
CHECK(huffman_path(nodes, count, value, &path));
|
|
for (const int bit : path) {
|
|
writer->write(static_cast<std::uint32_t>(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<std::uint8_t> 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<int>(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<std::uint8_t> 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<std::uint8_t> 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<std::uint8_t> 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<std::uint8_t> 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<std::uint8_t> 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<std::uint8_t> 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<std::uint8_t> 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<std::uint8_t> 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);
|
|
}
|
|
}
|
|
|
|
// Synthetic audio frames driven through the frame-level kernel.
|
|
struct FrameCase {
|
|
ejoc_renderer_handle handle = nullptr;
|
|
std::vector<float> bed;
|
|
std::vector<float> 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<double> dq;
|
|
std::vector<float> out;
|
|
|
|
FrameCase()
|
|
: bed(static_cast<std::size_t>(EJOC_MAX_CORE_CHANNELS) * EJOC_FRAME_SAMPLES, 0.0f),
|
|
lfe(EJOC_FRAME_SAMPLES, 0.0f),
|
|
dq(static_cast<std::size_t>(EJOC_MAX_OBJECTS) * EJOC_MAX_DPOINTS *
|
|
EJOC_MAX_CORE_CHANNELS * EJOC_MAX_PARAMETER_BANDS,
|
|
0.0),
|
|
out(static_cast<std::size_t>(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<std::size_t>(
|
|
(((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<std::size_t>(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<std::size_t>(channel) * EJOC_FRAME_SAMPLES + sample] =
|
|
step * static_cast<float>(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<int>(EJOC_FRAME_SAMPLES) - static_cast<int>(JOC_LFE_DELAY_SAMPLES); ++input) {
|
|
const double gain = input < 256
|
|
? 1.0 + static_cast<double>(input) * ((2.0 - 1.0) / 256.0)
|
|
: 2.0;
|
|
const double scaled = static_cast<double>(frame.lfe[static_cast<std::size_t>(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<float>(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<std::size_t>(channel) * EJOC_FRAME_SAMPLES];
|
|
}
|
|
expected[3] = frame.lfe[0];
|
|
for (int index = 0; index < 2; ++index) {
|
|
expected[4 + index] =
|
|
frame.bed[static_cast<std::size_t>(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<std::size_t>(channel) * EJOC_FRAME_SAMPLES];
|
|
}
|
|
current[3] = frame.lfe[0];
|
|
for (int index = 0; index < 2; ++index) {
|
|
current[4 + index] =
|
|
frame.bed[static_cast<std::size_t>(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<std::size_t>(channel) * EJOC_FRAME_SAMPLES];
|
|
}
|
|
expected[3] = frame.lfe[0];
|
|
for (int index = 0; index < 4; ++index) {
|
|
expected[4 + index] =
|
|
frame.bed[static_cast<std::size_t>(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_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<std::size_t>(sample)] =
|
|
static_cast<float>(0.2 * std::sin(static_cast<double>(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<std::size_t>(sample)] =
|
|
static_cast<float>(0.2 * std::sin(static_cast<double>(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));
|
|
}
|
|
}
|
|
|
|
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<std::size_t>(sample)] =
|
|
static_cast<float>(0.2 * std::sin(static_cast<double>(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<std::uint8_t> 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<std::uint8_t> 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<std::uint8_t> 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_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_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_lfe_clipgain_ramp();
|
|
test_joc_passthrough_8_plane_layout();
|
|
test_joc_frame_state_machine();
|
|
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;
|
|
}
|