Sync the kernel copy with the OAMD frame-level core
The kernel copy follows the new kernel. The renderer has a frame-level state machine (normal, hold, hard cut and passthrough, the 8-plane passthrough, the LFE clipgain ramp and interpolation when no previous state exists), the OAMD parser carries the complete frame state (several blocks, more than 16 objects) and the speaker renderer applies the metadata (gain and inactive flags, zone/elevation, size, snap, divergence, ISF and bed distribution). oamd_math and oamd_params are new modules, the ISF tables are compiled in now that the upstream data/ directory is gone, and the binaural timeline accepts a complete frame state. joc_core.h moves to ABI 6 (frame parameters and EMDF payload info at v2, JOC_FRAME_STATUS_*, raw 5-bit offset_ts) and eac3joc_core.h to EJOC ABI 4 (EJOC_FRAME_STATUS_*, ejoc_frame_input v1, ejoc_renderer_render_frame, EJOC_CORE_OUT_CHANNELS and EJOC_LFE_SLOT; the old ejoc_renderer_process stays). joc_stream.h and joc_version.h are unchanged. joc_kernel.vcxproj lists the two new translation units and the four new headers. The component's layout table gains the kernel's 6.0 layout (L R Ls Rs Lrs Rrs) after 9.1.6, and layout_table_test expects twelve layouts, so the list the preferences page shows and the list the renderer accepts are the same again. README, THIRD_PARTY_NOTICES and the CI comment pin the copy to commit 3f0d5e87fe41b90d9350528d2dca2ca82a637a3f; tag v1.2.0 points at the older a276028 and is not the sync baseline. Builds Release-Static|x64 and |Win32 with no errors. The offline test tools build and pass on both architectures: layout_table_test reports 12 layouts, and channel_swap_test, log_rotation_test and long_path_test pass. scan_crosscheck agrees with the core on the upstream test material, and the render harness delivers 7.1.4 speaker output and binaural output on both architectures, with the speaker-path WAV byte-identical between them. The core is still vendored under kernel/; building it from the upstream checkout at build time is a separate change.
This commit is contained in:
1 parent
5b41868e94
commit
defe9538fe
39 files changed
+6697
-599
No files matched your search
@@ -3,7 +3,8 @@ name: build
|
||||
# Builds both architectures, publishes the two installable component packages as
|
||||
# workflow artifacts, and — when a tag is pushed — turns them into a GitHub release.
|
||||
# The SDK is fetched from foobar2000.org at build time (tools/setup_sdk.ps1) and the
|
||||
# renderer sources are part of this repository (kernel/), so nothing else is needed.
|
||||
# renderer sources are part of this repository (kernel/, synced from JustOneCacophonyCXX
|
||||
# commit 3f0d5e87fe41b90d9350528d2dca2ca82a637a3f), so nothing else is needed.
|
||||
|
||||
on:
|
||||
push:
|
||||
|
||||
+3
-1
@@ -208,4 +208,6 @@ every container in the library, which is where the volume comes from.
|
||||
## Licence
|
||||
|
||||
`LICENSE` is the upstream MIT licence, copied unchanged; `kernel/` is a copy of the upstream
|
||||
rendering core sources and keeps their notices. See [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md).
|
||||
rendering core sources, synced to JustOneCacophonyCXX commit
|
||||
`3f0d5e87fe41b90d9350528d2dca2ca82a637a3f` (the `v1.2.0` tag points at an older commit and is not
|
||||
the sync baseline), and keeps their notices. See [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md).
|
||||
@@ -162,5 +162,6 @@ pwsh -File tools/package.ps1 # 两个架构,打包到 dist\*.fb2k-c
|
||||
|
||||
## 许可
|
||||
|
||||
`LICENSE` 是上游 MIT 许可,原样复制;`kernel/` 是上游渲染内核源码的副本,保留其声明。见
|
||||
`LICENSE` 是上游 MIT 许可,原样复制;`kernel/` 是上游渲染内核源码的副本,同步自 JustOneCacophonyCXX 的提交
|
||||
`3f0d5e87fe41b90d9350528d2dca2ca82a637a3f`(`v1.2.0` tag 指向更早的提交,不作为同步基准),保留其声明。见
|
||||
[THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md)。
|
||||
@@ -5,6 +5,10 @@
|
||||
(`kernel/src/joc_bitstream/joc_huffman_tables.h`)的公开标准来源,以及 HRTF 数据与
|
||||
专利的边界说明。
|
||||
|
||||
`kernel/` 整体是 JustOneCacophonyCXX 在提交
|
||||
`3f0d5e87fe41b90d9350528d2dca2ca82a637a3f`(版本号仍为 1.2.0)的逐字副本;
|
||||
`v1.2.0` tag 指向更早的提交 a276028,不作为同步基准。
|
||||
|
||||
## 公开标准来源
|
||||
|
||||
64-QMF → 77-hybrid 结构与 13-tap 低带 prototype 定义于
|
||||
|
||||
@@ -3,19 +3,22 @@
|
||||
#include <stdint.h>
|
||||
|
||||
/* EJOC_STATIC: this branch exists for building the sources directly into an application, where nothing is imported or exported. */
|
||||
#if defined(_WIN32)
|
||||
#define EJOC_CALL __cdecl
|
||||
#else
|
||||
#define EJOC_CALL
|
||||
#endif
|
||||
|
||||
#if defined(EJOC_STATIC)
|
||||
#define EJOC_API
|
||||
#define EJOC_CALL __cdecl
|
||||
#elif defined(_WIN32)
|
||||
#if defined(EJOC_BUILD_DLL)
|
||||
#define EJOC_API __declspec(dllexport)
|
||||
#else
|
||||
#define EJOC_API __declspec(dllimport)
|
||||
#endif
|
||||
#define EJOC_CALL __cdecl
|
||||
#else
|
||||
#define EJOC_API __attribute__((visibility("default")))
|
||||
#define EJOC_CALL
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
@@ -23,13 +26,15 @@ extern "C" {
|
||||
#endif
|
||||
|
||||
enum {
|
||||
EJOC_ABI_VERSION = 3,
|
||||
EJOC_ABI_VERSION = 4,
|
||||
EJOC_FRAME_SAMPLES = 1536,
|
||||
EJOC_TIMESLOTS = 24,
|
||||
EJOC_SUBBANDS = 64,
|
||||
EJOC_CORE_CHANNELS = 5, /* downmix configurations 0 and 3 */
|
||||
EJOC_MAX_CORE_CHANNELS = 7, /* downmix configurations 1, 2 and 4 */
|
||||
EJOC_OUTPUT_CHANNELS = 16,
|
||||
EJOC_CORE_OUT_CHANNELS = 8, /* passthrough order: L,R,C,LFE,Ls,Rs,(Lrs,Rrs) */
|
||||
EJOC_LFE_SLOT = 3, /* LFE slot of the passthrough order */
|
||||
EJOC_MAX_OBJECTS = 15,
|
||||
EJOC_MAX_DPOINTS = 2,
|
||||
EJOC_MAX_PARAMETER_BANDS = 23,
|
||||
@@ -43,6 +48,21 @@ enum {
|
||||
EJOC_BINAURAL_HYBRID_BANDS = 77
|
||||
};
|
||||
|
||||
/* Per-frame status of ejoc_renderer_render_frame(). A status outside 0..6 is
|
||||
* the renderer's own no-metadata marker; the parse-status values match
|
||||
* joc_frame_params.status (JOC_FRAME_STATUS_* in joc_core.h). Any non-zero
|
||||
* status makes the frame invalid for matrix rendering: the renderer holds the
|
||||
* previous matrices or passes the core PCM through instead of decoding it. */
|
||||
enum {
|
||||
EJOC_FRAME_STATUS_OK = 0,
|
||||
EJOC_FRAME_STATUS_UNSUPPORTED_DMX = 2,
|
||||
EJOC_FRAME_STATUS_OBJECTS_CLAMPED = 3,
|
||||
EJOC_FRAME_STATUS_BAD_PARAMETER_BAND = 4,
|
||||
EJOC_FRAME_STATUS_BAD_OFFSET_TS = 5,
|
||||
EJOC_FRAME_STATUS_TRAILING_DATA = 6,
|
||||
EJOC_FRAME_STATUS_NO_METADATA = 8
|
||||
};
|
||||
|
||||
typedef void* ejoc_renderer_handle;
|
||||
typedef void* ejoc_speaker_renderer_handle;
|
||||
typedef void* ejoc_binaural_renderer_handle;
|
||||
@@ -103,6 +123,63 @@ EJOC_API int EJOC_CALL ejoc_renderer_process(
|
||||
float output_scale,
|
||||
float* output16_planar);
|
||||
|
||||
/*
|
||||
Frame-level entry point: one E-AC-3 audio frame per call, with the seq state
|
||||
machine and the per-object previous-matrix state kept inside the renderer. This
|
||||
is what produces the 16-channel object result for the ADM, speaker and binaural
|
||||
backends; ejoc_renderer_process() stays as a single-frame kernel for A/B tests.
|
||||
|
||||
Fixed array layouts, identical to ejoc_renderer_process():
|
||||
bed_planar [core_channel_count][1536] (JOC lane order L,R,C,Ls,Rs,(pair))
|
||||
lfe [1536] or NULL (zeros; the LFE delay ring still advances)
|
||||
n_bands, n_dpoints, slope_idx [15]
|
||||
offset_ts [15][2] (raw 5-bit JOC offsets, 0..23)
|
||||
dq [15][2][7][23]
|
||||
output16 [16][1536] (ch0 = LFE, ch1..15 = objects)
|
||||
|
||||
frame_status is a JOC_FRAME_STATUS_* / EJOC_FRAME_STATUS_* value. has_metadata
|
||||
is 0 for an audio frame without a JOC EMDF container (frame_status must then be
|
||||
EJOC_FRAME_STATUS_NO_METADATA); such a frame always passes the 8 core planes
|
||||
through to output slots 0..7, delayed by 1217 samples, with slots 8..15 zero.
|
||||
declared_core_channels is the JOC header's n_channels (0 when unknown); a declared
|
||||
change against the previous frame's actual count turns the frame into a hard cut
|
||||
with the LFE ring cleared. phase_shift is sigma(k) = (k in {3,4}) for the frame's
|
||||
downmix configuration; phase_shift_valid = 0 keeps the previous switch (an
|
||||
unsupported downmix configuration has no usable one). clipgain is the frame's
|
||||
joc_clipgain when frame_status == 0. seq is the 10-bit JOC sequence counter.
|
||||
When has_metadata is 0 the object descriptors are ignored.
|
||||
|
||||
Slot 0 of output16 is the LFE, slots 1..15 are the 15 objects; each frame's
|
||||
values are float32(clamped PCM) * output_scale, exactly like the reference.
|
||||
*/
|
||||
typedef struct ejoc_frame_input {
|
||||
uint32_t struct_size;
|
||||
uint32_t struct_version;
|
||||
const float* bed_planar;
|
||||
const float* lfe;
|
||||
uint32_t core_channel_count;
|
||||
uint32_t declared_core_channels;
|
||||
uint32_t phase_shift;
|
||||
uint32_t phase_shift_valid;
|
||||
uint32_t frame_status;
|
||||
uint32_t seq;
|
||||
uint32_t has_metadata;
|
||||
uint32_t object_mask;
|
||||
const uint8_t* n_bands;
|
||||
const uint8_t* n_dpoints;
|
||||
const uint8_t* slope_idx;
|
||||
const uint8_t* offset_ts;
|
||||
const double* dq;
|
||||
double clipgain;
|
||||
float output_scale;
|
||||
float* output16_planar;
|
||||
} ejoc_frame_input;
|
||||
|
||||
enum { EJOC_FRAME_INPUT_VERSION = 1 };
|
||||
|
||||
EJOC_API int EJOC_CALL ejoc_renderer_render_frame(ejoc_renderer_handle handle,
|
||||
const ejoc_frame_input* input);
|
||||
|
||||
/*
|
||||
High-precision object-to-speaker renderer.
|
||||
|
||||
|
||||
+31
-11
@@ -36,27 +36,30 @@
|
||||
|
||||
#include "joc_version.h"
|
||||
|
||||
#define JOC_ABI_VERSION 5u
|
||||
#define JOC_FRAME_PARAMS_VERSION 1u
|
||||
#define JOC_EMDF_INFO_VERSION 1u
|
||||
#define JOC_ABI_VERSION 6u
|
||||
#define JOC_FRAME_PARAMS_VERSION 2u
|
||||
#define JOC_EMDF_INFO_VERSION 2u
|
||||
#define JOC_TASK_CONFIG_VERSION 4u
|
||||
#define JOC_TASK_RESULT_VERSION 2u
|
||||
#define JOC_EVENT_VERSION 1u
|
||||
|
||||
/* JOC_STATIC: this branch exists for building the sources directly into an application, where nothing is imported or exported. */
|
||||
#if defined(_WIN32)
|
||||
#define JOC_CALL __cdecl
|
||||
#else
|
||||
#define JOC_CALL
|
||||
#endif
|
||||
|
||||
#if defined(JOC_STATIC)
|
||||
#define JOC_API
|
||||
#define JOC_CALL __cdecl
|
||||
#elif defined(_WIN32)
|
||||
#if defined(JOC_BUILD_DLL)
|
||||
#define JOC_API __declspec(dllexport)
|
||||
#else
|
||||
#define JOC_API __declspec(dllimport)
|
||||
#endif
|
||||
#define JOC_CALL __cdecl
|
||||
#else
|
||||
#define JOC_API __attribute__((visibility("default")))
|
||||
#define JOC_CALL
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
@@ -152,8 +155,7 @@ JOC_API const char* JOC_CALL joc_last_error_detail(void);
|
||||
typedef struct joc_emdf_payload_info {
|
||||
uint8_t id;
|
||||
uint8_t reserved[3];
|
||||
uint16_t sample_offset; /* EMDF outer smpoffst, 11 bits */
|
||||
uint16_t reserved2;
|
||||
uint32_t sample_offset; /* EMDF outer smpoffst: variable_bits(11) */
|
||||
uint32_t bit_offset;
|
||||
uint32_t size; /* payload bytes */
|
||||
} joc_emdf_payload_info;
|
||||
@@ -170,7 +172,8 @@ typedef struct joc_emdf_info {
|
||||
|
||||
/* Per-object ID14/JOC descriptor plus its dequantized matrix.
|
||||
* dq[dp][ch][pb] is zero filled outside [0,n_dpoints) x [0,n_channels) x
|
||||
* [0,n_bands). Absent objects are entirely zero. */
|
||||
* [0,n_bands). Absent objects are entirely zero. offset_ts holds the raw
|
||||
* 5-bit JOC offsets (legal range 0..23, strictly increasing per object). */
|
||||
typedef struct joc_object_params {
|
||||
uint8_t present;
|
||||
uint8_t num_bands_idx;
|
||||
@@ -185,6 +188,21 @@ typedef struct joc_object_params {
|
||||
double dq[JOC_MAX_DPOINTS][JOC_MAX_CORE_CHANNELS][JOC_MAX_PARAMETER_BANDS];
|
||||
} joc_object_params;
|
||||
|
||||
/* Per-frame JOC parse status (joc_frame_params.status). A non-zero status makes
|
||||
* the frame invalid for rendering: the renderer holds the previous matrices or
|
||||
* passes the core PCM through instead of decoding the matrix. Only status 3
|
||||
* still carries a complete object list (object count clamped to 15) for
|
||||
* diagnostics; statuses 2 and 4 stop the parse after the failing header field. */
|
||||
enum {
|
||||
JOC_FRAME_STATUS_OK = 0,
|
||||
JOC_FRAME_STATUS_UNSUPPORTED_DMX = 2, /* joc_dmx_config_idx outside 0..4 */
|
||||
JOC_FRAME_STATUS_OBJECTS_CLAMPED = 3, /* declared object count above 15 */
|
||||
JOC_FRAME_STATUS_BAD_PARAMETER_BAND = 4, /* unknown num_bands index */
|
||||
JOC_FRAME_STATUS_BAD_OFFSET_TS = 5, /* offset_ts outside 0..23 or not */
|
||||
/* strictly increasing */
|
||||
JOC_FRAME_STATUS_TRAILING_DATA = 6 /* bytes after joc_data alignment */
|
||||
};
|
||||
|
||||
typedef struct joc_frame_params {
|
||||
uint32_t struct_size;
|
||||
uint32_t struct_version;
|
||||
@@ -196,12 +214,14 @@ typedef struct joc_frame_params {
|
||||
uint8_t clipgain_x_bits;
|
||||
uint8_t clipgain_y_bits;
|
||||
uint8_t objects_clamped; /* num_objects_bits+1 exceeded 15 */
|
||||
uint32_t seq_count; /* 10-bit JOC sequence counter, parsed only */
|
||||
uint32_t seq_count; /* 10-bit JOC sequence counter */
|
||||
uint32_t present_mask; /* bit i == object i present */
|
||||
uint8_t status; /* JOC_FRAME_STATUS_* */
|
||||
uint8_t reserved[3];
|
||||
uint32_t data_end_bits; /* bit position just after joc_data */
|
||||
uint32_t trailing_bits; /* bits left after joc_data (padding/ext) */
|
||||
uint8_t tail_bytes[8]; /* first up to 8 trailing bytes, for A/B */
|
||||
double clipgain; /* 1 + (y/32) * 2^(x-4), bit-exact */
|
||||
double clipgain; /* 2^(x-4) * (1 + y/32), bit-exact */
|
||||
joc_object_params objects[JOC_MAX_OBJECTS];
|
||||
} joc_frame_params;
|
||||
|
||||
|
||||
@@ -5,7 +5,8 @@
|
||||
shipping and loading joc_core.dll.
|
||||
|
||||
The sources under kernel\src and kernel\include are a verbatim copy of the
|
||||
upstream library (see JustOneCacophonyCXX\CMakeLists.txt): nothing under either
|
||||
upstream library at commit 3f0d5e87fe41b90d9350528d2dca2ca82a637a3f (see
|
||||
JustOneCacophonyCXX\CMakeLists.txt): nothing under either
|
||||
tree is edited here, and both are kept identical to it, so a single core serves
|
||||
the upstream tools and this component alike. The static build needs no branch
|
||||
of its own: JOC_STATIC (kernel\include\joc_core.h / joc_stream.h) and
|
||||
@@ -177,6 +178,8 @@
|
||||
<ClCompile Include="src\joc_bitstream\bed_layout_map.cpp" />
|
||||
<ClCompile Include="src\joc_bitstream\joc_parser.cpp" />
|
||||
<ClCompile Include="src\joc_core\objects16.cpp" />
|
||||
<ClCompile Include="src\oamd\oamd_math.cpp" />
|
||||
<ClCompile Include="src\oamd\oamd_params.cpp" />
|
||||
<ClCompile Include="src\oamd\oamd_parser.cpp" />
|
||||
<ClCompile Include="src\speaker\speaker_layout_lookup.cpp" />
|
||||
<ClCompile Include="src\speaker\speaker_step.cpp" />
|
||||
@@ -256,6 +259,9 @@
|
||||
<ClInclude Include="src\joc_bitstream\joc_parser.h" />
|
||||
<ClInclude Include="src\joc_core\objects16.h" />
|
||||
<ClInclude Include="src\joc_core\qmf_tables.h" />
|
||||
<ClInclude Include="src\oamd\isf_tables.h" />
|
||||
<ClInclude Include="src\oamd\oamd_math.h" />
|
||||
<ClInclude Include="src\oamd\oamd_params.h" />
|
||||
<ClInclude Include="src\oamd\oamd_parser.h" />
|
||||
<ClInclude Include="src\simd\cpu_probe.h" />
|
||||
<ClInclude Include="src\simd\simd.h" />
|
||||
@@ -264,6 +270,7 @@
|
||||
<ClInclude Include="src\speaker\speaker_trim.h" />
|
||||
<ClInclude Include="src\speaker\speaker_layouts.h" />
|
||||
<ClInclude Include="src\speaker\speaker_step.h" />
|
||||
<ClInclude Include="src\speaker\speaker_meta.h" />
|
||||
<ClInclude Include="src\stream\stream.h" />
|
||||
<ClInclude Include="src\task\task.h" />
|
||||
<ClInclude Include="src\telemetry\event_bus.h" />
|
||||
|
||||
@@ -98,7 +98,8 @@ Status JochrtfRuntime::open(const hrtf::Field& field, const hrtf::Kernels& kerne
|
||||
Status JochrtfRuntime::process_block() {
|
||||
double positions[timeline::kTimelineObjects][3] = {};
|
||||
const Status queried = timeline_.positions_at(static_cast<std::int64_t>(processed_samples_),
|
||||
positions);
|
||||
&positions[0][0],
|
||||
timeline::kTimelineObjects);
|
||||
if (!queried.ok()) {
|
||||
return queried;
|
||||
}
|
||||
|
||||
@@ -83,7 +83,7 @@ struct Options {
|
||||
};
|
||||
|
||||
const char* kLayoutChoices =
|
||||
"2.0 3.1 4.0 5.1 7.1 5.1.2 5.1.4 7.1.2 7.1.4 9.1.4 9.1.6";
|
||||
"2.0 3.1 4.0 5.1 7.1 5.1.2 5.1.4 7.1.2 7.1.4 9.1.4 9.1.6 6.0";
|
||||
|
||||
void print_usage() {
|
||||
std::printf(
|
||||
@@ -97,7 +97,7 @@ void print_usage() {
|
||||
" input 输入 .m4a/.eac3/.ec3\n"
|
||||
"\n"
|
||||
"模式(默认输出 ADM BWF):\n"
|
||||
" --speaker-layout L 直接扬声器渲染布局,例如 2.0、5.1、7.1.2\n"
|
||||
" --speaker-layout L 直接扬声器渲染布局,例如 2.0、5.1、6.0、7.1.2\n"
|
||||
" 可选值: %s\n"
|
||||
" --binaural 直接双耳渲染;不生成临时 ADM BWF\n"
|
||||
"\n"
|
||||
|
||||
@@ -102,9 +102,15 @@ Status parse_at(const std::uint8_t* data, std::size_t size, std::size_t start_bi
|
||||
}
|
||||
|
||||
const std::uint32_t has_sample_offset = reader.read(1);
|
||||
std::uint16_t sample_offset = 0;
|
||||
std::uint32_t sample_offset = 0;
|
||||
if (has_sample_offset != 0u) {
|
||||
sample_offset = static_cast<std::uint16_t>(reader.read(12) >> 1);
|
||||
std::uint32_t value = 0;
|
||||
if (!bits::variable_bits(reader, 11, 8, &value)) {
|
||||
return reader.error() == JOC_ERR_BITSTREAM_TRUNCATED
|
||||
? truncated_fail(reader)
|
||||
: syntax_fail(reader.error_message());
|
||||
}
|
||||
sample_offset = value;
|
||||
}
|
||||
if (reader.read(1) != 0u) {
|
||||
std::uint32_t ignored = 0;
|
||||
|
||||
@@ -17,7 +17,7 @@ inline constexpr std::size_t kMaxPayloads = JOC_MAX_EMDF_PAYLOADS;
|
||||
|
||||
struct Payload {
|
||||
std::uint8_t id = 0;
|
||||
std::uint16_t sample_offset = 0;
|
||||
std::uint32_t sample_offset = 0; // EMDF outer smpoffst: variable_bits(11)
|
||||
std::size_t bit_offset = 0; // MSB-first bit position of the payload bytes
|
||||
std::size_t size = 0; // payload byte count
|
||||
// Payload configuration data (ETSI TS 102 366 H.2.2.3). Spec section 8.2 and
|
||||
|
||||
@@ -1120,7 +1120,8 @@ struct RosellaRuntime::Impl {
|
||||
// rosella_binaural_renderer._set_block_parameters.
|
||||
Status set_block_parameters(std::int64_t sample) {
|
||||
double positions[timeline::kTimelineObjects][3] = {};
|
||||
Status status = timeline.positions_at(sample, positions);
|
||||
Status status = timeline.positions_at(sample, &positions[0][0],
|
||||
timeline::kTimelineObjects);
|
||||
if (!status.ok()) {
|
||||
return status;
|
||||
}
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
|
||||
#include "joc_bitstream/bed_layout_map.h"
|
||||
|
||||
#include <cmath>
|
||||
#include <cstring>
|
||||
|
||||
#include "speaker/speaker_layouts.h"
|
||||
@@ -100,6 +101,9 @@ constexpr LayoutName kLayoutNames[] = {
|
||||
{bit(BedChannel::kLeft) | bit(BedChannel::kRight) |
|
||||
bit(BedChannel::kLeftSurround) | bit(BedChannel::kRightSurround) |
|
||||
bit(BedChannel::kCenter) | bit(BedChannel::kLfe), "5.1"},
|
||||
{bit(BedChannel::kLeft) | bit(BedChannel::kRight) |
|
||||
bit(BedChannel::kLeftSurround) | bit(BedChannel::kRightSurround) |
|
||||
bit(BedChannel::kLeftRearSurround) | bit(BedChannel::kRightRearSurround), "6.0"},
|
||||
{bit(BedChannel::kLeft) | bit(BedChannel::kRight) |
|
||||
bit(BedChannel::kLeftSurround) | bit(BedChannel::kRightSurround) |
|
||||
bit(BedChannel::kCenter) | bit(BedChannel::kLfe) |
|
||||
@@ -328,4 +332,301 @@ bool layout_bed_anchor(std::uint32_t out_ch_config, BedChannel channel,
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
namespace {
|
||||
|
||||
// ETSI TS 103 420 Table B.10: the fixed ADM position of every Table 12 bed
|
||||
// channel. bed_output_description() matches these points against the target
|
||||
// layout; the kChannels table above keeps the ADM/binaural path's coordinates.
|
||||
struct TableB10Position {
|
||||
BedChannel channel;
|
||||
double xyz[3];
|
||||
};
|
||||
|
||||
constexpr TableB10Position kTableB10[oamd::kBedLabelCount] = {
|
||||
{BedChannel::kLeft, {-1.0, 1.0, 0.0}},
|
||||
{BedChannel::kRight, {1.0, 1.0, 0.0}},
|
||||
{BedChannel::kCenter, {0.0, 1.0, 0.0}},
|
||||
{BedChannel::kLfe, {-1.0, 1.0, -1.0}},
|
||||
{BedChannel::kLeftSurround, {-1.0, 0.0, 0.0}},
|
||||
{BedChannel::kRightSurround, {1.0, 0.0, 0.0}},
|
||||
{BedChannel::kLeftRearSurround, {-1.0, -1.0, 0.0}},
|
||||
{BedChannel::kRightRearSurround, {1.0, -1.0, 0.0}},
|
||||
{BedChannel::kTopFrontLeft, {-1.0, 1.0, 1.0}},
|
||||
{BedChannel::kTopFrontRight, {1.0, 1.0, 1.0}},
|
||||
{BedChannel::kTopSideLeft, {-1.0, 0.0, 1.0}},
|
||||
{BedChannel::kTopSideRight, {1.0, 0.0, 1.0}},
|
||||
{BedChannel::kTopBackLeft, {-1.0, -1.0, 1.0}},
|
||||
{BedChannel::kTopBackRight, {1.0, -1.0, 1.0}},
|
||||
{BedChannel::kLeftWide, {-1.0, 21.0 / 31.0, 0.0}},
|
||||
{BedChannel::kRightWide, {1.0, 21.0 / 31.0, 0.0}},
|
||||
{BedChannel::kLfe2, {1.0, 1.0, -1.0}},
|
||||
};
|
||||
|
||||
// bed_layout.BED_REFERENCE_POSITIONS_Q15; index 3 is the non-spatial sentinel.
|
||||
constexpr std::int32_t kReferencePositions[kBedReferencePositionCount][3] = {
|
||||
{0, 0, 0}, {32767, 0, 0}, {16384, 0, 0}, {-1, -1, -1},
|
||||
{0, 16384, 0}, {32767, 16384, 0}, {0, 32767, 0}, {32767, 32767, 0},
|
||||
{16384, 32767, 0}, {5285, 0, 0}, {27483, 0, 0}, {0, 5285, 0},
|
||||
{32767, 5285, 0}, {7928, 0, 32767}, {24840, 0, 32767}, {7928, 7928, 32767},
|
||||
{24840, 7928, 32767}, {7928, 16384, 32767}, {24840, 16384, 32767},
|
||||
{7928, 24840, 32767}, {24840, 24840, 32767}, {7928, 32767, 32767},
|
||||
{24840, 32767, 32767}, {11099, 0, 0}, {21669, 0, 0}, {0, 11099, 0},
|
||||
{32767, 11099, 0}, {0, 21669, 0}, {32767, 21669, 0}, {0, 27483, 0},
|
||||
{32767, 27483, 0}, {5285, 32767, 0}, {27483, 32767, 0}, {11099, 32767, 0},
|
||||
{21669, 32767, 0}, {16384, 0, 32767}, {16384, 16384, 32767},
|
||||
{16384, 32767, 32767},
|
||||
};
|
||||
|
||||
// 自动 trim 的每个布局基准衰减,单位 dB。
|
||||
struct AttenuationEntry {
|
||||
const char* compact_name;
|
||||
double db;
|
||||
};
|
||||
|
||||
constexpr AttenuationEntry kAttenuation[] = {
|
||||
{"20", -4.5}, {"31", -4.5}, {"40", -3.0}, {"51", -3.0},
|
||||
{"60", -1.5}, {"71", -1.5}, {"512", -2.25}, {"514", -1.5},
|
||||
{"712", -0.75}, {"714", 0.0}, {"914", 0.0}, {"916", 0.0},
|
||||
};
|
||||
|
||||
constexpr int kMaxChannels = static_cast<int>(ejoc::speaker_tables::kMaxChannels);
|
||||
|
||||
void set_sentinel(std::int32_t coordinate[3]) {
|
||||
coordinate[0] = -1;
|
||||
coordinate[1] = -1;
|
||||
coordinate[2] = -1;
|
||||
}
|
||||
|
||||
bool is_sentinel(const std::int32_t coordinate[3]) {
|
||||
return coordinate[0] == -1 && coordinate[1] == -1 && coordinate[2] == -1;
|
||||
}
|
||||
|
||||
bool is_lfe_label(BedChannel channel) {
|
||||
return channel == BedChannel::kLfe || channel == BedChannel::kLfe2;
|
||||
}
|
||||
|
||||
const TableB10Position* table_b10(BedChannel channel) {
|
||||
for (const TableB10Position& entry : kTableB10) {
|
||||
if (entry.channel == channel) {
|
||||
return &entry;
|
||||
}
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// ADM 笛卡尔坐标 -> 渲染器方位 (u 右, v 后, w 上)。
|
||||
void render_coordinates(const double xyz[3], double out[3]) {
|
||||
out[0] = (xyz[0] + 1.0) * 0.5;
|
||||
out[1] = (1.0 - xyz[1]) * 0.5;
|
||||
out[2] = xyz[2];
|
||||
}
|
||||
|
||||
// 渲染器方位的欧氏距离,比较的是归一化到 0..1 的坐标。
|
||||
double render_distance(const double left[3], const double right[3]) {
|
||||
const double du = left[0] - right[0];
|
||||
const double dv = left[1] - right[1];
|
||||
const double dw = left[2] - right[2];
|
||||
return std::sqrt(du * du + dv * dv + dw * dw);
|
||||
}
|
||||
|
||||
// Reference-position matching: the non-spatial sentinel resolves to index 3.
|
||||
int nearest_reference(const std::int32_t coordinate[3]) {
|
||||
if (is_sentinel(coordinate)) {
|
||||
return 3;
|
||||
}
|
||||
const double position[3] = {
|
||||
static_cast<double>(coordinate[0]) / 32768.0,
|
||||
static_cast<double>(coordinate[1]) / 32768.0,
|
||||
static_cast<double>(coordinate[2]) / 32768.0,
|
||||
};
|
||||
int best = 3;
|
||||
double best_distance = 0.0;
|
||||
bool have_best = false;
|
||||
for (int index = 0; index < kBedReferencePositionCount; ++index) {
|
||||
const std::int32_t* candidate = kReferencePositions[index];
|
||||
if (candidate[0] == -1 && candidate[1] == -1 && candidate[2] == -1) {
|
||||
continue;
|
||||
}
|
||||
const double point[3] = {
|
||||
static_cast<double>(candidate[0]) / 32768.0,
|
||||
static_cast<double>(candidate[1]) / 32768.0,
|
||||
static_cast<double>(candidate[2]) / 32768.0,
|
||||
};
|
||||
const double distance = render_distance(position, point);
|
||||
if (!have_best || distance < best_distance) {
|
||||
best = index;
|
||||
best_distance = distance;
|
||||
have_best = true;
|
||||
}
|
||||
}
|
||||
return best;
|
||||
}
|
||||
|
||||
// 目标布局里离 desired 最近、且在 0.05 容差内的输出声道;没有返回 -1。
|
||||
int nearest_channel(const double desired[3], const std::int32_t positions[][3],
|
||||
std::uint32_t channel_count) {
|
||||
int best = -1;
|
||||
double best_distance = 0.0;
|
||||
bool have_best = false;
|
||||
for (std::uint32_t index = 0; index < channel_count; ++index) {
|
||||
if (is_sentinel(positions[index])) {
|
||||
continue;
|
||||
}
|
||||
const double point[3] = {
|
||||
static_cast<double>(positions[index][0]) / 32768.0,
|
||||
static_cast<double>(positions[index][1]) / 32768.0,
|
||||
static_cast<double>(positions[index][2]) / 32768.0,
|
||||
};
|
||||
const double distance = render_distance(desired, point);
|
||||
if (!have_best || distance < best_distance) {
|
||||
best = static_cast<int>(index);
|
||||
best_distance = distance;
|
||||
have_best = true;
|
||||
}
|
||||
}
|
||||
if (have_best && best_distance <= 0.05) {
|
||||
return best;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
// 输出声道 index -> 该声道的 Q15 方位;LFE 与非空间声道给 sentinel。
|
||||
void channel_positions(const speaker::LayoutInfo& layout,
|
||||
std::int32_t positions[][3]) {
|
||||
for (int index = 0; index < kMaxChannels; ++index) {
|
||||
set_sentinel(positions[index]);
|
||||
}
|
||||
const auto* geometry = ejoc::speaker_tables::find_layout(layout.speaker_bitfield);
|
||||
if (geometry != nullptr) {
|
||||
bool known[kMaxChannels] = {};
|
||||
std::int32_t found[kMaxChannels][3];
|
||||
for (int index = 0; index < kMaxChannels; ++index) {
|
||||
set_sentinel(found[index]);
|
||||
}
|
||||
for (const auto& region : geometry->regions) {
|
||||
for (std::size_t point = 0; point < region.point_count; ++point) {
|
||||
const auto speaker = static_cast<int>(region.points[point].speaker_id);
|
||||
if (speaker < 0 || speaker >= kMaxChannels || known[speaker]) {
|
||||
continue;
|
||||
}
|
||||
for (int axis = 0; axis < 3; ++axis) {
|
||||
found[speaker][axis] =
|
||||
static_cast<std::int32_t>(region.points[point].coordinate_q15[axis]);
|
||||
}
|
||||
known[speaker] = true;
|
||||
}
|
||||
}
|
||||
const std::uint32_t count =
|
||||
layout.channel_count < static_cast<std::uint32_t>(kMaxChannels)
|
||||
? layout.channel_count
|
||||
: static_cast<std::uint32_t>(kMaxChannels);
|
||||
for (std::uint32_t index = 0; index < count; ++index) {
|
||||
const char* name = layout.channel_names != nullptr ? layout.channel_names[index]
|
||||
: nullptr;
|
||||
if (name != nullptr && std::strcmp(name, "LFE") == 0) {
|
||||
continue;
|
||||
}
|
||||
if (known[index]) {
|
||||
for (int axis = 0; axis < 3; ++axis) {
|
||||
positions[index][axis] = found[index][axis];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int channel_index(const speaker::LayoutInfo& layout, const char* name) {
|
||||
if (name == nullptr || layout.channel_names == nullptr) {
|
||||
return -1;
|
||||
}
|
||||
for (std::uint32_t index = 0; index < layout.channel_count; ++index) {
|
||||
if (std::strcmp(layout.channel_names[index], name) == 0) {
|
||||
return static_cast<int>(index);
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
double attenuation_db(const speaker::LayoutInfo& layout) {
|
||||
for (const AttenuationEntry& entry : kAttenuation) {
|
||||
if (std::strcmp(entry.compact_name, layout.compact_name) == 0) {
|
||||
return entry.db;
|
||||
}
|
||||
}
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
const std::int32_t (*bed_reference_positions_q15())[3] {
|
||||
return kReferencePositions;
|
||||
}
|
||||
|
||||
BedOutputDescription bed_output_description(const speaker::LayoutInfo& layout) {
|
||||
BedOutputDescription description;
|
||||
std::int32_t positions[kMaxChannels][3];
|
||||
channel_positions(layout, positions);
|
||||
const std::uint32_t output_count =
|
||||
layout.channel_count < static_cast<std::uint32_t>(kMaxChannels)
|
||||
? layout.channel_count
|
||||
: static_cast<std::uint32_t>(kMaxChannels);
|
||||
description.output_labels.reserve(output_count);
|
||||
for (std::uint32_t index = 0; index < output_count; ++index) {
|
||||
description.output_labels.push_back(nearest_reference(positions[index]));
|
||||
}
|
||||
for (int label = 0; label < oamd::kBedLabelCount; ++label) {
|
||||
const BedChannel channel = static_cast<BedChannel>(label);
|
||||
const char* name = channel == BedChannel::kLfe2 ? nullptr
|
||||
: bed_channel_short_name(channel);
|
||||
int slot = -1;
|
||||
if (name != nullptr && name[0] != '\0') {
|
||||
slot = channel_index(layout, name);
|
||||
}
|
||||
if (slot < 0 && channel == BedChannel::kLfe2) {
|
||||
slot = channel_index(layout, "LFE");
|
||||
}
|
||||
const TableB10Position* position = table_b10(channel);
|
||||
double desired[3] = {0.0, 0.0, 0.0};
|
||||
if (position != nullptr) {
|
||||
render_coordinates(position->xyz, desired);
|
||||
}
|
||||
if (slot < 0 && position != nullptr) {
|
||||
slot = nearest_channel(desired, positions, output_count);
|
||||
}
|
||||
if (slot < 0) {
|
||||
description.label_to_slot[label] = is_lfe_label(channel) ? -1 : -2;
|
||||
} else {
|
||||
description.label_to_slot[label] = slot;
|
||||
}
|
||||
if (is_lfe_label(channel)) {
|
||||
description.direct_output_labels[label] = 3;
|
||||
} else {
|
||||
int best = 3;
|
||||
double best_distance = 0.0;
|
||||
bool have_best = false;
|
||||
for (int index = 0; index < kBedReferencePositionCount; ++index) {
|
||||
const std::int32_t* candidate = kReferencePositions[index];
|
||||
if (candidate[0] == -1 && candidate[1] == -1 && candidate[2] == -1) {
|
||||
continue;
|
||||
}
|
||||
const double point[3] = {
|
||||
static_cast<double>(candidate[0]) / 32768.0,
|
||||
static_cast<double>(candidate[1]) / 32768.0,
|
||||
static_cast<double>(candidate[2]) / 32768.0,
|
||||
};
|
||||
const double distance = render_distance(desired, point);
|
||||
if (!have_best || distance < best_distance) {
|
||||
best = index;
|
||||
best_distance = distance;
|
||||
have_best = true;
|
||||
}
|
||||
}
|
||||
description.direct_output_labels[label] = best;
|
||||
}
|
||||
}
|
||||
description.automatic_attenuation_db = attenuation_db(layout);
|
||||
return description;
|
||||
}
|
||||
|
||||
} // namespace joc::joc
|
||||
@@ -6,31 +6,12 @@
|
||||
#include <vector>
|
||||
|
||||
#include "oamd/oamd_parser.h"
|
||||
#include "speaker/speaker_layout_lookup.h"
|
||||
|
||||
namespace joc::joc {
|
||||
|
||||
// OAMD Table 12 的标准 bed 声道。LSB 顺序与声明顺序一致:L/R、C、LFE、
|
||||
// Ls/Rs、Lrs/Rrs、TFL/TFR、TSL/TSR、TBL/TBR、LW/RW、LFE2。
|
||||
enum class BedChannel : std::uint8_t {
|
||||
kLeft = 0,
|
||||
kRight,
|
||||
kCenter,
|
||||
kLfe,
|
||||
kLeftSurround,
|
||||
kRightSurround,
|
||||
kLeftRearSurround,
|
||||
kRightRearSurround,
|
||||
kTopFrontLeft,
|
||||
kTopFrontRight,
|
||||
kTopSideLeft,
|
||||
kTopSideRight,
|
||||
kTopBackLeft,
|
||||
kTopBackRight,
|
||||
kLeftWide,
|
||||
kRightWide,
|
||||
kLfe2,
|
||||
kCount,
|
||||
};
|
||||
// BedChannel lives in oamd/oamd_parser.h: the enum is the OAMD Table 12
|
||||
// label order and OAMD frame state carries it directly.
|
||||
|
||||
// 内容声明的 bed 布局。bed 对象在 OAMD 里没有位置字段,位置由这里的布局决定。
|
||||
struct BedLayout {
|
||||
@@ -61,8 +42,28 @@ bool bed_channel_adm_position(BedChannel channel, double xyz[3]);
|
||||
bool bed_channel_q15(BedChannel channel, std::uint16_t q15[3]);
|
||||
|
||||
// 目标布局里同名扬声器的 Q15 方位:bed 声道直连到该扬声器,而不是参与声像。
|
||||
// 目标布局没有这个声道时返回 false。
|
||||
// 目标布局没有这个声道时返回 false。4.0 与 6.0 共用未分配的 out_ch_config
|
||||
// 0xFF,因此这里按 4.0 的声道集合解释 0xFF。
|
||||
bool layout_bed_anchor(std::uint32_t out_ch_config, BedChannel channel,
|
||||
std::uint16_t q15[3]);
|
||||
|
||||
// 参考位置网格 ``BED_REFERENCE_POSITIONS_Q15``:bed 标签与输出 slots 的最近邻
|
||||
// 匹配都用这一组固定 Q15 点。索引 3 是 (-1,-1,-1),表示 LFE 那样的非空间声源。
|
||||
inline constexpr int kBedReferencePositionCount = 38;
|
||||
const std::int32_t (*bed_reference_positions_q15())[3];
|
||||
|
||||
// 一个目标扬声器布局的 bed 路由描述(bed_layout.bed_output_description):
|
||||
// 按标准 bed 标签序(Table 12 的 17 个标签)给出目标 layout 的输出参考位置、
|
||||
// 每个标签的输出 slot 与直连参考位置,以及该布局的自动 trim 基准衰减。
|
||||
struct BedOutputDescription {
|
||||
std::vector<int> output_labels; // 每个输出声道最近邻的参考位置索引
|
||||
int label_to_slot[oamd::kBedLabelCount] = {}; // -2 不可达,-1 LFE 通路
|
||||
int direct_output_labels[oamd::kBedLabelCount] = {};
|
||||
double automatic_attenuation_db = 0.0;
|
||||
};
|
||||
|
||||
// 由布局名/几何派生 bed 路由描述;``layout.channel_names`` 必须按标准声道
|
||||
// 顺序给出 ``layout.channel_count`` 个名字。
|
||||
BedOutputDescription bed_output_description(const speaker::LayoutInfo& layout);
|
||||
|
||||
} // namespace joc::joc
|
||||
@@ -182,6 +182,55 @@ std::int16_t num_bands_for_index(std::uint32_t num_bands_idx) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
namespace {
|
||||
|
||||
// Reads the 12-bit joc_header at the start of the payload. Mirrors
|
||||
// parse_joc_header(): a downmix configuration outside 0..4 is a frame status,
|
||||
// not an exception, because a metadata scan records it as an unsupported
|
||||
// variant while the frame itself stays classified.
|
||||
Status parse_id14_header(const std::uint8_t* payload, std::size_t payload_size,
|
||||
joc_frame_params* out) {
|
||||
bits::BitReader reader(payload, payload_size);
|
||||
out->dmx_config_idx = static_cast<std::uint8_t>(reader.read(3));
|
||||
out->num_objects_bits = static_cast<std::uint8_t>(reader.read(6));
|
||||
out->ext_config_idx = static_cast<std::uint8_t>(reader.read(3));
|
||||
if (reader.failed()) {
|
||||
return truncated_fail(reader);
|
||||
}
|
||||
const std::int16_t n_channels = num_channels_for_config(out->dmx_config_idx);
|
||||
if (n_channels < 0) {
|
||||
// The core channel count decides how the object syntax expands, so an
|
||||
// unknown configuration stops the parse after the header fields.
|
||||
out->status = JOC_FRAME_STATUS_UNSUPPORTED_DMX;
|
||||
out->objects_clamped = 0u;
|
||||
out->n_objects = 0u;
|
||||
return Status::success();
|
||||
}
|
||||
out->n_channels = static_cast<std::uint8_t>(n_channels);
|
||||
const std::uint32_t declared = static_cast<std::uint32_t>(out->num_objects_bits) + 1u;
|
||||
out->objects_clamped = declared > JOC_MAX_OBJECTS ? 1u : 0u;
|
||||
out->n_objects = static_cast<std::uint8_t>(
|
||||
std::min<std::uint32_t>(declared, static_cast<std::uint32_t>(JOC_MAX_OBJECTS)));
|
||||
if (out->objects_clamped != 0u) {
|
||||
out->status = JOC_FRAME_STATUS_OBJECTS_CLAMPED;
|
||||
}
|
||||
return Status::success();
|
||||
}
|
||||
|
||||
// Records where joc_data ends and the first trailing bytes, like _tail_info().
|
||||
void tail_info(joc_frame_params* out, const bits::BitReader& reader, const std::uint8_t* payload,
|
||||
std::size_t payload_size) {
|
||||
out->data_end_bits = static_cast<std::uint32_t>(reader.position());
|
||||
out->trailing_bits = static_cast<std::uint32_t>(payload_size * 8u - reader.position());
|
||||
const std::size_t tail_offset = reader.position() / 8u;
|
||||
if (tail_offset < payload_size) {
|
||||
const std::size_t tail_bytes = std::min<std::size_t>(8u, payload_size - tail_offset);
|
||||
std::memcpy(out->tail_bytes, payload + tail_offset, tail_bytes);
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
Status parse_id14(const std::uint8_t* payload, std::size_t payload_size, joc_frame_params* out,
|
||||
FrameSymbols* symbols) {
|
||||
if (payload == nullptr || out == nullptr) {
|
||||
@@ -195,45 +244,53 @@ Status parse_id14(const std::uint8_t* payload, std::size_t payload_size, joc_fra
|
||||
FrameSymbols& capture = (symbols != nullptr) ? *symbols : local_symbols;
|
||||
std::memset(&capture, 0, sizeof(capture));
|
||||
|
||||
bits::BitReader reader(payload, payload_size);
|
||||
|
||||
out->dmx_config_idx = static_cast<std::uint8_t>(reader.read(3));
|
||||
out->num_objects_bits = static_cast<std::uint8_t>(reader.read(6));
|
||||
out->ext_config_idx = static_cast<std::uint8_t>(reader.read(3));
|
||||
|
||||
const std::uint32_t declared_objects = static_cast<std::uint32_t>(out->num_objects_bits) + 1u;
|
||||
const std::int16_t n_channels = num_channels_for_config(out->dmx_config_idx);
|
||||
if (n_channels < 0) {
|
||||
return syntax_fail("unknown JOC downmix configuration " +
|
||||
std::to_string(out->dmx_config_idx));
|
||||
const Status header = parse_id14_header(payload, payload_size, out);
|
||||
if (!header.ok()) {
|
||||
return header;
|
||||
}
|
||||
out->n_channels = static_cast<std::uint8_t>(n_channels);
|
||||
// A declared object count above 15 is clamped to 15: the frame is parsed for
|
||||
// 15 objects only, and the clamp is reported separately.
|
||||
out->objects_clamped = declared_objects > JOC_MAX_OBJECTS ? 1u : 0u;
|
||||
const std::uint32_t n_objects =
|
||||
std::min<std::uint32_t>(declared_objects, JOC_MAX_OBJECTS);
|
||||
out->n_objects = static_cast<std::uint8_t>(n_objects);
|
||||
|
||||
bits::BitReader reader(payload, payload_size);
|
||||
reader.skip(12);
|
||||
out->clipgain_x_bits = static_cast<std::uint8_t>(reader.read(3));
|
||||
out->clipgain_y_bits = static_cast<std::uint8_t>(reader.read(5));
|
||||
out->seq_count = reader.read(10);
|
||||
// clipgain = 1 + (y/32) * 2^(x-4); ldexp builds the power of two exactly
|
||||
// over the whole legal range.
|
||||
out->clipgain = 1.0 + static_cast<double>(out->clipgain_y_bits) / 32.0 *
|
||||
std::ldexp(1.0, static_cast<int>(out->clipgain_x_bits) - 4);
|
||||
if (reader.failed()) {
|
||||
return truncated_fail(reader);
|
||||
}
|
||||
// clipgain = 2^(x-4) * (1 + y/32); ldexp builds the power of two exactly
|
||||
// over the whole legal range, so the result is bit-exact to the reference.
|
||||
out->clipgain = std::ldexp(1.0, static_cast<int>(out->clipgain_x_bits) - 4) *
|
||||
(1.0 + static_cast<double>(out->clipgain_y_bits) / 32.0);
|
||||
|
||||
if (out->status == JOC_FRAME_STATUS_UNSUPPORTED_DMX) {
|
||||
tail_info(out, reader, payload, payload_size);
|
||||
return Status::success();
|
||||
}
|
||||
const std::int16_t n_channels = num_channels_for_config(out->dmx_config_idx);
|
||||
const std::uint32_t n_objects = out->n_objects;
|
||||
|
||||
for (std::uint32_t obj = 0; obj < n_objects; ++obj) {
|
||||
joc_object_params& info = out->objects[obj];
|
||||
info.present = static_cast<std::uint8_t>(reader.read(1));
|
||||
if (reader.failed()) {
|
||||
return truncated_fail(reader);
|
||||
}
|
||||
if (info.present == 0u) {
|
||||
continue;
|
||||
}
|
||||
info.num_bands_idx = static_cast<std::uint8_t>(reader.read(3));
|
||||
if (reader.failed()) {
|
||||
return truncated_fail(reader);
|
||||
}
|
||||
const std::int16_t bands = num_bands_for_index(info.num_bands_idx);
|
||||
if (bands < 0) {
|
||||
return syntax_fail("unknown JOC num_bands index " +
|
||||
std::to_string(info.num_bands_idx));
|
||||
// The symbol count depends on the parameter-band count, so the rest
|
||||
// of the payload cannot be parsed.
|
||||
if (out->status == JOC_FRAME_STATUS_OK) {
|
||||
out->status = JOC_FRAME_STATUS_BAD_PARAMETER_BAND;
|
||||
}
|
||||
tail_info(out, reader, payload, payload_size);
|
||||
return Status::success();
|
||||
}
|
||||
info.n_bands = static_cast<std::uint8_t>(bands);
|
||||
info.sparse = static_cast<std::uint8_t>(reader.read(1));
|
||||
@@ -241,16 +298,42 @@ Status parse_id14(const std::uint8_t* payload, std::size_t payload_size, joc_fra
|
||||
info.slope_idx = static_cast<std::uint8_t>(reader.read(1));
|
||||
info.num_dpoints_bits = static_cast<std::uint8_t>(reader.read(1));
|
||||
info.n_dpoints = static_cast<std::uint8_t>(info.num_dpoints_bits + 1u);
|
||||
if (reader.failed()) {
|
||||
return truncated_fail(reader);
|
||||
}
|
||||
if (info.slope_idx == 1u) {
|
||||
for (std::uint32_t dp = 0; dp < info.n_dpoints; ++dp) {
|
||||
info.offset_ts[dp] = static_cast<std::uint8_t>(reader.read(5) + 1u);
|
||||
}
|
||||
}
|
||||
info.offset_ts[dp] = static_cast<std::uint8_t>(reader.read(5));
|
||||
}
|
||||
if (reader.failed()) {
|
||||
return truncated_fail(reader);
|
||||
}
|
||||
// offset_ts is the raw 5-bit slot index (legal range 0..23) and one
|
||||
// object's data points must be strictly increasing.
|
||||
bool invalid = false;
|
||||
for (std::uint32_t dp = 0; dp < info.n_dpoints; ++dp) {
|
||||
if (info.offset_ts[dp] >= JOC_TIMESLOTS) {
|
||||
invalid = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!invalid && info.n_dpoints > 1u) {
|
||||
for (std::uint32_t dp = 1; dp < info.n_dpoints; ++dp) {
|
||||
if (info.offset_ts[dp] <= info.offset_ts[dp - 1u]) {
|
||||
invalid = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (invalid && out->status == JOC_FRAME_STATUS_OK) {
|
||||
out->status = JOC_FRAME_STATUS_BAD_OFFSET_TS;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// joc_data (Huffman): dense reads MTX per channel and band, sparse reads IDX
|
||||
// then VEC. A frame whose status is already non-zero dequantizes below but
|
||||
// is never rendered, so a misaligned parse cannot reach the DSP.
|
||||
for (std::uint32_t obj = 0; obj < n_objects; ++obj) {
|
||||
const joc_object_params& info = out->objects[obj];
|
||||
if (info.present == 0u) {
|
||||
@@ -300,12 +383,16 @@ Status parse_id14(const std::uint8_t* payload, std::size_t payload_size, joc_fra
|
||||
}
|
||||
}
|
||||
|
||||
out->data_end_bits = static_cast<std::uint32_t>(reader.position());
|
||||
out->trailing_bits = static_cast<std::uint32_t>(payload_size * 8u - reader.position());
|
||||
const std::size_t tail_offset = reader.position() / 8u;
|
||||
if (tail_offset < payload_size) {
|
||||
const std::size_t tail_bytes = std::min<std::size_t>(8u, payload_size - tail_offset);
|
||||
std::memcpy(out->tail_bytes, payload + tail_offset, tail_bytes);
|
||||
tail_info(out, reader, payload, payload_size);
|
||||
if (out->status == JOC_FRAME_STATUS_OK && out->ext_config_idx == 0u) {
|
||||
// The tail pads with zero bits up to the next byte; a whole byte after
|
||||
// that alignment is unexpected data.
|
||||
const std::uint32_t pad =
|
||||
(8u - (static_cast<std::uint32_t>(reader.position()) % 8u)) % 8u;
|
||||
const std::uint32_t total_bits = static_cast<std::uint32_t>(payload_size * 8u);
|
||||
if (total_bits > static_cast<std::uint32_t>(reader.position()) + pad) {
|
||||
out->status = JOC_FRAME_STATUS_TRAILING_DATA;
|
||||
}
|
||||
}
|
||||
|
||||
for (std::uint32_t obj = 0; obj < n_objects; ++obj) {
|
||||
@@ -313,8 +400,7 @@ Status parse_id14(const std::uint8_t* payload, std::size_t payload_size, joc_fra
|
||||
if (info.present == 0u) {
|
||||
continue;
|
||||
}
|
||||
std::uint32_t mask_bit = 1u << obj;
|
||||
out->present_mask |= mask_bit;
|
||||
out->present_mask |= 1u << obj;
|
||||
|
||||
const std::int64_t nquant = (info.quant_idx == 0u) ? 96 : 192;
|
||||
std::int64_t q[JOC_MAX_DPOINTS][JOC_MAX_CORE_CHANNELS][JOC_MAX_PARAMETER_BANDS] = {};
|
||||
@@ -372,7 +458,13 @@ int score_container_as_joc(const std::uint8_t* data, std::size_t size,
|
||||
if (emdf::extract_payload_bytes(data, size, *payload, &bytes).ok()) {
|
||||
joc_frame_params params;
|
||||
FrameSymbols symbols;
|
||||
parses = parse_id14(bytes.data(), bytes.size(), ¶ms, &symbols).ok();
|
||||
if (parse_id14(bytes.data(), bytes.size(), ¶ms, &symbols).ok()) {
|
||||
// The reference scores a payload by the frame status: an unsupported
|
||||
// downmix configuration (2) or an unknown parameter-band count (4)
|
||||
// leaves the syntax unparsable and must not win the container choice.
|
||||
parses = params.status != JOC_FRAME_STATUS_UNSUPPORTED_DMX &&
|
||||
params.status != JOC_FRAME_STATUS_BAD_PARAMETER_BAND;
|
||||
}
|
||||
}
|
||||
const bool associated = oamd->has_group_id != 0u && payload->has_group_id != 0u &&
|
||||
oamd->group_id == payload->group_id;
|
||||
@@ -406,7 +498,20 @@ Status parse_eac3_frame(const std::uint8_t* frame, std::size_t frame_size, joc_f
|
||||
if (!extract.ok()) {
|
||||
return extract;
|
||||
}
|
||||
return parse_id14(bytes.data(), bytes.size(), out, symbols);
|
||||
const Status parsed = parse_id14(bytes.data(), bytes.size(), out, symbols);
|
||||
if (!parsed.ok()) {
|
||||
return parsed;
|
||||
}
|
||||
// A metadata scan rejects an unsupported downmix configuration outright: the
|
||||
// core channel count decides how every later frame is expanded, so this is a
|
||||
// variant error rather than a per-frame status.
|
||||
if (out->status == JOC_FRAME_STATUS_UNSUPPORTED_DMX) {
|
||||
const std::string message =
|
||||
"downmix_config_unsupported: ID14 declares joc_dmx_config_idx=" +
|
||||
std::to_string(out->dmx_config_idx) + " (legal values are 0..4)";
|
||||
return Status::fail(JOC_ERR_JOC_UNSUPPORTED_VARIANT, stage::kJoc, message);
|
||||
}
|
||||
return Status::success();
|
||||
}
|
||||
|
||||
Status check_id14_padding(const std::uint8_t* payload, std::size_t payload_size,
|
||||
@@ -417,6 +522,17 @@ Status check_id14_padding(const std::uint8_t* payload, std::size_t payload_size,
|
||||
if (!status.ok()) {
|
||||
return status;
|
||||
}
|
||||
// The two statuses that stop the parse early leave the payload without a
|
||||
// joc_data end position, so they keep reporting the syntax failure they
|
||||
// reported before the frame-status split.
|
||||
if (params.status == JOC_FRAME_STATUS_UNSUPPORTED_DMX) {
|
||||
return Status::fail(JOC_ERR_JOC_UNSUPPORTED_VARIANT, stage::kJoc,
|
||||
"downmix_config_unsupported: joc_dmx_config_idx outside 0..4");
|
||||
}
|
||||
if (params.status == JOC_FRAME_STATUS_BAD_PARAMETER_BAND) {
|
||||
return Status::fail(JOC_ERR_JOC_SYNTAX, stage::kJoc,
|
||||
"unknown JOC num_bands index stops the payload");
|
||||
}
|
||||
if (out_trailing_bits != nullptr) {
|
||||
*out_trailing_bits = params.trailing_bits;
|
||||
}
|
||||
@@ -861,6 +977,7 @@ Status check_cross_layer(const joc_frame_params& params, const eac3::Frame* core
|
||||
std::uint16_t chanmap,
|
||||
const std::vector<oamd::BedAssignment>* bed_assignments,
|
||||
std::string* error, CrossLayerNotes* notes) {
|
||||
(void)has_dependent;
|
||||
const std::uint8_t config_idx = params.dmx_config_idx;
|
||||
const int core_channels = params.n_channels;
|
||||
std::vector<Position> wanted;
|
||||
|
||||
@@ -69,6 +69,19 @@ public:
|
||||
std::memset(synthesis_state_, 0, sizeof(synthesis_state_));
|
||||
std::memset(x_, 0, sizeof(x_));
|
||||
std::memset(z_, 0, sizeof(z_));
|
||||
// Frame-level state: per-object previous matrices and presence markers,
|
||||
// the seq state machine, the 8-plane passthrough history, the LFE ramp
|
||||
// start value and the previous actual core-channel count.
|
||||
std::memset(prev_matrix_, 0, sizeof(prev_matrix_));
|
||||
std::memset(prev_present_, 0, sizeof(prev_present_));
|
||||
std::memset(core_history_, 0, sizeof(core_history_));
|
||||
state_ = 0;
|
||||
expected_seq_ = 0;
|
||||
invalid_count_ = 0;
|
||||
last_frame_valid_ = false;
|
||||
n_channels_prev_ = -1;
|
||||
has_lfe_clipgain_ = false;
|
||||
lfe_clipgain_ = 0.0;
|
||||
// Sentinel: the first frame after reset takes the new scalar directly,
|
||||
// without an intra-frame transition.
|
||||
analysis_phase_ = -0.5f;
|
||||
@@ -174,13 +187,22 @@ public:
|
||||
}
|
||||
|
||||
std::memset(output16, 0, sizeof(float) * EJOC_OUTPUT_CHANNELS * EJOC_FRAME_SAMPLES);
|
||||
analysis(bed_planar, phase_new, clipgain);
|
||||
render_lfe(lfe, output_scale, output16);
|
||||
// Analysis-side scalar = the structural 1/16 times this frame's clipgain.
|
||||
// clipgain enters the analysis at this stage and the x16 at the output
|
||||
// cancels the 1/16, so the net effect is a multiply by joc_clipgain.
|
||||
analysis(bed_planar, static_cast<float>(phase_new * clipgain));
|
||||
decode_lfe(lfe, clipgain, output16, output_scale);
|
||||
process_objects(object_mask, n_bands, n_dpoints, slope_idx, offset_ts,
|
||||
dq, output_scale, output16);
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Frame-level entry point; the state machine and per-object history live
|
||||
// inside the renderer (see render_frame_impl()).
|
||||
int render_frame(const ejoc_frame_input& input) noexcept {
|
||||
return render_frame_impl(input);
|
||||
}
|
||||
|
||||
private:
|
||||
void initialize_tables() noexcept {
|
||||
for (int i = 0; i < 64; ++i) {
|
||||
@@ -378,13 +400,12 @@ private:
|
||||
}
|
||||
}
|
||||
|
||||
void analysis(const float* bed_planar, const float phase_new, const double clipgain) noexcept {
|
||||
// Frames the analysis QMF of the core PCM with the given analysis-side
|
||||
// scalar (the structural 1/16 times joc_clipgain). The scalar ramps over the
|
||||
// frame's first 256 samples from the previous frame's value; the first frame
|
||||
// after a reset takes it directly.
|
||||
void analysis(const float* bed_planar, const float scalar) noexcept {
|
||||
job_bed_ = bed_planar;
|
||||
// Analysis-side scalar = the structural 1/16 times this frame's clipgain.
|
||||
// clipgain enters the analysis at this stage and the x16 at the output
|
||||
// cancels the 1/16, so the net effect is a multiply by joc_clipgain; the
|
||||
// previous frame's scalar is the ramp start.
|
||||
const float scalar = static_cast<float>(phase_new * clipgain);
|
||||
job_phase_old_ = analysis_phase_;
|
||||
if (job_phase_old_ <= 0.0f && job_phase_old_ != 0.0f) {
|
||||
job_phase_old_ = scalar;
|
||||
@@ -509,11 +530,11 @@ private:
|
||||
}
|
||||
qmf5_step(state, rotated, pcm64);
|
||||
for (int sample = 0; sample < 64; ++sample) {
|
||||
// The clamp is on the ×16 object PCM; joc_clipgain already
|
||||
// entered the analysis, so only the user output gain remains, and
|
||||
// it is a float32 multiply like the reference.
|
||||
const double clipped = clamp_unit(16.0 * pcm64[sample]);
|
||||
// joc_clipgain already entered the analysis (see analysis()); what
|
||||
// remains here is the user output gain.
|
||||
const float value = static_cast<float>(clipped * output_scale);
|
||||
destination[timeslot * 64 + sample] = value;
|
||||
destination[timeslot * 64 + sample] = static_cast<float>(clipped) * output_scale;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -533,8 +554,10 @@ private:
|
||||
const int item = job_objects_[index];
|
||||
if (job_kind_ == JobKind::Analysis) {
|
||||
analysis_channel(item);
|
||||
} else {
|
||||
} else if (job_kind_ == JobKind::Objects) {
|
||||
process_one_object(item);
|
||||
} else {
|
||||
process_one_object_frame(item);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -620,24 +643,477 @@ private:
|
||||
dispatch_jobs();
|
||||
}
|
||||
|
||||
void render_lfe(const float* lfe, const float output_scale, float* output16) noexcept {
|
||||
if (!lfe) {
|
||||
return;
|
||||
// Core LFE: the full joc_clipgain is applied as a sample-wise ramp before the
|
||||
// 1217-sample delay, and the read-out is only clamped. The ramp is
|
||||
// G_old + n*(G_new-G_old)/256 for n < 256 and G_new afterwards; the first
|
||||
// frame after a reset uses G_old = G_new.
|
||||
void decode_lfe(const float* lfe, const double clipgain, float* output16,
|
||||
const float output_scale) noexcept {
|
||||
const double new_gain = clipgain;
|
||||
const double old_gain = has_lfe_clipgain_ ? lfe_clipgain_ : new_gain;
|
||||
const bool ramped = old_gain != new_gain;
|
||||
const double step = (new_gain - old_gain) / 256.0;
|
||||
double ramp[256];
|
||||
for (int n = 0; n < 256; ++n) {
|
||||
ramp[n] = ramped ? old_gain + static_cast<double>(n) * step : new_gain;
|
||||
}
|
||||
has_lfe_clipgain_ = true;
|
||||
lfe_clipgain_ = new_gain;
|
||||
|
||||
float* channel0 = output16;
|
||||
for (int sample = 0; sample < kLfeDelay; ++sample) {
|
||||
channel0[sample] =
|
||||
static_cast<float>(clamp_unit(lfe_delay_[sample])) * output_scale;
|
||||
}
|
||||
for (int sample = kLfeDelay; sample < EJOC_FRAME_SAMPLES; ++sample) {
|
||||
const int input = sample - kLfeDelay;
|
||||
const double gain = input < 256 ? ramp[input] : new_gain;
|
||||
const double value = (lfe != nullptr) ? static_cast<double>(lfe[input]) : 0.0;
|
||||
channel0[sample] =
|
||||
static_cast<float>(clamp_unit(value * gain)) * output_scale;
|
||||
}
|
||||
for (int sample = 0; sample < kLfeDelay; ++sample) {
|
||||
const float value = static_cast<float>(clamp_unit(lfe_delay_[sample]));
|
||||
output16[sample] = static_cast<float>(value * output_scale);
|
||||
}
|
||||
for (int sample = kLfeDelay; sample < 1536; ++sample) {
|
||||
const float value = static_cast<float>(clamp_unit(static_cast<double>(lfe[sample - kLfeDelay])));
|
||||
output16[sample] = static_cast<float>(value * output_scale);
|
||||
}
|
||||
for (int sample = 0; sample < kLfeDelay; ++sample) {
|
||||
lfe_delay_[sample] = static_cast<double>(lfe[sample + (1536 - kLfeDelay)]);
|
||||
const int input = sample + (EJOC_FRAME_SAMPLES - kLfeDelay);
|
||||
const double gain = input < 256 ? ramp[input] : new_gain;
|
||||
const double value = (lfe != nullptr) ? static_cast<double>(lfe[input]) : 0.0;
|
||||
lfe_delay_[sample] = value * gain;
|
||||
}
|
||||
}
|
||||
|
||||
enum class JobKind : uint8_t { Analysis, Objects };
|
||||
enum class FrameMode : uint8_t { Normal, Hold, HardCut, Passthrough };
|
||||
|
||||
// ---- frame-level state machine ------------------------------------- //
|
||||
// The Renderer owns the seq state machine (normal / hold / hard cut /
|
||||
// passthrough), the per-object previous matrix and its presence marker, the
|
||||
// analysis/synthesis state, the LFE delay ring with its clipgain ramp, and
|
||||
// the 8-plane core history of the passthrough path, so one audio frame in
|
||||
// produces the complete 16-channel object frame.
|
||||
|
||||
float held_analysis_scalar() const noexcept {
|
||||
// Sentinel: a renderer that has not seen a JOC frame yet reports the
|
||||
// structural 1/16, i.e. clipgain 1.0.
|
||||
return (analysis_phase_ <= 0.0f && analysis_phase_ != 0.0f) ? 0.0625f
|
||||
: analysis_phase_;
|
||||
}
|
||||
|
||||
double held_clipgain() const noexcept {
|
||||
return static_cast<double>(held_analysis_scalar()) * 16.0;
|
||||
}
|
||||
|
||||
// The 10-bit JOC sequence counter wraps from 1023 back to 1.
|
||||
static uint32_t next_seq(const uint32_t value) noexcept {
|
||||
return value == 1023u ? 1u : value + 1u;
|
||||
}
|
||||
|
||||
// Drops the state of the core channels a smaller layout does not use.
|
||||
void clear_unused_channels(const uint32_t n_channels) noexcept {
|
||||
if (n_channels >= EJOC_MAX_CORE_CHANNELS) {
|
||||
return;
|
||||
}
|
||||
for (uint32_t channel = n_channels; channel < EJOC_MAX_CORE_CHANNELS; ++channel) {
|
||||
std::memset(analysis_fifo_[channel], 0, sizeof(analysis_fifo_[channel]));
|
||||
}
|
||||
for (int object = 0; object < EJOC_MAX_OBJECTS; ++object) {
|
||||
for (uint32_t channel = n_channels; channel < EJOC_MAX_CORE_CHANNELS; ++channel) {
|
||||
std::memset(prev_matrix_[object][channel], 0,
|
||||
sizeof(prev_matrix_[object][channel]));
|
||||
}
|
||||
}
|
||||
if (n_channels == 5u) {
|
||||
// A 5-channel frame does not drive the extra-pair delay lanes.
|
||||
std::memset(analysis_delay_[3], 0, sizeof(analysis_delay_[3]));
|
||||
std::memset(analysis_delay_[4], 0, sizeof(analysis_delay_[4]));
|
||||
}
|
||||
}
|
||||
|
||||
// A declared core-channel-count change (renderer status 9) clears the LFE
|
||||
// ring; the clipgain ramp state is kept, so the gain does not retune.
|
||||
void maybe_clear_lfe_ring(const uint32_t status) noexcept {
|
||||
if (status == 9u) {
|
||||
std::memset(lfe_delay_, 0, sizeof(lfe_delay_));
|
||||
}
|
||||
}
|
||||
|
||||
// Advances the seq state machine for this frame and reports the state the
|
||||
// renderer was in before the frame. status 8 (no metadata) neither advances
|
||||
// the expected counter nor compares the sequence.
|
||||
uint32_t advance_state(const uint32_t status, const uint32_t seq) noexcept {
|
||||
const uint32_t pre_state = state_;
|
||||
const bool valid = status == 0u || status == 9u;
|
||||
if (status == EJOC_FRAME_STATUS_NO_METADATA && pre_state != 0u) {
|
||||
state_ = 3;
|
||||
return pre_state;
|
||||
}
|
||||
expected_seq_ = next_seq(expected_seq_);
|
||||
if (valid && seq == 0u && pre_state != 0u) {
|
||||
// The programme restarted: hard cut and drop the object history.
|
||||
state_ = 4;
|
||||
return pre_state;
|
||||
}
|
||||
uint32_t state = state_;
|
||||
if (state == 0u) {
|
||||
if (valid) {
|
||||
state = 1u;
|
||||
expected_seq_ = seq;
|
||||
}
|
||||
} else if (state == 1u) {
|
||||
if (valid) {
|
||||
if (seq != expected_seq_) {
|
||||
state = 4u;
|
||||
}
|
||||
} else {
|
||||
state = 2u;
|
||||
invalid_count_ = 1u;
|
||||
}
|
||||
} else if (state == 2u) {
|
||||
if (valid) {
|
||||
state = 1u;
|
||||
expected_seq_ = seq;
|
||||
} else if (invalid_count_ == 5u) {
|
||||
state = 3u;
|
||||
} else {
|
||||
++invalid_count_;
|
||||
}
|
||||
} else if (state == 3u) {
|
||||
if (valid) {
|
||||
state = 1u;
|
||||
expected_seq_ = seq;
|
||||
} else {
|
||||
++invalid_count_;
|
||||
}
|
||||
} else {
|
||||
// state 4: the hard cut lasted one frame; a valid frame resyncs and
|
||||
// an invalid one starts the invalid-frame count.
|
||||
if (valid) {
|
||||
state = 1u;
|
||||
expected_seq_ = seq;
|
||||
} else {
|
||||
state = 2u;
|
||||
invalid_count_ = 1u;
|
||||
}
|
||||
}
|
||||
state_ = state;
|
||||
if (status == 9u) {
|
||||
state_ = 4u;
|
||||
}
|
||||
last_frame_valid_ = valid;
|
||||
return pre_state;
|
||||
}
|
||||
|
||||
FrameMode select_mode(const uint32_t status) const noexcept {
|
||||
if (status == EJOC_FRAME_STATUS_NO_METADATA) {
|
||||
return FrameMode::Passthrough;
|
||||
}
|
||||
if (state_ == 4u) {
|
||||
return FrameMode::HardCut;
|
||||
}
|
||||
if (state_ == 2u || state_ == 3u) {
|
||||
return FrameMode::Hold;
|
||||
}
|
||||
if (state_ == 1u && status == 0u) {
|
||||
return FrameMode::Normal;
|
||||
}
|
||||
return FrameMode::Passthrough;
|
||||
}
|
||||
|
||||
// JOC input order 5/7 channels (without LFE) -> 8-plane core order
|
||||
// L,R,C,LFE,Ls,Rs,(Lrs,Rrs). Used by the passthrough path and its history.
|
||||
void build_core8(const float* bed_planar, const float* lfe,
|
||||
const uint32_t n_channels) noexcept {
|
||||
std::memset(core8_, 0, sizeof(core8_));
|
||||
for (uint32_t channel = 0; channel < 3u && channel < n_channels; ++channel) {
|
||||
for (int sample = 0; sample < EJOC_FRAME_SAMPLES; ++sample) {
|
||||
core8_[channel][sample] =
|
||||
static_cast<double>(bed_planar[channel * EJOC_FRAME_SAMPLES + sample]);
|
||||
}
|
||||
}
|
||||
if (lfe != nullptr) {
|
||||
for (int sample = 0; sample < EJOC_FRAME_SAMPLES; ++sample) {
|
||||
core8_[EJOC_LFE_SLOT][sample] = static_cast<double>(lfe[sample]);
|
||||
}
|
||||
}
|
||||
const uint32_t rest = n_channels > 3u ? n_channels - 3u : 0u;
|
||||
for (uint32_t index = 0; index < rest; ++index) {
|
||||
const uint32_t channel = 3u + index;
|
||||
for (int sample = 0; sample < EJOC_FRAME_SAMPLES; ++sample) {
|
||||
core8_[4u + index][sample] =
|
||||
static_cast<double>(bed_planar[channel * EJOC_FRAME_SAMPLES + sample]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Passthrough output: slots 0..7 take the previous frame's 8 core planes
|
||||
// delayed by 1217 samples plus this frame's leading 319 samples; slots 8..15
|
||||
// stay zero.
|
||||
void write_passthrough(float* output16, const float output_scale) const noexcept {
|
||||
for (int channel = 0; channel < EJOC_CORE_OUT_CHANNELS; ++channel) {
|
||||
float* destination = output16 + channel * EJOC_FRAME_SAMPLES;
|
||||
for (int sample = 0; sample < kLfeDelay; ++sample) {
|
||||
destination[sample] = static_cast<float>(
|
||||
core_history_[channel][EJOC_FRAME_SAMPLES - kLfeDelay + sample]) *
|
||||
output_scale;
|
||||
}
|
||||
for (int sample = kLfeDelay; sample < EJOC_FRAME_SAMPLES; ++sample) {
|
||||
destination[sample] =
|
||||
static_cast<float>(core8_[channel][sample - kLfeDelay]) * output_scale;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Normal rendering: interpolate the per-object matrix from its previous
|
||||
// frame-end value (or hard cut when there is none) and publish objects that
|
||||
// disappeared as an all-zero matrix until they come back.
|
||||
void matrix_object_frame(const int object) noexcept {
|
||||
std::memset(z_[object], 0, sizeof(z_[object]));
|
||||
const int n_channels = static_cast<int>(core_channels_);
|
||||
const bool present = (job_object_mask_ & (1u << object)) != 0u;
|
||||
if (!present) {
|
||||
if (prev_present_[object]) {
|
||||
for (int channel = 0; channel < n_channels; ++channel) {
|
||||
std::memset(prev_matrix_[object][channel], 0,
|
||||
sizeof(prev_matrix_[object][channel]));
|
||||
}
|
||||
prev_present_[object] = true;
|
||||
}
|
||||
return;
|
||||
}
|
||||
const int bands = job_n_bands_[object];
|
||||
const int points = job_n_dpoints_[object];
|
||||
const int slope = job_slope_idx_[object];
|
||||
const uint8_t* pb_map = parameter_band_map(bands);
|
||||
const bool has_previous = prev_present_[object];
|
||||
for (int channel = 0; channel < n_channels; ++channel) {
|
||||
for (int subband = 0; subband < EJOC_SUBBANDS; ++subband) {
|
||||
const int parameter_band = pb_map[subband];
|
||||
const double target0 = job_dq_[dq_index(object, 0, channel, parameter_band)];
|
||||
const double target1 = points == 2
|
||||
? job_dq_[dq_index(object, 1, channel, parameter_band)]
|
||||
: target0;
|
||||
const double previous =
|
||||
has_previous ? prev_matrix_[object][channel][subband] : 0.0;
|
||||
double last = target0;
|
||||
for (int timeslot = 0; timeslot < EJOC_TIMESLOTS; ++timeslot) {
|
||||
double coefficient = 0.0;
|
||||
if (slope == 0) {
|
||||
if (!has_previous) {
|
||||
if (points == 1 || timeslot < EJOC_TIMESLOTS / 2) {
|
||||
// Hard cut: no fade-in from zero. With two data
|
||||
// points the second half still interpolates.
|
||||
coefficient = target0;
|
||||
} else {
|
||||
const double alpha =
|
||||
static_cast<double>(timeslot - (EJOC_TIMESLOTS / 2 - 1)) /
|
||||
static_cast<double>(EJOC_TIMESLOTS / 2);
|
||||
coefficient = target0 * (1.0 - alpha) + target1 * alpha;
|
||||
}
|
||||
} else if (points == 1) {
|
||||
const double alpha =
|
||||
static_cast<double>(timeslot + 1) /
|
||||
static_cast<double>(EJOC_TIMESLOTS);
|
||||
coefficient = previous * (1.0 - alpha) + target0 * alpha;
|
||||
} else if (timeslot < EJOC_TIMESLOTS / 2) {
|
||||
const double alpha = static_cast<double>(timeslot + 1) /
|
||||
(EJOC_TIMESLOTS / 2);
|
||||
coefficient = previous * (1.0 - alpha) + target0 * alpha;
|
||||
} else {
|
||||
const double alpha =
|
||||
static_cast<double>(timeslot - (EJOC_TIMESLOTS / 2 - 1)) /
|
||||
static_cast<double>(EJOC_TIMESLOTS / 2);
|
||||
coefficient = target0 * (1.0 - alpha) + target1 * alpha;
|
||||
}
|
||||
} else {
|
||||
// Step mode switches targets at the raw offset slots.
|
||||
const double base = has_previous ? previous : target0;
|
||||
coefficient = timeslot < job_offset_ts_[object * EJOC_MAX_DPOINTS]
|
||||
? base
|
||||
: target0;
|
||||
if (points == 2 &&
|
||||
timeslot >= job_offset_ts_[object * EJOC_MAX_DPOINTS + 1]) {
|
||||
coefficient = target1;
|
||||
}
|
||||
}
|
||||
z_[object][subband][timeslot].re +=
|
||||
x_[channel][subband][timeslot].re * coefficient;
|
||||
z_[object][subband][timeslot].im +=
|
||||
x_[channel][subband][timeslot].im * coefficient;
|
||||
last = coefficient;
|
||||
}
|
||||
prev_matrix_[object][channel][subband] = last;
|
||||
}
|
||||
}
|
||||
prev_present_[object] = true;
|
||||
}
|
||||
|
||||
// Hold rendering: all 24 slots reuse the previous frame-end matrix and the
|
||||
// previous state is not updated.
|
||||
void matrix_object_hold(const int object) noexcept {
|
||||
std::memset(z_[object], 0, sizeof(z_[object]));
|
||||
const int n_channels = static_cast<int>(core_channels_);
|
||||
for (int channel = 0; channel < n_channels; ++channel) {
|
||||
for (int subband = 0; subband < EJOC_SUBBANDS; ++subband) {
|
||||
const double previous = prev_matrix_[object][channel][subband];
|
||||
for (int timeslot = 0; timeslot < EJOC_TIMESLOTS; ++timeslot) {
|
||||
z_[object][subband][timeslot].re +=
|
||||
x_[channel][subband][timeslot].re * previous;
|
||||
z_[object][subband][timeslot].im +=
|
||||
x_[channel][subband][timeslot].im * previous;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void process_one_object_frame(const int object) noexcept {
|
||||
if (frame_mode_ == FrameMode::Normal) {
|
||||
matrix_object_frame(object);
|
||||
} else if (frame_mode_ == FrameMode::Hold) {
|
||||
matrix_object_hold(object);
|
||||
} else {
|
||||
// Hard cut and passthrough publish silence, but every object slot is
|
||||
// still synthesised so the synthesis state stays aligned.
|
||||
std::memset(z_[object], 0, sizeof(z_[object]));
|
||||
}
|
||||
synthesis_object(object, job_output_scale_, job_output16_);
|
||||
}
|
||||
|
||||
// One E-AC-3 audio frame: validates the description, advances the state
|
||||
// machine and dispatches one of the four rendering modes.
|
||||
int render_frame_impl(const ejoc_frame_input& input) noexcept {
|
||||
error_[0] = '\0';
|
||||
if (input.struct_size != sizeof(ejoc_frame_input) ||
|
||||
input.struct_version != EJOC_FRAME_INPUT_VERSION) {
|
||||
return fail("unsupported ejoc_frame_input struct version");
|
||||
}
|
||||
if (input.bed_planar == nullptr || input.output16_planar == nullptr) {
|
||||
return fail("null bed or output pointer passed to ejoc_renderer_render_frame");
|
||||
}
|
||||
const uint32_t n_channels = input.core_channel_count;
|
||||
if (n_channels != EJOC_CORE_CHANNELS && n_channels != EJOC_MAX_CORE_CHANNELS) {
|
||||
return fail("core_channel_count must be 5 or 7");
|
||||
}
|
||||
if (!std::isfinite(input.clipgain) || !std::isfinite(input.output_scale)) {
|
||||
return fail("clipgain and output_scale must be finite");
|
||||
}
|
||||
const bool has_metadata = input.has_metadata != 0u;
|
||||
uint32_t status = input.frame_status;
|
||||
if (!has_metadata) {
|
||||
if (status != EJOC_FRAME_STATUS_NO_METADATA) {
|
||||
return fail("a frame without JOC metadata must use frame_status 8");
|
||||
}
|
||||
} else if (status != 0u && (status < 2u || status > 6u)) {
|
||||
return fail("frame_status is not a JOC parse status");
|
||||
}
|
||||
if ((input.object_mask & ~((1u << EJOC_MAX_OBJECTS) - 1u)) != 0u) {
|
||||
return fail("object_mask contains an object index above 14");
|
||||
}
|
||||
if (has_metadata && status == 0u) {
|
||||
for (int object = 0; object < EJOC_MAX_OBJECTS; ++object) {
|
||||
if ((input.object_mask & (1u << object)) == 0u) {
|
||||
continue;
|
||||
}
|
||||
if (parameter_band_map(input.n_bands[object]) == nullptr) {
|
||||
return fail("unsupported parameter-band count");
|
||||
}
|
||||
if (input.n_dpoints[object] < 1u || input.n_dpoints[object] > 2u) {
|
||||
return fail("n_dpoints must be 1 or 2");
|
||||
}
|
||||
if (input.slope_idx[object] > 1u) {
|
||||
return fail("slope_idx must be 0 or 1");
|
||||
}
|
||||
if (input.slope_idx[object] == 1u) {
|
||||
const uint8_t* offsets =
|
||||
input.offset_ts + object * EJOC_MAX_DPOINTS;
|
||||
for (uint32_t point = 0; point < input.n_dpoints[object]; ++point) {
|
||||
if (offsets[point] >= EJOC_TIMESLOTS) {
|
||||
return fail("offset_ts leaves the 0..23 range");
|
||||
}
|
||||
if (point != 0u && offsets[point] <= offsets[point - 1u]) {
|
||||
return fail("offset_ts is not strictly increasing");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (n_channels_prev_ >= 0 && n_channels != static_cast<uint32_t>(n_channels_prev_)) {
|
||||
clear_unused_channels(n_channels);
|
||||
}
|
||||
// The parse status decides whether the frame's clipgain is usable; a
|
||||
// declared-channel-count change (status 9) is only the renderer's own
|
||||
// dispatch tag, so the new gain still applies to that frame.
|
||||
const uint32_t parse_status = status;
|
||||
// A declared core-channel-count change is the renderer's status 9: hard
|
||||
// cut with the LFE ring cleared, while the clipgain ramp state is kept.
|
||||
if (has_metadata && status == 0u && input.declared_core_channels != 0u &&
|
||||
n_channels_prev_ >= 0 &&
|
||||
input.declared_core_channels != static_cast<uint32_t>(n_channels_prev_)) {
|
||||
status = 9u;
|
||||
}
|
||||
advance_state(status, input.seq);
|
||||
maybe_clear_lfe_ring(status);
|
||||
const FrameMode mode = select_mode(status);
|
||||
if (input.phase_shift_valid != 0u) {
|
||||
phase_shift_enabled_ = input.phase_shift != 0u;
|
||||
}
|
||||
const bool valid_metadata =
|
||||
has_metadata && parse_status == 0u && input.declared_core_channels != 0u;
|
||||
double clipgain;
|
||||
float phase_new;
|
||||
if ((mode == FrameMode::Normal || mode == FrameMode::HardCut) && valid_metadata) {
|
||||
clipgain = input.clipgain;
|
||||
phase_new = static_cast<float>(0.0625 * clipgain);
|
||||
} else {
|
||||
// Held frames reuse the current clipgain; they do not retune it.
|
||||
clipgain = held_clipgain();
|
||||
phase_new = held_analysis_scalar();
|
||||
}
|
||||
|
||||
core_channels_ = n_channels;
|
||||
std::memset(input.output16_planar, 0,
|
||||
sizeof(float) * EJOC_OUTPUT_CHANNELS * EJOC_FRAME_SAMPLES);
|
||||
build_core8(input.bed_planar, input.lfe, n_channels);
|
||||
analysis(input.bed_planar, phase_new);
|
||||
|
||||
job_kind_ = JobKind::FrameObjects;
|
||||
frame_mode_ = mode;
|
||||
job_object_mask_ = mode == FrameMode::Normal ? input.object_mask : 0u;
|
||||
job_n_bands_ = input.n_bands;
|
||||
job_n_dpoints_ = input.n_dpoints;
|
||||
job_slope_idx_ = input.slope_idx;
|
||||
job_offset_ts_ = input.offset_ts;
|
||||
job_dq_ = input.dq;
|
||||
job_output_scale_ = input.output_scale;
|
||||
job_output16_ = input.output16_planar;
|
||||
job_count_ = EJOC_MAX_OBJECTS;
|
||||
for (int object = 0; object < EJOC_MAX_OBJECTS; ++object) {
|
||||
job_objects_[object] = object;
|
||||
}
|
||||
dispatch_jobs();
|
||||
|
||||
decode_lfe(input.lfe, clipgain, input.output16_planar, input.output_scale);
|
||||
if (mode == FrameMode::HardCut) {
|
||||
// All matrices are zero this frame; the presence markers stay set so
|
||||
// the next valid frame fades in from zero.
|
||||
std::memset(input.output16_planar, 0,
|
||||
sizeof(float) * EJOC_OUTPUT_CHANNELS * EJOC_FRAME_SAMPLES);
|
||||
for (int object = 0; object < EJOC_MAX_OBJECTS; ++object) {
|
||||
prev_present_[object] = true;
|
||||
for (int channel = 0; channel < EJOC_MAX_CORE_CHANNELS; ++channel) {
|
||||
std::memset(prev_matrix_[object][channel], 0,
|
||||
sizeof(prev_matrix_[object][channel]));
|
||||
}
|
||||
}
|
||||
} else if (mode == FrameMode::Passthrough) {
|
||||
write_passthrough(input.output16_planar, input.output_scale);
|
||||
}
|
||||
|
||||
// The 8-plane history is updated on every frame so a later passthrough
|
||||
// frame is continuous with the last core PCM.
|
||||
std::memcpy(core_history_, core8_, sizeof(core_history_));
|
||||
n_channels_prev_ = static_cast<int>(n_channels);
|
||||
return 0;
|
||||
}
|
||||
|
||||
enum class JobKind : uint8_t { Analysis, Objects, FrameObjects };
|
||||
|
||||
std::vector<std::thread> workers_;
|
||||
std::unique_ptr<std::barrier<>> work_barrier_;
|
||||
@@ -657,6 +1133,8 @@ private:
|
||||
const double* job_dq_ = nullptr;
|
||||
float job_output_scale_ = 1.0f;
|
||||
float* job_output16_ = nullptr;
|
||||
uint32_t job_object_mask_ = 0;
|
||||
FrameMode frame_mode_ = FrameMode::Normal;
|
||||
|
||||
uint32_t core_channels_ = EJOC_CORE_CHANNELS;
|
||||
alignas(64) double analysis_fifo_[EJOC_MAX_CORE_CHANNELS][9][64];
|
||||
@@ -668,11 +1146,29 @@ private:
|
||||
// sigma(k) switch; the caller sets it for downmix configurations 3 and 4.
|
||||
bool phase_shift_enabled_ = true;
|
||||
alignas(64) double lfe_delay_[kLfeDelay];
|
||||
// LFE gain ramp start; cleared by reset() and cleared/unset only there, so a
|
||||
// held frame keeps the last applied gain.
|
||||
double lfe_clipgain_ = 0.0;
|
||||
bool has_lfe_clipgain_ = false;
|
||||
alignas(64) double matrix_previous_[15][EJOC_MAX_CORE_CHANNELS][64];
|
||||
alignas(64) double synthesis_state_[15][640];
|
||||
alignas(64) Complex x_[EJOC_MAX_CORE_CHANNELS][64][24];
|
||||
alignas(64) Complex z_[15][64][24];
|
||||
|
||||
// Frame-level state: the seq state machine and the per-object interpolation
|
||||
// previous matrix (frame-end timeslot of the last published matrix).
|
||||
uint32_t state_ = 0;
|
||||
uint32_t expected_seq_ = 0;
|
||||
uint32_t invalid_count_ = 0;
|
||||
bool last_frame_valid_ = false;
|
||||
int n_channels_prev_ = -1;
|
||||
alignas(64) double prev_matrix_[EJOC_MAX_OBJECTS][EJOC_MAX_CORE_CHANNELS][64];
|
||||
bool prev_present_[EJOC_MAX_OBJECTS];
|
||||
// Passthrough history: the 8 core planes of the previous frame and of this
|
||||
// frame, in the order L,R,C,LFE,Ls,Rs,(Lrs,Rrs).
|
||||
alignas(64) double core_history_[EJOC_CORE_OUT_CHANNELS][EJOC_FRAME_SAMPLES];
|
||||
alignas(64) double core8_[EJOC_CORE_OUT_CHANNELS][EJOC_FRAME_SAMPLES];
|
||||
|
||||
uint8_t bit_reverse_[64];
|
||||
Complex fft_twiddle_[32];
|
||||
double rotation_sin_[64];
|
||||
@@ -690,13 +1186,13 @@ uint32_t EJOC_CALL ejoc_abi_version(void) {
|
||||
|
||||
const char* EJOC_CALL ejoc_build_info(void) {
|
||||
#if defined(_MSC_VER)
|
||||
return "eac3joc-core abi=1 compiler=MSVC fft=fixed64 speaker=double binaural=double crt=static-by-build";
|
||||
return "eac3joc-core abi=4 compiler=MSVC fft=fixed64 speaker=double binaural=double crt=static-by-build";
|
||||
#elif defined(__clang__)
|
||||
return "eac3joc-core abi=1 compiler=Clang fft=fixed64 speaker=double binaural=double";
|
||||
return "eac3joc-core abi=4 compiler=Clang fft=fixed64 speaker=double binaural=double";
|
||||
#elif defined(__GNUC__)
|
||||
return "eac3joc-core abi=1 compiler=GCC fft=fixed64 speaker=double binaural=double";
|
||||
return "eac3joc-core abi=4 compiler=GCC fft=fixed64 speaker=double binaural=double";
|
||||
#else
|
||||
return "eac3joc-core abi=1 compiler=unknown fft=fixed64 speaker=double binaural=double";
|
||||
return "eac3joc-core abi=4 compiler=unknown fft=fixed64 speaker=double binaural=double";
|
||||
#endif
|
||||
}
|
||||
|
||||
@@ -760,4 +1256,15 @@ int EJOC_CALL ejoc_renderer_process(
|
||||
slope_idx, offset_ts, dq, clipgain, phase_new, output_scale, output16_planar);
|
||||
}
|
||||
|
||||
int EJOC_CALL ejoc_renderer_render_frame(ejoc_renderer_handle handle,
|
||||
const ejoc_frame_input* input) {
|
||||
if (!handle) {
|
||||
return -1;
|
||||
}
|
||||
if (!input) {
|
||||
return -1;
|
||||
}
|
||||
return static_cast<ejoc::Renderer*>(handle)->render_frame(*input);
|
||||
}
|
||||
|
||||
} // extern "C"
|
||||
@@ -6,16 +6,17 @@
|
||||
namespace joc::joc {
|
||||
|
||||
Status rebuild_objects16(ejoc_renderer_handle handle, const joc_frame_params& params,
|
||||
const float* bed_planar, const float* lfe, float gain,
|
||||
const float* bed_planar, const float* lfe,
|
||||
std::uint32_t core_channel_count, bool has_metadata, float gain,
|
||||
std::vector<float>* out16, std::string* error) {
|
||||
if (handle == nullptr || bed_planar == nullptr || out16 == nullptr) {
|
||||
return Status::fail(JOC_ERR_INVALID_ARGUMENT, stage::kDsp, "null argument");
|
||||
}
|
||||
if (params.n_channels != JOC_CORE_CHANNELS &&
|
||||
params.n_channels != JOC_MAX_CORE_CHANNELS) {
|
||||
if (core_channel_count != JOC_CORE_CHANNELS &&
|
||||
core_channel_count != JOC_MAX_CORE_CHANNELS) {
|
||||
if (error != nullptr) {
|
||||
*error = "the reused JOC kernel requires 5 or 7 core channels, frame declares " +
|
||||
std::to_string(static_cast<unsigned>(params.n_channels));
|
||||
*error = "the reused JOC kernel requires 5 or 7 core channels, the frame has " +
|
||||
std::to_string(core_channel_count);
|
||||
}
|
||||
return Status::fail(JOC_ERR_JOC_UNSUPPORTED_VARIANT, stage::kDsp, *error);
|
||||
}
|
||||
@@ -39,7 +40,7 @@ Status rebuild_objects16(ejoc_renderer_handle handle, const joc_frame_params& pa
|
||||
offset_ts[obj * JOC_MAX_DPOINTS + dp] = object.offset_ts[dp];
|
||||
}
|
||||
for (unsigned dp = 0; dp < object.n_dpoints; ++dp) {
|
||||
for (unsigned ch = 0; ch < params.n_channels; ++ch) {
|
||||
for (unsigned ch = 0; ch < core_channel_count; ++ch) {
|
||||
for (unsigned pb = 0; pb < object.n_bands; ++pb) {
|
||||
const std::size_t index =
|
||||
((static_cast<std::size_t>(obj) * JOC_MAX_DPOINTS + dp) *
|
||||
@@ -53,19 +54,42 @@ Status rebuild_objects16(ejoc_renderer_handle handle, const joc_frame_params& pa
|
||||
}
|
||||
}
|
||||
|
||||
out16->assign(static_cast<std::size_t>(JOC_OUTPUT_CHANNELS) * JOC_FRAME_SAMPLES, 0.0f);
|
||||
ejoc_frame_input input{};
|
||||
input.struct_size = sizeof(input);
|
||||
input.struct_version = EJOC_FRAME_INPUT_VERSION;
|
||||
input.bed_planar = bed_planar;
|
||||
input.lfe = lfe;
|
||||
input.core_channel_count = core_channel_count;
|
||||
// A frame without metadata has no declared channel count; the renderer's
|
||||
// status-9 path is gated on has_metadata, so the value is not consulted.
|
||||
input.declared_core_channels =
|
||||
has_metadata ? static_cast<std::uint32_t>(params.n_channels) : 0u;
|
||||
// sigma(k) = (k in {3,4}) gates the Ls/Rs -j rotation and the band-0 21-tap
|
||||
// DC compensation together; other configurations keep the common processing.
|
||||
const std::uint32_t phase_shift =
|
||||
(params.dmx_config_idx == 3 || params.dmx_config_idx == 4) ? 1u : 0u;
|
||||
const int result = ejoc_renderer_process(
|
||||
handle, bed_planar, lfe, params.n_channels, phase_shift, params.present_mask, n_bands,
|
||||
n_dpoints, slope_idx, offset_ts, dq.data(), params.clipgain, 0.0625f, gain,
|
||||
out16->data());
|
||||
// An unsupported downmix configuration (status 2) has no usable switch, so
|
||||
// the renderer keeps the previous one.
|
||||
input.phase_shift =
|
||||
(params.dmx_config_idx == 3u || params.dmx_config_idx == 4u) ? 1u : 0u;
|
||||
input.phase_shift_valid = params.status == JOC_FRAME_STATUS_UNSUPPORTED_DMX ? 0u : 1u;
|
||||
input.frame_status = has_metadata ? params.status : EJOC_FRAME_STATUS_NO_METADATA;
|
||||
input.seq = params.seq_count;
|
||||
input.has_metadata = has_metadata ? 1u : 0u;
|
||||
input.object_mask = params.present_mask;
|
||||
input.n_bands = n_bands;
|
||||
input.n_dpoints = n_dpoints;
|
||||
input.slope_idx = slope_idx;
|
||||
input.offset_ts = offset_ts;
|
||||
input.dq = dq.data();
|
||||
input.clipgain = params.clipgain;
|
||||
input.output_scale = gain;
|
||||
out16->assign(static_cast<std::size_t>(JOC_OUTPUT_CHANNELS) * JOC_FRAME_SAMPLES, 0.0f);
|
||||
input.output16_planar = out16->data();
|
||||
|
||||
const int result = ejoc_renderer_render_frame(handle, &input);
|
||||
if (result != 0) {
|
||||
const char* detail = ejoc_renderer_last_error(handle);
|
||||
const std::string message =
|
||||
"ejoc_renderer_process failed (" + std::to_string(result) + "): " +
|
||||
"ejoc_renderer_render_frame failed (" + std::to_string(result) + "): " +
|
||||
(detail != nullptr ? detail : "unknown");
|
||||
if (error != nullptr) {
|
||||
*error = message;
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
@@ -10,10 +11,20 @@
|
||||
|
||||
namespace joc::joc {
|
||||
|
||||
// [16][1536] planar float32. bed_planar is [params.n_channels][1536], where
|
||||
// n_channels comes from joc_dmx_config_idx (5 or 7).
|
||||
// Rebuilds the 16-channel object frame ([16][1536] planar float32) for one
|
||||
// audio frame through the renderer's frame-level state machine. bed_planar is
|
||||
// [core_channel_count][1536] in JOC lane order (L,R,C,Ls,Rs,(extra pair)), where
|
||||
// core_channel_count is the actual bed lane count (5 or 7) and lfe is the
|
||||
// separate core LFE plane (NULL = zeros; the LFE ring still advances).
|
||||
//
|
||||
// has_metadata is false for an audio frame without a JOC EMDF container: such a
|
||||
// frame always passes the 8 core planes through to output slots 0..7. For a
|
||||
// frame with metadata, params.status selects normal rendering or the invalid
|
||||
// frame path (hold / hard cut), and params.seq_count drives the state machine.
|
||||
// gain is the user output gain (not joc_clipgain).
|
||||
Status rebuild_objects16(ejoc_renderer_handle handle, const joc_frame_params& params,
|
||||
const float* bed_planar, const float* lfe, float gain,
|
||||
const float* bed_planar, const float* lfe,
|
||||
std::uint32_t core_channel_count, bool has_metadata, float gain,
|
||||
std::vector<float>* out16, std::string* error);
|
||||
|
||||
} // namespace joc::joc
|
||||
@@ -338,7 +338,7 @@ inline constexpr uint8_t kPbMap1[64] = {
|
||||
};
|
||||
|
||||
inline constexpr uint8_t kPbMap3[64] = {
|
||||
0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
|
||||
0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
@@ -346,8 +346,8 @@ inline constexpr uint8_t kPbMap3[64] = {
|
||||
|
||||
inline constexpr uint8_t kPbMap5[64] = {
|
||||
0, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
};
|
||||
|
||||
@@ -359,8 +359,8 @@ inline constexpr uint8_t kPbMap7[64] = {
|
||||
};
|
||||
|
||||
inline constexpr uint8_t kPbMap9[64] = {
|
||||
0, 1, 2, 3, 3, 3, 4, 5, 5, 6, 6, 6, 7, 7, 8, 8,
|
||||
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
|
||||
0, 1, 2, 3, 3, 4, 4, 5, 5, 6, 6, 6, 6, 6, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8,
|
||||
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
|
||||
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
|
||||
};
|
||||
@@ -373,9 +373,9 @@ inline constexpr uint8_t kPbMap12[64] = {
|
||||
};
|
||||
|
||||
inline constexpr uint8_t kPbMap15[64] = {
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 10, 10, 11, 11, 11,
|
||||
12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 10, 10, 10, 11, 11,
|
||||
11, 11, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
};
|
||||
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,101 @@
|
||||
// Port of src/oamd_math.py: float32 equations for the metadata application path.
|
||||
//
|
||||
// The routines implement the fixed float32 equations for the size tables, ISF
|
||||
// basis assembly, bed channel routing and the position-dependent compensation.
|
||||
// The size tables are generated from the region geometry with grouped equal-power
|
||||
// panning, an S448 weight and a power sum; every operation is evaluated in
|
||||
// float32 in a fixed order so the coefficients are reproducible.
|
||||
//
|
||||
// The caller passes the parameter mappings from oamd_params; this module does
|
||||
// not read files itself.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <array>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <vector>
|
||||
|
||||
#include "oamd/oamd_params.h"
|
||||
#include "speaker/speaker_layout_lookup.h"
|
||||
#include "speaker/speaker_layouts.h"
|
||||
|
||||
namespace joc::oamd {
|
||||
|
||||
// The specified 2**x approximation used by the compensation kernels.
|
||||
float exp2_approx(float value);
|
||||
|
||||
// The specified x**power approximation; power is a float32.
|
||||
float pow_approx(float value, float power);
|
||||
|
||||
// Stable float32 normalisation with the tiny-norm floor.
|
||||
std::vector<float> norm(const std::vector<float>& vector);
|
||||
|
||||
// One boundary weight of the size kernel.
|
||||
float boundary(int axis, int edge, float position, float t);
|
||||
|
||||
// Maps a scalar size in [0, 1] to t on the size curve.
|
||||
float size_curve_value(double size);
|
||||
|
||||
// Size kernel response in region-speaker order (the region point order).
|
||||
std::vector<float> size_kernel(const ::ejoc::speaker_tables::RegionGeometry& region,
|
||||
const float position[3], float t, bool height);
|
||||
|
||||
// Size-kernel target vector in layout channel order.
|
||||
std::vector<float> size_targets(const MetadataParams& meta,
|
||||
const ::ejoc::speaker_tables::LayoutGeometry& layout,
|
||||
int region_index, const double position[3],
|
||||
double size, bool height);
|
||||
|
||||
// One assembled ISF basis matrix (row_count x layout output_count, row major).
|
||||
struct IsfBasis {
|
||||
int rows = 0;
|
||||
int columns = 0;
|
||||
std::vector<float> values;
|
||||
|
||||
float at(int row, int column) const {
|
||||
return values[static_cast<std::size_t>(row) * static_cast<std::size_t>(columns) +
|
||||
static_cast<std::size_t>(column)];
|
||||
}
|
||||
};
|
||||
|
||||
// Assembles one ISF basis matrix from the compressed base tables.
|
||||
IsfBasis assemble_isf(const MetadataParams& meta, const char* layout_key, int isf_idx);
|
||||
|
||||
// Returns the per-basis ISF compensation gain.
|
||||
float isf_compensation(const MetadataParams& meta, const char* layout_key, int isf_idx,
|
||||
int row, bool disabled);
|
||||
|
||||
// Per-label bed redistribution weight, in the reference-position index space
|
||||
// used by the layout descriptors.
|
||||
float bed_weight(int label, std::uint32_t mask, int target_label);
|
||||
|
||||
// The five height-candidate flags for one input bed label.
|
||||
std::array<int, 5> bed_candidates(int label, std::uint32_t mask,
|
||||
const std::vector<int>& output_labels);
|
||||
|
||||
// Route and weights for one input bed label. route == -1 means the returned
|
||||
// weights are the target; otherwise route is the reference position used to
|
||||
// synthesise a point source.
|
||||
struct BedDistribution {
|
||||
int route = -1;
|
||||
std::vector<float> weights;
|
||||
};
|
||||
|
||||
// Derives the bed routing of one input bed label from the target layout.
|
||||
BedDistribution bed_distribution(const ::joc::speaker::LayoutInfo& layout, int label,
|
||||
std::uint32_t mask, bool distribute);
|
||||
|
||||
// Returns the Q15 reference position used by the bed fallback path.
|
||||
void bed_reference_position(int index, int q15[3]);
|
||||
|
||||
// Returns the bed path compensation gain for one input bed label. ``mode`` is
|
||||
// the trim mode (0 automatic, 1 disabled, 2 explicit) and ``levels`` holds the
|
||||
// surround, height and centre levels in dB.
|
||||
float bed_compensation(const ::joc::speaker::LayoutInfo& layout, int label, int mode,
|
||||
bool bypass, const double levels[3]);
|
||||
|
||||
// Automatic attenuation of a target layout in dB.
|
||||
float bed_attenuation_db(const ::joc::speaker::LayoutInfo& layout);
|
||||
|
||||
} // namespace joc::oamd
|
||||
@@ -0,0 +1,108 @@
|
||||
#include "oamd/oamd_params.h"
|
||||
|
||||
#include <cstddef>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
#include "oamd/isf_tables.h"
|
||||
|
||||
namespace joc::oamd {
|
||||
|
||||
namespace {
|
||||
|
||||
namespace tables = isf_tables;
|
||||
|
||||
// Builds the renderer-facing view from the checked-in table header. There is no
|
||||
// file I/O and no runtime parsing: the numbers are compiled in as static data.
|
||||
MetadataParams build_params() {
|
||||
MetadataParams params;
|
||||
params.configs.reserve(tables::kConfigCount);
|
||||
for (const tables::Config& source : tables::kConfigs) {
|
||||
IsfConfig config;
|
||||
for (std::size_t index = 0; index < config.counts.size(); ++index) {
|
||||
config.counts[index] = source.counts[index];
|
||||
}
|
||||
const std::size_t rows = static_cast<std::size_t>(config.row_count());
|
||||
config.primary_row_map.assign(source.primary_row_map, source.primary_row_map + rows);
|
||||
config.secondary_row_map.assign(source.secondary_row_map,
|
||||
source.secondary_row_map + rows);
|
||||
const std::size_t coefficients = rows * static_cast<std::size_t>(tables::kMatrixColumns);
|
||||
config.matrix.assign(source.matrix, source.matrix + coefficients);
|
||||
params.configs.push_back(std::move(config));
|
||||
}
|
||||
|
||||
params.layouts.reserve(tables::kLayoutCount);
|
||||
for (const tables::Layout& source : tables::kLayouts) {
|
||||
IsfLayout layout;
|
||||
layout.output_count = source.output_count;
|
||||
for (std::size_t index = 0; index < layout.selectors.size(); ++index) {
|
||||
layout.selectors[index] = source.selectors[index];
|
||||
}
|
||||
layout.compensation_value = source.compensation_value;
|
||||
layout.output_ids.assign(source.output_ids,
|
||||
source.output_ids + tables::kOutputIdSlots);
|
||||
params.layouts.emplace(source.key, std::move(layout));
|
||||
}
|
||||
|
||||
const auto copy_groups = [](const tables::GroupRecord* records, int count,
|
||||
std::vector<IsfGroupRecord>* out) {
|
||||
out->reserve(static_cast<std::size_t>(count));
|
||||
for (int index = 0; index < count; ++index) {
|
||||
out->push_back(IsfGroupRecord{records[index].selector, records[index].begin,
|
||||
records[index].end});
|
||||
}
|
||||
};
|
||||
copy_groups(tables::kLayoutGroups.floor_a, tables::kLayoutGroups.floor_a_count,
|
||||
¶ms.layout_groups.floor_a);
|
||||
copy_groups(tables::kLayoutGroups.floor_b, tables::kLayoutGroups.floor_b_count,
|
||||
¶ms.layout_groups.floor_b);
|
||||
copy_groups(tables::kLayoutGroups.height, tables::kLayoutGroups.height_count,
|
||||
¶ms.layout_groups.height);
|
||||
copy_groups(tables::kLayoutGroups.additional, tables::kLayoutGroups.additional_count,
|
||||
¶ms.layout_groups.additional);
|
||||
|
||||
params.paired_columns.assign(tables::kPairedColumns,
|
||||
tables::kPairedColumns + tables::kPairedColumnCount);
|
||||
return params;
|
||||
}
|
||||
|
||||
const MetadataParams& loaded_params() {
|
||||
static const MetadataParams params = build_params();
|
||||
return params;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
const std::vector<IsfGroupRecord>* IsfLayoutGroups::find(const char* name) const {
|
||||
if (name == nullptr) {
|
||||
return nullptr;
|
||||
}
|
||||
const std::string key(name);
|
||||
if (key == "floor_a") {
|
||||
return &floor_a;
|
||||
}
|
||||
if (key == "floor_b") {
|
||||
return &floor_b;
|
||||
}
|
||||
if (key == "height") {
|
||||
return &height;
|
||||
}
|
||||
if (key == "additional") {
|
||||
return &additional;
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
const IsfLayout* MetadataParams::layout(const char* key) const {
|
||||
if (key == nullptr) {
|
||||
return nullptr;
|
||||
}
|
||||
const auto found = layouts.find(key);
|
||||
return found != layouts.end() ? &found->second : nullptr;
|
||||
}
|
||||
|
||||
const MetadataParams* metadata_params() { return &loaded_params(); }
|
||||
|
||||
const char* metadata_params_error() { return ""; }
|
||||
|
||||
} // namespace joc::oamd
|
||||
@@ -0,0 +1,82 @@
|
||||
// Port of src/oamd_params.py: the static ISF lookup data of the metadata path.
|
||||
//
|
||||
// The numbers are compiled in as the generated header `oamd/isf_tables.h`:
|
||||
// ISF base coefficients and layout descriptors, applied as lookup tables.
|
||||
// The remaining values (gain, size, priority, position, delta and refinement
|
||||
// tables) are computed in code; the size tables are generated from the region
|
||||
// geometry at runtime, and bed routing is derived from the speaker layouts.
|
||||
// The arrays are adapted once per process into the structures below; nothing
|
||||
// reads a data file.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <array>
|
||||
#include <cstdint>
|
||||
#include <string>
|
||||
#include <unordered_map>
|
||||
#include <vector>
|
||||
|
||||
#include "foundation/status.h"
|
||||
|
||||
namespace joc::oamd {
|
||||
|
||||
// One ISF configuration: the compressed basis matrix and the two row maps
|
||||
// that expand it to the layout output channels.
|
||||
struct IsfConfig {
|
||||
// mid, upper, lower, zenith, row_count (the reference's counts tuple).
|
||||
std::array<int, 5> counts{};
|
||||
std::vector<int> primary_row_map;
|
||||
std::vector<int> secondary_row_map;
|
||||
// row_count * 73 float32 coefficients, row major.
|
||||
std::vector<float> matrix;
|
||||
|
||||
int row_count() const { return counts[4]; }
|
||||
};
|
||||
|
||||
// One layout descriptor: how many output channels the basis has,
|
||||
// the layout-group selectors and the automatic compensation value.
|
||||
struct IsfLayout {
|
||||
int output_count = 0;
|
||||
std::array<int, 4> selectors{}; // floor_a, floor_b, height, additional
|
||||
double compensation_value = 0.0;
|
||||
// ISF channel id of each matrix output column, padded with zeros to 37.
|
||||
std::vector<std::uint8_t> output_ids;
|
||||
};
|
||||
|
||||
// One record of a layout group: selector id and the half-open column range
|
||||
// [begin, end).
|
||||
struct IsfGroupRecord {
|
||||
int selector = 0;
|
||||
int begin = 0;
|
||||
int end = 0;
|
||||
};
|
||||
|
||||
// The four layout groups of the ISF tables.
|
||||
struct IsfLayoutGroups {
|
||||
std::vector<IsfGroupRecord> floor_a;
|
||||
std::vector<IsfGroupRecord> floor_b;
|
||||
std::vector<IsfGroupRecord> height;
|
||||
std::vector<IsfGroupRecord> additional;
|
||||
|
||||
const std::vector<IsfGroupRecord>* find(const char* name) const;
|
||||
};
|
||||
|
||||
// The ISF lookup data in the shape the metadata renderer consumes.
|
||||
struct MetadataParams {
|
||||
std::vector<IsfConfig> configs;
|
||||
std::unordered_map<std::string, IsfLayout> layouts;
|
||||
IsfLayoutGroups layout_groups;
|
||||
// One flag per matrix column: whether the column also contributes through
|
||||
// the secondary row map.
|
||||
std::vector<bool> paired_columns;
|
||||
|
||||
const IsfLayout* layout(const char* key) const;
|
||||
};
|
||||
|
||||
// Returns the process-wide tables. They are compiled in, so the pointer is
|
||||
// never null; ``metadata_params_error`` is kept for callers that log a load
|
||||
// failure and always returns an empty string.
|
||||
const MetadataParams* metadata_params();
|
||||
const char* metadata_params_error();
|
||||
|
||||
} // namespace joc::oamd
|
||||
+1057
-328
File diff suppressed because it is too large.
Load diff
+172
-11
@@ -9,6 +9,34 @@
|
||||
#include "foundation/status.h"
|
||||
#include "joc_core.h"
|
||||
|
||||
namespace joc::joc {
|
||||
|
||||
// OAMD Table 12 的标准 bed 声道。LSB 顺序与声明顺序一致:L/R、C、LFE、
|
||||
// Ls/Rs、Lrs/Rrs、TFL/TFR、TSL/TSR、TBL/TBR、LW/RW、LFE2。
|
||||
// The enum values are the reference's BED_LABEL_INDEX - 1.
|
||||
enum class BedChannel : std::uint8_t {
|
||||
kLeft = 0,
|
||||
kRight,
|
||||
kCenter,
|
||||
kLfe,
|
||||
kLeftSurround,
|
||||
kRightSurround,
|
||||
kLeftRearSurround,
|
||||
kRightRearSurround,
|
||||
kTopFrontLeft,
|
||||
kTopFrontRight,
|
||||
kTopSideLeft,
|
||||
kTopSideRight,
|
||||
kTopBackLeft,
|
||||
kTopBackRight,
|
||||
kLeftWide,
|
||||
kRightWide,
|
||||
kLfe2,
|
||||
kCount,
|
||||
};
|
||||
|
||||
} // namespace joc::joc
|
||||
|
||||
namespace joc::oamd {
|
||||
|
||||
inline constexpr int kMaxSlots = 16;
|
||||
@@ -17,8 +45,16 @@ inline constexpr int kAxes = 3;
|
||||
inline constexpr int kNQ12 = 62;
|
||||
inline constexpr int kNQ3 = 15;
|
||||
inline constexpr int kQ15Scale = 32768;
|
||||
// Largest ISF configuration of Table 11b (5.6.0.11). A frame cannot carry more
|
||||
// objects than this through any of the standard programmes, but the parser does
|
||||
// not reject a larger count: it only bounds the legacy 16-slot view.
|
||||
inline constexpr int kMaxObjects = 30;
|
||||
inline constexpr int kMaxBlocks = 8;
|
||||
inline constexpr std::uint32_t kTrimElementId = 2;
|
||||
inline constexpr std::uint32_t kObjectElementId = 1;
|
||||
inline constexpr std::uint32_t kExtendedElementId = 5;
|
||||
inline constexpr int kTrimConfigs = 9;
|
||||
inline constexpr int kBedLabelCount = 17;
|
||||
|
||||
// One of the nine per-configuration trim records of the OAMD trim element.
|
||||
// ``kAbsent`` means the configuration carries no data (the element only
|
||||
@@ -50,6 +86,92 @@ struct OamdTrim {
|
||||
bool disable_per_object[kMaxSlots] = {};
|
||||
};
|
||||
|
||||
// OAMD object kind: the programme assigns objects to the bed, to an ISF
|
||||
// configuration, or to the dynamic (positional) set, in that order.
|
||||
enum class ObjectKind : std::uint8_t {
|
||||
kBed = 0,
|
||||
kIsf = 1,
|
||||
kDynamic = 2,
|
||||
};
|
||||
|
||||
// Render state of one object in one block (5.5.9 object_info_block).
|
||||
struct ObjectRenderState {
|
||||
bool not_active = false;
|
||||
std::int32_t gain_q = 0; // integer gain, unity = 4096
|
||||
std::int32_t priority_q = 0; // Q10 priority, 32767 = default
|
||||
std::int32_t qx = 0; // Q15 room position, 0..32767
|
||||
std::int32_t qy = 0; // Q15 room position, 0..32767
|
||||
std::int32_t qz = 0; // signed Q15 elevation
|
||||
std::uint8_t zone_idx = 0;
|
||||
bool enable_elevation = true;
|
||||
std::uint8_t size_mode = 0; // 0 none, 1 isotropic, 2 per-axis
|
||||
std::uint16_t size_q[3] = {0, 0, 0}; // Q15 size per axis
|
||||
bool snap = false;
|
||||
std::uint16_t divergence_q = 0; // Q15 divergence width
|
||||
};
|
||||
|
||||
struct ObjectBlockState {
|
||||
ObjectRenderState render;
|
||||
};
|
||||
|
||||
// One object of the frame: its kind and the state of every block.
|
||||
struct ObjectElementState {
|
||||
ObjectKind kind = ObjectKind::kDynamic;
|
||||
std::vector<ObjectBlockState> blocks;
|
||||
};
|
||||
|
||||
// Timing shared by every object of one block. ``block_offset_samples`` already
|
||||
// includes the element's sample_offset, like the reference block dictionary.
|
||||
struct BlockTiming {
|
||||
std::uint32_t block_offset_samples = 0;
|
||||
std::uint32_t ramp_duration_samples = 0;
|
||||
};
|
||||
|
||||
// Program assignment (5.5.3) as consumed by the speaker renderer.
|
||||
struct ProgramState {
|
||||
bool dynamic_object_only = false;
|
||||
bool lfe_present = false;
|
||||
bool b_bed_chan_distribute = false;
|
||||
// program_assignment() content_description flags.
|
||||
bool content_reserved = false;
|
||||
bool content_bed = false;
|
||||
bool content_isf = false;
|
||||
bool content_dynamic = false;
|
||||
std::uint32_t num_bed_objects = 0;
|
||||
std::uint32_t num_isf_objects = 0;
|
||||
std::int32_t num_dynamic_objects = -1; // -1 when the frame declares none
|
||||
std::uint32_t bed_mask = 0; // 17-bit non-standard bed mask
|
||||
std::int32_t isf_idx = -1; // -1 when the frame declares none
|
||||
// Declared bed labels in channel order, including LFE/LFE2. Index i is the
|
||||
// label of object i for i < num_bed_objects.
|
||||
std::vector<::joc::joc::BedChannel> bed_labels;
|
||||
};
|
||||
|
||||
// One element whose parsed content ended past its declared size. The reference
|
||||
// keeps parsing such elements and only records the difference.
|
||||
struct ElementSizeMismatch {
|
||||
std::uint32_t element_ordinal = 0;
|
||||
std::uint32_t element_id = 0;
|
||||
std::uint32_t declared_size_bytes = 0;
|
||||
std::uint32_t declared_end_bit = 0;
|
||||
std::uint32_t parsed_end_bit = 0;
|
||||
};
|
||||
|
||||
// Full frame state (frame_state() in the reference): per-object per-block
|
||||
// render state plus programme assignment, timing and trim.
|
||||
struct FrameState {
|
||||
std::uint32_t object_count = 0;
|
||||
std::uint32_t block_count = 0;
|
||||
std::uint32_t sample_offset = 0; // object_element sample offset
|
||||
std::uint32_t ramp_duration_samples = 0; // block 0
|
||||
std::vector<BlockTiming> blocks;
|
||||
std::vector<ObjectElementState> objects;
|
||||
ProgramState program;
|
||||
bool has_trim = false;
|
||||
OamdTrim trim;
|
||||
std::vector<ElementSizeMismatch> size_mismatch;
|
||||
};
|
||||
|
||||
// (the reference's None), i.e. hold the previous position.
|
||||
struct SlotUpdate {
|
||||
std::int16_t q1 = -1;
|
||||
@@ -76,6 +198,12 @@ struct OamdUpdate {
|
||||
// keeps whatever controls the caller already holds.
|
||||
OamdTrim trim;
|
||||
bool has_trim = false;
|
||||
// Full per-object per-block state of this payload. ``has_frame_state`` is
|
||||
// true whenever the parser produced it; the speaker metadata path and the
|
||||
// binaural position timeline consume it, while the legacy slot fields above
|
||||
// stay authoritative for ADM export and the point-renderer path.
|
||||
bool has_frame_state = false;
|
||||
FrameState frame_state;
|
||||
};
|
||||
|
||||
class OamdState {
|
||||
@@ -103,6 +231,23 @@ public:
|
||||
|
||||
std::int16_t q(int slot, int axis) const { return q_[slot][axis]; }
|
||||
|
||||
// Resolves one frame-state position block for one object. The legacy
|
||||
// apply() entry above keeps the reference frame_update() view (16 slots,
|
||||
// block 0); the binaural position timeline uses this entry so a frame may
|
||||
// carry more objects and more blocks than that view can express. Callers
|
||||
// skip inactive and non-dynamic objects themselves, exactly like the
|
||||
// reference's frame_update() value construction.
|
||||
void apply_render_state(int object_index, const ObjectRenderState& render) {
|
||||
if (object_index < 0 || object_index >= kMaxObjects) {
|
||||
return;
|
||||
}
|
||||
q_[object_index][0] = static_cast<std::int16_t>(render.qx);
|
||||
q_[object_index][1] = static_cast<std::int16_t>(render.qy);
|
||||
const std::int32_t elevation = render.enable_elevation ? render.qz : 0;
|
||||
q_[object_index][2] =
|
||||
static_cast<std::int16_t>(elevation > 0 ? elevation : 0);
|
||||
}
|
||||
|
||||
// Objects 1..15 as q15 triples, the layout the speaker renderer consumes.
|
||||
void object_positions_q15(std::uint16_t out[kObjects][kAxes]) const {
|
||||
for (int object = 0; object < kObjects; ++object) {
|
||||
@@ -113,25 +258,18 @@ public:
|
||||
}
|
||||
|
||||
private:
|
||||
std::int16_t q_[kMaxSlots][kAxes] = {};
|
||||
std::int16_t q_[kMaxObjects][kAxes] = {};
|
||||
};
|
||||
|
||||
// q_of(k, n) = min(32767, floor(32768 k / n + 0.5)), the reference's quantiser.
|
||||
int q_of(int k, int n);
|
||||
|
||||
Status parse_id11(const std::uint8_t* payload, std::size_t payload_size, OamdUpdate* out);
|
||||
|
||||
// Parses only the trim element of a payload. ``out`` receives the first trim
|
||||
// element found; ``*present`` is false when the payload carries none. decode
|
||||
// paths that need the OAMD calibration but no object state can use this
|
||||
// without requiring an object element.
|
||||
Status parse_trim(const std::uint8_t* payload, std::size_t payload_size, OamdTrim* out,
|
||||
bool* present);
|
||||
|
||||
struct BedAssignment {
|
||||
bool lfe_only = false;
|
||||
bool standard = false;
|
||||
std::uint32_t mask = 0;
|
||||
std::uint32_t mask = 0; // 10-bit standard or 17-bit non-standard mask
|
||||
// Declared channels in channel order; LFE is kept in place.
|
||||
std::vector<::joc::joc::BedChannel> channels;
|
||||
};
|
||||
|
||||
struct ParseTrace {
|
||||
@@ -145,6 +283,26 @@ struct ParseTrace {
|
||||
bool reserved_data_not_present = false;
|
||||
};
|
||||
|
||||
// Legacy single-frame view (frame_update() in the reference): the 16-slot
|
||||
// position update plus programme and trim. A payload carrying more than 16
|
||||
// objects or more than one position block is rejected, exactly like the
|
||||
// reference legacy entry point. The ADM export path keeps this view; the
|
||||
// speaker and binaural renderers use parse_id11_state().
|
||||
Status parse_id11(const std::uint8_t* payload, std::size_t payload_size, OamdUpdate* out);
|
||||
|
||||
// Full frame_state() view: per-object per-block state, no 16-slot or
|
||||
// single-block restriction. The legacy fields are filled as well whenever the
|
||||
// frame fits them, so a caller can parse once and hand the same update to the
|
||||
// renderers and to the ADM export path where its shape allows it.
|
||||
Status parse_id11_state(const std::uint8_t* payload, std::size_t payload_size, OamdUpdate* out);
|
||||
|
||||
// Parses only the trim element of a payload. ``out`` receives the first trim
|
||||
// element found; ``*present`` is false when the payload carries none. decode
|
||||
// paths that need the OAMD calibration but no object state can use this
|
||||
// without requiring an object element.
|
||||
Status parse_trim(const std::uint8_t* payload, std::size_t payload_size, OamdTrim* out,
|
||||
bool* present);
|
||||
|
||||
Status parse_id11_verbose(const std::uint8_t* payload, std::size_t payload_size, OamdUpdate* out,
|
||||
ParseTrace* trace);
|
||||
|
||||
@@ -153,4 +311,7 @@ Status parse_id11_verbose(const std::uint8_t* payload, std::size_t payload_size,
|
||||
Status parse_id11_bed_assignments(const std::uint8_t* payload, std::size_t payload_size,
|
||||
std::vector<BedAssignment>* out);
|
||||
|
||||
// 10-bit standard bed mask -> 17-bit non-standard bed mask (5.6.1.1.4).
|
||||
std::uint32_t standard_bed_mask(std::uint32_t bed_mask);
|
||||
|
||||
} // namespace joc::oamd
|
||||
@@ -8,32 +8,55 @@ namespace {
|
||||
|
||||
struct FrozenLayout {
|
||||
const char* name;
|
||||
const char* compact_name;
|
||||
std::uint32_t out_ch_config;
|
||||
std::uint32_t speaker_bitfield;
|
||||
std::uint32_t surround_channels;
|
||||
std::uint32_t height_channels;
|
||||
bool carries_trim;
|
||||
const char* const* channel_names;
|
||||
};
|
||||
|
||||
const char* const kChannels20[] = {"L", "R"};
|
||||
const char* const kChannels31[] = {"L", "R", "C", "LFE"};
|
||||
const char* const kChannels40[] = {"L", "R", "Lrs", "Rrs"};
|
||||
const char* const kChannels51[] = {"L", "R", "C", "LFE", "Ls", "Rs"};
|
||||
const char* const kChannels71[] = {"L", "R", "C", "LFE", "Ls", "Rs", "Lrs", "Rrs"};
|
||||
const char* const kChannels512[] = {"L", "R", "C", "LFE", "Ls", "Rs", "Ltm", "Rtm"};
|
||||
const char* const kChannels514[] = {"L", "R", "C", "LFE", "Ls", "Rs", "Ltf", "Rtf",
|
||||
"Ltr", "Rtr"};
|
||||
const char* const kChannels712[] = {"L", "R", "C", "LFE", "Ls", "Rs", "Lrs", "Rrs",
|
||||
"Ltm", "Rtm"};
|
||||
const char* const kChannels714[] = {"L", "R", "C", "LFE", "Ls", "Rs", "Lrs", "Rrs",
|
||||
"Ltf", "Rtf", "Ltr", "Rtr"};
|
||||
const char* const kChannels914[] = {"L", "R", "C", "LFE", "Ls", "Rs", "Lrs", "Rrs",
|
||||
"Lw", "Rw", "Ltf", "Rtf", "Ltr", "Rtr"};
|
||||
const char* const kChannels916[] = {"L", "R", "C", "LFE", "Ls", "Rs", "Lrs", "Rrs",
|
||||
"Lw", "Rw", "Ltf", "Rtf", "Ltm", "Rtm", "Ltr", "Rtr"};
|
||||
const char* const kChannels60[] = {"L", "R", "Ls", "Rs", "Lrs", "Rrs"};
|
||||
|
||||
constexpr FrozenLayout kLayouts[kLayoutCount] = {
|
||||
{"2.0", 0, 1, 0, 0, true},
|
||||
{"3.1", 3, 7, 0, 0, true},
|
||||
{"4.0", 0xFF, 9, 2, 0, true},
|
||||
{"5.1", 7, 15, 2, 0, true},
|
||||
{"7.1", 11, 31, 4, 0, true},
|
||||
{"5.1.2", 13, 1039, 2, 2, true},
|
||||
{"5.1.4", 14, 2575, 2, 4, true},
|
||||
{"7.1.2", 15, 1055, 4, 2, false},
|
||||
{"7.1.4", 16, 2591, 4, 4, false},
|
||||
{"9.1.4", 19, 2719, 4, 4, false},
|
||||
{"9.1.6", 20, 3743, 4, 6, false},
|
||||
{"2.0", "20", 0, 1, 0, 0, true, kChannels20},
|
||||
{"3.1", "31", 3, 7, 0, 0, true, kChannels31},
|
||||
{"4.0", "40", 0xFF, 9, 2, 0, true, kChannels40},
|
||||
{"5.1", "51", 7, 15, 2, 0, true, kChannels51},
|
||||
{"7.1", "71", 11, 31, 4, 0, true, kChannels71},
|
||||
{"5.1.2", "512", 13, 1039, 2, 2, true, kChannels512},
|
||||
{"5.1.4", "514", 14, 2575, 2, 4, true, kChannels514},
|
||||
{"7.1.2", "712", 15, 1055, 4, 2, false, kChannels712},
|
||||
{"7.1.4", "714", 16, 2591, 4, 4, false, kChannels714},
|
||||
{"9.1.4", "914", 19, 2719, 4, 4, false, kChannels914},
|
||||
{"9.1.6", "916", 20, 3743, 4, 6, false, kChannels916},
|
||||
{"6.0", "60", 0xFF, 25, 4, 0, false, kChannels60},
|
||||
};
|
||||
|
||||
void fill(const FrozenLayout& source, LayoutInfo* out) {
|
||||
out->name = source.name;
|
||||
out->compact_name = source.compact_name;
|
||||
out->out_ch_config = source.out_ch_config;
|
||||
out->speaker_bitfield = source.speaker_bitfield;
|
||||
out->channel_count = ejoc_speaker_layout_channel_count(source.speaker_bitfield);
|
||||
out->channel_names = source.channel_names;
|
||||
out->surround_channels = source.surround_channels;
|
||||
out->height_channels = source.height_channels;
|
||||
out->carries_trim = source.carries_trim;
|
||||
|
||||
@@ -8,13 +8,18 @@
|
||||
|
||||
namespace joc::speaker {
|
||||
|
||||
inline constexpr int kLayoutCount = 11;
|
||||
inline constexpr int kLayoutCount = 12;
|
||||
|
||||
struct LayoutInfo {
|
||||
const char* name = "";
|
||||
// The reference's compact layout key ("2.0" -> "20", ...), the key of the
|
||||
// automatic-attenuation and divide-by-default tables.
|
||||
const char* compact_name = "";
|
||||
std::uint32_t out_ch_config = 0;
|
||||
std::uint32_t speaker_bitfield = 0;
|
||||
std::uint32_t channel_count = 0;
|
||||
// Standard channel names in output order, ``channel_count`` entries.
|
||||
const char* const* channel_names = nullptr;
|
||||
// Ls/Rs/Lrs/Rrs and Ltf/Rtf/Ltr/Rtr/Ltm/Rtm, the labels the OAMD trim
|
||||
// configuration index counts.
|
||||
std::uint32_t surround_channels = 0;
|
||||
@@ -24,8 +29,8 @@ struct LayoutInfo {
|
||||
bool carries_trim = false;
|
||||
};
|
||||
|
||||
// All eleven layouts in the reference's order (2.0, 3.1, 4.0, 5.1, 7.1, 5.1.2,
|
||||
// 5.1.4, 7.1.2, 7.1.4, 9.1.4, 9.1.6).
|
||||
// All twelve layouts in the reference's order (2.0, 3.1, 4.0, 5.1, 7.1, 5.1.2,
|
||||
// 5.1.4, 7.1.2, 7.1.4, 9.1.4, 9.1.6, 6.0).
|
||||
bool layout_at(int index, LayoutInfo* out);
|
||||
|
||||
// False when the name is unknown (case-sensitive, as the reference CLI). "4.0"
|
||||
|
||||
@@ -39,7 +39,7 @@ struct LayoutGeometry {
|
||||
std::array<RegionGeometry, 7> regions{};
|
||||
};
|
||||
|
||||
inline constexpr std::array<LayoutGeometry, 11> kLayouts{{
|
||||
inline constexpr std::array<LayoutGeometry, 12> kLayouts{{
|
||||
LayoutGeometry{
|
||||
0x1u, 0, 2,
|
||||
{{0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
|
||||
@@ -159,9 +159,9 @@ inline constexpr std::array<LayoutGeometry, 11> kLayouts{{
|
||||
{{AxisGroup{}, AxisGroup{}, AxisGroup{}, AxisGroup{}}}
|
||||
},
|
||||
RegionGeometry{
|
||||
2, 1, 1, 0,
|
||||
{{SpeakerPoint{{0, 32767, 0}, 2}, SpeakerPoint{{32767, 32767, 0}, 3}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{AxisGroup{2, {0, 1, 0}}, AxisGroup{}, AxisGroup{}, AxisGroup{}}},
|
||||
4, 2, 2, 0,
|
||||
{{SpeakerPoint{{0, 0, 0}, 0}, SpeakerPoint{{32767, 0, 0}, 1}, SpeakerPoint{{0, 32767, 0}, 2}, SpeakerPoint{{32767, 32767, 0}, 3}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{AxisGroup{2, {0, 1, 0}}, AxisGroup{2, {2, 3, 0}}, AxisGroup{}, AxisGroup{}}},
|
||||
{{AxisGroup{}, AxisGroup{}, AxisGroup{}, AxisGroup{}}}
|
||||
},
|
||||
RegionGeometry{
|
||||
@@ -190,25 +190,25 @@ inline constexpr std::array<LayoutGeometry, 11> kLayouts{{
|
||||
{{
|
||||
RegionGeometry{
|
||||
5, 2, 2, 0,
|
||||
{{SpeakerPoint{{0, 0, 0}, 0}, SpeakerPoint{{32767, 0, 0}, 1}, SpeakerPoint{{16384, 0, 0}, 2}, SpeakerPoint{{0, 32767, 0}, 4}, SpeakerPoint{{32767, 32767, 0}, 5}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{SpeakerPoint{{0, 0, 0}, 0}, SpeakerPoint{{32767, 0, 0}, 1}, SpeakerPoint{{16384, 0, 0}, 2}, SpeakerPoint{{0, 16384, 0}, 4}, SpeakerPoint{{32767, 16384, 0}, 5}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{AxisGroup{3, {0, 2, 1}}, AxisGroup{2, {3, 4, 0}}, AxisGroup{}, AxisGroup{}}},
|
||||
{{AxisGroup{}, AxisGroup{}, AxisGroup{}, AxisGroup{}}}
|
||||
},
|
||||
RegionGeometry{
|
||||
5, 2, 2, 0,
|
||||
{{SpeakerPoint{{0, 0, 0}, 0}, SpeakerPoint{{32767, 0, 0}, 1}, SpeakerPoint{{16384, 0, 0}, 2}, SpeakerPoint{{0, 32767, 0}, 4}, SpeakerPoint{{32767, 32767, 0}, 5}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{SpeakerPoint{{0, 0, 0}, 0}, SpeakerPoint{{32767, 0, 0}, 1}, SpeakerPoint{{16384, 0, 0}, 2}, SpeakerPoint{{0, 16384, 0}, 4}, SpeakerPoint{{32767, 16384, 0}, 5}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{AxisGroup{3, {0, 2, 1}}, AxisGroup{2, {3, 4, 0}}, AxisGroup{}, AxisGroup{}}},
|
||||
{{AxisGroup{}, AxisGroup{}, AxisGroup{}, AxisGroup{}}}
|
||||
},
|
||||
RegionGeometry{
|
||||
5, 2, 2, 0,
|
||||
{{SpeakerPoint{{0, 0, 0}, 0}, SpeakerPoint{{32767, 0, 0}, 1}, SpeakerPoint{{16384, 0, 0}, 2}, SpeakerPoint{{0, 32767, 0}, 4}, SpeakerPoint{{32767, 32767, 0}, 5}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{SpeakerPoint{{0, 0, 0}, 0}, SpeakerPoint{{32767, 0, 0}, 1}, SpeakerPoint{{16384, 0, 0}, 2}, SpeakerPoint{{0, 16384, 0}, 4}, SpeakerPoint{{32767, 16384, 0}, 5}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{AxisGroup{3, {0, 2, 1}}, AxisGroup{2, {3, 4, 0}}, AxisGroup{}, AxisGroup{}}},
|
||||
{{AxisGroup{}, AxisGroup{}, AxisGroup{}, AxisGroup{}}}
|
||||
},
|
||||
RegionGeometry{
|
||||
3, 2, 2, 0,
|
||||
{{SpeakerPoint{{16384, 0, 0}, 2}, SpeakerPoint{{0, 32767, 0}, 4}, SpeakerPoint{{32767, 32767, 0}, 5}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{SpeakerPoint{{16384, 0, 0}, 2}, SpeakerPoint{{0, 16384, 0}, 4}, SpeakerPoint{{32767, 16384, 0}, 5}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{AxisGroup{1, {0, 0, 0}}, AxisGroup{2, {1, 2, 0}}, AxisGroup{}, AxisGroup{}}},
|
||||
{{AxisGroup{}, AxisGroup{}, AxisGroup{}, AxisGroup{}}}
|
||||
},
|
||||
@@ -220,7 +220,7 @@ inline constexpr std::array<LayoutGeometry, 11> kLayouts{{
|
||||
},
|
||||
RegionGeometry{
|
||||
2, 1, 1, 0,
|
||||
{{SpeakerPoint{{0, 32767, 0}, 4}, SpeakerPoint{{32767, 32767, 0}, 5}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{SpeakerPoint{{0, 16384, 0}, 4}, SpeakerPoint{{32767, 16384, 0}, 5}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{AxisGroup{2, {0, 1, 0}}, AxisGroup{}, AxisGroup{}, AxisGroup{}}},
|
||||
{{AxisGroup{}, AxisGroup{}, AxisGroup{}, AxisGroup{}}}
|
||||
},
|
||||
@@ -286,25 +286,25 @@ inline constexpr std::array<LayoutGeometry, 11> kLayouts{{
|
||||
{{
|
||||
RegionGeometry{
|
||||
7, 3, 2, 1,
|
||||
{{SpeakerPoint{{0, 0, 0}, 0}, SpeakerPoint{{32767, 0, 0}, 1}, SpeakerPoint{{16384, 0, 0}, 2}, SpeakerPoint{{0, 32767, 0}, 4}, SpeakerPoint{{32767, 32767, 0}, 5}, SpeakerPoint{{7928, 16384, 32767}, 6}, SpeakerPoint{{24840, 16384, 32767}, 7}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{SpeakerPoint{{0, 0, 0}, 0}, SpeakerPoint{{32767, 0, 0}, 1}, SpeakerPoint{{16384, 0, 0}, 2}, SpeakerPoint{{0, 16384, 0}, 4}, SpeakerPoint{{32767, 16384, 0}, 5}, SpeakerPoint{{7928, 16384, 32767}, 6}, SpeakerPoint{{24840, 16384, 32767}, 7}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{AxisGroup{3, {0, 2, 1}}, AxisGroup{2, {3, 4, 0}}, AxisGroup{}, AxisGroup{}}},
|
||||
{{AxisGroup{2, {5, 6, 0}}, AxisGroup{}, AxisGroup{}, AxisGroup{}}}
|
||||
},
|
||||
RegionGeometry{
|
||||
7, 3, 2, 1,
|
||||
{{SpeakerPoint{{0, 0, 0}, 0}, SpeakerPoint{{32767, 0, 0}, 1}, SpeakerPoint{{16384, 0, 0}, 2}, SpeakerPoint{{0, 32767, 0}, 4}, SpeakerPoint{{32767, 32767, 0}, 5}, SpeakerPoint{{7928, 16384, 32767}, 6}, SpeakerPoint{{24840, 16384, 32767}, 7}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{SpeakerPoint{{0, 0, 0}, 0}, SpeakerPoint{{32767, 0, 0}, 1}, SpeakerPoint{{16384, 0, 0}, 2}, SpeakerPoint{{0, 16384, 0}, 4}, SpeakerPoint{{32767, 16384, 0}, 5}, SpeakerPoint{{7928, 16384, 32767}, 6}, SpeakerPoint{{24840, 16384, 32767}, 7}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{AxisGroup{3, {0, 2, 1}}, AxisGroup{2, {3, 4, 0}}, AxisGroup{}, AxisGroup{}}},
|
||||
{{AxisGroup{2, {5, 6, 0}}, AxisGroup{}, AxisGroup{}, AxisGroup{}}}
|
||||
},
|
||||
RegionGeometry{
|
||||
7, 3, 2, 1,
|
||||
{{SpeakerPoint{{0, 0, 0}, 0}, SpeakerPoint{{32767, 0, 0}, 1}, SpeakerPoint{{16384, 0, 0}, 2}, SpeakerPoint{{0, 32767, 0}, 4}, SpeakerPoint{{32767, 32767, 0}, 5}, SpeakerPoint{{7928, 16384, 32767}, 6}, SpeakerPoint{{24840, 16384, 32767}, 7}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{SpeakerPoint{{0, 0, 0}, 0}, SpeakerPoint{{32767, 0, 0}, 1}, SpeakerPoint{{16384, 0, 0}, 2}, SpeakerPoint{{0, 16384, 0}, 4}, SpeakerPoint{{32767, 16384, 0}, 5}, SpeakerPoint{{7928, 16384, 32767}, 6}, SpeakerPoint{{24840, 16384, 32767}, 7}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{AxisGroup{3, {0, 2, 1}}, AxisGroup{2, {3, 4, 0}}, AxisGroup{}, AxisGroup{}}},
|
||||
{{AxisGroup{2, {5, 6, 0}}, AxisGroup{}, AxisGroup{}, AxisGroup{}}}
|
||||
},
|
||||
RegionGeometry{
|
||||
5, 3, 2, 1,
|
||||
{{SpeakerPoint{{16384, 0, 0}, 2}, SpeakerPoint{{0, 32767, 0}, 4}, SpeakerPoint{{32767, 32767, 0}, 5}, SpeakerPoint{{7928, 16384, 32767}, 6}, SpeakerPoint{{24840, 16384, 32767}, 7}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{SpeakerPoint{{16384, 0, 0}, 2}, SpeakerPoint{{0, 16384, 0}, 4}, SpeakerPoint{{32767, 16384, 0}, 5}, SpeakerPoint{{7928, 16384, 32767}, 6}, SpeakerPoint{{24840, 16384, 32767}, 7}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{AxisGroup{1, {0, 0, 0}}, AxisGroup{2, {1, 2, 0}}, AxisGroup{}, AxisGroup{}}},
|
||||
{{AxisGroup{2, {3, 4, 0}}, AxisGroup{}, AxisGroup{}, AxisGroup{}}}
|
||||
},
|
||||
@@ -316,7 +316,7 @@ inline constexpr std::array<LayoutGeometry, 11> kLayouts{{
|
||||
},
|
||||
RegionGeometry{
|
||||
4, 3, 1, 1,
|
||||
{{SpeakerPoint{{0, 32767, 0}, 4}, SpeakerPoint{{32767, 32767, 0}, 5}, SpeakerPoint{{7928, 16384, 32767}, 6}, SpeakerPoint{{24840, 16384, 32767}, 7}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{SpeakerPoint{{0, 16384, 0}, 4}, SpeakerPoint{{32767, 16384, 0}, 5}, SpeakerPoint{{7928, 16384, 32767}, 6}, SpeakerPoint{{24840, 16384, 32767}, 7}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{AxisGroup{2, {0, 1, 0}}, AxisGroup{}, AxisGroup{}, AxisGroup{}}},
|
||||
{{AxisGroup{2, {2, 3, 0}}, AxisGroup{}, AxisGroup{}, AxisGroup{}}}
|
||||
},
|
||||
@@ -334,25 +334,25 @@ inline constexpr std::array<LayoutGeometry, 11> kLayouts{{
|
||||
{{
|
||||
RegionGeometry{
|
||||
9, 3, 2, 2,
|
||||
{{SpeakerPoint{{0, 0, 0}, 0}, SpeakerPoint{{32767, 0, 0}, 1}, SpeakerPoint{{16384, 0, 0}, 2}, SpeakerPoint{{0, 32767, 0}, 4}, SpeakerPoint{{32767, 32767, 0}, 5}, SpeakerPoint{{7928, 7928, 32767}, 6}, SpeakerPoint{{24840, 7928, 32767}, 7}, SpeakerPoint{{7928, 24840, 32767}, 8}, SpeakerPoint{{24840, 24840, 32767}, 9}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{SpeakerPoint{{0, 0, 0}, 0}, SpeakerPoint{{32767, 0, 0}, 1}, SpeakerPoint{{16384, 0, 0}, 2}, SpeakerPoint{{0, 16384, 0}, 4}, SpeakerPoint{{32767, 16384, 0}, 5}, SpeakerPoint{{7928, 7928, 32767}, 6}, SpeakerPoint{{24840, 7928, 32767}, 7}, SpeakerPoint{{7928, 24840, 32767}, 8}, SpeakerPoint{{24840, 24840, 32767}, 9}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{AxisGroup{3, {0, 2, 1}}, AxisGroup{2, {3, 4, 0}}, AxisGroup{}, AxisGroup{}}},
|
||||
{{AxisGroup{2, {5, 6, 0}}, AxisGroup{2, {7, 8, 0}}, AxisGroup{}, AxisGroup{}}}
|
||||
},
|
||||
RegionGeometry{
|
||||
9, 3, 2, 2,
|
||||
{{SpeakerPoint{{0, 0, 0}, 0}, SpeakerPoint{{32767, 0, 0}, 1}, SpeakerPoint{{16384, 0, 0}, 2}, SpeakerPoint{{0, 32767, 0}, 4}, SpeakerPoint{{32767, 32767, 0}, 5}, SpeakerPoint{{7928, 7928, 32767}, 6}, SpeakerPoint{{24840, 7928, 32767}, 7}, SpeakerPoint{{7928, 24840, 32767}, 8}, SpeakerPoint{{24840, 24840, 32767}, 9}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{SpeakerPoint{{0, 0, 0}, 0}, SpeakerPoint{{32767, 0, 0}, 1}, SpeakerPoint{{16384, 0, 0}, 2}, SpeakerPoint{{0, 16384, 0}, 4}, SpeakerPoint{{32767, 16384, 0}, 5}, SpeakerPoint{{7928, 7928, 32767}, 6}, SpeakerPoint{{24840, 7928, 32767}, 7}, SpeakerPoint{{7928, 24840, 32767}, 8}, SpeakerPoint{{24840, 24840, 32767}, 9}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{AxisGroup{3, {0, 2, 1}}, AxisGroup{2, {3, 4, 0}}, AxisGroup{}, AxisGroup{}}},
|
||||
{{AxisGroup{2, {5, 6, 0}}, AxisGroup{2, {7, 8, 0}}, AxisGroup{}, AxisGroup{}}}
|
||||
},
|
||||
RegionGeometry{
|
||||
9, 3, 2, 2,
|
||||
{{SpeakerPoint{{0, 0, 0}, 0}, SpeakerPoint{{32767, 0, 0}, 1}, SpeakerPoint{{16384, 0, 0}, 2}, SpeakerPoint{{0, 32767, 0}, 4}, SpeakerPoint{{32767, 32767, 0}, 5}, SpeakerPoint{{7928, 7928, 32767}, 6}, SpeakerPoint{{24840, 7928, 32767}, 7}, SpeakerPoint{{7928, 24840, 32767}, 8}, SpeakerPoint{{24840, 24840, 32767}, 9}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{SpeakerPoint{{0, 0, 0}, 0}, SpeakerPoint{{32767, 0, 0}, 1}, SpeakerPoint{{16384, 0, 0}, 2}, SpeakerPoint{{0, 16384, 0}, 4}, SpeakerPoint{{32767, 16384, 0}, 5}, SpeakerPoint{{7928, 7928, 32767}, 6}, SpeakerPoint{{24840, 7928, 32767}, 7}, SpeakerPoint{{7928, 24840, 32767}, 8}, SpeakerPoint{{24840, 24840, 32767}, 9}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{AxisGroup{3, {0, 2, 1}}, AxisGroup{2, {3, 4, 0}}, AxisGroup{}, AxisGroup{}}},
|
||||
{{AxisGroup{2, {5, 6, 0}}, AxisGroup{2, {7, 8, 0}}, AxisGroup{}, AxisGroup{}}}
|
||||
},
|
||||
RegionGeometry{
|
||||
7, 3, 2, 2,
|
||||
{{SpeakerPoint{{16384, 0, 0}, 2}, SpeakerPoint{{0, 32767, 0}, 4}, SpeakerPoint{{32767, 32767, 0}, 5}, SpeakerPoint{{7928, 7928, 32767}, 6}, SpeakerPoint{{24840, 7928, 32767}, 7}, SpeakerPoint{{7928, 24840, 32767}, 8}, SpeakerPoint{{24840, 24840, 32767}, 9}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{SpeakerPoint{{16384, 0, 0}, 2}, SpeakerPoint{{0, 16384, 0}, 4}, SpeakerPoint{{32767, 16384, 0}, 5}, SpeakerPoint{{7928, 7928, 32767}, 6}, SpeakerPoint{{24840, 7928, 32767}, 7}, SpeakerPoint{{7928, 24840, 32767}, 8}, SpeakerPoint{{24840, 24840, 32767}, 9}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{AxisGroup{1, {0, 0, 0}}, AxisGroup{2, {1, 2, 0}}, AxisGroup{}, AxisGroup{}}},
|
||||
{{AxisGroup{2, {3, 4, 0}}, AxisGroup{2, {5, 6, 0}}, AxisGroup{}, AxisGroup{}}}
|
||||
},
|
||||
@@ -364,7 +364,7 @@ inline constexpr std::array<LayoutGeometry, 11> kLayouts{{
|
||||
},
|
||||
RegionGeometry{
|
||||
6, 3, 1, 2,
|
||||
{{SpeakerPoint{{0, 32767, 0}, 4}, SpeakerPoint{{32767, 32767, 0}, 5}, SpeakerPoint{{7928, 7928, 32767}, 6}, SpeakerPoint{{24840, 7928, 32767}, 7}, SpeakerPoint{{7928, 24840, 32767}, 8}, SpeakerPoint{{24840, 24840, 32767}, 9}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{SpeakerPoint{{0, 16384, 0}, 4}, SpeakerPoint{{32767, 16384, 0}, 5}, SpeakerPoint{{7928, 7928, 32767}, 6}, SpeakerPoint{{24840, 7928, 32767}, 7}, SpeakerPoint{{7928, 24840, 32767}, 8}, SpeakerPoint{{24840, 24840, 32767}, 9}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{AxisGroup{2, {0, 1, 0}}, AxisGroup{}, AxisGroup{}, AxisGroup{}}},
|
||||
{{AxisGroup{2, {2, 3, 0}}, AxisGroup{2, {4, 5, 0}}, AxisGroup{}, AxisGroup{}}}
|
||||
},
|
||||
@@ -567,7 +567,55 @@ inline constexpr std::array<LayoutGeometry, 11> kLayouts{{
|
||||
{{AxisGroup{2, {5, 6, 0}}, AxisGroup{}, AxisGroup{}, AxisGroup{}}}
|
||||
}
|
||||
}}
|
||||
},
|
||||
LayoutGeometry{
|
||||
0x19u, 0xFFu, 6,
|
||||
{{0, 1, 2, 3, 4, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
|
||||
{{
|
||||
RegionGeometry{
|
||||
6, 2, 3, 0,
|
||||
{{SpeakerPoint{{0, 0, 0}, 0}, SpeakerPoint{{32767, 0, 0}, 1}, SpeakerPoint{{0, 16384, 0}, 2}, SpeakerPoint{{32767, 16384, 0}, 3}, SpeakerPoint{{0, 32767, 0}, 4}, SpeakerPoint{{32767, 32767, 0}, 5}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{AxisGroup{2, {0, 1, 0}}, AxisGroup{2, {2, 3, 0}}, AxisGroup{2, {4, 5, 0}}, AxisGroup{}}},
|
||||
{{AxisGroup{}, AxisGroup{}, AxisGroup{}, AxisGroup{}}}
|
||||
},
|
||||
RegionGeometry{
|
||||
4, 2, 2, 0,
|
||||
{{SpeakerPoint{{0, 0, 0}, 0}, SpeakerPoint{{32767, 0, 0}, 1}, SpeakerPoint{{0, 16384, 0}, 2}, SpeakerPoint{{32767, 16384, 0}, 3}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{AxisGroup{2, {0, 1, 0}}, AxisGroup{2, {2, 3, 0}}, AxisGroup{}, AxisGroup{}}},
|
||||
{{AxisGroup{}, AxisGroup{}, AxisGroup{}, AxisGroup{}}}
|
||||
},
|
||||
RegionGeometry{
|
||||
4, 2, 2, 0,
|
||||
{{SpeakerPoint{{0, 0, 0}, 0}, SpeakerPoint{{32767, 0, 0}, 1}, SpeakerPoint{{0, 32767, 0}, 4}, SpeakerPoint{{32767, 32767, 0}, 5}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{AxisGroup{2, {0, 1, 0}}, AxisGroup{2, {2, 3, 0}}, AxisGroup{}, AxisGroup{}}},
|
||||
{{AxisGroup{}, AxisGroup{}, AxisGroup{}, AxisGroup{}}}
|
||||
},
|
||||
RegionGeometry{
|
||||
2, 2, 1, 0,
|
||||
{{SpeakerPoint{{0, 32767, 0}, 4}, SpeakerPoint{{32767, 32767, 0}, 5}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{AxisGroup{2, {0, 1, 0}}, AxisGroup{}, AxisGroup{}, AxisGroup{}}},
|
||||
{{AxisGroup{}, AxisGroup{}, AxisGroup{}, AxisGroup{}}}
|
||||
},
|
||||
RegionGeometry{
|
||||
2, 1, 1, 0,
|
||||
{{SpeakerPoint{{0, 0, 0}, 0}, SpeakerPoint{{32767, 0, 0}, 1}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{AxisGroup{2, {0, 1, 0}}, AxisGroup{}, AxisGroup{}, AxisGroup{}}},
|
||||
{{AxisGroup{}, AxisGroup{}, AxisGroup{}, AxisGroup{}}}
|
||||
},
|
||||
RegionGeometry{
|
||||
4, 2, 2, 0,
|
||||
{{SpeakerPoint{{0, 16384, 0}, 2}, SpeakerPoint{{32767, 16384, 0}, 3}, SpeakerPoint{{0, 32767, 0}, 4}, SpeakerPoint{{32767, 32767, 0}, 5}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{AxisGroup{2, {0, 1, 0}}, AxisGroup{2, {2, 3, 0}}, AxisGroup{}, AxisGroup{}}},
|
||||
{{AxisGroup{}, AxisGroup{}, AxisGroup{}, AxisGroup{}}}
|
||||
},
|
||||
RegionGeometry{
|
||||
2, 1, 1, 0,
|
||||
{{SpeakerPoint{{0, 0, 0}, 0}, SpeakerPoint{{32767, 0, 0}, 1}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}, SpeakerPoint{}}},
|
||||
{{AxisGroup{2, {0, 1, 0}}, AxisGroup{}, AxisGroup{}, AxisGroup{}}},
|
||||
{{AxisGroup{}, AxisGroup{}, AxisGroup{}, AxisGroup{}}}
|
||||
}
|
||||
}}
|
||||
},
|
||||
}};
|
||||
|
||||
inline constexpr const LayoutGeometry* find_layout(const std::uint32_t speaker_bitfield) noexcept {
|
||||
|
||||
@@ -0,0 +1,90 @@
|
||||
// Port of the metadata application path of src/speaker_renderer.py HEAD.
|
||||
//
|
||||
// The metadata path consumes the full per-object per-block OAMD frame state and
|
||||
// schedules block targets frame by frame: object gain/inactive, zone/elevation,
|
||||
// snap, divergence, size kernel fusion, priority size budget, ISF basis rows and
|
||||
// bed channel distribution, with the same float64 gain ramps and block alignment
|
||||
// as the reference renderer.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
|
||||
#include "eac3joc_core.h"
|
||||
#include "foundation/status.h"
|
||||
#include "oamd/oamd_parser.h"
|
||||
#include "speaker/speaker_layout_lookup.h"
|
||||
#include "speaker/speaker_trim.h"
|
||||
|
||||
namespace joc::speaker {
|
||||
|
||||
// One metadata target matrix: object_count x layout channel_count in the
|
||||
// renderer's internal channel order, before the ramp/timing stage.
|
||||
struct MetadataTargets {
|
||||
std::uint32_t object_count = 0;
|
||||
std::uint32_t channel_count = 0;
|
||||
std::vector<double> values; // object major
|
||||
|
||||
double at(std::uint32_t object, std::uint32_t channel) const {
|
||||
return values[static_cast<std::size_t>(object) * channel_count + channel];
|
||||
}
|
||||
};
|
||||
|
||||
// Computes the metadata target matrix of one block of a parsed frame without
|
||||
// touching renderer state: the reference's _init_meta validation plus
|
||||
// _block_targets. ``trim`` carries the current programme trim (bypass flags),
|
||||
// ``controls`` the derived per-layout controls, ``size_budget`` the priority
|
||||
// budget (0 means unlimited, the production value).
|
||||
Status metadata_block_targets(const LayoutInfo& layout, const oamd::OamdUpdate& update,
|
||||
std::uint32_t block_index,
|
||||
const ejoc_speaker_controls& controls,
|
||||
const oamd::OamdTrim* trim, std::uint32_t size_budget,
|
||||
MetadataTargets* out);
|
||||
|
||||
// Stateful metadata-path renderer. It owns the object target ramps and the
|
||||
// cross-block pending schedule; the legacy point-renderer state stays in the
|
||||
// C ABI renderer, which is used for the blocks of a frame that precede the first
|
||||
// metadata targets (the reference renders those with its legacy block path).
|
||||
class MetaRenderer {
|
||||
public:
|
||||
MetaRenderer();
|
||||
~MetaRenderer();
|
||||
MetaRenderer(MetaRenderer&&) noexcept;
|
||||
MetaRenderer& operator=(MetaRenderer&&) noexcept;
|
||||
MetaRenderer(const MetaRenderer&) = delete;
|
||||
MetaRenderer& operator=(const MetaRenderer&) = delete;
|
||||
|
||||
// Binds the target layout. Must be called once before process_frame().
|
||||
Status configure(const LayoutInfo& layout);
|
||||
|
||||
// Drops the ramp, schedule and metadata state (the layout stays bound).
|
||||
Status reset();
|
||||
|
||||
bool configured() const;
|
||||
// True once a metadata frame has been accepted (the reference's _meta_mode).
|
||||
bool engaged() const;
|
||||
|
||||
const char* last_error() const;
|
||||
|
||||
Status process_frame(ejoc_speaker_renderer_handle legacy,
|
||||
const float* objects16_interleaved, std::uint32_t sample_count,
|
||||
const oamd::OamdUpdate* update, std::uint32_t metadata_offset,
|
||||
const ejoc_speaker_controls& controls, const oamd::OamdTrim* trim,
|
||||
std::uint32_t raw_trim_mode, std::uint32_t size_budget,
|
||||
double* output_interleaved);
|
||||
|
||||
// Computes the target matrix of one block of ``update`` into ``out`` using a
|
||||
// scratch context; unlike metadata_block_targets() this validates through
|
||||
// the renderer's own state-independent path.
|
||||
Status block_targets(const oamd::OamdUpdate& update, std::uint32_t block_index,
|
||||
const ejoc_speaker_controls& controls, const oamd::OamdTrim* trim,
|
||||
std::uint32_t size_budget, MetadataTargets* out) const;
|
||||
|
||||
private:
|
||||
struct Impl;
|
||||
std::unique_ptr<Impl> impl_;
|
||||
};
|
||||
|
||||
} // namespace joc::speaker
|
||||
File diff suppressed because it is too large.
Load diff
@@ -37,18 +37,52 @@ Status step(SpeakerStep* context, const std::vector<float>& objects16_planar,
|
||||
}
|
||||
context->controls_ready = true;
|
||||
}
|
||||
std::uint32_t ramp = 0;
|
||||
if (update != nullptr) {
|
||||
if (update->has_trim) {
|
||||
const Status status = parameters_from_oamd(&update->trim, context->layout,
|
||||
&context->controls);
|
||||
if (update != nullptr && update->has_trim) {
|
||||
const Status status =
|
||||
parameters_from_oamd(&update->trim, context->layout, &context->controls);
|
||||
if (!status.ok()) {
|
||||
if (error != nullptr) {
|
||||
*error = status.message();
|
||||
}
|
||||
return status;
|
||||
}
|
||||
context->trim = update->trim;
|
||||
context->has_trim = true;
|
||||
context->raw_trim_mode = update->trim.global_trim_mode;
|
||||
}
|
||||
|
||||
const bool metadata_frame =
|
||||
update != nullptr && update->has_frame_state &&
|
||||
update->frame_state.object_count != 0u;
|
||||
if (metadata_frame || context->meta_engaged) {
|
||||
if (!context->meta_configured) {
|
||||
const Status configured = context->meta.configure(context->layout);
|
||||
if (!configured.ok()) {
|
||||
if (error != nullptr) {
|
||||
*error = configured.message();
|
||||
}
|
||||
return configured;
|
||||
}
|
||||
context->meta_configured = true;
|
||||
}
|
||||
const oamd::OamdTrim* trim = context->has_trim ? &context->trim : nullptr;
|
||||
const Status processed = context->meta.process_frame(
|
||||
context->handle, context->interleaved.data(), JOC_FRAME_SAMPLES,
|
||||
metadata_frame ? update : nullptr, context->metadata_offset,
|
||||
context->controls, trim, context->raw_trim_mode, 0u,
|
||||
context->output.data());
|
||||
if (!processed.ok()) {
|
||||
if (error != nullptr) {
|
||||
*error = processed.message();
|
||||
}
|
||||
return processed;
|
||||
}
|
||||
context->meta_engaged = context->meta.engaged();
|
||||
return Status::success();
|
||||
}
|
||||
|
||||
std::uint32_t ramp = 0;
|
||||
if (update != nullptr) {
|
||||
context->state.apply(*update);
|
||||
ramp = update->ramp_duration_samples;
|
||||
context->last_block_offset = update->block_offset_samples;
|
||||
|
||||
@@ -9,6 +9,7 @@
|
||||
#include "foundation/status.h"
|
||||
#include "oamd/oamd_parser.h"
|
||||
#include "speaker/speaker_layout_lookup.h"
|
||||
#include "speaker/speaker_meta.h"
|
||||
#include "speaker/speaker_trim.h"
|
||||
|
||||
namespace joc::speaker {
|
||||
@@ -32,6 +33,16 @@ struct SpeakerStep {
|
||||
// 对象槽 → Q15 方位;bed_override 为 false 的槽仍按 OAMD 坐标声像。
|
||||
std::uint16_t bed_positions[oamd::kObjects][oamd::kAxes] = {};
|
||||
bool bed_override[oamd::kObjects] = {};
|
||||
// Metadata path: a frame that carries the full per-object block state
|
||||
// switches the speaker output to the metadata renderer. The programme trim
|
||||
// element and its raw global mode stay here because the metadata path needs
|
||||
// the per-object bypass flags and the ISF compensation mode.
|
||||
MetaRenderer meta;
|
||||
bool meta_configured = false;
|
||||
bool meta_engaged = false;
|
||||
oamd::OamdTrim trim{};
|
||||
bool has_trim = false;
|
||||
std::uint32_t raw_trim_mode = 0;
|
||||
};
|
||||
|
||||
Status step(SpeakerStep* context, const std::vector<float>& objects16_planar,
|
||||
|
||||
@@ -343,7 +343,14 @@ Status Stream::push_eac3(const std::uint8_t* data, std::size_t size, std::size_t
|
||||
if (!extracted.ok()) {
|
||||
return extracted;
|
||||
}
|
||||
const Status oamd = oamd::parse_id11(bytes.data(), bytes.size(), &pending_frame_.update);
|
||||
// Speaker and binaural consume the full per-object block state; the
|
||||
// other stream paths keep the reference's legacy single-block view.
|
||||
const bool full_metadata_state = speaker_enabled_ || binaural_enabled_;
|
||||
const Status oamd =
|
||||
full_metadata_state ? oamd::parse_id11_state(bytes.data(), bytes.size(),
|
||||
&pending_frame_.update)
|
||||
: oamd::parse_id11(bytes.data(), bytes.size(),
|
||||
&pending_frame_.update);
|
||||
if (!oamd.ok()) {
|
||||
return oamd;
|
||||
}
|
||||
@@ -536,8 +543,10 @@ Status Stream::process_ready_frames(bool drain_all) {
|
||||
compact_bed_pending();
|
||||
|
||||
std::string error;
|
||||
const Status rebuilt = joc::rebuild_objects16(rebuilder_, entry.params, bed5_.data(),
|
||||
lfe_.data(), gain_, &objects16_, &error);
|
||||
const Status rebuilt = joc::rebuild_objects16(
|
||||
rebuilder_, entry.params, bed5_.data(), lfe_.data(),
|
||||
static_cast<std::uint32_t>(core_channels), entry.has_joc, gain_, &objects16_,
|
||||
&error);
|
||||
if (!rebuilt.ok()) {
|
||||
return Status::fail(rebuilt.code(), stage::kDsp, error);
|
||||
}
|
||||
|
||||
@@ -348,7 +348,7 @@ Status probe_atmos_trim(const std::string& path, std::uint64_t max_frames,
|
||||
continue;
|
||||
}
|
||||
oamd::OamdUpdate update;
|
||||
if (!oamd::parse_id11(bytes.data(), bytes.size(), &update).ok() ||
|
||||
if (!oamd::parse_id11_state(bytes.data(), bytes.size(), &update).ok() ||
|
||||
!update.has_trim) {
|
||||
continue;
|
||||
}
|
||||
@@ -1429,6 +1429,11 @@ Status run(const joc_task_config& raw, const joc_event_sink* sink, joc_task_resu
|
||||
return finalize_with_error(seeded.code(), "render", seeded.message());
|
||||
}
|
||||
speaker.controls_ready = true;
|
||||
// The metadata path needs the programme trim before its own event
|
||||
// arrives; the probe above read it from the leading frames.
|
||||
speaker.trim = initial_trim;
|
||||
speaker.has_trim = true;
|
||||
speaker.raw_trim_mode = initial_trim.global_trim_mode;
|
||||
}
|
||||
bus.emit(JOC_EV_RENDERER_INITIALIZED, JOC_STAGE_RENDER, JOC_LOG_INFO,
|
||||
fmt("speaker renderer: %s, %u channels", speaker.layout.name,
|
||||
@@ -1590,6 +1595,9 @@ Status run(const joc_task_config& raw, const joc_event_sink* sink, joc_task_resu
|
||||
// container that is not this frame's JOC metadata.
|
||||
std::uint64_t missing_joc_frames = 0;
|
||||
std::uint64_t objects_clamped_frames = 0;
|
||||
std::uint64_t bad_parameter_band_frames = 0;
|
||||
std::uint64_t bad_offset_ts_frames = 0;
|
||||
std::uint64_t trailing_data_frames = 0;
|
||||
std::uint64_t extra_container_frames = 0;
|
||||
std::uint64_t chanmap_pair_mismatch_frames = 0;
|
||||
std::uint64_t bed_mask_mismatch_frames = 0;
|
||||
@@ -1660,6 +1668,19 @@ Status run(const joc_task_config& raw, const joc_event_sink* sink, joc_task_resu
|
||||
if (params.objects_clamped != 0u) {
|
||||
++objects_clamped_frames;
|
||||
}
|
||||
switch (params.status) {
|
||||
case JOC_FRAME_STATUS_BAD_PARAMETER_BAND:
|
||||
++bad_parameter_band_frames;
|
||||
break;
|
||||
case JOC_FRAME_STATUS_BAD_OFFSET_TS:
|
||||
++bad_offset_ts_frames;
|
||||
break;
|
||||
case JOC_FRAME_STATUS_TRAILING_DATA:
|
||||
++trailing_data_frames;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
++missing_joc_frames;
|
||||
}
|
||||
@@ -1691,8 +1712,9 @@ Status run(const joc_task_config& raw, const joc_event_sink* sink, joc_task_resu
|
||||
}
|
||||
std::string dsp_error;
|
||||
const Status rebuilt = ::joc::joc::rebuild_objects16(
|
||||
rebuilder, params, bed5.data(), lfe.data(), gain, &objects16,
|
||||
&dsp_error);
|
||||
rebuilder, params, bed5.data(), lfe.data(),
|
||||
static_cast<std::uint32_t>(resolved_core_channels), has_joc, gain,
|
||||
&objects16, &dsp_error);
|
||||
if (!rebuilt.ok()) {
|
||||
return Status::fail(rebuilt.code(), "joc", dsp_error);
|
||||
}
|
||||
@@ -1819,8 +1841,16 @@ Status run(const joc_task_config& raw, const joc_event_sink* sink, joc_task_resu
|
||||
stream_done = true;
|
||||
break;
|
||||
}
|
||||
// The speaker and binaural renderers consume the full per-object
|
||||
// block state (multi-block and every declared object); the ADM
|
||||
// export path keeps the reference's 15-track single-block view.
|
||||
const bool full_metadata_state = speaker_enabled || binaural_enabled;
|
||||
const Status oamd =
|
||||
::joc::oamd::parse_id11(bytes.data(), bytes.size(), &job.update);
|
||||
full_metadata_state
|
||||
? ::joc::oamd::parse_id11_state(bytes.data(), bytes.size(),
|
||||
&job.update)
|
||||
: ::joc::oamd::parse_id11(bytes.data(), bytes.size(),
|
||||
&job.update);
|
||||
if (!oamd.ok()) {
|
||||
failures.record(produced, StageRank::kJoc, oamd.code(), oamd.stage(),
|
||||
"frame " + std::to_string(produced) + ": " +
|
||||
@@ -2166,11 +2196,28 @@ Status run(const joc_task_config& raw, const joc_event_sink* sink, joc_task_resu
|
||||
joiner.shutdown(false);
|
||||
if (missing_joc_frames != 0u) {
|
||||
bus.warning(std::to_string(missing_joc_frames) +
|
||||
" audio frame(s) carried no JOC payload; their object channels stay silent");
|
||||
" audio frame(s) carried no JOC payload; their core PCM was passed "
|
||||
"through (8 core planes, 1217-sample delay)");
|
||||
}
|
||||
if (objects_clamped_frames != 0u) {
|
||||
bus.warning(std::to_string(objects_clamped_frames) +
|
||||
" audio frame(s) declared more than 15 objects; the count was clamped to 15");
|
||||
" audio frame(s) declared more than 15 objects; the count was clamped "
|
||||
"to 15 and the frame took the invalid-frame path");
|
||||
}
|
||||
if (bad_parameter_band_frames != 0u) {
|
||||
bus.warning(std::to_string(bad_parameter_band_frames) +
|
||||
" audio frame(s) declared an unknown JOC parameter-band count; the "
|
||||
"frame took the invalid-frame path");
|
||||
}
|
||||
if (bad_offset_ts_frames != 0u) {
|
||||
bus.warning(std::to_string(bad_offset_ts_frames) +
|
||||
" audio frame(s) carried an invalid JOC offset_ts value; the frame "
|
||||
"took the invalid-frame path");
|
||||
}
|
||||
if (trailing_data_frames != 0u) {
|
||||
bus.warning(std::to_string(trailing_data_frames) +
|
||||
" audio frame(s) carried JOC data after the byte-alignment padding; "
|
||||
"the frame took the invalid-frame path");
|
||||
}
|
||||
if (extra_container_frames != 0u) {
|
||||
bus.warning(std::to_string(extra_container_frames) +
|
||||
|
||||
@@ -95,37 +95,100 @@ Status ObjectPositionTrack::position_at(std::int64_t sample, double out[3]) {
|
||||
return Status::success();
|
||||
}
|
||||
|
||||
OamdPositionTimeline::OamdPositionTimeline(int object_count) : object_count_(object_count) {
|
||||
if (object_count != kTimelineObjects) {
|
||||
object_count_ = kTimelineObjects;
|
||||
OamdPositionTimeline::OamdPositionTimeline(int object_count)
|
||||
: object_count_(std::clamp(object_count, 1, oamd::kMaxObjects - 1)) {
|
||||
const std::size_t count = static_cast<std::size_t>(object_count_);
|
||||
tracks_.resize(count);
|
||||
previous_targets_.resize(count);
|
||||
has_previous_.assign(count, false);
|
||||
fixed_.assign(count, false);
|
||||
fixed_xyz_.resize(count);
|
||||
}
|
||||
|
||||
void OamdPositionTimeline::ensure_tracks(int count) {
|
||||
const int capped = std::clamp(count, 1, oamd::kMaxObjects - 1);
|
||||
if (capped <= object_count_) {
|
||||
return;
|
||||
}
|
||||
const std::size_t size = static_cast<std::size_t>(capped);
|
||||
object_count_ = capped;
|
||||
tracks_.resize(size);
|
||||
previous_targets_.resize(size);
|
||||
has_previous_.resize(size, false);
|
||||
fixed_.resize(size, false);
|
||||
fixed_xyz_.resize(size);
|
||||
}
|
||||
|
||||
void OamdPositionTimeline::set_fixed_position(int object_index, const double position[3]) {
|
||||
if (object_index < 1 || object_index > object_count_) {
|
||||
return;
|
||||
}
|
||||
const std::size_t index = static_cast<std::size_t>(object_index - 1);
|
||||
fixed_[index] = true;
|
||||
for (int axis = 0; axis < 3; ++axis) {
|
||||
fixed_xyz_[index][static_cast<std::size_t>(axis)] = position[axis];
|
||||
}
|
||||
}
|
||||
|
||||
Status OamdPositionTimeline::submit_update(const oamd::OamdUpdate& update,
|
||||
std::int64_t frame_start_sample,
|
||||
std::int64_t outer_sample_offset,
|
||||
std::int64_t object_delay_samples,
|
||||
std::int64_t processed_sample) {
|
||||
if (frame_start_sample < 0 || outer_sample_offset < 0 || object_delay_samples < 0) {
|
||||
return Status::fail(JOC_ERR_INVALID_ARGUMENT, stage::kOamd,
|
||||
"OAMD frame, outer offset and object delay must be non-negative");
|
||||
void OamdPositionTimeline::reset() {
|
||||
state_.reset();
|
||||
for (int index = 0; index < object_count_; ++index) {
|
||||
tracks_[static_cast<std::size_t>(index)] = ObjectPositionTrack();
|
||||
has_previous_[static_cast<std::size_t>(index)] = false;
|
||||
previous_targets_[static_cast<std::size_t>(index)] = {0.0, 0.0, 0.0};
|
||||
}
|
||||
state_.apply(update);
|
||||
initialized_ = false;
|
||||
payload_count_ = 0;
|
||||
transition_count_ = 0;
|
||||
last_coded_event_sample_ = -1;
|
||||
}
|
||||
|
||||
double targets[kTimelineObjects][3] = {};
|
||||
for (int index = 0; index < kTimelineObjects; ++index) {
|
||||
if (fixed_[index]) {
|
||||
std::memcpy(targets[index], fixed_xyz_[index], sizeof(targets[index]));
|
||||
void OamdPositionTimeline::apply_block(const oamd::FrameState& state,
|
||||
std::uint32_t block_index) {
|
||||
// Track i reads OAMD object i + 1: object 0 is the LFE/bed slot the JOC
|
||||
// renderers do not position. Bed and ISF objects carry no position field,
|
||||
// and an inactive block keeps the previous position, exactly like the
|
||||
// reference frame_update() value construction.
|
||||
for (int track = 0; track < object_count_; ++track) {
|
||||
const int object_index = track + 1;
|
||||
if (object_index >= static_cast<int>(state.objects.size())) {
|
||||
break;
|
||||
}
|
||||
const oamd::ObjectElementState& element =
|
||||
state.objects[static_cast<std::size_t>(object_index)];
|
||||
if (block_index >= element.blocks.size()) {
|
||||
continue;
|
||||
}
|
||||
geometry::q_to_adm_xyz(state_.q(index + 1, 0), state_.q(index + 1, 1),
|
||||
state_.q(index + 1, 2), &targets[index][0], &targets[index][1],
|
||||
&targets[index][2]);
|
||||
const oamd::ObjectRenderState& render =
|
||||
element.blocks[static_cast<std::size_t>(block_index)].render;
|
||||
if (render.not_active || element.kind != oamd::ObjectKind::kDynamic) {
|
||||
continue;
|
||||
}
|
||||
state_.apply_render_state(object_index, render);
|
||||
}
|
||||
}
|
||||
|
||||
const std::int64_t coded_event =
|
||||
frame_start_sample + outer_sample_offset +
|
||||
static_cast<std::int64_t>(update.block_offset_samples);
|
||||
void OamdPositionTimeline::targets(std::vector<std::array<double, 3>>* out) const {
|
||||
out->resize(static_cast<std::size_t>(object_count_));
|
||||
for (int index = 0; index < object_count_; ++index) {
|
||||
const std::size_t slot = static_cast<std::size_t>(index);
|
||||
if (fixed_[slot]) {
|
||||
(*out)[slot] = fixed_xyz_[slot];
|
||||
continue;
|
||||
}
|
||||
double x = 0.0;
|
||||
double y = 0.0;
|
||||
double z = 0.0;
|
||||
geometry::q_to_adm_xyz(state_.q(index + 1, 0), state_.q(index + 1, 1),
|
||||
state_.q(index + 1, 2), &x, &y, &z);
|
||||
(*out)[slot] = {x, y, z};
|
||||
}
|
||||
}
|
||||
|
||||
Status OamdPositionTimeline::schedule(const std::vector<std::array<double, 3>>& targets,
|
||||
std::int64_t coded_event, std::int64_t ramp_samples,
|
||||
std::int64_t object_delay_samples,
|
||||
std::int64_t processed_sample) {
|
||||
if (coded_event < last_coded_event_sample_) {
|
||||
return timeline_fail(JOC_ERR_OAMD_UNSUPPORTED_VARIANT,
|
||||
"non_monotonic_binaural_updates: event sample " +
|
||||
@@ -141,44 +204,105 @@ Status OamdPositionTimeline::submit_update(const oamd::OamdUpdate& update,
|
||||
"sample " + std::to_string(processed_sample) +
|
||||
" had been processed, so sample 0 cannot be backfilled");
|
||||
}
|
||||
for (int index = 0; index < kTimelineObjects; ++index) {
|
||||
tracks_[index].set_initial(targets[index]);
|
||||
std::memcpy(previous_targets_[index], targets[index], sizeof(targets[index]));
|
||||
has_previous_[index] = true;
|
||||
for (int index = 0; index < object_count_; ++index) {
|
||||
const std::size_t slot = static_cast<std::size_t>(index);
|
||||
tracks_[slot].set_initial(targets[slot].data());
|
||||
previous_targets_[slot] = targets[slot];
|
||||
has_previous_[slot] = true;
|
||||
}
|
||||
initialized_ = true;
|
||||
++payload_count_;
|
||||
return Status::success();
|
||||
}
|
||||
|
||||
const std::int64_t effective_ramp =
|
||||
std::max<std::int64_t>(0, static_cast<std::int64_t>(update.ramp_duration_samples));
|
||||
const std::int64_t effective_ramp = std::max<std::int64_t>(0, ramp_samples);
|
||||
const std::int64_t transition_start =
|
||||
timing::align_metadata_sample(coded_event + object_delay_samples);
|
||||
for (int index = 0; index < kTimelineObjects; ++index) {
|
||||
const bool changed = !has_previous_[index] ||
|
||||
std::memcmp(previous_targets_[index], targets[index],
|
||||
sizeof(targets[index])) != 0;
|
||||
for (int index = 0; index < object_count_; ++index) {
|
||||
const std::size_t slot = static_cast<std::size_t>(index);
|
||||
const bool changed =
|
||||
!has_previous_[slot] ||
|
||||
std::memcmp(previous_targets_[slot].data(), targets[slot].data(),
|
||||
sizeof(targets[slot])) != 0;
|
||||
if (!changed) {
|
||||
continue;
|
||||
}
|
||||
const Status status = tracks_[index].append(transition_start, effective_ramp,
|
||||
targets[index], index + 1);
|
||||
const Status status =
|
||||
tracks_[slot].append(transition_start, effective_ramp, targets[slot].data(),
|
||||
index + 1);
|
||||
if (!status.ok()) {
|
||||
return status;
|
||||
}
|
||||
std::memcpy(previous_targets_[index], targets[index], sizeof(targets[index]));
|
||||
has_previous_[index] = true;
|
||||
previous_targets_[slot] = targets[slot];
|
||||
has_previous_[slot] = true;
|
||||
++transition_count_;
|
||||
}
|
||||
return Status::success();
|
||||
}
|
||||
|
||||
Status OamdPositionTimeline::submit_update(const oamd::OamdUpdate& update,
|
||||
std::int64_t frame_start_sample,
|
||||
std::int64_t outer_sample_offset,
|
||||
std::int64_t object_delay_samples,
|
||||
std::int64_t processed_sample) {
|
||||
if (frame_start_sample < 0 || outer_sample_offset < 0 || object_delay_samples < 0) {
|
||||
return Status::fail(JOC_ERR_INVALID_ARGUMENT, stage::kOamd,
|
||||
"OAMD frame, outer offset and object delay must be non-negative");
|
||||
}
|
||||
if (!update.has_frame_state) {
|
||||
state_.apply(update);
|
||||
targets(&targets_);
|
||||
const std::int64_t coded_event =
|
||||
frame_start_sample + outer_sample_offset +
|
||||
static_cast<std::int64_t>(update.block_offset_samples);
|
||||
const Status status =
|
||||
schedule(targets_, coded_event, update.ramp_duration_samples, object_delay_samples,
|
||||
processed_sample);
|
||||
if (status.ok()) {
|
||||
++payload_count_;
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
const oamd::FrameState& state = update.frame_state;
|
||||
ensure_tracks(state.object_count > 0u ? static_cast<int>(state.object_count) - 1 : 0);
|
||||
const std::uint32_t block_count =
|
||||
state.blocks.empty() ? 1u : static_cast<std::uint32_t>(state.blocks.size());
|
||||
for (std::uint32_t block = 0; block < block_count; ++block) {
|
||||
apply_block(state, block);
|
||||
targets(&targets_);
|
||||
std::int64_t block_offset = 0;
|
||||
std::int64_t ramp_samples = 0;
|
||||
if (block < state.blocks.size()) {
|
||||
block_offset = static_cast<std::int64_t>(state.blocks[block].block_offset_samples);
|
||||
ramp_samples = static_cast<std::int64_t>(state.blocks[block].ramp_duration_samples);
|
||||
}
|
||||
const std::int64_t coded_event =
|
||||
frame_start_sample + outer_sample_offset + block_offset;
|
||||
const Status status = schedule(targets_, coded_event, ramp_samples,
|
||||
object_delay_samples, processed_sample);
|
||||
if (!status.ok()) {
|
||||
return status;
|
||||
}
|
||||
}
|
||||
++payload_count_;
|
||||
return Status::success();
|
||||
}
|
||||
|
||||
Status OamdPositionTimeline::positions_at(std::int64_t sample,
|
||||
double positions[kTimelineObjects][3]) {
|
||||
for (int index = 0; index < kTimelineObjects; ++index) {
|
||||
const Status status = tracks_[index].position_at(sample, positions[index]);
|
||||
Status OamdPositionTimeline::positions_at(std::int64_t sample, double* positions,
|
||||
int count) {
|
||||
if (positions == nullptr || count < 0) {
|
||||
return Status::fail(JOC_ERR_INVALID_ARGUMENT, stage::kOamd,
|
||||
"binaural positions need a non-negative count and a buffer");
|
||||
}
|
||||
if (count > object_count_) {
|
||||
return Status::fail(JOC_ERR_INVALID_ARGUMENT, stage::kOamd,
|
||||
"binaural positions requested " + std::to_string(count) +
|
||||
" objects but the timeline tracks " +
|
||||
std::to_string(object_count_));
|
||||
}
|
||||
for (int index = 0; index < count; ++index) {
|
||||
const Status status = tracks_[static_cast<std::size_t>(index)].position_at(
|
||||
sample, positions + static_cast<std::size_t>(index) * 3u);
|
||||
if (!status.ok()) {
|
||||
return status;
|
||||
}
|
||||
|
||||
@@ -2,6 +2,7 @@
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <array>
|
||||
#include <cstdint>
|
||||
#include <vector>
|
||||
|
||||
@@ -10,6 +11,11 @@
|
||||
|
||||
namespace joc::timeline {
|
||||
|
||||
// The JOC binaural renderers carry one LFE plus fifteen object sources, but the
|
||||
// timeline is not tied to that product: it keeps one track per declared OAMD
|
||||
// object (bounded only by oamd::kMaxObjects) and the renderer reads as many as
|
||||
// its source layout consumes. A binaural output with a different source count
|
||||
// (for example one fed by a TrueHD decode) can ask for more tracks.
|
||||
inline constexpr int kTimelineObjects = 15;
|
||||
|
||||
struct PositionTransition {
|
||||
@@ -42,56 +48,53 @@ class OamdPositionTimeline {
|
||||
public:
|
||||
explicit OamdPositionTimeline(int object_count = kTimelineObjects);
|
||||
|
||||
// Schedules one OAMD payload. A payload parsed by parse_id11_state() carries
|
||||
// the full frame state: every position block is applied at its own offset and
|
||||
// ramp, and the track list grows to cover every declared object. The legacy
|
||||
// single-block slot view is still accepted for direct callers.
|
||||
Status submit_update(const oamd::OamdUpdate& update, std::int64_t frame_start_sample,
|
||||
std::int64_t outer_sample_offset, std::int64_t object_delay_samples,
|
||||
std::int64_t processed_sample);
|
||||
|
||||
// positions[15][3]; queries must be monotonically increasing.
|
||||
Status positions_at(std::int64_t sample, double positions[kTimelineObjects][3]);
|
||||
// positions[count][3]; queries must be monotonically increasing.
|
||||
Status positions_at(std::int64_t sample, double* positions, int count);
|
||||
|
||||
// bed 声道是固定通道:OAMD 不给位置,方位由声明的 bed 布局给出。
|
||||
void set_fixed_position(int object_index, const double position[3]) {
|
||||
if (object_index < 1 || object_index > kTimelineObjects) {
|
||||
return;
|
||||
}
|
||||
fixed_[object_index - 1] = true;
|
||||
fixed_xyz_[object_index - 1][0] = position[0];
|
||||
fixed_xyz_[object_index - 1][1] = position[1];
|
||||
fixed_xyz_[object_index - 1][2] = position[2];
|
||||
}
|
||||
void set_fixed_position(int object_index, const double position[3]);
|
||||
|
||||
// Drops the OAMD state and every transition but keeps the fixed bed positions:
|
||||
// they describe the content, not the playback position.
|
||||
void reset() {
|
||||
state_.reset();
|
||||
for (int index = 0; index < kTimelineObjects; ++index) {
|
||||
tracks_[index] = ObjectPositionTrack();
|
||||
has_previous_[index] = false;
|
||||
for (int axis = 0; axis < 3; ++axis) {
|
||||
previous_targets_[index][axis] = 0.0;
|
||||
}
|
||||
}
|
||||
initialized_ = false;
|
||||
payload_count_ = 0;
|
||||
transition_count_ = 0;
|
||||
last_coded_event_sample_ = -1;
|
||||
}
|
||||
void reset();
|
||||
|
||||
int object_count() const { return object_count_; }
|
||||
std::uint64_t payload_count() const { return payload_count_; }
|
||||
std::uint64_t transition_count() const { return transition_count_; }
|
||||
bool initialized() const { return initialized_; }
|
||||
|
||||
const ObjectPositionTrack& track(int index) const { return tracks_[index]; }
|
||||
const ObjectPositionTrack& track(int index) const { return tracks_[static_cast<std::size_t>(index)]; }
|
||||
|
||||
private:
|
||||
// Grows the track list so every declared OAMD object has one (the JOC
|
||||
// renderers use the first kTimelineObjects).
|
||||
void ensure_tracks(int count);
|
||||
// OAMD position state after applying one frame-state block.
|
||||
void apply_block(const oamd::FrameState& state, std::uint32_t block_index);
|
||||
// Current ADM cartesian target of every track.
|
||||
void targets(std::vector<std::array<double, 3>>* out) const;
|
||||
// Initialises from the first update or appends the changed transitions.
|
||||
Status schedule(const std::vector<std::array<double, 3>>& targets,
|
||||
std::int64_t coded_event, std::int64_t ramp_samples,
|
||||
std::int64_t object_delay_samples, std::int64_t processed_sample);
|
||||
|
||||
int object_count_;
|
||||
oamd::OamdState state_;
|
||||
ObjectPositionTrack tracks_[kTimelineObjects];
|
||||
std::vector<ObjectPositionTrack> tracks_;
|
||||
bool initialized_ = false;
|
||||
double previous_targets_[kTimelineObjects][3] = {};
|
||||
bool has_previous_[kTimelineObjects] = {};
|
||||
bool fixed_[kTimelineObjects] = {};
|
||||
double fixed_xyz_[kTimelineObjects][3] = {};
|
||||
std::vector<std::array<double, 3>> previous_targets_;
|
||||
std::vector<bool> has_previous_;
|
||||
std::vector<bool> fixed_;
|
||||
std::vector<std::array<double, 3>> fixed_xyz_;
|
||||
std::vector<std::array<double, 3>> targets_;
|
||||
std::uint64_t payload_count_ = 0;
|
||||
std::uint64_t transition_count_ = 0;
|
||||
std::int64_t last_coded_event_sample_ = -1;
|
||||
|
||||
@@ -331,6 +331,7 @@ const LayoutSpec kLayouts[] = {
|
||||
{"9.1.6", 16,
|
||||
{"L", "R", "C", "LFE", "Ls", "Rs", "Lrs", "Rrs", "Lw", "Rw", "Ltf", "Rtf", "Ltm",
|
||||
"Rtm", "Ltr", "Rtr"}},
|
||||
{"6.0", 6, {"L", "R", "Ls", "Rs", "Lrs", "Rrs"}},
|
||||
};
|
||||
|
||||
constexpr std::size_t kLayoutCount = sizeof(kLayouts) / sizeof(kLayouts[0]);
|
||||
|
||||
@@ -53,6 +53,7 @@ const Expected kExpected[] = {
|
||||
{"7.1.4", "L R C LFE Ls Rs Lrs Rrs Ltf Rtf Ltr Rtr"},
|
||||
{"9.1.4", "L R C LFE Ls Rs Lrs Rrs Lw Rw Ltf Rtf Ltr Rtr"},
|
||||
{"9.1.6", "L R C LFE Ls Rs Lrs Rrs Lw Rw Ltf Rtf Ltm Rtm Ltr Rtr"},
|
||||
{"6.0", "L R Ls Rs Lrs Rrs"},
|
||||
};
|
||||
|
||||
std::string join(const std::vector<std::string>& words) {
|
||||
|
||||
Reference in new issue
Block a user