Files
JustOneCacophony/src/oamd/oamd_math.cpp
T
TheM14 0bb82e4115
ci / ubuntu-latest (push) Failing after 19s
ci / macos-latest (push) Canceled after 0s
ci / windows-latest (push) Canceled after 0s
ci / release (push) Canceled after 0s
Port the OAMD metadata rendering and the frame-level JOC core
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.
2026-11-08 14:04:21 +08:00

1265 lines
50 KiB
C++

#include "oamd/oamd_math.h"
#include <algorithm>
#include <array>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <unordered_map>
#include <utility>
#include <vector>
#include "joc_bitstream/bed_layout_map.h"
namespace joc::oamd {
namespace {
// 2**-126, the reference's TINY.
constexpr float kTiny = 1.17549435e-38f;
// The float32 constants of the reference equations, written as the reference
// writes them so that the rounding matches.
constexpr float kQuarter = 0.25f;
constexpr float kHalf = 0.5f;
constexpr float kPanAngle = 0.78539819f;
constexpr float kLayerAngle = 0.39269909f;
constexpr float kBoundaryAngle = 0.34147748f;
constexpr float kBoundaryPower = 26.575424f;
constexpr float kBoundaryShape = 0.6328125f;
constexpr float kSizeStep = 0.036842104f;
constexpr float kSizeCurveScale = 0.71428573f;
constexpr float kQ15Scale = 32768.0f;
constexpr float kLogScale = 4.0793457f;
constexpr float kLogOffset = 2.6931152f;
constexpr float kLogSquare = 1.3862305f;
constexpr float kExpFactor = -0.1660964f;
constexpr std::size_t kMaxPoints = ::ejoc::speaker_tables::kMaxPoints;
constexpr std::size_t kMaxGroups = ::ejoc::speaker_tables::kMaxGroups;
inline float max_float(const float left, const float right) {
return left > right ? left : right;
}
inline float min_float(const float left, const float right) {
return left < right ? left : right;
}
} // namespace
float exp2_approx(const float value) {
const float x = value;
const int n = static_cast<int>(std::floor(static_cast<double>(x)));
const float f = x - static_cast<float>(n);
float poly = f * 0.6862793f;
poly = poly + 1.0f;
poly = poly + (f * f) * 0.25482178f;
poly = poly + (f * (f * f)) * 0.058898926f;
return static_cast<float>(std::ldexp(static_cast<double>(poly), n));
}
float pow_approx(const float value, const float power) {
const float x = value;
if (std::fabs(x) < kTiny) {
return 0.0f;
}
int exponent = 0;
const double fraction = std::frexp(static_cast<double>(x), &exponent);
const float fraction32 = static_cast<float>(fraction);
float logarithm = fraction32 * kLogScale;
logarithm = logarithm - kLogOffset;
logarithm = logarithm - (fraction32 * fraction32) * kLogSquare;
logarithm = logarithm + static_cast<float>(exponent);
return exp2_approx(logarithm * power);
}
std::vector<float> norm(const std::vector<float>& vector) {
float total = 0.0f;
for (const float value : vector) {
total = total + value * value;
}
if (std::fabs(total) < kTiny) {
total = 0.0f;
}
const float root = static_cast<float>(std::sqrt(static_cast<double>(total)));
const float denominator = max_float(root, 1e-5f);
std::vector<float> result(vector.size());
for (std::size_t index = 0; index < vector.size(); ++index) {
float value = vector[index] / denominator;
if (std::fabs(value) < kTiny) {
value = 0.0f;
}
result[index] = value;
}
return result;
}
float boundary(const int axis, const int edge, const float position, const float t) {
const float edge32 = static_cast<float>(edge);
const float position32 = position;
const float t32 = t;
const float delta = (edge32 - position32) * kQuarter;
if (t32 < 0.000025f || std::fabs(delta) > t32) {
return 0.0f;
}
const float ratio = static_cast<float>(static_cast<double>(delta) /
static_cast<double>(t32));
const float ratio2 = ratio * ratio;
float weight = exp2_approx((-(ratio2 * ratio2) * kBoundaryShape) * kBoundaryPower);
int exponent = 0;
std::frexp(static_cast<double>(weight), &exponent);
if (exponent < -31 || exponent > 1) {
weight = 0.0f;
}
if (axis == 2) {
const float angle = (edge32 * kBoundaryAngle) * 4.0f;
weight = std::cos(angle) * weight;
}
return weight;
}
namespace {
struct PanVector {
std::vector<float> values;
};
struct RegionCoordinates {
std::array<std::array<float, 3>, kMaxPoints> values{};
int count = 0;
};
RegionCoordinates region_coordinates(const ::ejoc::speaker_tables::RegionGeometry& region) {
RegionCoordinates coordinates;
coordinates.count = region.point_count;
for (int index = 0; index < region.point_count; ++index) {
for (int component = 0; component < 3; ++component) {
coordinates.values[static_cast<std::size_t>(index)][static_cast<std::size_t>(
component)] = static_cast<float>(region.points[static_cast<std::size_t>(index)]
.coordinate_q15[static_cast<std::size_t>(
component)]) /
kQ15Scale;
}
}
return coordinates;
}
using GroupList = std::vector<std::vector<int>>;
GroupList collect_groups(const std::array<::ejoc::speaker_tables::AxisGroup, kMaxGroups>& groups,
const int count) {
GroupList result;
result.reserve(static_cast<std::size_t>(count));
for (int row = 0; row < count; ++row) {
const auto& group = groups[static_cast<std::size_t>(row)];
std::vector<int> indices;
indices.reserve(group.size);
for (std::size_t index = 0; index < group.size; ++index) {
indices.push_back(static_cast<int>(group.indices[index]));
}
result.push_back(std::move(indices));
}
return result;
}
int group_total(const GroupList& groups) {
int total = 0;
for (const auto& group : groups) {
total += static_cast<int>(group.size());
}
return total;
}
void group_pan_x(const RegionCoordinates& coordinates, const GroupList& groups,
const float position, std::vector<float>& output) {
for (const auto& group : groups) {
if (group.empty()) {
continue;
}
const std::size_t first = static_cast<std::size_t>(group.front());
const std::size_t last = static_cast<std::size_t>(group.back());
const float x_first = coordinates.values[first][0];
const float x_last = coordinates.values[last][0];
if (position < x_first) {
output[first] = 1.0f;
continue;
}
if (position > x_last) {
output[last] = 1.0f;
continue;
}
for (std::size_t index = 0; index + 1 < group.size(); ++index) {
const std::size_t left = static_cast<std::size_t>(group[index]);
const std::size_t right = static_cast<std::size_t>(group[index + 1]);
const float x_left = coordinates.values[left][0];
const float x_right = coordinates.values[right][0];
if (!(x_left < x_right && x_left <= position && position <= x_right)) {
continue;
}
const float fraction = (position - x_left) / (x_right - x_left);
if (fraction <= kHalf) {
const float angle = ((fraction * kPanAngle) * kHalf) * 4.0f;
output[left] = std::cos(angle);
output[right] = std::sin(angle);
} else {
const float angle = (((1.0f - fraction) * kPanAngle) * kHalf) * 4.0f;
output[left] = std::sin(angle);
output[right] = std::cos(angle);
}
break;
}
}
}
void group_pan_y(const RegionCoordinates& coordinates, const GroupList& groups,
const float position, std::vector<float>& output) {
if (groups.empty()) {
return;
}
std::vector<float> rows;
rows.reserve(groups.size());
for (const auto& group : groups) {
rows.push_back(coordinates.values[static_cast<std::size_t>(group.front())][1]);
}
if (position <= rows.front()) {
for (const int index : groups.front()) {
output[static_cast<std::size_t>(index)] = 1.0f;
}
return;
}
if (position > rows.back()) {
for (const int index : groups.back()) {
output[static_cast<std::size_t>(index)] = 1.0f;
}
return;
}
for (std::size_t row = 0; row + 1 < groups.size(); ++row) {
const float y_low = rows[row];
const float y_high = rows[row + 1];
if (!(y_low <= position && position <= y_high && y_low < y_high)) {
continue;
}
const float fraction = (position - y_low) / (y_high - y_low);
float low_gain = 0.0f;
float high_gain = 0.0f;
if (fraction <= kHalf) {
const float angle = ((fraction * kPanAngle) * kHalf) * 4.0f;
low_gain = std::cos(angle);
high_gain = std::sin(angle);
} else {
const float angle = (((1.0f - fraction) * kPanAngle) * kHalf) * 4.0f;
low_gain = std::sin(angle);
high_gain = std::cos(angle);
}
for (const int index : groups[row]) {
output[static_cast<std::size_t>(index)] = low_gain;
}
for (const int index : groups[row + 1]) {
output[static_cast<std::size_t>(index)] = high_gain;
}
return;
}
}
std::vector<float> layer_pan_z(const RegionCoordinates& coordinates, const float position) {
float floor_gain = 0.0f;
float height_gain = 0.0f;
if (position <= 0.0f) {
floor_gain = 1.0f;
height_gain = 0.0f;
} else if (position < 0.99996948f) {
const float angle = (position * kLayerAngle) * 4.0f;
floor_gain = std::cos(angle);
height_gain = std::sin(angle);
} else {
floor_gain = 0.0f;
height_gain = 1.0f;
}
std::vector<float> output(static_cast<std::size_t>(coordinates.count), 0.0f);
for (int index = 0; index < coordinates.count; ++index) {
output[static_cast<std::size_t>(index)] =
coordinates.values[static_cast<std::size_t>(index)][2] >= kHalf ? height_gain
: floor_gain;
}
return output;
}
std::vector<float> pan_x_all(const RegionCoordinates& coordinates, const GroupList& floor_groups,
const GroupList& height_groups, const float position,
const int mode) {
std::vector<float> output(static_cast<std::size_t>(coordinates.count), 0.0f);
group_pan_x(coordinates, floor_groups, position, output);
if (mode == 3 && !height_groups.empty()) {
std::vector<float> extra(static_cast<std::size_t>(coordinates.count), 0.0f);
group_pan_x(coordinates, height_groups, position, extra);
for (std::size_t index = 0; index < output.size(); ++index) {
output[index] = output[index] + extra[index];
}
}
return output;
}
std::vector<float> pan_y_all(const RegionCoordinates& coordinates, const GroupList& floor_groups,
const GroupList& height_groups, const float position,
const int mode) {
std::vector<float> output(static_cast<std::size_t>(coordinates.count), 0.0f);
group_pan_y(coordinates, floor_groups, position, output);
if (mode == 3 && !height_groups.empty()) {
std::vector<float> extra(static_cast<std::size_t>(coordinates.count), 0.0f);
group_pan_y(coordinates, height_groups, position, extra);
for (std::size_t index = 0; index < output.size(); ++index) {
output[index] = output[index] + extra[index];
}
}
return output;
}
using BoundaryRows = std::array<std::vector<float>, 5>;
BoundaryRows boundary_rows(const RegionCoordinates& coordinates, const GroupList& floor_groups,
const GroupList& height_groups, const int mode) {
BoundaryRows rows;
rows[0] = pan_x_all(coordinates, floor_groups, height_groups, 0.0f, mode);
rows[1] = pan_x_all(coordinates, floor_groups, height_groups, 1.0f, mode);
rows[2] = pan_y_all(coordinates, floor_groups, height_groups, 0.0f, mode);
rows[3] = pan_y_all(coordinates, floor_groups, height_groups, 1.0f, mode);
if (mode == 3) {
rows[4] = layer_pan_z(coordinates, 1.0f);
} else {
rows[4] = std::vector<float>(static_cast<std::size_t>(coordinates.count), 0.0f);
}
return rows;
}
// Per-virtual-point S448 weight used by the generated size tables.
float size_weight(const float position, const float u, const float t, const int axis) {
const float offset = ((u - position) * kQuarter);
if (t < 0.000025f || std::fabs(offset) > t) {
return 0.0f;
}
const float ratio = offset / t;
const float squared = ratio * ratio;
const float power = (-(squared * squared)) * kBoundaryShape;
float weight = exp2_approx(power * kBoundaryPower);
if (axis == 2) {
const float angle = (u * kBoundaryAngle) * 4.0f;
weight = std::cos(angle) * weight;
}
return weight;
}
float size_m(const float t) {
return t <= 0.125f ? 6.0f : (6.869565f - t * 6.956522f);
}
struct AxisTable {
int position_nodes = 0;
int size_nodes = 0;
int floor_stride = 0;
int height_stride = 0;
std::vector<float> floor_values;
std::vector<float> height_values;
};
AxisTable axis_table(const std::vector<PanVector>& pan_vectors, const int position_nodes,
const int speaker_count, const int offset_start, const int axis) {
AxisTable table;
table.position_nodes = position_nodes;
table.size_nodes = 20;
table.floor_stride = 0;
table.height_stride = 0;
table.floor_values.assign(
static_cast<std::size_t>(position_nodes) * 20u *
static_cast<std::size_t>(speaker_count),
0.0f);
const float denominator = static_cast<float>(pan_vectors.size() - 1u);
for (int position_index = 0; position_index < position_nodes; ++position_index) {
const float position = static_cast<float>(position_index) /
static_cast<float>(position_nodes - 1);
for (int size_index = 0; size_index < 20; ++size_index) {
const float t = static_cast<float>(size_index) * kSizeStep;
const float m = size_m(t);
for (std::size_t u = 0; u < pan_vectors.size(); ++u) {
const float weight =
size_weight(position, static_cast<float>(u) / denominator, t, axis);
if (weight == 0.0f) {
continue;
}
for (int speaker = 0; speaker < speaker_count; ++speaker) {
const float value =
pan_vectors[u].values[static_cast<std::size_t>(offset_start + speaker)] *
weight;
const std::size_t index =
(static_cast<std::size_t>(position_index) * 20u +
static_cast<std::size_t>(size_index)) *
static_cast<std::size_t>(speaker_count) +
static_cast<std::size_t>(speaker);
table.floor_values[index] =
table.floor_values[index] + pow_approx(value, m);
}
}
}
}
return table;
}
AxisTable axis2_table(const std::vector<PanVector>& pan_vectors, const int speaker_index) {
AxisTable table;
table.position_nodes = 4;
table.size_nodes = 20;
table.floor_stride = 1;
table.height_stride = 1;
// The z axis tables are stored scalar per (position node, size node); the
// reference repeats the scalar over the group members when it consumes it.
table.floor_values.assign(4u * 20u, 0.0f);
table.height_values.assign(4u * 20u, 0.0f);
if (pan_vectors.empty() ||
static_cast<std::size_t>(speaker_index) >= pan_vectors.front().values.size()) {
return table;
}
std::vector<float>& target = table.floor_values;
for (int position_index = 0; position_index < 4; ++position_index) {
const float position = static_cast<float>(position_index) / 3.0f;
for (int size_index = 0; size_index < 20; ++size_index) {
const float t = static_cast<float>(size_index) * kSizeStep;
const float m = size_m(t);
float total = 0.0f;
for (std::size_t u = 0; u < pan_vectors.size(); ++u) {
const float weight = size_weight(position, static_cast<float>(u) / 7.0f, t, 2);
if (weight == 0.0f) {
continue;
}
const float value =
pan_vectors[u].values[static_cast<std::size_t>(speaker_index)] * weight;
total = total + pow_approx(value, m);
}
target[static_cast<std::size_t>(position_index) * 20u +
static_cast<std::size_t>(size_index)] = total;
}
}
return table;
}
struct RegionSizeTables {
int floor_count = 0;
int height_count = 0;
int mode = 0;
int floor_axis_group_count = 0;
int height_axis_group_count = 0;
BoundaryRows boundary_3d;
BoundaryRows boundary_2d;
AxisTable axes[3];
};
RegionSizeTables build_region_size_tables(const ::ejoc::speaker_tables::RegionGeometry& region) {
RegionSizeTables entry;
const RegionCoordinates coordinates = region_coordinates(region);
const GroupList floor_groups = collect_groups(region.axis0_groups,
region.axis0_group_count);
const GroupList height_groups =
region.mode == 3 ? collect_groups(region.axis1_groups, region.axis1_group_count)
: GroupList{};
entry.floor_count = group_total(floor_groups);
entry.height_count = group_total(height_groups);
entry.mode = region.mode;
entry.floor_axis_group_count = static_cast<int>(floor_groups.size());
entry.height_axis_group_count = static_cast<int>(height_groups.size());
std::vector<PanVector> x_vectors;
std::vector<PanVector> y_vectors;
std::vector<PanVector> z_vectors;
x_vectors.reserve(20);
y_vectors.reserve(20);
z_vectors.reserve(8);
for (int index = 0; index < 20; ++index) {
const float position = static_cast<float>(index) / 19.0f;
x_vectors.push_back(PanVector{pan_x_all(coordinates, floor_groups, height_groups,
position, region.mode)});
y_vectors.push_back(PanVector{pan_y_all(coordinates, floor_groups, height_groups,
position, region.mode)});
}
if (region.mode == 3) {
for (int index = 0; index < 8; ++index) {
z_vectors.push_back(
PanVector{layer_pan_z(coordinates, static_cast<float>(index) / 7.0f)});
}
} else {
for (int index = 0; index < 8; ++index) {
z_vectors.push_back(PanVector{
std::vector<float>(static_cast<std::size_t>(coordinates.count), 0.0f)});
}
}
entry.axes[0] = axis_table(x_vectors, 35, entry.floor_count, 0, 0);
entry.axes[0].height_values =
axis_table(x_vectors, 35, entry.height_count, entry.floor_count, 0).floor_values;
entry.axes[0].height_stride = entry.height_count;
entry.axes[0].floor_stride = entry.floor_count;
entry.axes[1] = axis_table(y_vectors, 35, entry.floor_count, 0, 1);
entry.axes[1].height_values =
axis_table(y_vectors, 35, entry.height_count, entry.floor_count, 1).floor_values;
entry.axes[1].height_stride = entry.height_count;
entry.axes[1].floor_stride = entry.floor_count;
if (region.mode == 3) {
entry.axes[2] = axis2_table(z_vectors, 0);
entry.axes[2].height_values = axis2_table(z_vectors, entry.floor_count).floor_values;
} else {
entry.axes[2] = AxisTable{};
entry.axes[2].position_nodes = 4;
entry.axes[2].size_nodes = 20;
entry.axes[2].floor_stride = 1;
entry.axes[2].height_stride = 1;
}
entry.boundary_3d = boundary_rows(coordinates, floor_groups, height_groups, region.mode);
entry.boundary_2d = boundary_rows(coordinates, floor_groups, GroupList{}, 2);
return entry;
}
const RegionSizeTables& region_size_tables(const ::ejoc::speaker_tables::RegionGeometry& region) {
static std::unordered_map<const void*, RegionSizeTables> cache;
const auto found = cache.find(&region);
if (found != cache.end()) {
return found->second;
}
return cache.emplace(&region, build_region_size_tables(region)).first->second;
}
void bracket(const float position, const int axis, int* low, int* high, float* alpha) {
const int last = axis == 2 ? 3 : 34;
const float step = 1.0f / static_cast<float>(last);
int low_value = static_cast<int>(
std::floor(static_cast<double>(static_cast<float>(last) * position)));
int high_value = std::min(low_value + 1, last);
if (low_value > last) {
low_value = last;
high_value = last;
}
*low = low_value;
*high = high_value;
if (low_value == high_value) {
*alpha = 0.0f;
} else {
const float position32 = position;
const float remainder = position32 -
(static_cast<float>(low_value) * step);
*alpha = max_float(0.0f, remainder / step);
}
}
void size_bracket(const float t, int* low, int* high, float* beta) {
const float step = kSizeStep;
int low_value = static_cast<int>(std::floor(static_cast<double>(
((t * kSizeCurveScale) * 2.0f) * 19.0f)));
if (low_value > 19) {
*low = 19;
*high = 19;
*beta = 0.0f;
return;
}
const int high_value = std::min(low_value + 1, 19);
*low = low_value;
*high = high_value;
if (low_value == high_value) {
*beta = 0.0f;
} else {
const float remainder = t - (static_cast<float>(low_value) * step);
*beta = max_float(
0.0f, static_cast<float>(static_cast<double>(remainder) /
static_cast<double>(step)));
}
}
std::vector<float> axis_weights(const RegionSizeTables& entry, const int axis,
const float position, const float t, const bool height) {
int low = 0;
int high = 0;
float alpha = 0.0f;
bracket(position, axis, &low, &high, &alpha);
int low_t = 0;
int high_t = 0;
float beta = 0.0f;
size_bracket(t, &low_t, &high_t, &beta);
const float weight0 = 1.0f - max_float(beta, alpha);
const float weight1 = 1.0f - max_float(beta, 1.0f - alpha);
const float weight2 = 1.0f - max_float(1.0f - beta, alpha);
const float weight3 = 1.0f - max_float(1.0f - beta, 1.0f - alpha);
const float total = ((weight1 + weight0) + weight2) + weight3;
const float scales[4] = {weight0 / total, weight1 / total, weight2 / total,
weight3 / total};
const AxisTable& table = entry.axes[axis];
std::vector<float> result;
result.reserve(static_cast<std::size_t>(entry.floor_count +
(height ? entry.height_count : 0)));
const auto append_group = [&](const std::vector<float>& values, const int count,
const int stride) {
if (count == 0) {
return;
}
const auto index = [&](const int position_index, const int size_index,
const int speaker) {
const int column = stride == 1 ? 0 : speaker;
return (static_cast<std::size_t>(position_index) * 20u +
static_cast<std::size_t>(size_index)) *
static_cast<std::size_t>(stride) +
static_cast<std::size_t>(column);
};
for (int speaker = 0; speaker < count; ++speaker) {
const float value =
((scales[0] * values[index(low, low_t, speaker)] +
scales[1] * values[index(high, low_t, speaker)]) +
scales[2] * values[index(low, high_t, speaker)]) +
scales[3] * values[index(high, high_t, speaker)];
result.push_back(value);
}
};
append_group(table.floor_values, entry.floor_count, table.floor_stride);
if (height && entry.height_count > 0) {
append_group(table.height_values, entry.height_count, table.height_stride);
}
return result;
}
float size_curve(const double size_value) {
static constexpr std::array<std::array<float, 2>, 5> kNodes{{
{0.0f, 0.0f}, {0.2f, 0.075f}, {0.5f, 0.25f}, {0.75f, 0.45f}, {1.0f, 0.7f}}};
const float size = static_cast<float>(size_value);
if (size <= kNodes.front()[0]) {
return 0.0f;
}
if (size >= kNodes.back()[0]) {
return 1.0f;
}
for (std::size_t index = 0; index + 1 < kNodes.size(); ++index) {
const float size_low = kNodes[index][0];
const float size_high = kNodes[index + 1][0];
if (size <= size_high) {
const float span = size_high - size_low;
const float fraction = span != 0.0f ? (size - size_low) / span : 0.0f;
const float t_low = kNodes[index][1];
const float t_high = kNodes[index + 1][1];
return t_low + fraction * (t_high - t_low);
}
}
return 1.0f;
}
} // namespace
float size_curve_value(const double size) {
return size_curve(size);
}
std::vector<float> size_kernel(const ::ejoc::speaker_tables::RegionGeometry& region,
const float position[3], const float t, const bool height) {
const RegionSizeTables& entry = region_size_tables(region);
const int floor_count = entry.floor_count;
const int height_count = height ? entry.height_count : 0;
const int total = floor_count + height_count;
if (total == 0) {
return std::vector<float>();
}
const int dim = height ? entry.mode
: (entry.floor_axis_group_count == 1 ? 1 : 2);
const float m = size_m(t);
const float inverse_m = 1.0f / m;
std::array<float, 3> position32{position[0], position[1], position[2]};
std::vector<float> axes[3];
for (int axis = 0; axis < dim; ++axis) {
axes[axis] = axis_weights(entry, axis, position32[static_cast<std::size_t>(axis)], t,
height);
}
const BoundaryRows& source = dim == 3 ? entry.boundary_3d : entry.boundary_2d;
// The reference reorders the five boundary rows to z1, x0, x1, y0, y1 and
// keeps the first ``total`` columns.
std::array<std::vector<float>, 5> boundary_table;
constexpr std::array<int, 5> kOrder{4, 0, 1, 2, 3};
for (std::size_t row = 0; row < 5; ++row) {
const std::vector<float>& line = source[static_cast<std::size_t>(kOrder[row])];
boundary_table[row].assign(line.begin(),
line.begin() + std::min<std::size_t>(
line.size(),
static_cast<std::size_t>(total)));
boundary_table[row].resize(static_cast<std::size_t>(total), 0.0f);
}
constexpr std::array<std::array<int, 2>, 5> kRowAxes{{
{2, 1}, {0, 0}, {0, 1}, {1, 0}, {1, 1}}};
for (std::size_t row = 0; row < 5; ++row) {
const int axis = kRowAxes[row][0];
const int edge = kRowAxes[row][1];
const float weight = boundary(axis, edge, position32[static_cast<std::size_t>(axis)], t);
for (float& value : boundary_table[row]) {
value = value * weight;
}
}
std::vector<float> inside = axes[0];
if (dim > 1) {
for (std::size_t index = 0; index < inside.size(); ++index) {
inside[index] = inside[index] * axes[1][index];
}
}
if (dim > 2) {
for (std::size_t index = 0; index < inside.size(); ++index) {
inside[index] = inside[index] * axes[2][index];
}
}
inside = norm(inside);
if (dim == 1) {
std::vector<float> result(inside.size());
for (std::size_t index = 0; index < inside.size(); ++index) {
result[index] = pow_approx(inside[index], inverse_m);
}
return result;
}
std::array<std::vector<float>, 5> powered;
for (std::size_t row = 0; row < 5; ++row) {
powered[row].resize(boundary_table[row].size());
for (std::size_t index = 0; index < boundary_table[row].size(); ++index) {
powered[row][index] = pow_approx(boundary_table[row][index], m);
}
}
std::vector<float> edge(static_cast<std::size_t>(total), 0.0f);
if (dim == 2) {
const std::vector<float>& x = axes[0];
const std::vector<float>& y = axes[1];
for (std::size_t index = 0; index < edge.size(); ++index) {
edge[index] = ((powered[1][index] * y[index] + powered[2][index] * y[index]) +
powered[3][index] * x[index]) +
powered[4][index] * x[index];
}
} else {
const std::vector<float>& x = axes[0];
const std::vector<float>& y = axes[1];
const std::vector<float>& z = axes[2];
for (std::size_t index = 0; index < edge.size(); ++index) {
const float xy = x[index] * y[index];
const float yz = y[index] * z[index];
const float xz = x[index] * z[index];
edge[index] = ((((xy * powered[0][index] + yz * powered[1][index]) +
yz * powered[2][index]) +
xz * powered[3][index]) +
xz * powered[4][index]);
}
}
edge = norm(edge);
float distance = std::min(position32[0], 1.0f - position32[0]);
distance = std::min(distance, position32[1]);
distance = std::min(distance, 1.0f - position32[1]);
if (dim == 3) {
distance = std::min(distance, 1.0f - position32[2]);
}
const float quarter_distance = kQuarter * distance;
float mix = 0.0f;
if (t < 0.000025f || (quarter_distance > t && quarter_distance > 0.05f)) {
mix = 1.0f;
} else {
const float four_t = t * 4.0f;
const float first = static_cast<float>(static_cast<double>(distance) /
static_cast<double>(four_t));
const float scaled = distance * 5.0f;
mix = first * (scaled * scaled);
}
std::vector<float> result(static_cast<std::size_t>(total));
for (std::size_t index = 0; index < result.size(); ++index) {
const float joined = ((mix * inside[index] + edge[index]) * kHalf) * 0.0625f;
result[index] = pow_approx(joined, inverse_m);
}
return result;
}
std::vector<float> size_targets(const MetadataParams& meta,
const ::ejoc::speaker_tables::LayoutGeometry& layout,
const int region_index, const double position[3],
const double size, const bool height) {
std::vector<float> result(static_cast<std::size_t>(layout.channel_count), 0.0f);
if (region_index < 0 || region_index >= static_cast<int>(layout.regions.size())) {
return result;
}
const ::ejoc::speaker_tables::RegionGeometry& region =
layout.regions[static_cast<std::size_t>(region_index)];
if (region.point_count == 0) {
return result;
}
(void)meta;
const float t = size_curve_value(size);
const float position32[3] = {static_cast<float>(position[0]),
static_cast<float>(position[1]),
static_cast<float>(position[2])};
const std::vector<float> kernel = size_kernel(region, position32, t, height);
const std::size_t count = std::min<std::size_t>(
kernel.size(), static_cast<std::size_t>(region.point_count));
for (std::size_t index = 0; index < count; ++index) {
const std::size_t speaker = region.points[index].speaker_id;
if (speaker < result.size()) {
result[speaker] = kernel[index];
}
}
return result;
}
IsfBasis assemble_isf(const MetadataParams& meta, const char* layout_key,
const int isf_idx) {
IsfBasis basis;
if (isf_idx < 0 || static_cast<std::size_t>(isf_idx) >= meta.configs.size()) {
return basis;
}
const IsfConfig& config = meta.configs[static_cast<std::size_t>(isf_idx)];
const IsfLayout* geometry = meta.layout(layout_key);
if (geometry == nullptr || geometry->output_count <= 0) {
return basis;
}
basis.rows = config.row_count();
basis.columns = geometry->output_count;
basis.values.assign(static_cast<std::size_t>(basis.rows) *
static_cast<std::size_t>(basis.columns),
0.0f);
const std::size_t output_ids = geometry->output_ids.size();
std::size_t cursor = 0;
const auto add_group = [&](const char* name, const int selector) {
const std::vector<IsfGroupRecord>* records = meta.layout_groups.find(name);
if (records == nullptr) {
return;
}
const IsfGroupRecord* record = nullptr;
for (const IsfGroupRecord& candidate : *records) {
if (candidate.selector == selector) {
record = &candidate;
break;
}
}
if (record == nullptr) {
return;
}
for (int column = record->begin; column < record->end; ++column) {
const bool paired = column >= 0 && static_cast<std::size_t>(column) <
meta.paired_columns.size() &&
meta.paired_columns[static_cast<std::size_t>(column)];
const std::vector<int>* mappings[2] = {&config.primary_row_map,
&config.secondary_row_map};
const int mapping_count = paired ? 2 : 1;
for (int which = 0; which < mapping_count; ++which) {
std::size_t speaker = 0;
if (cursor < output_ids) {
speaker = geometry->output_ids[cursor];
} else if (cursor >= output_ids && output_ids > 0) {
// The reference indexes the padded 37-entry table; a cursor
// past the table is impossible for the shipped data.
speaker = 0;
}
const std::vector<int>& mapping = *mappings[which];
for (int row = 0; row < basis.rows; ++row) {
const int source_row = mapping[static_cast<std::size_t>(row)];
const std::size_t matrix_index =
static_cast<std::size_t>(source_row) * 73u +
static_cast<std::size_t>(column);
if (matrix_index < config.matrix.size() &&
speaker < static_cast<std::size_t>(basis.columns)) {
float& target =
basis.values[static_cast<std::size_t>(row) *
static_cast<std::size_t>(basis.columns) +
speaker];
target = target + config.matrix[matrix_index];
}
}
++cursor;
}
}
};
const auto& selectors = geometry->selectors;
add_group("floor_a", selectors[0]);
cursor = cursor >= 2 ? cursor - 2 : 0;
add_group("floor_b", selectors[1]);
cursor = cursor >= 2 ? cursor - 2 : 0;
add_group("height", selectors[2]);
const int counts[5] = {config.counts[0], config.counts[1], config.counts[2],
config.counts[3], config.counts[4]};
if (selectors[3] != 0) {
const int mid = counts[0];
const int upper = counts[1];
const int lower = counts[2];
const int zenith = counts[3];
const auto clear_rows = [&](int begin, int end) {
begin = std::max(begin, 0);
end = std::min(end, basis.rows);
for (int row = begin; row < end; ++row) {
for (int column = 0; column < basis.columns; ++column) {
basis.values[static_cast<std::size_t>(row) *
static_cast<std::size_t>(basis.columns) +
static_cast<std::size_t>(column)] = 0.0f;
}
}
};
clear_rows(mid, mid + upper);
clear_rows(mid + upper + lower, mid + upper + lower + zenith);
add_group("additional", selectors[3]);
}
return basis;
}
float isf_compensation(const MetadataParams& meta, const char* layout_key,
const int isf_idx, const int row, const bool disabled) {
if (disabled) {
return 1.0f;
}
if (isf_idx < 0 || static_cast<std::size_t>(isf_idx) >= meta.configs.size()) {
return 1.0f;
}
const IsfConfig& config = meta.configs[static_cast<std::size_t>(isf_idx)];
const IsfLayout* geometry = meta.layout(layout_key);
if (geometry == nullptr) {
return 1.0f;
}
const int first = config.counts[0];
float value = static_cast<float>(geometry->compensation_value);
if (row < first) {
const float distance = static_cast<float>(std::min(row, first - row));
const float lower = max_float(static_cast<float>(first) * 0.16666667f, 1.0f);
const float width = static_cast<float>(first) * 0.11111111f;
float fraction = 0.0f;
if (distance <= lower) {
fraction = 0.0f;
} else if (distance > lower + width) {
fraction = 1.0f;
} else {
fraction = (distance - lower) / width;
}
value = fraction * value;
}
return exp2_approx(value * 0.1660964f);
}
namespace {
constexpr int kDirectBedLabels[17] = {0, 1, 2, 3, 4, 5, 6, 7, 13, 14,
17, 18, 21, 22, 11, 12, 3};
constexpr float kAWeight = 0.5011872053146362f;
constexpr float kBWeight = 0.7079457640647888f;
constexpr float kCWeight = 0.3548133969306946f;
constexpr float kRow537 = 0.5370317697525024f;
constexpr float kRow288 = 0.2884031534194946f;
constexpr float kRow813 = 0.8128305077552795f;
constexpr float kRow661 = 0.6606934666633606f;
constexpr float kRow437 = 0.43651583790779114f;
int direct_bed_label(const int label) {
if (label >= 1 && label <= 17) {
return kDirectBedLabels[label - 1];
}
return 3;
}
struct RowEntry {
int target = 0;
float weight = 0.0f;
};
const std::vector<RowEntry>* bed_rows(const int label, const std::uint32_t mask) {
static const std::vector<RowEntry> row9{{13, 1.0f}, {15, kBWeight}, {17, kAWeight}};
static const std::vector<RowEntry> row10{{14, 1.0f}, {16, kBWeight}, {18, kAWeight}};
static const std::vector<RowEntry> row11{{13, kAWeight}, {15, kBWeight}, {17, 1.0f},
{19, kBWeight}, {21, kAWeight}};
static const std::vector<RowEntry> row12{{14, kAWeight}, {16, kBWeight}, {18, 1.0f},
{20, kBWeight}, {22, kAWeight}};
static const std::vector<RowEntry> row13{{17, kAWeight}, {19, kBWeight}, {21, 1.0f}};
static const std::vector<RowEntry> row14{{18, kAWeight}, {20, kBWeight}, {22, 1.0f}};
static const std::vector<RowEntry> maskC05{{4, 1.0f}, {25, kBWeight}, {27, kBWeight}};
static const std::vector<RowEntry> maskC06{{5, 1.0f}, {26, kBWeight}, {28, kBWeight}};
static const std::vector<RowEntry> maskC07{{6, 1.0f}, {8, kCWeight}, {29, kBWeight},
{31, kBWeight}, {33, kAWeight}};
static const std::vector<RowEntry> maskC08{{7, 1.0f}, {8, kCWeight}, {30, kBWeight},
{32, kBWeight}, {34, kAWeight}};
static const std::vector<RowEntry> mask305{{4, 1.0f}, {6, kRow537}, {8, kRow288},
{25, kBWeight}, {27, kRow813}, {29, kRow661},
{31, kRow437}, {33, kCWeight}};
static const std::vector<RowEntry> mask306{{5, 1.0f}, {7, kRow537}, {8, kRow288},
{26, kBWeight}, {28, kRow813}, {30, kRow661},
{32, kRow437}, {34, kCWeight}};
if (label >= 9 && label <= 14) {
switch (label) {
case 9: return &row9;
case 10: return &row10;
case 11: return &row11;
case 12: return &row12;
case 13: return &row13;
default: return &row14;
}
}
if ((mask & 0xC0u) != 0u) {
switch (label) {
case 5: return &maskC05;
case 6: return &maskC06;
case 7: return &maskC07;
case 8: return &maskC08;
default: return nullptr;
}
}
if ((mask & 0x30u) != 0u) {
switch (label) {
case 5: return &mask305;
case 6: return &mask306;
default: return nullptr;
}
}
return nullptr;
}
} // namespace
float bed_weight(const int label, const std::uint32_t mask, const int target_label) {
const float value =
target_label == direct_bed_label(label) ? 1.0f : 0.0f;
if (label >= 9 && label <= 14) {
const std::vector<RowEntry>* rows = bed_rows(label, mask);
for (const RowEntry& entry : *rows) {
if (entry.target == target_label) {
return entry.weight;
}
}
return value;
}
if ((mask & 0xC0u) == 0u && (mask & 0x30u) == 0u) {
return value;
}
if (label == 5 && (mask & 0x4000u) == 0u && target_label == 11) {
return kAWeight;
}
if (label == 6 && (mask & 0x8000u) == 0u && target_label == 12) {
return kAWeight;
}
const std::vector<RowEntry>* rows = bed_rows(label, mask);
if (rows == nullptr) {
return value;
}
for (const RowEntry& entry : *rows) {
if (entry.target == target_label) {
return entry.weight;
}
}
return value;
}
std::array<int, 5> bed_candidates(const int label, const std::uint32_t mask,
const std::vector<int>& output_labels) {
const auto present = [&](const int value) {
return std::find(output_labels.begin(), output_labels.end(), value) !=
output_labels.end()
? 1
: 0;
};
std::array<int, 5> available{present(13), present(15), present(17), present(19),
present(21)};
std::array<int, 5> remaining = available;
const bool front_bits = label == 9 || label == 11 || label == 13;
const int front_bit = front_bits ? 8 : 9;
const int middle_bit = front_bits ? 10 : 11;
const int rear_bit = front_bits ? 12 : 13;
const int front = static_cast<int>((mask >> static_cast<unsigned>(front_bit)) & 1u);
const int middle = static_cast<int>((mask >> static_cast<unsigned>(middle_bit)) & 1u);
const int rear = static_cast<int>((mask >> static_cast<unsigned>(rear_bit)) & 1u);
if (front != 0) {
if (available[0] != 0) {
remaining[0] = 0;
} else if (available[1] != 0) {
remaining[1] = 0;
}
}
if (middle != 0 && available[2] != 0) {
remaining[2] = 0;
}
if (rear != 0) {
if (available[4] != 0) {
remaining[4] = 0;
} else if (available[3] != 0) {
remaining[3] = 0;
}
}
const int available_sum =
available[0] + available[1] + available[2] + available[3] + available[4];
const bool special = available[2] == 0 && available_sum == 2 && front == 0 &&
rear == 0 && middle != 0 &&
(available[0] != 0 || available[1] != 0) &&
(available[3] != 0 || available[4] != 0);
if (label == 9 || label == 10) {
if (available[0] != 0 || available[1] != 0 || remaining[2] != 0) {
return {available[0], available[1], remaining[2], 0, 0};
}
return {0, 0, 0, 0, 0};
}
if (label == 11 || label == 12) {
if (special) {
return {0, 0, 0, 0, 0};
}
return {remaining[0], remaining[1], available[2], remaining[3], remaining[4]};
}
if (label == 13 || label == 14) {
if (available[3] != 0 || available[4] != 0 || remaining[2] != 0) {
return {0, 0, remaining[2], available[3], available[4]};
}
return {0, 0, 0, 0, 0};
}
return {0, 0, 0, 0, 0};
}
BedDistribution bed_distribution(const ::joc::speaker::LayoutInfo& layout, const int label,
const std::uint32_t mask, const bool distribute) {
const ::joc::joc::BedOutputDescription description =
::joc::joc::bed_output_description(layout);
const std::vector<int>& labels = description.output_labels;
BedDistribution result;
result.weights.assign(labels.size(), 0.0f);
const int bed_index = label - 1;
if (bed_index < 0 || bed_index >= kBedLabelCount) {
return result;
}
const int slot = description.label_to_slot[bed_index];
const int fallback = description.direct_output_labels[bed_index];
const bool height = label >= 9 && label <= 14;
if (slot == -2 && (!height || !distribute)) {
result.route = fallback;
return result;
}
if (slot == -1) {
result.route = -1;
return result;
}
if (slot >= 0 && static_cast<std::size_t>(slot) < result.weights.size()) {
result.weights[static_cast<std::size_t>(slot)] = 1.0f;
}
if (!distribute) {
result.route = -1;
return result;
}
std::vector<float> weights;
if (height) {
const std::array<int, 5> candidates = bed_candidates(label, mask, labels);
if (std::none_of(candidates.begin(), candidates.end(),
[](const int value) { return value != 0; })) {
result.route = fallback;
return result;
}
static constexpr std::array<int, 5> kSideOdd{13, 15, 17, 19, 21};
static constexpr std::array<int, 5> kSideEven{14, 16, 18, 20, 22};
const std::array<int, 5>& side_labels = (label % 2) != 0 ? kSideOdd : kSideEven;
weights.assign(labels.size(), 0.0f);
for (std::size_t index = 0; index < labels.size(); ++index) {
bool allowed = false;
for (std::size_t candidate = 0; candidate < candidates.size(); ++candidate) {
if (candidates[candidate] != 0 && side_labels[candidate] == labels[index]) {
allowed = true;
break;
}
}
weights[index] = allowed ? bed_weight(label, mask, labels[index]) : 0.0f;
}
} else {
weights.resize(labels.size());
bool binary = true;
for (std::size_t index = 0; index < labels.size(); ++index) {
weights[index] = bed_weight(label, mask, labels[index]);
if (weights[index] != 0.0f && weights[index] != 1.0f) {
binary = false;
}
}
if (binary) {
result.route = -1;
return result;
}
}
std::size_t count = 0;
for (const float value : weights) {
if (value != 0.0f) {
++count;
}
}
if (count == 1) {
for (float& value : weights) {
if (value != 0.0f) {
value = 1.0f;
}
}
} else if (count > 1) {
weights = norm(weights);
} else {
result.route = fallback;
return result;
}
result.route = -1;
result.weights = std::move(weights);
return result;
}
void bed_reference_position(const int index, int q15[3]) {
q15[0] = 0;
q15[1] = 0;
q15[2] = 0;
if (index < 0 || index >= ::joc::joc::kBedReferencePositionCount) {
return;
}
const std::int32_t(*positions)[3] = ::joc::joc::bed_reference_positions_q15();
if (positions == nullptr) {
return;
}
q15[0] = static_cast<int>(positions[index][0]);
q15[1] = static_cast<int>(positions[index][1]);
q15[2] = static_cast<int>(positions[index][2]);
}
float bed_attenuation_db(const ::joc::speaker::LayoutInfo& layout) {
return static_cast<float>(::joc::joc::bed_output_description(layout).automatic_attenuation_db);
}
float bed_compensation(const ::joc::speaker::LayoutInfo& layout, const int label,
const int mode, const bool bypass, const double levels[3]) {
if (label == 4 || label == 17 || bypass || mode == 1) {
return 1.0f;
}
if (label < 1 || label > kBedLabelCount) {
return 1.0f;
}
const ::joc::joc::BedOutputDescription description =
::joc::joc::bed_output_description(layout);
const int source = description.direct_output_labels[label - 1];
int position[3] = {0, 0, 0};
bed_reference_position(source, position);
const float x = static_cast<float>(static_cast<double>(position[0]) / 32768.0);
const float y = static_cast<float>(static_cast<double>(position[1]) / 32768.0);
const float z = static_cast<float>(static_cast<double>(position[2]) / 32768.0);
float value_db = 0.0f;
if (mode == 0) {
const float y_term = y >= 0.6f ? 1.0f
: (y <= 0.0f
? 0.0f
: static_cast<float>(static_cast<double>(y) / 0.6));
const float z_term =
z >= 1.0f ? 1.0f
: (z <= 0.2f
? 0.0f
: static_cast<float>(static_cast<double>(z - 0.2f) / 0.8));
const float amount = max_float(0.0f, min_float(y_term + z_term, 1.0f));
value_db = amount * static_cast<float>(description.automatic_attenuation_db);
} else {
const float surround = static_cast<float>(levels[0]);
const float height = static_cast<float>(levels[1]);
const float centre = static_cast<float>(levels[2]);
const float surround_factor =
y >= 0.5f ? surround
: static_cast<float>(static_cast<double>(y * surround) * 2.0);
float centre_position = max_float(std::fabs(z) - 0.05f, y - 0.05f);
centre_position =
max_float(centre_position, std::fabs(x - 0.5f) - 0.05f);
const float centre_factor =
1.0f - min_float(max_float(10.0f * centre_position, 0.0f), 1.0f);
value_db = ((surround_factor * (1.0f - z)) + (z * height)) +
(centre_factor * centre);
}
return exp2_approx(value_db * 0.1660964f);
}
} // namespace joc::oamd