Render SOFA HRIRs directly and place bed channels by their labels
ci / ubuntu-latest (push) Failing after 11s
ci / macos-latest (push) Canceled after 0s
ci / windows-latest (push) Canceled after 0s
ci / release (push) Canceled after 0s

Two changes that belong to the same reproduction model: a bed channel has
one position, defined by its label, and a SOFA set keeps the impulse
responses it was measured with.

CBA bed channels: the position comes from the channel's label in ETSI
TS 103 420 Table B.10, not from the layout the decoder is asked to render
to. The per-layout anchor table displaced bed channels onto the nearest
target speaker, which silently moved content whenever the target layout
changed.

- Drop the anchor table and the geometry lookup; bed_channel_q15 is the
  only source of bed positions, so stream and task no longer need a
  layout to ask for one
- Keep the 17-bit non-standard bed mask in channel order, as Table 13 /
  TS 103 190-2 Table 65 transmit it
- Exclude LFE channels from the object list while keeping them in the
  coverage mask
- Cover the Table B.10 coordinates, the q15 encoding, the 10-bit and
  17-bit masks and the LFE split in tests

SOFA rendering: compiling a SOFA set into a fifth-order directional field
threw away the measured impulse response - the SH projection, the
64-QMF/77-hybrid round trip and the synthetic room replaced it. The full
IRs are now kept and rendered as such, with the reproduction defined by a
configuration that names a personalized model rather than by the renderer
itself.

- Add SphericalMesh: incremental convex hull over the measurement
  directions, barycentric weights inside the containing triangle and
  spherical Voronoi areas for the centre spectrum
- Add FullHrirField: rfft of the selected shell, 200-1500 Hz phase fit for
  the delay, delay-aligned spectra, log-magnitude/phase or MCA
  interpolation, rigid-sphere radial ratio, recording origin and the
  common FFT/2 latency
- Add Uniform/MultiSourcePartitionedConvolver: block 128, numpy FFT
  conventions, zero-fade filter rebuild from the blocks in flight
- Move the Rosella reference arithmetic (profile geometry, direction
  basis, direct gains and room send, table-A room) out of the renderer
  into rosella_reference so both renderers share it
- Add ReferenceEnvironment and SofaReferenceRuntime: JSON configuration
  with model hash and distance-profile mapping, level calibration over
  equal-area directions, the reference room, 1536-sample batching and a
  single latency removal
- Keep .jochrtf an explicit input and the SOFA compile step behind
  --hrtf-cache-policy/--hrtf-cache-dir; add --reference-config and
  --sofa-interpolation, and make --hrtf-radius-m optional for a single
  shell
- Cover the mesh weights and Voronoi areas, the sphere series and the
  partitioned convolver with reference values in tests
- Document both rules in the READMEs and the binaural notes

Rosella renders stay byte-identical (d5877e89...) and so do renders of
the legacy compiled path (6f0a75d2...). Direct SOFA renders match the
Python reference to 1e-4 in level; the residual comes from the
barycentric solve (analytic inverse here, LAPACK there) on near-degenerate
triangles.
This commit is contained in:
TheM14 committed 2026-11-01 02:54:55 +08:00
1 parent 34a722f56a
commit fd842db26f
27 files changed
+4746 -1065

No files matched your search

+6
View File
@@ -92,7 +92,9 @@ set(JOC_REUSED_SOURCES
set(JOC_INTERNAL_SOURCES set(JOC_INTERNAL_SOURCES
src/adm/adm_metadata.cpp src/adm/adm_metadata.cpp
src/adm/adm_tracks.cpp src/adm/adm_tracks.cpp
src/binaural/binaural_reference.cpp
src/binaural/binaural_runtime.cpp src/binaural/binaural_runtime.cpp
src/binaural/sofa_reference_runtime.cpp
src/binaural/sofa_binaural_renderer.cpp src/binaural/sofa_binaural_renderer.cpp
src/eac3_transport/eac3_reader.cpp src/eac3_transport/eac3_reader.cpp
src/emdf/emdf_parser.cpp src/emdf/emdf_parser.cpp
@@ -108,10 +110,14 @@ set(JOC_INTERNAL_SOURCES
src/hrtf/rosella_filterbank.cpp src/hrtf/rosella_filterbank.cpp
src/hrtf/rosella_model.cpp src/hrtf/rosella_model.cpp
src/hrtf/rosella_renderer.cpp src/hrtf/rosella_renderer.cpp
src/hrtf/rosella_reference.cpp
src/hrtf/kernel_tables.cpp src/hrtf/kernel_tables.cpp
src/hrtf/full_hrir_field.cpp
src/hrtf/partitioned_convolution.cpp
src/hrtf/sofa.cpp src/hrtf/sofa.cpp
src/hrtf/sofa_cache.cpp src/hrtf/sofa_cache.cpp
src/hrtf/sofa_field.cpp src/hrtf/sofa_field.cpp
src/hrtf/spherical_mesh.cpp
src/io/adm_writer.cpp src/io/adm_writer.cpp
src/io/hdf5.cpp src/io/hdf5.cpp
src/io/inflate.cpp src/io/inflate.cpp
+7 -3
View File
@@ -6,8 +6,8 @@ The C++ implementation of JustOneCacophony: an execution core for E-AC-3 JOC
bitstream parsing, object reconstruction and rendering. It extracts EMDF, ID14 JOC bitstream parsing, object reconstruction and rendering. It extracts EMDF, ID14 JOC
parameters and ID11 OAMD metadata from E-AC-3 syncframes, combines them with the parameters and ID11 OAMD metadata from E-AC-3 syncframes, combines them with the
core 5.1 PCM decoded by FFmpeg to rebuild the LFE and 15 object signals, and writes core 5.1 PCM decoded by FFmpeg to rebuild the LFE and 15 object signals, and writes
ADM BWF, a WAV for a chosen speaker layout, or a binaural WAV using a compiled HRTF ADM BWF, a WAV for a chosen speaker layout, or a binaural WAV rendered directly from
directional field. full SOFA HRIRs (or from a compiled `.jochrtf` directional field).
This is research code, not a complete, standard-conformant or production JOC This is research code, not a complete, standard-conformant or production JOC
decoder. It covers the bitstream forms it implements and reports an explicit error decoder. It covers the bitstream forms it implements and reports an explicit error
@@ -224,7 +224,11 @@ The extra pair's **identity** never reaches the DSP (section 10.1): when the dep
renders, with the bed mapping following the channel codes the `chanmap` declares. The bed renders, with the bed mapping following the channel codes the `chanmap` declares. The bed
layout the OAMD declares may hold more channels than the core substream codes (a 9.1.6 bed layout the OAMD declares may hold more channels than the core substream codes (a 9.1.6 bed
with a 5.1 core, for example): only a core channel missing from that layout counts as a with a 5.1 core, for example): only a core channel missing from that layout counts as a
mismatch. When one audio frame holds several EMDF containers carrying ID11/ID14, they mismatch. For bed-only content the 15 JOC object slots are the bed channels, each rendered as
a point source at the fixed position its channel label defines (ETSI TS 103 420 table B.10);
speaker, ADM and binaural output share those source coordinates and never re-place them per
layout, while LFE keeps its separate path. When one audio frame holds several EMDF
containers carrying ID11/ID14, they
are scored by the association rule of section 8.2 and its Table 56: a container whose OAMD and JOC are scored by the association rule of section 8.2 and its Table 56: a container whose OAMD and JOC
payloads share a group id and whose ID14 parses completely wins, then one whose ID14 merely parses; payloads share a group id and whose ID14 parses completely wins, then one whose ID14 merely parses;
only a unique best score is used and the others are recorded as a diagnostic only a unique best score is used and the others are recorded as a diagnostic
+4 -2
View File
@@ -4,8 +4,8 @@
JustOneCacophony 的 C++ 实现:E-AC-3 JOC 码流解析、对象重建与渲染的执行内核。它从 E-AC-3 JustOneCacophony 的 C++ 实现:E-AC-3 JOC 码流解析、对象重建与渲染的执行内核。它从 E-AC-3
同步帧中提取 EMDF、ID14 JOC 参数与 ID11 OAMD 元数据,结合 FFmpeg 解码出的核心 PCM(N=5 或 7) 同步帧中提取 EMDF、ID14 JOC 参数与 ID11 OAMD 元数据,结合 FFmpeg 解码出的核心 PCM(N=5 或 7)
重建 LFE 与 15 路对象 PCM,并输出 ADM BWF、指定扬声器布局的 WAV,或用编译好的 HRTF 方向场 重建 LFE 与 15 路对象 PCM,并输出 ADM BWF、指定扬声器布局的 WAV,或按完整 HRIR 直接
直接输出双耳 WAV。 渲染双耳 WAV(SOFA),也可以读入编译好的 `.jochrtf` 方向场渲染。
这是研究代码,不是完整、标准兼容或生产级的 JOC 解码器。它只覆盖已实现的码流形态,遇到未知 这是研究代码,不是完整、标准兼容或生产级的 JOC 解码器。它只覆盖已实现的码流形态,遇到未知
变体时明确报错,而不是假装一切都很和谐。 变体时明确报错,而不是假装一切都很和谐。
@@ -191,6 +191,8 @@ ffmpeg 侧只在 $N=5$ 档位传 `-ac 6`;$N=7$ 档位不传 `-ac`,保留解
拒绝。额外那一对的**身份**只进元数据、不进 DSP(§10.1):依赖子流 `chanmap` 与 $k$ 不一致、或 拒绝。额外那一对的**身份**只进元数据、不进 DSP(§10.1):依赖子流 `chanmap` 与 $k$ 不一致、或
OAMD 声明的 bed 布局可以比核心子流实际编码的声道多(例如 9.1.6 bed 只编 5.1 核心),只有核心 OAMD 声明的 bed 布局可以比核心子流实际编码的声道多(例如 9.1.6 bed 只编 5.1 核心),只有核心
声道在 bed 布局里找不到位置才记 diagnostics 并照常解码,床映射按 `chanmap` 的通道码走。 声道在 bed 布局里找不到位置才记 diagnostics 并照常解码,床映射按 `chanmap` 的通道码走。
bed-only 内容的 15 路 JOC 对象就是 bed 声道:每一路按其声道标签的固定方位(ETSI TS 103 420
Table B.10)作为点声源渲染,扬声器、ADM 与双耳共用同一组源坐标,不随输出布局改变;LFE 独立处理。
同一音频帧里出现多个含 ID11/ID14 的 EMDF 容器时,按规格 §8.2 + Table 56 的关联规则打分: 同一音频帧里出现多个含 ID11/ID14 的 EMDF 容器时,按规格 §8.2 + Table 56 的关联规则打分:
OAMD 与 JOC 载荷 groupid 相同且 ID14 能完整解析的优先,其次只看 ID14 能否解析;唯一最高分才用, OAMD 与 JOC 载荷 groupid 相同且 ID14 能完整解析的优先,其次只看 ID14 能否解析;唯一最高分才用,
其余记入 diagnostics(`emdf/extra_container_ignored`)。额外那一对在 10 槽 ADM 骨架上的落位 其余记入 diagnostics(`emdf/extra_container_ignored`)。额外那一对在 10 槽 ADM 骨架上的落位
+69 -17
View File
@@ -5,28 +5,70 @@
JustOneCacophony's binaural backend supports three HRTF sources: JustOneCacophony's binaural backend supports three HRTF sources:
`SimpleFreeFieldHRIR` SOFA, the Rosella `.personalized_headphone` model exported `SimpleFreeFieldHRIR` SOFA, the Rosella `.personalized_headphone` model exported
by Dolby's official personalization scan (its JSON parsing is implemented by by Dolby's official personalization scan (its JSON parsing is implemented by
this project and invokes no Dolby software), and the `.jochrtf` cache compiled this project and invokes no Dolby software), and `.jochrtf` (a JOC compiled HRTF
from SOFA. SOFA is compiled into an in-memory directional field when the model cache).
is loaded. A `.jochrtf` file is only a disposable, reproducible JOC compiled
HRTF cache; it is neither an interchange format nor a prerequisite for using SOFA keeps its full HRIRs and renders directly through a configured reference
SOFA. environment; it is no longer compiled into a directional field:
```text ```text
SOFA FIR SOFA full HRIR [M,2,N]
-> CanonicalHrtf -> CanonicalHrtf (48 kHz / one radius shell)
-> 48 kHz / one radius shell / delay-phase policy -> delay-aligned complex spectra (200-1500 Hz phase fit, Data.Delay included)
-> 64-QMF / 77-hybrid projection -> spherical-triangle barycentric interpolation (lf_logmag_phase or lf_mca_zero)
-> fifth-order ACN/N3D real-SH field -> rigid-sphere radial correction (reference-environment distance)
-> per-object direct + early reflections -> per-object partitioned convolution (block 128, FFT = max(2048, >=2*support))
-> shared unitary-FDN late room -> reference-environment recursive room model
-> float64 stereo -> float64 stereo (one common latency removed)
``` ```
`.jochrtf` stays an explicit input (`--compiled-hrtf-cache`) and keeps the
real-SH field renderer; passing `--hrtf-cache-policy` / `--hrtf-cache-dir`
selects the legacy "SOFA -> `.jochrtf`" compile path.
## Reference environment
Direct SOFA rendering needs a reference-environment configuration
(`--reference-config`, default `<exe>/local/binaural_reference.json`). It names
the Rosella `.personalized_headphone` model together with its SHA-256, the
`profile_index` used as the level anchor (2 = far, 3 = mid), the room impulse
slots (4096 by default) and the number of level-calibration directions (128).
Every SOFA direction is first mapped into the reference reproduction through the
model's distance profile:
```text
ADM position -> int16 metadata grid -> distance profile
-> unit direction + distance scale
-> direct gain a = 1/sqrt(1+coupling*(h0*d)^2) (1 for near)
-> room send = h0*d*a (0 for near)
-> near-centre regularization: ear distance = max(d, minimum_distance)
```
`near|mid|far` (`--binaural-mode`) selects one of the model's three distance
profiles; level calibration always uses the configured `profile_index` as its
anchor, so all three modes share one level.
The direct path is the interpolated, delay-aligned full HRIR; the room send only
feeds the reference room model (the LFE channel never does). Their latencies come
from the larger of the field (FFT/2 plus the recording origin) and the bank
(961), and are removed once before the output.
## Inputs ## Inputs
The binaural backend consumes a compiled directional field (a JOC compiled HRTF cache, A SOFA input renders directly from its full HRIRs and only needs the SOFA file and
`.jochrtf`) plus the shared filterbank tables. Both are read-only inputs: this library the reference-environment configuration:
performs no parsing or conversion of measurement data formats.
```powershell
joc_cli input.m4a --binaural `
--sofa-hrtf HRTF\subject.sofa `
--reference-config local\binaural_reference.json `
--binaural-mode mid --sofa-interpolation lf_logmag_phase
```
A `.jochrtf` input (and `.personalized_headphone`) also needs the shared filterbank
tables. Both are read-only inputs; parsing and coordinate validation happen while the
model is loaded, and nothing is converted again during rendering.
```powershell ```powershell
joc_cli input.m4a --binaural ` joc_cli input.m4a --binaural `
@@ -35,8 +77,14 @@ joc_cli input.m4a --binaural `
--binaural-mode mid --binaural-tail-seconds 5.0 --binaural-mode mid --binaural-tail-seconds 5.0
``` ```
A multi-radius SOFA requires `--hrtf-radius-m`; a single shell is selected
automatically. `--sofa-interpolation` picks the local interpolation of the full HRIR:
`lf_logmag_phase` (default, log magnitude plus phase) or `lf_mca_zero` (auditory-band
magnitude correction).
The library exposes the same fields: `joc_task_config` for a file task, The library exposes the same fields: `joc_task_config` for a file task,
`joc_stream_config` for streaming, where `hrtf_path`, `kernels_path`, `joc_stream_config` for streaming, where `hrtf_sofa_path` (or `hrtf_path`),
`reference_config_path`, `sofa_interpolation`, `hrtf_compile`, `kernels_path`,
`binaural_mode` and `binaural_tail_seconds` configure the binaural path. `binaural_mode` and `binaural_tail_seconds` configure the binaural path.
The `.jochrtf` file is an **input**, not a product of this library: compiling it from The `.jochrtf` file is an **input**, not a product of this library: compiling it from
@@ -110,6 +158,10 @@ The compiler recognizes three mutually exclusive representations:
No path may add a second ear delay or phase-group delay. No path may add a second ear delay or phase-group delay.
The direct SOFA path does not use this compile-time policy: it keeps the full IRs and
estimates the arrival time with a 200-1500 Hz phase fit, so `Data.Delay` and the fitted
delay are each applied once (the delay is removed first and restored afterwards).
## Public filterbank and directional field ## Public filterbank and directional field
The SOFA and `.jochrtf` runtime is fixed at: The SOFA and `.jochrtf` runtime is fixed at:
+57 -14
View File
@@ -4,25 +4,60 @@
JustOneCacophony 的双耳后端支持三种 HRTF 来源:`SimpleFreeFieldHRIR` SOFA、 JustOneCacophony 的双耳后端支持三种 HRTF 来源:`SimpleFreeFieldHRIR` SOFA、
杜比官方软件个性化扫描导出的 Rosella `.personalized_headphone`(JSON 解析由本项目 杜比官方软件个性化扫描导出的 Rosella `.personalized_headphone`(JSON 解析由本项目
自行实现,不调用杜比软件),以及从 SOFA 编译出的 `.jochrtf` 缓存。SOFA 在模型加载 自行实现,不调用杜比软件),以及 `.jochrtf`(JOC compiled HRTF cache)。
时编译成内存方向场;`.jochrtf` 只是可删除、可重建的 JOC compiled HRTF cache,
不是交换格式,也不是使用 SOFA 的前置步骤。 SOFA 默认保留完整 HRIR,按“参考环境”直连渲染,不再编译成方向场:
```text ```text
SOFA FIR SOFA 完整 HRIR [M,2,N]
-> CanonicalHrtf -> CanonicalHrtf(48 kHz / 单 radius shell)
-> 48 kHz / 单 radius shell / delay-phase policy -> 延迟对齐的复数频谱(200-1500 Hz 相位拟合,含 Data.Delay)
-> 64-QMF / 77-hybrid projection -> 球面三角形重心插值(lf_logmag_phase 或 lf_mca_zero)
-> 五阶 ACN/N3D 实球谐场 -> 刚性球径向修正(按参考环境距离)
-> 逐对象 direct + early reflections -> 逐对象 partitioned convolution(block 128,FFT = max(2048, ≥2×support))
-> shared unitary-FDN late room -> 参考环境的递归房间模型
-> stereo float64 -> stereo float64(统一扣除 latency)
``` ```
`.jochrtf` 仍是显式输入(`--compiled-hrtf-cache`),走球谐方向场渲染;显式给出
`--hrtf-cache-policy` / `--hrtf-cache-dir` 会回到旧的“SOFA → `.jochrtf`”编译路径。
## 参考环境
SOFA 直连渲染需要一个参考环境配置(`--reference-config`,默认
`<exe>/local/binaural_reference.json`)。配置给出 Rosella `.personalized_headphone`
模型的路径与 SHA-256、`profile_index`(2=far、3=mid,作为 level 校准锚点)、
`room_impulse_slots`(默认 4096)与 `level_calibration_directions`(默认 128)。
渲染时每个 SOFA 方向先经该模型的 distance profile 映射成参考环境中的位置:
```text
ADM position -> int16 metadata grid -> distance profile
-> direction(单位向量)+ 距离 scale
-> direct gain a = 1/sqrt(1+coupling·(h0·d)^2)(near 恒为 1)
-> room send = h0·d·a(near 恒为 0)
-> 近中心正则化:ear distance 取 max(d, minimum_distance)
```
`near|mid|far` 选择该模型的三个 distance profile 之一(`--binaural-mode`),level 校准
始终用配置里的 `profile_index` 作为锚点,因此三种模式共享同一个 level。
指向同一声道的直达声是延迟对齐后的完整 HRIR 插值结果,房间 send 只进参考环境的
房间模型(LFE 声道不进房间)。两者的 latency 由 field(FFT/2 与 recording origin)
和 bank(961)中的较大者决定,输出前统一扣除。
## 输入接口 ## 输入接口
双耳后端消费一个已编译的方向场(JOC compiled HRTF cache,`.jochrtf`)与共享滤波器组表; SOFA 输入直接按完整 HRIR 渲染,只需要 SOFA 与参考环境配置:
两者都是只读输入,本库不做任何测量数据格式的解析或转换:
```powershell
joc_cli input.m4a --binaural `
--sofa-hrtf HRTF\subject.sofa `
--reference-config local\binaural_reference.json `
--binaural-mode mid --sofa-interpolation lf_logmag_phase
```
`.jochrtf` 输入(以及 `.personalized_headphone`)需要共享滤波器组表,两者都是只读输入:
```powershell ```powershell
joc_cli input.m4a --binaural ` joc_cli input.m4a --binaural `
@@ -31,8 +66,13 @@ joc_cli input.m4a --binaural `
--binaural-mode mid --binaural-tail-seconds 5.0 --binaural-mode mid --binaural-tail-seconds 5.0
``` ```
多球壳 SOFA 必须用 `--hrtf-radius-m` 指定球壳(单球壳自动选择);`--hrtf-radius-m`
对已编译的 `.jochrtf` 不再生效。`--sofa-interpolation` 选择完整 HRIR 的局部插值:
`lf_logmag_phase`(默认,对数幅度 + 相位)或 `lf_mca_zero`(听觉带幅度修正)。
库接口使用同一组字段:文件任务用 `joc_task_config`,流式用 `joc_stream_config`, 库接口使用同一组字段:文件任务用 `joc_task_config`,流式用 `joc_stream_config`,
其中 `hrtf_path`、`kernels_path`、`binaural_mode`、`binaural_tail_seconds` 决定双耳通路。 其中 `hrtf_sofa_path`(或 `hrtf_path`)、`reference_config_path`、`sofa_interpolation`、
`hrtf_compile`、`kernels_path`、`binaural_mode`、`binaural_tail_seconds` 决定双耳通路。
`.jochrtf` 是**输入**而不是本库的产物:从 SOFA 或测量数据编译该缓存属于工具链的职责, `.jochrtf` 是**输入**而不是本库的产物:从 SOFA 或测量数据编译该缓存属于工具链的职责,
与本仓库解耦。缓存加载时会校验成员集合、dtype 与形状、C 连续性、CRC-32 以及按成员重算的 与本仓库解耦。缓存加载时会校验成员集合、dtype 与形状、C 连续性、CRC-32 以及按成员重算的
@@ -96,6 +136,9 @@ convention adapter,不能只通过 reshape 进入核心 importer。
任何路径都不能再叠加第二套 ear delay 或 phase-group delay。 任何路径都不能再叠加第二套 ear delay 或 phase-group delay。
SOFA 直连路径不走这套编译期语义:它保留完整 IR,用 200-1500 Hz 相位拟合估计到达时间,
`Data.Delay` 与拟合出的延迟各应用一次(先去掉 `Data.Delay`,再用插值后的延迟复原)。
## 公开 filterbank 与方向场 ## 公开 filterbank 与方向场
运行时固定为: 运行时固定为:
+18 -6
View File
@@ -358,8 +358,14 @@ typedef enum joc_clip_action {
JOC_CLIP_ABORT = 3 /* fail the task */ JOC_CLIP_ABORT = 3 /* fail the task */
} joc_clip_action; } joc_clip_action;
/* Compiled-HRTF cache policy for a SOFA input; the .jochrtf itself is an /* Local interpolation of the full-HRIR SOFA field (config version 3). */
* internal artifact of the compile step. */ typedef enum joc_sofa_interpolation {
JOC_SOFA_INTERPOLATION_LOGMAG_PHASE = 0, /* delay-aligned log-magnitude/phase */
JOC_SOFA_INTERPOLATION_MCA_ZERO = 1 /* auditory-band magnitude correction */
} joc_sofa_interpolation;
/* Compiled-HRTF cache policy for the legacy SOFA compile step; the .jochrtf
* itself stays an explicit input (hrtf_path). */
typedef enum joc_hrtf_cache_policy { typedef enum joc_hrtf_cache_policy {
JOC_HRTF_CACHE_NONE = 0, /* compile and discard */ JOC_HRTF_CACHE_NONE = 0, /* compile and discard */
JOC_HRTF_CACHE_MEMORY = 1, /* compile and keep in this process (default) */ JOC_HRTF_CACHE_MEMORY = 1, /* compile and keep in this process (default) */
@@ -424,16 +430,22 @@ typedef struct joc_task_config {
joc_cancel_token* cancel; /* optional */ joc_cancel_token* cancel; /* optional */
/* Binaural HRTF input (config version 2): when hrtf_sofa_path is set the /* Binaural HRTF input: when hrtf_sofa_path is set the SOFA renders directly
* library compiles it with hrtf_cache_policy / hrtf_cache_dir / hrtf_radius_m * from its full HRIRs through the reference environment (config version 3)
* and hrtf_path is unused. hrtf_path stays the advanced override that reads * and hrtf_path is unused. hrtf_path stays the advanced override that reads
* a .jochrtf directly. */ * a .jochrtf directly with the compiled-field renderer. */
const char* hrtf_sofa_path; /* SOFA SimpleFreeFieldHRIR input */ const char* hrtf_sofa_path; /* SOFA SimpleFreeFieldHRIR input */
const char* personalized_headphone_path; /* Rosella .personalized_headphone input */ const char* personalized_headphone_path; /* Rosella .personalized_headphone input */
const char* hrtf_cache_dir; /* disk policy directory */ const char* hrtf_cache_dir; /* disk policy directory */
uint32_t hrtf_cache_policy; /* joc_hrtf_cache_policy */ uint32_t hrtf_cache_policy; /* joc_hrtf_cache_policy */
uint32_t rosella_filterbank; /* joc_rosella_filterbank; 0 = PUBLIC */ uint32_t rosella_filterbank; /* joc_rosella_filterbank; 0 = PUBLIC */
double hrtf_radius_m; /* SOFA measurement-radius shell */ double hrtf_radius_m; /* SOFA shell radius; <= 0 = automatic */
/* Reference environment for the direct SOFA path (config version 3). */
const char* reference_config_path; /* NULL = local/binaural_reference.json */
uint32_t sofa_interpolation; /* joc_sofa_interpolation */
/* Nonzero keeps the legacy SOFA compile step (hrtf_cache_policy/hrtf_cache_dir
* decide where the .jochrtf lands); zero renders the SOFA directly. */
uint32_t hrtf_compile;
} joc_task_config; } joc_task_config;
typedef enum joc_task_status { typedef enum joc_task_status {
+393
View File
@@ -0,0 +1,393 @@
#include "binaural/binaural_reference.h"
#include <algorithm>
#include <cmath>
#include <cctype>
#include <cstring>
#include <fstream>
#include <sstream>
#include "foundation/fft.h"
#include "foundation/fs_utf8.h"
#include "foundation/mini_json.h"
#include "foundation/sha256.h"
#include "hrtf/sofa_field.h"
namespace joc::binaural {
namespace {
constexpr double kPi = 3.141592653589793238462643383279502884;
constexpr double kMaximumExtension = 50.1;
Status reference_error(const char* message) {
return Status::fail(JOC_ERR_INVALID_CONFIG, joc::stage::kRender, message);
}
bool read_text_file(const std::string& path, std::string* out) {
std::ifstream stream(fs_utf8::to_path(path), std::ios::binary);
if (!stream) {
return false;
}
std::ostringstream buffer;
buffer << stream.rdbuf();
*out = buffer.str();
return true;
}
bool read_binary_file(const std::string& path, std::string* out) {
return read_text_file(path, out);
}
std::string directory_of(const std::string& path) {
const std::size_t slash = path.find_last_of("/\\");
return slash == std::string::npos ? std::string() : path.substr(0, slash + 1);
}
std::string join_path(const std::string& directory, const std::string& name) {
if (directory.empty()) {
return name;
}
const char last = directory.back();
return (last == '/' || last == '\\' ? directory : directory + "/") + name;
}
std::vector<double> parse_number_list(const std::string& raw) {
std::vector<double> values;
std::size_t index = 0;
while (index < raw.size()) {
if (raw[index] == '-' || raw[index] == '+' || raw[index] == '.' ||
(raw[index] >= '0' && raw[index] <= '9')) {
std::size_t end = index;
while (end < raw.size() &&
(raw[end] == '-' || raw[end] == '+' || raw[end] == '.' ||
raw[end] == 'e' || raw[end] == 'E' ||
(raw[end] >= '0' && raw[end] <= '9'))) {
++end;
}
values.push_back(std::strtod(raw.substr(index, end - index).c_str(), nullptr));
index = end;
continue;
}
++index;
}
return values;
}
} // namespace
std::string ReferenceEnvironment::default_reference_config_path() {
return std::string("local/binaural_reference.json");
}
Status ReferenceEnvironment::load(const std::string& config_path, int mode_index,
bool mode_specified) {
config_path_ = config_path.empty() ? default_reference_config_path() : config_path;
std::string text;
if (!read_text_file(config_path_, &text)) {
return Status::fail(JOC_ERR_HRTF_NOT_FOUND, joc::stage::kRender,
"reference configuration not found: " + config_path_);
}
configuration_sha256_ = joc::crypto::sha256_hex(text.data(), text.size());
std::vector<json::Member> members;
std::string error;
if (!json::parse_object(text, &members, &error)) {
return reference_error("reference configuration is not a JSON object");
}
std::string schema;
const json::Member* schema_member = json::find(members, "schema");
if (schema_member == nullptr || !json::as_string(*schema_member, &schema) ||
schema != "binaural-reference-v1") {
return reference_error("unsupported reference configuration schema");
}
std::string model_path;
std::string expected_sha;
const json::Member* model_member = json::find(members, "model_path");
const json::Member* sha_member = json::find(members, "model_sha256");
if (model_member == nullptr || sha_member == nullptr ||
!json::as_string(*model_member, &model_path) ||
!json::as_string(*sha_member, &expected_sha)) {
return reference_error("reference configuration needs model_path and model_sha256");
}
long long profile_index = 0;
const json::Member* profile_member = json::find(members, "profile_index");
if (profile_member == nullptr || !json::as_integer(*profile_member, &profile_index)) {
return reference_error("reference configuration needs profile_index");
}
calibration_profile_index_ = static_cast<int>(profile_index);
if (calibration_profile_index_ != kProfileFar &&
calibration_profile_index_ != kProfileMid) {
return reference_error("unsupported reference profile");
}
const json::Member* profile_id_member = json::find(members, "profile_id");
if (profile_id_member != nullptr) {
json::as_string(*profile_id_member, &profile_id_);
}
long long slots = 4096;
if (const json::Member* member = json::find(members, "room_impulse_slots")) {
json::as_integer(*member, &slots);
}
long long directions = 128;
if (const json::Member* member = json::find(members, "level_calibration_directions")) {
json::as_integer(*member, &directions);
}
if (slots < 128 || slots > 16384 || directions < 16 || directions > 2048) {
return reference_error("reference configuration exceeds supported bounds");
}
room_impulse_slots_ = static_cast<int>(slots);
calibration_directions_ = static_cast<int>(directions);
// The model path is relative to the configuration file unless absolute.
std::string resolved = model_path;
if (!(model_path.size() > 1 && (model_path[1] == ':' || model_path[0] == '/' ||
model_path[0] == '\\'))) {
resolved = join_path(directory_of(config_path_), model_path);
}
std::string model_bytes;
if (!read_binary_file(resolved, &model_bytes)) {
return Status::fail(JOC_ERR_HRTF_NOT_FOUND, joc::stage::kRender,
"reference model not found: " + resolved);
}
model_sha256_ = joc::crypto::sha256_hex(model_bytes.data(), model_bytes.size());
std::string lower_expected = expected_sha;
std::transform(lower_expected.begin(), lower_expected.end(), lower_expected.begin(),
[](unsigned char value) { return static_cast<char>(std::tolower(value)); });
std::string lower_actual = model_sha256_;
std::transform(lower_actual.begin(), lower_actual.end(), lower_actual.begin(),
[](unsigned char value) { return static_cast<char>(std::tolower(value)); });
if (lower_actual != lower_expected) {
return reference_error("reference data hash mismatch");
}
const Status status = hrtf::load_personalized_headphone(resolved, &model_);
if (!status.ok()) {
return status;
}
if (model_.sample_rate != 48000) {
return reference_error("unsupported reference profile");
}
// Cartesian reference configurations only.
if (model_.header_integer_fields[0] != 0) {
return reference_error("reference-v1 requires a Cartesian mapping");
}
mode_name_ = mode_specified
? (mode_index == kProfileNear ? "near"
: (mode_index == kProfileFar ? "far" : "mid"))
: (calibration_profile_index_ == kProfileFar ? "far" : "mid");
profile_index_ = mode_specified ? mode_index
: (calibration_profile_index_ == kProfileFar ? kProfileFar
: kProfileMid);
if (profile_index_ != kProfileNear && profile_index_ != kProfileFar &&
profile_index_ != kProfileMid) {
return reference_error("reference mode must be near, mid, or far");
}
header_constant_ = model_.header_float_scalars[0];
coupling_ = model_.header_float_scalars[1];
if (!(header_constant_ > 0.0) || !(coupling_ > 0.0)) {
return reference_error("invalid reference energy coupling");
}
const hrtf::RosellaDistanceProfile& profile =
model_.profiles[calibration_profile_index_];
minimum_distance_m_ = static_cast<double>(profile.minimum_normalized_radius) *
static_cast<double>(profile.distance_scale_m);
const double origin[3] = {0.0, 1.0, 0.0};
ReferencePosition position;
const Status mapped = map_position(origin, &position);
if (!mapped.ok()) {
return mapped;
}
reference_distance_m_ = position.distance_m;
if (const json::Member* member = json::find(members, "compiled_receiver_positions_m")) {
compiled_receivers_m_ = parse_number_list(member->raw);
if (compiled_receivers_m_.size() != 6u) {
compiled_receivers_m_.clear();
}
}
return Status::success();
}
Status ReferenceEnvironment::map_position(const double position[3],
ReferencePosition* out) const {
return map_position(position, profile_index_, out);
}
Status ReferenceEnvironment::map_position(const double position[3], int profile_index,
ReferencePosition* out) const {
if (out == nullptr) {
return reference_error("reference position output is null");
}
for (int axis = 0; axis < 3; ++axis) {
if (!std::isfinite(position[axis])) {
return reference_error("reference position must contain three finite values");
}
}
double maximum = 0.0;
for (int axis = 0; axis < 3; ++axis) {
maximum = std::max(maximum, std::fabs(position[axis]));
}
const double extension = std::max(1.0, maximum);
if (extension > kMaximumExtension + 1e-9) {
return reference_error("position exceeds the finite metadata domain");
}
const double scaled[3] = {position[0] / extension, position[1] / extension,
position[2] / extension};
const int profile = profile_index < 0 ? profile_index_ : profile_index;
hrtf::ProfileGeometry geometry;
Status status = hrtf::profile_geometry(model_, scaled, profile, &geometry);
if (!status.ok()) {
return status;
}
const hrtf::RosellaDistanceProfile& distance_profile = model_.profiles[profile];
const double scale = static_cast<double>(distance_profile.distance_scale_m);
const double distance = scale * geometry.radius * extension;
const double minimum =
static_cast<double>(distance_profile.minimum_normalized_radius) * scale;
const double regularized = std::max(distance, minimum);
const double alpha = regularized > 0.0 ? distance / regularized : 0.0;
const double effective = header_constant_ * distance;
double gain = 1.0;
double send = 0.0;
if (profile != kProfileNear) {
gain = 1.0 / std::sqrt(1.0 + coupling_ * effective * effective);
send = effective * gain;
}
for (int axis = 0; axis < 3; ++axis) {
out->direction[axis] = geometry.direction[axis];
}
out->distance_m = distance;
out->ear_distance_m = regularized;
out->centre_weight = alpha;
out->direct_gain = gain;
out->room_send = send;
return Status::success();
}
Status ReferenceEnvironment::create_room(std::unique_ptr<hrtf::RosellaRoomFir>* out) const {
if (out == nullptr) {
return reference_error("room output is null");
}
std::unique_ptr<hrtf::RosellaRoomFir> room = std::make_unique<hrtf::RosellaRoomFir>();
Status status = room->configure(model_, room_impulse_slots_);
if (!status.ok()) {
return status;
}
*out = std::move(room);
return Status::success();
}
std::unique_ptr<hrtf::RosellaBank> ReferenceEnvironment::create_analysis_bank(
std::size_t channels) const {
return hrtf::RosellaBank::create(hrtf::RosellaBankKind::Public, channels);
}
std::unique_ptr<hrtf::RosellaBank> ReferenceEnvironment::create_synthesis_bank() const {
return hrtf::RosellaBank::create(hrtf::RosellaBankKind::Public, 2u);
}
Status ReferenceEnvironment::calibrate(std::size_t fft_size,
const std::vector<double>& frequencies,
const SpectrumAt& spectrum_at, double* level) const {
if (level == nullptr || frequencies.empty()) {
return reference_error("calibration needs a spectrum callback and frequencies");
}
const std::vector<double> dictionary =
hrtf::hybrid_gain_synthesis_dictionary_for_check(fft_size);
if (dictionary.size() != fft_size * 154u) {
return reference_error("hybrid gain dictionary has the wrong shape");
}
const std::vector<double> field_left = hrtf::rosella_logical_field(model_.field_left_padded);
const std::vector<double> field_right = hrtf::rosella_logical_field(model_.field_right_padded);
// Fibonacci sphere: equal-area calibration directions.
const int count = calibration_directions_;
std::vector<std::size_t> band_bins;
std::vector<double> weights;
for (std::size_t bin = 0; bin < frequencies.size(); ++bin) {
if (frequencies[bin] >= 100.0 && frequencies[bin] <= 16000.0) {
band_bins.push_back(bin);
weights.push_back(1.0 / frequencies[bin]);
}
}
if (band_bins.empty()) {
return reference_error("calibration band is empty");
}
const std::size_t bins = frequencies.size();
double reference_energy = 0.0;
double new_energy = 0.0;
std::vector<std::complex<double>> reference(2 * bins);
std::vector<std::complex<double>> target;
std::vector<double> parameters(2 * 154);
for (int index = 0; index < count; ++index) {
const double z = 1.0 - 2.0 * (static_cast<double>(index) + 0.5) / count;
const double phi = static_cast<double>(index) * kPi * (3.0 - std::sqrt(5.0));
const double radial = std::sqrt(std::max(0.0, 1.0 - z * z));
const double direction[3] = {-radial * std::sin(phi), radial * std::cos(phi), z};
const double adm[3] = {-direction[1], direction[0], direction[2]};
ReferencePosition state;
Status status = map_position(adm, calibration_profile_index_, &state);
if (!status.ok()) {
return status;
}
hrtf::DirectResult result;
status = hrtf::direct_and_room_send(model_, field_left, field_right, adm,
calibration_profile_index_, &result);
if (!status.ok()) {
return status;
}
for (int ear = 0; ear < 2; ++ear) {
for (int band = 0; band < 77; ++band) {
parameters[static_cast<std::size_t>(ear * 154 + 2 * band)] =
result.gains[ear][band].real();
parameters[static_cast<std::size_t>(ear * 154 + 2 * band + 1)] =
result.gains[ear][band].imag();
}
}
for (int ear = 0; ear < 2; ++ear) {
std::vector<double> time(fft_size, 0.0);
for (std::size_t tap = 0; tap < fft_size; ++tap) {
double sum = 0.0;
for (int parameter = 0; parameter < 154; ++parameter) {
sum += dictionary[tap * 154u + static_cast<std::size_t>(parameter)] *
parameters[static_cast<std::size_t>(ear * 154 + parameter)];
}
time[tap] = sum;
}
std::vector<std::complex<double>> buffer(fft_size);
for (std::size_t tap = 0; tap < fft_size; ++tap) {
buffer[tap] = std::complex<double>(time[tap], 0.0);
}
dsp::fft_radix2(&buffer, false);
for (std::size_t bin = 0; bin < bins; ++bin) {
reference[static_cast<std::size_t>(ear) * bins + bin] = buffer[bin];
}
}
status = spectrum_at(state, &target);
if (!status.ok()) {
return status;
}
if (target.size() != 2 * bins) {
return reference_error("calibration spectrum has the wrong shape");
}
for (std::size_t index_band = 0; index_band < band_bins.size(); ++index_band) {
const std::size_t bin = band_bins[index_band];
const double weight = weights[index_band];
for (int ear = 0; ear < 2; ++ear) {
const std::size_t offset = static_cast<std::size_t>(ear) * bins + bin;
reference_energy += std::norm(reference[offset]) * weight;
new_energy +=
std::norm(target[offset] * state.direct_gain) * weight;
}
}
}
if (!(reference_energy > 1e-24) || !(new_energy > 1e-24) ||
!std::isfinite(new_energy)) {
return reference_error("reference level calibration has no finite signal energy");
}
*level = std::sqrt(reference_energy / new_energy);
return Status::success();
}
} // namespace joc::binaural
+97
View File
@@ -0,0 +1,97 @@
#pragma once
#include <complex>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <string>
#include <vector>
#include "foundation/status.h"
#include "hrtf/full_hrir_field.h"
#include "hrtf/rosella_bank.h"
#include "hrtf/rosella_model.h"
#include "hrtf/rosella_reference.h"
// Configured reference environment for the SOFA renderer, ported from the
// reference binaural_reference.py: the JSON configuration names the personalized
// model that defines the reference reproduction (room, bank and level anchor),
// and every SOFA direction is mapped through that model's distance profile.
namespace joc::binaural {
// Profile indices, as in the reference rosella_direct module.
inline constexpr int kProfileNear = 1;
inline constexpr int kProfileFar = 2;
inline constexpr int kProfileMid = 3;
struct ReferencePosition {
double direction[3] = {1.0, 0.0, 0.0};
double distance_m = 0.0; // physical distance implied by the metadata
double ear_distance_m = 0.0; // distance floored at the near-centre minimum
double centre_weight = 1.0; // direction vs centre blend
double direct_gain = 1.0;
double room_send = 0.0;
};
class ReferenceEnvironment {
public:
// Loads `config_path` (JSON) and the model it names, verifying its SHA-256.
// An empty path selects `default_reference_config_path()`.
Status load(const std::string& config_path, int mode_index, bool mode_specified);
int profile_index() const { return profile_index_; }
int calibration_profile_index() const { return calibration_profile_index_; }
int minimum_profile_index() const { return calibration_profile_index_; }
const std::string& mode_name() const { return mode_name_; }
const hrtf::RosellaModel& model() const { return model_; }
const std::string& profile_id() const { return profile_id_; }
const std::string& model_sha256() const { return model_sha256_; }
const std::string& configuration_sha256() const { return configuration_sha256_; }
double reference_distance_m() const { return reference_distance_m_; }
double minimum_distance_m() const { return minimum_distance_m_; }
int room_impulse_slots() const { return room_impulse_slots_; }
int calibration_directions() const { return calibration_directions_; }
const std::vector<double>& compiled_receivers_m() const { return compiled_receivers_m_; }
Status map_position(const double position[3], ReferencePosition* out) const;
// `profile_index` selects the distance profile; negative keeps the mode's.
Status map_position(const double position[3], int profile_index,
ReferencePosition* out) const;
Status create_room(std::unique_ptr<hrtf::RosellaRoomFir>* out) const;
// The public bank is the reference bank; the analysis side carries the source
// channels, the synthesis side the two ears.
std::unique_ptr<hrtf::RosellaBank> create_analysis_bank(std::size_t channels) const;
std::unique_ptr<hrtf::RosellaBank> create_synthesis_bank() const;
// Raises the SOFA field to the reference level: one scalar over the equal-area
// calibration directions, shared by all three modes.
using SpectrumAt = std::function<Status(const ReferencePosition&,
std::vector<std::complex<double>>*)>;
Status calibrate(std::size_t fft_size, const std::vector<double>& frequencies,
const SpectrumAt& spectrum_at, double* level) const;
static std::string default_reference_config_path();
private:
hrtf::RosellaModel model_;
std::string config_path_;
std::string profile_id_;
std::string model_sha256_;
std::string configuration_sha256_;
std::string mode_name_;
int calibration_profile_index_ = kProfileMid;
int profile_index_ = kProfileMid;
int room_impulse_slots_ = 4096;
int calibration_directions_ = 128;
double header_constant_ = 1.0; // header_float_scalars[0]
double coupling_ = 0.0; // header_float_scalars[1]
double minimum_distance_m_ = 0.0;
double reference_distance_m_ = 0.0;
std::vector<double> compiled_receivers_m_; // [2][3], when the config supplies them
};
} // namespace joc::binaural
+571
View File
@@ -0,0 +1,571 @@
#include "binaural/sofa_reference_runtime.h"
#include <algorithm>
#include <cmath>
#include <cstring>
#include <limits>
#include "foundation/fft.h"
#include "hrtf/sofa.h"
#include "hrtf/sofa_field.h"
namespace joc::binaural {
namespace {
constexpr double kPi = 3.141592653589793238462643383279502884;
Status runtime_error(const char* message) {
return Status::fail(JOC_ERR_INVALID_ARGUMENT, joc::stage::kRender, message);
}
Status render_fail(const char* message) {
return Status::fail(JOC_ERR_HRTF_FORMAT, joc::stage::kDsp, message);
}
// Inverse real transform: Hermitian half -> n real samples (numpy irfft).
void irfft_to_real(const std::vector<std::complex<double>>& half, std::size_t count,
std::vector<double>* out) {
std::vector<std::complex<double>> buffer(count);
const std::size_t bins = count / 2 + 1;
for (std::size_t bin = 0; bin < bins; ++bin) {
buffer[bin] = half[bin];
}
for (std::size_t bin = 1; bin + 1 < bins; ++bin) {
buffer[count - bin] = std::conj(half[bin]);
}
dsp::fft_radix2(&buffer, true);
out->resize(count);
for (std::size_t index = 0; index < count; ++index) {
(*out)[index] = buffer[index].real();
}
}
// numpy.roll along the sample axis.
void roll_forward(const std::vector<double>& source, std::size_t shift,
std::vector<double>* out) {
const std::size_t count = source.size();
std::vector<double> copy(source);
out->resize(count);
if (count == 0) {
return;
}
const std::size_t offset = shift % count;
for (std::size_t index = 0; index < count; ++index) {
(*out)[index] = copy[(index + count - offset) % count];
}
}
// scipy.signal.firwin(129, 150, fs=48000): windowed-sinc, unit DC gain.
std::vector<double> lowpass_150(double sample_rate) {
constexpr int kTaps = 129;
const double cutoff = 150.0 / (sample_rate * 0.5);
std::vector<double> taps(kTaps, 0.0);
double total = 0.0;
for (int index = 0; index < kTaps; ++index) {
const double position = static_cast<double>(index) - 0.5 * (kTaps - 1);
double value = 0.0;
if (std::fabs(position) < 1e-12) {
value = cutoff;
} else {
value = cutoff * std::sin(kPi * cutoff * position) / (kPi * position);
}
const double window = 0.54 - 0.46 * std::cos(2.0 * kPi * index / (kTaps - 1));
taps[static_cast<std::size_t>(index)] = value * window;
total += value * window;
}
for (double& value : taps) {
value /= total;
}
return taps;
}
void stereo_delay(const std::vector<double>& input, std::size_t delay, std::vector<double>* state,
std::vector<double>* out) {
const std::size_t samples = input.size() / 2;
out->assign(input.size(), 0.0);
const std::size_t capacity = delay * 2;
std::vector<double> joined(capacity + input.size(), 0.0);
for (std::size_t index = 0; index < capacity; ++index) {
joined[index] = (*state)[index];
}
std::copy(input.begin(), input.end(), joined.begin() + static_cast<std::ptrdiff_t>(capacity));
for (std::size_t index = 0; index < input.size(); ++index) {
(*out)[index] = joined[index];
}
state->assign(capacity, 0.0);
for (std::size_t index = 0; index < capacity; ++index) {
(*state)[index] = joined[input.size() + index];
}
}
} // namespace
SofaReferenceRuntime::SofaReferenceRuntime() = default;
SofaReferenceRuntime::~SofaReferenceRuntime() = default;
void SofaReferenceRuntime::rebuild_latency() {
latency_samples_ = std::max(implementation_latency_, bank_latency_) +
std::max(origin_samples_, 0);
room_delay_samples_ = latency_samples_ - bank_latency_;
direct_delay_samples_ = std::max(
0, latency_samples_ - implementation_latency_ - std::max(origin_samples_, 0));
latency_remaining_ = latency_samples_;
room_delay_state_.assign(static_cast<std::size_t>(room_delay_samples_) * 2, 0.0);
direct_delay_state_.assign(static_cast<std::size_t>(direct_delay_samples_) * 2, 0.0);
}
Status SofaReferenceRuntime::open(const std::string& sofa_path,
const SofaReferenceOptions& options) {
output_gain_ = options.output_gain;
Status status = environment_.load(options.reference_config, options.mode_index,
options.mode_specified);
if (!status.ok()) {
return status;
}
hrtf::SofaHrir sofa;
status = hrtf::load_sofa(sofa_path, &sofa);
if (!status.ok()) {
return status;
}
hrtf::CanonicalHrtf canonical;
status = hrtf::canonicalize_sofa(sofa, &canonical);
if (!status.ok()) {
return status;
}
hrtf::FullHrirOptions field_options;
field_options.method = options.interpolation;
field_options.has_shell_radius = options.has_shell_radius;
field_options.shell_radius_m = options.shell_radius_m;
status = field_.build(canonical, field_options);
if (!status.ok()) {
return status;
}
fft_size_ = field_.fft_size();
bins_ = field_.frequency_bins();
frequencies_ = field_.frequencies();
implementation_latency_ = field_.common_latency_samples();
origin_samples_ = field_.recording_origin_samples();
if (origin_samples_ < 0) {
return runtime_error("negative recording origin requires an explicit time base");
}
bank_latency_ = static_cast<int>(hrtf::rosella_bank_latency(hrtf::RosellaBankKind::Public));
if (environment_.minimum_distance_m() <= field_.head_radius_m()) {
return runtime_error("reference near-centre regularization lies inside the head");
}
rebuild_latency();
const auto callback = [this](const ReferencePosition& state,
std::vector<std::complex<double>>* out) {
return spectrum_at(state, out);
};
status = environment_.calibrate(fft_size_, frequencies_, callback, &level_calibration_);
if (!status.ok()) {
return status;
}
analysis_bank_ = environment_.create_analysis_bank(kSofaReferenceSources);
synthesis_bank_ = environment_.create_synthesis_bank();
status = environment_.create_room(&room_);
if (!status.ok()) {
return status;
}
convolver_.configure(kSofaReferenceSources, kSofaReferenceBlock, fft_size_, 2);
hop_block_.assign(kSofaReferenceBlock * kSofaReferenceSources, 0.0);
staging_.assign(kSofaReferenceBatch * kSofaReferenceSources, 0.0);
direct_.assign(kSofaReferenceBlock * 2, 0.0);
qmf_.assign(2 * kSofaReferenceSources * 64, std::complex<double>(0.0, 0.0));
hybrid_.assign(2 * kSofaReferenceSources * 77, std::complex<double>(0.0, 0.0));
room_in_.assign(2 * 77, std::complex<double>(0.0, 0.0));
room_out_.assign(2 * 2 * 77, std::complex<double>(0.0, 0.0));
synth_.assign(2 * 2 * 64, std::complex<double>(0.0, 0.0));
synth_time_.assign(2 * 2 * 64, 0.0);
wet_.assign(kSofaReferenceBlock * 2, 0.0);
sends_.assign(kSofaReferenceSources, 0.0);
send_targets_.assign(kSofaReferenceSources, 0.0);
distance_states_.assign(kSofaReferenceSources, ReferencePosition{});
has_state_.assign(kSofaReferenceSources, 0);
last_position_.assign(kSofaReferenceSources * 3, 0.0);
std::memset(last_key_, 0, sizeof(last_key_));
for (double& value : last_gain_) {
value = std::numeric_limits<double>::quiet_NaN();
}
status = build_lfe_filter();
if (!status.ok()) {
return status;
}
return reset();
}
Status SofaReferenceRuntime::build_lfe_filter() {
const std::vector<double> lowpass = lowpass_150(48000.0);
lfe_filter_.assign(2 * fft_size_, 0.0);
const int start = latency_samples_ - 64;
if (start < 0 || static_cast<std::size_t>(start) + lowpass.size() > fft_size_) {
return runtime_error("LFE latency exceeds the filter budget");
}
const double scale = 1.0 / std::sqrt(2.0);
for (int ear = 0; ear < 2; ++ear) {
for (std::size_t tap = 0; tap < lowpass.size(); ++tap) {
lfe_filter_[static_cast<std::size_t>(ear) * fft_size_ +
static_cast<std::size_t>(start) + tap] = lowpass[tap] * scale;
}
}
return Status::success();
}
Status SofaReferenceRuntime::reset() {
for (hrtf::RosellaBank* bank : {analysis_bank_.get(), synthesis_bank_.get()}) {
if (bank != nullptr) {
bank->reset();
}
}
if (room_) {
room_->reset();
}
convolver_.reset();
timeline_.reset();
output_.clear();
std::fill(sends_.begin(), sends_.end(), 0.0);
std::fill(send_targets_.begin(), send_targets_.end(), 0.0);
std::fill(has_state_.begin(), has_state_.end(), 0);
for (double& value : last_gain_) {
value = std::numeric_limits<double>::quiet_NaN();
}
spectrum_cache_.clear();
pending_room_.clear();
pending_direct_.clear();
pending_slots_ = 0;
pending_direct_samples_ = 0;
input_samples_ = 0;
processed_input_samples_ = 0;
parameter_updates_ = 0;
latency_remaining_ = latency_samples_;
std::fill(room_delay_state_.begin(), room_delay_state_.end(), 0.0);
std::fill(direct_delay_state_.begin(), direct_delay_state_.end(), 0.0);
return Status::success();
}
Status SofaReferenceRuntime::spectrum_at(const ReferencePosition& state,
std::vector<std::complex<double>>* out) {
double key[5] = {state.direction[0], state.direction[1], state.direction[2],
state.ear_distance_m, state.centre_weight};
for (const SpectrumEntry& entry : spectrum_cache_) {
bool match = true;
for (int axis = 0; axis < 5; ++axis) {
if (entry.key[axis] != key[axis]) {
match = false;
break;
}
}
if (match) {
*out = entry.spectrum;
return Status::success();
}
}
std::vector<std::complex<double>> interpolated;
Status status = field_.spectrum(state.direction, &interpolated);
if (!status.ok()) {
return status;
}
std::vector<std::complex<double>> ratio;
status = field_.radial_ratio(state.direction, state.ear_distance_m, &ratio);
if (!status.ok()) {
return status;
}
out->assign(2 * bins_, std::complex<double>(0.0, 0.0));
for (int ear = 0; ear < 2; ++ear) {
for (std::size_t bin = 0; bin < bins_; ++bin) {
const std::size_t offset = static_cast<std::size_t>(ear) * bins_ + bin;
const std::complex<double> radial =
interpolated[offset] * ratio[offset] * state.centre_weight;
(*out)[offset] =
radial + (1.0 - state.centre_weight) * field_.centre_spectrum()[bin];
}
}
SpectrumEntry entry;
for (int axis = 0; axis < 5; ++axis) {
entry.key[axis] = key[axis];
}
entry.spectrum = *out;
if (spectrum_cache_.size() >= 128) {
spectrum_cache_.erase(spectrum_cache_.begin());
}
spectrum_cache_.push_back(std::move(entry));
return Status::success();
}
Status SofaReferenceRuntime::set_source(int source, const double position[3], double gain,
bool special_lfe, bool fade) {
if (source < 0 || source >= kSofaReferenceSources) {
return runtime_error("source index is out of range");
}
if (!std::isfinite(gain)) {
return runtime_error("source gain must be finite");
}
const std::size_t slot = static_cast<std::size_t>(source);
double key[5] = {position[0], position[1], position[2], gain,
special_lfe ? 1.0 : 0.0};
bool unchanged = has_state_[slot] != 0;
for (int axis = 0; axis < 5 && unchanged; ++axis) {
unchanged = last_key_[slot][axis] == key[axis];
}
if (unchanged) {
return Status::success();
}
for (int axis = 0; axis < 5; ++axis) {
last_key_[slot][axis] = key[axis];
}
const bool first = processed_input_samples_ == 0;
std::vector<double> filters(2 * fft_size_, 0.0);
if (special_lfe) {
send_targets_[slot] = 0.0;
std::copy(lfe_filter_.begin(), lfe_filter_.end(), filters.begin());
for (double& value : filters) {
value *= gain;
}
} else {
ReferencePosition state;
Status status = environment_.map_position(position, &state);
if (!status.ok()) {
return status;
}
distance_states_[slot] = state;
send_targets_[slot] = state.room_send * gain;
std::vector<std::complex<double>> spectrum;
status = spectrum_at(state, &spectrum);
if (!status.ok()) {
return status;
}
const double scale = state.direct_gain * level_calibration_ * gain;
for (std::complex<double>& value : spectrum) {
value *= scale;
}
// One ear at a time: the field returns both ears side by side.
std::vector<std::complex<double>> ear_spectrum(bins_);
for (int ear = 0; ear < 2; ++ear) {
std::copy(spectrum.begin() + static_cast<std::ptrdiff_t>(ear * bins_),
spectrum.begin() + static_cast<std::ptrdiff_t>((ear + 1) * bins_),
ear_spectrum.begin());
std::vector<double> impulse;
irfft_to_real(ear_spectrum, fft_size_, &impulse);
roll_forward(impulse, fft_size_ / 2, &impulse);
std::copy(impulse.begin(), impulse.end(),
filters.begin() + static_cast<std::ptrdiff_t>(ear * fft_size_));
}
}
const std::size_t fade_blocks = (first || !fade) ? 0u : 1u;
const Status status = convolver_.set_filter(static_cast<std::size_t>(source),
filters.data(), fft_size_, fade_blocks);
if (!status.ok()) {
return status;
}
has_state_[slot] = 1;
if (first) {
sends_[slot] = send_targets_[slot];
}
++parameter_updates_;
return Status::success();
}
Status SofaReferenceRuntime::process_block() {
// One 128-sample block is two 64-sample hops of the 16 source channels.
std::vector<double> hops(2 * kSofaReferenceSources * 64, 0.0);
for (std::size_t slot = 0; slot < 2; ++slot) {
for (std::size_t channel = 0; channel < kSofaReferenceSources; ++channel) {
for (std::size_t tap = 0; tap < 64; ++tap) {
hops[(slot * kSofaReferenceSources + channel) * 64 + tap] =
hop_block_[(slot * 64 + tap) * kSofaReferenceSources + channel];
}
}
}
analysis_bank_->analyze_qmf(hops, 2, &qmf_);
analysis_bank_->analyze_hybrid(qmf_, 2, &hybrid_);
const double amount[2] = {0.5, 1.0};
std::fill(room_in_.begin(), room_in_.end(), std::complex<double>(0.0, 0.0));
for (std::size_t slot = 0; slot < 2; ++slot) {
for (std::size_t source = 0; source < kSofaReferenceSources; ++source) {
const double ramp = sends_[source] +
(send_targets_[source] - sends_[source]) * amount[slot];
const std::complex<double>* hybrid =
hybrid_.data() + (slot * kSofaReferenceSources + source) * 77;
for (std::size_t band = 0; band < 77; ++band) {
room_in_[slot * 77 + band] += hybrid[band] * ramp;
}
}
}
sends_ = send_targets_;
const Status status = convolver_.process_block(hop_block_.data(), direct_.data());
if (!status.ok()) {
return status;
}
pending_room_.insert(pending_room_.end(), room_in_.begin(), room_in_.end());
pending_direct_.insert(pending_direct_.end(), direct_.begin(), direct_.end());
pending_slots_ += 2;
pending_direct_samples_ += kSofaReferenceBlock;
processed_input_samples_ += kSofaReferenceBlock;
if (pending_slots_ * 64 < static_cast<std::size_t>(kSofaReferenceBatch)) {
return Status::success();
}
return flush_batch(nullptr);
}
Status SofaReferenceRuntime::flush_batch(std::vector<double>* /*out*/) {
const std::size_t slots = pending_slots_;
Status status = room_->process_chunk(pending_room_, slots, &room_out_);
if (!status.ok()) {
return status;
}
synthesis_bank_->synthesize_hybrid(room_out_, slots, &synth_);
synth_time_.assign(slots * 2 * 64, 0.0);
synthesis_bank_->synthesize_qmf(synth_, slots, &synth_time_);
const std::size_t samples = slots * 64;
wet_.assign(samples * 2, 0.0);
for (std::size_t sample = 0; sample < samples; ++sample) {
const std::size_t slot = sample / 64;
const std::size_t tap = sample % 64;
for (std::size_t ear = 0; ear < 2; ++ear) {
wet_[sample * 2 + ear] = synth_time_[(slot * 2 + ear) * 64 + tap];
}
}
std::vector<double> wet_delayed;
std::vector<double> direct_delayed;
stereo_delay(wet_, static_cast<std::size_t>(room_delay_samples_), &room_delay_state_,
&wet_delayed);
stereo_delay(pending_direct_, static_cast<std::size_t>(direct_delay_samples_),
&direct_delay_state_, &direct_delayed);
std::vector<double> combined(samples * 2, 0.0);
for (std::size_t index = 0; index < combined.size(); ++index) {
combined[index] = wet_delayed[index] + direct_delayed[index];
}
const std::size_t skip = static_cast<std::size_t>(
std::min<std::int64_t>(static_cast<std::int64_t>(samples), latency_remaining_));
latency_remaining_ -= static_cast<std::int64_t>(skip);
for (std::size_t sample = skip; sample < samples; ++sample) {
for (std::size_t ear = 0; ear < 2; ++ear) {
output_.push_back(combined[sample * 2 + ear] * output_gain_);
}
}
pending_room_.clear();
pending_direct_.clear();
pending_slots_ = 0;
pending_direct_samples_ = 0;
return Status::success();
}
Status SofaReferenceRuntime::submit_frame(const float* objects16_planar,
const oamd::OamdUpdate* update,
std::int64_t /*frame_index*/,
std::int64_t outer_sample_offset,
std::int64_t object_delay_samples) {
if (objects16_planar == nullptr) {
return runtime_error("frame buffer is null");
}
for (std::size_t channel = 0; channel < kSofaReferenceSources; ++channel) {
for (std::size_t sample = 0; sample < static_cast<std::size_t>(kSofaReferenceBatch);
++sample) {
staging_[sample * kSofaReferenceSources + channel] =
static_cast<double>(objects16_planar[channel * kSofaReferenceBatch + sample]);
}
}
if (update != nullptr) {
const Status status = timeline_.submit_update(*update, input_samples_,
outer_sample_offset,
object_delay_samples,
processed_input_samples_);
if (!status.ok()) {
return status;
}
}
input_samples_ += kSofaReferenceBatch;
for (std::size_t block = 0; block < 12; ++block) {
double positions[timeline::kTimelineObjects][3] = {};
Status status = timeline_.positions_at(processed_input_samples_, positions);
if (!status.ok()) {
return status;
}
status = set_source(0, kSofaReferenceLfePosition, 1.0, true, true);
if (!status.ok()) {
return status;
}
for (int object = 0; object < timeline::kTimelineObjects; ++object) {
status = set_source(object + 1, positions[object], 1.0, false, true);
if (!status.ok()) {
return status;
}
}
for (std::size_t sample = 0; sample < static_cast<std::size_t>(kSofaReferenceBlock);
++sample) {
for (std::size_t channel = 0; channel < kSofaReferenceSources; ++channel) {
hop_block_[sample * kSofaReferenceSources + channel] =
staging_[static_cast<std::size_t>(block * kSofaReferenceBlock + sample) *
kSofaReferenceSources + channel];
}
}
status = process_block();
if (!status.ok()) {
return status;
}
}
return Status::success();
}
std::uint32_t SofaReferenceRuntime::finish_capacity(double tail_seconds) const {
const double tail = tail_seconds;
const double samples = tail * 48000.0 + static_cast<double>(latency_samples_) +
static_cast<double>(fft_size_);
const double blocks = std::ceil(samples / 128.0);
return static_cast<std::uint32_t>(std::max(0.0, blocks * 128.0));
}
Status SofaReferenceRuntime::finish(std::uint32_t flush_samples, std::vector<double>* out) {
if (out == nullptr) {
return runtime_error("finish output is null");
}
std::vector<double> tail;
const std::size_t before = output_.size();
const std::size_t output_samples_before = before;
const std::size_t pending = pending_slots_ * 64;
const std::size_t count = flush_samples;
const double padded_blocks =
std::ceil((static_cast<double>(count + pending)) /
static_cast<double>(kSofaReferenceBatch));
const std::size_t padded = static_cast<std::size_t>(
std::max(0.0, padded_blocks * kSofaReferenceBatch - static_cast<double>(pending)));
const std::int64_t expected =
std::max<std::int64_t>(0, processed_input_samples_ + static_cast<std::int64_t>(count) -
latency_samples_ -
static_cast<std::int64_t>(output_samples_before));
std::fill(hop_block_.begin(), hop_block_.end(), 0.0);
for (std::size_t block = 0; block < padded / kSofaReferenceBlock; ++block) {
double positions[timeline::kTimelineObjects][3] = {};
Status status = timeline_.positions_at(processed_input_samples_, positions);
if (!status.ok()) {
return status;
}
status = set_source(0, kSofaReferenceLfePosition, 1.0, true, true);
if (!status.ok()) {
return status;
}
for (int object = 0; object < timeline::kTimelineObjects; ++object) {
status = set_source(object + 1, positions[object], 1.0, false, true);
if (!status.ok()) {
return status;
}
}
status = process_block();
if (!status.ok()) {
return status;
}
}
tail.assign(output_.begin() + static_cast<std::ptrdiff_t>(before), output_.end());
if (static_cast<std::int64_t>(tail.size()) > expected) {
tail.resize(static_cast<std::size_t>(expected));
}
output_.resize(before + tail.size() / 2 * 2);
out->swap(tail);
return Status::success();
}
} // namespace joc::binaural
+155
View File
@@ -0,0 +1,155 @@
#pragma once
#include <complex>
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
#include "binaural/binaural_reference.h"
#include "foundation/status.h"
#include "hrtf/full_hrir_field.h"
#include "hrtf/partitioned_convolution.h"
#include "hrtf/rosella_bank.h"
#include "hrtf/rosella_reference.h"
#include "oamd/oamd_parser.h"
#include "timeline/position_timeline.h"
// SOFA binaural renderer with a configured reference environment, ported from
// the reference sofa_reference_backend.py: the direct sound is the interpolated
// full HRIR (delay-aligned, partitioned convolution), the room send goes through
// the reference model's room, and the two are summed after their own latency
// compensation.
namespace joc::binaural {
inline constexpr int kSofaReferenceSources = 16;
inline constexpr int kSofaReferenceBlock = 128;
inline constexpr int kSofaReferenceBatch = 1536;
inline constexpr double kSofaReferenceLfePosition[3] = {0.0, 1.0, 0.0};
struct SofaReferenceOptions {
int mode_index = kProfileMid;
bool mode_specified = false;
std::string reference_config; // empty selects the default configuration
hrtf::HrirInterpolation interpolation = hrtf::HrirInterpolation::kLogMagnitudePhase;
bool has_shell_radius = false;
double shell_radius_m = 0.0;
double output_gain = 1.0;
std::int64_t object_delay_samples = 1473;
double tail_seconds = 5.0;
};
class SofaReferenceRuntime {
public:
SofaReferenceRuntime();
~SofaReferenceRuntime();
SofaReferenceRuntime(const SofaReferenceRuntime&) = delete;
SofaReferenceRuntime& operator=(const SofaReferenceRuntime&) = delete;
Status open(const std::string& sofa_path, const SofaReferenceOptions& options);
// objects16_planar is channel-major: channel * 1536 + sample.
Status submit_frame(const float* objects16_planar, const oamd::OamdUpdate* update,
std::int64_t frame_index, std::int64_t outer_sample_offset,
std::int64_t object_delay_samples);
Status finish(std::uint32_t flush_samples, std::vector<double>* out);
std::uint32_t finish_capacity(double tail_seconds) const;
Status reset();
const std::vector<double>& output() const { return output_; }
void take_output(std::vector<double>* out) {
out->swap(output_);
output_.clear();
}
std::uint64_t input_samples() const { return input_samples_; }
std::uint64_t processed_input_samples() const { return processed_input_samples_; }
std::uint64_t parameter_updates() const { return parameter_updates_; }
const timeline::OamdPositionTimeline& timeline() const { return timeline_; }
void set_fixed_position(int object_index, const double position[3]) {
timeline_.set_fixed_position(object_index, position);
}
// Reporting surface (mirrors the reference backend's info()).
int latency_samples() const { return latency_samples_; }
int recording_origin_samples() const { return origin_samples_; }
double level_calibration() const { return level_calibration_; }
const ReferenceEnvironment& environment() const { return environment_; }
const hrtf::FullHrirField& field() const { return field_; }
bool fixed_reference() const { return true; }
private:
Status process_block();
Status flush_batch(std::vector<double>* out);
Status set_source(int source, const double position[3], double gain, bool special_lfe,
bool fade);
Status spectrum_at(const ReferencePosition& state,
std::vector<std::complex<double>>* out);
Status build_lfe_filter();
void rebuild_latency();
ReferenceEnvironment environment_;
hrtf::FullHrirField field_;
std::unique_ptr<hrtf::RosellaBank> analysis_bank_;
std::unique_ptr<hrtf::RosellaBank> synthesis_bank_;
std::unique_ptr<hrtf::RosellaRoomFir> room_;
hrtf::MultiSourcePartitionedConvolver convolver_;
std::vector<double> lfe_filter_; // [2][fft_size]
std::vector<double> sends_; // [sources]
std::vector<double> send_targets_;
std::vector<ReferencePosition> distance_states_;
std::vector<std::uint8_t> has_state_;
double last_gain_[kSofaReferenceSources] = {};
std::vector<double> last_position_; // [sources][3]
double last_key_[kSofaReferenceSources][5] = {};
std::vector<std::complex<double>> pending_room_; // [slots][77]
std::vector<double> pending_direct_; // [samples][2]
std::size_t pending_slots_ = 0;
std::size_t pending_direct_samples_ = 0;
std::vector<double> hop_block_; // [block][sources]
std::vector<double> staging_; // [frame][sources]
std::vector<double> output_;
std::vector<std::complex<double>> qmf_; // [slots][sources][64]
std::vector<std::complex<double>> hybrid_; // [slots][sources][77]
std::vector<std::complex<double>> room_in_; // [bins][77]
std::vector<std::complex<double>> room_out_; // [bins][2][77]
std::vector<std::complex<double>> synth_; // [bins][2][64]
std::vector<double> synth_time_; // [bins][2][64]
std::vector<double> wet_; // [samples][2]
std::vector<double> direct_; // [samples][2]
// Reference-position spectrum cache (the reference keeps 128 entries).
struct SpectrumEntry {
double key[5] = {};
std::vector<std::complex<double>> spectrum;
};
std::vector<SpectrumEntry> spectrum_cache_;
timeline::OamdPositionTimeline timeline_;
std::int64_t input_samples_ = 0;
std::int64_t processed_input_samples_ = 0;
std::uint64_t parameter_updates_ = 0;
int origin_samples_ = 0;
int latency_samples_ = 0;
int implementation_latency_ = 0;
int bank_latency_ = 0;
int room_delay_samples_ = 0;
int direct_delay_samples_ = 0;
std::int64_t latency_remaining_ = 0;
double level_calibration_ = 1.0;
double output_gain_ = 1.0;
std::size_t fft_size_ = 0;
std::size_t bins_ = 0;
std::vector<double> frequencies_;
std::vector<double> room_delay_state_;
std::vector<double> direct_delay_state_;
bool empty_block_ = true;
};
} // namespace joc::binaural
+37 -7
View File
@@ -48,7 +48,9 @@ struct Options {
bool rosella_filterbank_set = false; bool rosella_filterbank_set = false;
std::string hrtf_cache_policy; std::string hrtf_cache_policy;
std::string hrtf_cache_dir; std::string hrtf_cache_dir;
double hrtf_radius_m = 1.0; double hrtf_radius_m = 0.0; // 0 selects the single measurement shell
std::string reference_config;
std::string sofa_interpolation;
double binaural_tail_seconds = 5.0; double binaural_tail_seconds = 5.0;
double binaural_tail_threshold = 1.0e-8; double binaural_tail_threshold = 1.0e-8;
int binaural_chunk_frames = 64; int binaural_chunk_frames = 64;
@@ -250,6 +252,8 @@ void parse_args(const std::vector<std::string>& arguments, Options* options) {
else if (arg == "--hrtf-cache-policy") { options->hrtf_cache_policy = require_value(arguments, &index); } else if (arg == "--hrtf-cache-policy") { options->hrtf_cache_policy = require_value(arguments, &index); }
else if (arg == "--hrtf-cache-dir") { options->hrtf_cache_dir = require_value(arguments, &index); } else if (arg == "--hrtf-cache-dir") { options->hrtf_cache_dir = require_value(arguments, &index); }
else if (arg == "--hrtf-radius-m") { options->hrtf_radius_m = to_double(require_value(arguments, &index), "--hrtf-radius-m"); } else if (arg == "--hrtf-radius-m") { options->hrtf_radius_m = to_double(require_value(arguments, &index), "--hrtf-radius-m"); }
else if (arg == "--reference-config") { options->reference_config = require_value(arguments, &index); }
else if (arg == "--sofa-interpolation") { options->sofa_interpolation = require_value(arguments, &index); }
else if (arg == "--binaural-tail-seconds") { options->binaural_tail_seconds = to_double(require_value(arguments, &index), "--binaural-tail-seconds"); } else if (arg == "--binaural-tail-seconds") { options->binaural_tail_seconds = to_double(require_value(arguments, &index), "--binaural-tail-seconds"); }
else if (arg == "--binaural-tail-threshold") { options->binaural_tail_threshold = to_double(require_value(arguments, &index), "--binaural-tail-threshold"); } else if (arg == "--binaural-tail-threshold") { options->binaural_tail_threshold = to_double(require_value(arguments, &index), "--binaural-tail-threshold"); }
else if (arg == "--binaural-chunk-frames") { options->binaural_chunk_frames = static_cast<int>(to_int(require_value(arguments, &index), "--binaural-chunk-frames")); } else if (arg == "--binaural-chunk-frames") { options->binaural_chunk_frames = static_cast<int>(to_int(require_value(arguments, &index), "--binaural-chunk-frames")); }
@@ -354,7 +358,10 @@ struct HrtfInput {
std::string compiled_path; // or read this .jochrtf directly std::string compiled_path; // or read this .jochrtf directly
std::string cache_dir; // disk policy directory std::string cache_dir; // disk policy directory
std::string personalized_path; // Rosella .personalized_headphone std::string personalized_path; // Rosella .personalized_headphone
std::string reference_config; // SOFA reference environment
std::string interpolation; // SOFA local interpolation
bool disk = false; bool disk = false;
bool compile = false;
}; };
std::string resolve_compiled_hrtf(const Options& options, const std::string& project_directory) { std::string resolve_compiled_hrtf(const Options& options, const std::string& project_directory) {
@@ -396,12 +403,12 @@ HrtfInput resolve_hrtf_input(const Options& options, const std::string& project_
if (!options.compiled_hrtf_cache.empty() && !options.hrtf_cache_policy.empty()) { if (!options.compiled_hrtf_cache.empty() && !options.hrtf_cache_policy.empty()) {
fail("显式 .jochrtf 输入不能再指定 --hrtf-cache-policy"); fail("显式 .jochrtf 输入不能再指定 --hrtf-cache-policy");
} }
if (!options.compiled_hrtf_cache.empty() && options.hrtf_radius_m != 1.0) { if (!options.compiled_hrtf_cache.empty() && options.hrtf_radius_m > 0.0) {
fail("显式 .jochrtf 输入不能再选择 SOFA radius shell"); fail("显式 .jochrtf 输入不能再选择 SOFA radius shell");
} }
if (options.personalized_headphone_used && if (options.personalized_headphone_used &&
(!options.hrtf_cache_policy.empty() || !options.hrtf_cache_dir.empty() || (!options.hrtf_cache_policy.empty() || !options.hrtf_cache_dir.empty() ||
options.hrtf_radius_m != 1.0)) { options.hrtf_radius_m > 0.0)) {
fail("Rosella 模型输入不能使用 --hrtf-cache-policy/--hrtf-cache-dir/--hrtf-radius-m"); fail("Rosella 模型输入不能使用 --hrtf-cache-policy/--hrtf-cache-dir/--hrtf-radius-m");
} }
@@ -434,7 +441,7 @@ HrtfInput resolve_hrtf_input(const Options& options, const std::string& project_
} }
if (sofa.empty() && compiled.empty()) { if (sofa.empty() && compiled.empty()) {
if (!options.hrtf_cache_policy.empty() || !options.hrtf_cache_dir.empty() || if (!options.hrtf_cache_policy.empty() || !options.hrtf_cache_dir.empty() ||
options.hrtf_radius_m != 1.0) { options.hrtf_radius_m > 0.0) {
fail("HRTF cache/radius 选项需要 --sofa-hrtf"); fail("HRTF cache/radius 选项需要 --sofa-hrtf");
} }
fail("--binaural 未找到 HRTF 输入:默认 " + default_sofa + "、" + default_private + fail("--binaural 未找到 HRTF 输入:默认 " + default_sofa + "、" + default_private +
@@ -443,7 +450,7 @@ HrtfInput resolve_hrtf_input(const Options& options, const std::string& project_
"或 --compiled-hrtf-cache PATH 指定"); "或 --compiled-hrtf-cache PATH 指定");
} }
if (sofa.empty() && (!options.hrtf_cache_policy.empty() || !options.hrtf_cache_dir.empty() || if (sofa.empty() && (!options.hrtf_cache_policy.empty() || !options.hrtf_cache_dir.empty() ||
options.hrtf_radius_m != 1.0)) { options.hrtf_radius_m > 0.0)) {
fail("HRTF cache/radius 选项需要 --sofa-hrtf"); fail("HRTF cache/radius 选项需要 --sofa-hrtf");
} }
if (sofa.empty()) { if (sofa.empty()) {
@@ -452,11 +459,18 @@ HrtfInput resolve_hrtf_input(const Options& options, const std::string& project_
} }
const std::string effective_policy = const std::string effective_policy =
options.hrtf_cache_policy.empty() ? "memory" : options.hrtf_cache_policy; options.hrtf_cache_policy.empty() ? "memory" : options.hrtf_cache_policy;
input.compile = !options.hrtf_cache_policy.empty() || !options.hrtf_cache_dir.empty();
if (!options.hrtf_cache_dir.empty() && effective_policy != "disk") { if (!options.hrtf_cache_dir.empty() && effective_policy != "disk") {
fail("--hrtf-cache-dir 需要 SOFA 与 disk cache policy 一起使用"); fail("--hrtf-cache-dir 需要 SOFA 与 disk cache policy 一起使用");
} }
input.sofa_path = sofa; input.sofa_path = sofa;
input.disk = effective_policy == "disk"; input.disk = effective_policy == "disk";
input.reference_config =
options.reference_config.empty()
? fs_utf8::from_path(fs_utf8::to_path(project_directory) / "local" /
"binaural_reference.json")
: options.reference_config;
input.interpolation = options.sofa_interpolation;
input.cache_dir = options.hrtf_cache_dir.empty() ? default_cache_dir : options.hrtf_cache_dir; input.cache_dir = options.hrtf_cache_dir.empty() ? default_cache_dir : options.hrtf_cache_dir;
if (!fs_utf8::exists(input.sofa_path)) { if (!fs_utf8::exists(input.sofa_path)) {
fail("SOFA HRTF 不存在: " + input.sofa_path); fail("SOFA HRTF 不存在: " + input.sofa_path);
@@ -564,6 +578,10 @@ int main(int argc, char** argv) {
{"ask", "continue", "float32", "abort"}); {"ask", "continue", "float32", "abort"});
check_choice(options.binaural_mode, "--binaural-mode", {"off", "near", "mid", "far"}); check_choice(options.binaural_mode, "--binaural-mode", {"off", "near", "mid", "far"});
check_choice(options.trajectory_mode, "--trajectory-mode", {"compact", "dense64"}); check_choice(options.trajectory_mode, "--trajectory-mode", {"compact", "dense64"});
if (!options.sofa_interpolation.empty()) {
check_choice(options.sofa_interpolation, "--sofa-interpolation",
{"lf_logmag_phase", "lf_mca_zero"});
}
check_choice(options.backend, "--backend", {"auto", "native", "python"}); check_choice(options.backend, "--backend", {"auto", "native", "python"});
check_choice(options.print_metadata, "--print-metadata", {"none", "summary", "frames"}); check_choice(options.print_metadata, "--print-metadata", {"none", "summary", "frames"});
check_choice(options.metadata_backend, "--metadata-backend", {"auto", "emdf", "sidecar"}); check_choice(options.metadata_backend, "--metadata-backend", {"auto", "emdf", "sidecar"});
@@ -605,7 +623,7 @@ int main(int argc, char** argv) {
const bool hrtf_options_used = const bool hrtf_options_used =
!options.sofa_hrtf.empty() || !options.compiled_hrtf_cache.empty() || !options.sofa_hrtf.empty() || !options.compiled_hrtf_cache.empty() ||
options.personalized_headphone_used || !options.hrtf_cache_policy.empty() || options.personalized_headphone_used || !options.hrtf_cache_policy.empty() ||
!options.hrtf_cache_dir.empty() || options.hrtf_radius_m != 1.0; !options.hrtf_cache_dir.empty() || options.hrtf_radius_m > 0.0;
if (hrtf_options_used && !binaural_mode) { if (hrtf_options_used && !binaural_mode) {
fail("SOFA/HRTF 选项仅与 --binaural 一起使用"); fail("SOFA/HRTF 选项仅与 --binaural 一起使用");
} }
@@ -623,7 +641,7 @@ int main(int argc, char** argv) {
if (options.binaural_chunk_frames <= 0) { if (options.binaural_chunk_frames <= 0) {
fail("binaural-chunk-frames 必须大于 0"); fail("binaural-chunk-frames 必须大于 0");
} }
if (!std::isfinite(options.hrtf_radius_m) || options.hrtf_radius_m <= 0.0) { if (!std::isfinite(options.hrtf_radius_m) || options.hrtf_radius_m < 0.0) {
fail("hrtf-radius-m 必须是正有限值"); fail("hrtf-radius-m 必须是正有限值");
} }
if (options.duration_set && options.duration <= 0.0) { if (options.duration_set && options.duration <= 0.0) {
@@ -718,12 +736,18 @@ int main(int argc, char** argv) {
std::string hrtf_cache_dir; std::string hrtf_cache_dir;
std::string personalized_path; std::string personalized_path;
std::string kernels_path; std::string kernels_path;
std::string hrtf_reference_config;
std::string hrtf_interpolation;
bool hrtf_compile = false;
if (binaural_mode) { if (binaural_mode) {
try { try {
const HrtfInput input = resolve_hrtf_input(options, project_directory); const HrtfInput input = resolve_hrtf_input(options, project_directory);
hrtf_path = input.compiled_path; hrtf_path = input.compiled_path;
hrtf_sofa_path = input.sofa_path; hrtf_sofa_path = input.sofa_path;
hrtf_cache_dir = input.cache_dir; hrtf_cache_dir = input.cache_dir;
hrtf_reference_config = input.reference_config;
hrtf_interpolation = input.interpolation;
hrtf_compile = input.compile;
personalized_path = input.personalized_path; personalized_path = input.personalized_path;
kernels_path = find_kernels(options, arguments.empty() ? std::string() kernels_path = find_kernels(options, arguments.empty() ? std::string()
: arguments.front()); : arguments.front());
@@ -745,6 +769,12 @@ int main(int argc, char** argv) {
: options.hrtf_cache_policy == "none" ? JOC_HRTF_CACHE_NONE : options.hrtf_cache_policy == "none" ? JOC_HRTF_CACHE_NONE
: JOC_HRTF_CACHE_MEMORY; : JOC_HRTF_CACHE_MEMORY;
config.hrtf_radius_m = options.hrtf_radius_m; config.hrtf_radius_m = options.hrtf_radius_m;
config.reference_config_path =
hrtf_reference_config.empty() ? nullptr : hrtf_reference_config.c_str();
config.sofa_interpolation = hrtf_interpolation == "lf_mca_zero"
? JOC_SOFA_INTERPOLATION_MCA_ZERO
: JOC_SOFA_INTERPOLATION_LOGMAG_PHASE;
config.hrtf_compile = hrtf_compile ? 1u : 0u;
config.kernels_path = kernels_path.empty() ? nullptr : kernels_path.c_str(); config.kernels_path = kernels_path.empty() ? nullptr : kernels_path.c_str();
joc_validation_issue issues[32]; joc_validation_issue issues[32];
+774
View File
@@ -0,0 +1,774 @@
#include "hrtf/full_hrir_field.h"
#include <algorithm>
#include <cmath>
#include <complex>
#include <cstring>
#include <limits>
#include "foundation/fft.h"
#include "hrtf/sofa_field.h"
namespace joc::hrtf {
namespace {
constexpr double kPi = 3.141592653589793238462643383279502884;
constexpr double kSoundSpeed = 343.3;
constexpr double kScanTolerance = 1.0e-10;
constexpr int kMcaBands = 41;
Status field_error(const char* message) {
return Status::fail(JOC_ERR_HRTF_FORMAT, joc::stage::kRender, message);
}
Status argument_error(const char* message) {
return Status::fail(JOC_ERR_INVALID_ARGUMENT, joc::stage::kRender, message);
}
// Unnormalised forward transform of a real block, first n/2+1 bins (numpy rfft).
void real_fft(const double* time, std::size_t count, std::vector<std::complex<double>>* out) {
std::vector<std::complex<double>> buffer(count);
for (std::size_t index = 0; index < count; ++index) {
buffer[index] = std::complex<double>(time[index], 0.0);
}
dsp::fft_radix2(&buffer, false);
out->assign(buffer.begin(), buffer.begin() + static_cast<std::ptrdiff_t>(count / 2 + 1));
}
// In-place phase unwrapping (numpy.unwrap with the default 2*pi period).
void unwrap_phase(const std::vector<double>& wrapped, std::vector<double>* out) {
out->assign(wrapped.size(), 0.0);
if (wrapped.empty()) {
return;
}
(*out)[0] = wrapped[0];
for (std::size_t index = 1; index < wrapped.size(); ++index) {
double delta = wrapped[index] - wrapped[index - 1];
delta -= 2.0 * kPi * std::round(delta / (2.0 * kPi));
(*out)[index] = (*out)[index - 1] + delta;
}
}
double median(std::vector<double> values) {
if (values.empty()) {
return 0.0;
}
const std::size_t middle = values.size() / 2;
std::nth_element(values.begin(), values.begin() + static_cast<std::ptrdiff_t>(middle),
values.end());
if (values.size() % 2 != 0) {
return values[middle];
}
const double upper = values[middle];
std::nth_element(values.begin(), values.begin() + static_cast<std::ptrdiff_t>(middle - 1),
values.end());
return 0.5 * (values[middle - 1] + upper);
}
// scipy.signal._cubic edge/interior slopes of PchipInterpolator.
double pchip_edge(double h0, double h1, double m0, double m1) {
double derivative = ((2.0 * h0 + h1) * m0 - h0 * m1) / (h0 + h1);
const bool opposite = std::signbit(derivative) != std::signbit(m0);
const bool clamp = (std::signbit(m0) != std::signbit(m1)) &&
(std::fabs(derivative) > 3.0 * std::fabs(m0));
if (opposite) {
derivative = 0.0;
} else if (clamp) {
derivative = 3.0 * m0;
}
return derivative;
}
class PchipEvaluator {
public:
void build(const std::vector<double>& x, const std::vector<double>& y) {
x_ = x;
y_ = y;
const std::size_t count = x.size();
d_.assign(count, 0.0);
std::vector<double> h(count - 1);
std::vector<double> delta(count - 1);
for (std::size_t index = 0; index + 1 < count; ++index) {
h[index] = x[index + 1] - x[index];
delta[index] = h[index] != 0.0 ? (y[index + 1] - y[index]) / h[index] : 0.0;
}
if (count == 2) {
d_[0] = delta[0];
d_[1] = delta[0];
return;
}
d_[0] = pchip_edge(h[0], h[1], delta[0], delta[1]);
d_[count - 1] = pchip_edge(h[count - 2], h[count - 3], delta[count - 2], delta[count - 3]);
for (std::size_t index = 1; index + 1 < count; ++index) {
if (delta[index - 1] * delta[index] <= 0.0) {
d_[index] = 0.0;
continue;
}
const double w1 = 2.0 * h[index] + h[index - 1];
const double w2 = h[index] + 2.0 * h[index - 1];
d_[index] = (w1 + w2) / (w1 / delta[index - 1] + w2 / delta[index]);
}
}
double evaluate(double value) const {
const std::size_t count = x_.size();
if (count < 2) {
return count == 1 ? y_[0] : 0.0;
}
std::size_t index = 0;
if (value >= x_.back()) {
index = count - 2;
} else if (value > x_.front()) {
index = static_cast<std::size_t>(
std::upper_bound(x_.begin(), x_.end(), value) - x_.begin()) - 1;
}
const double h = x_[index + 1] - x_[index];
if (h == 0.0) {
return y_[index];
}
const double t = (value - x_[index]) / h;
const double t2 = t * t;
const double t3 = t2 * t;
return (2.0 * t3 - 3.0 * t2 + 1.0) * y_[index] +
(t3 - 2.0 * t2 + t) * h * d_[index] +
(-2.0 * t3 + 3.0 * t2) * y_[index + 1] +
(t3 - t2) * h * d_[index + 1];
}
private:
std::vector<double> x_;
std::vector<double> y_;
std::vector<double> d_;
};
} // namespace
Status sphere_transfer(const std::vector<double>& frequencies, double radius, double head_radius,
const std::vector<double>& cosines,
std::vector<std::complex<double>>* out) {
if (out == nullptr || !(radius > head_radius) || head_radius <= 0.0) {
return argument_error("sphere transfer needs a source outside the head");
}
const std::size_t bands = frequencies.size();
out->assign(cosines.size() * bands, std::complex<double>(0.0, 0.0));
std::vector<std::complex<double>> x(bands);
std::vector<std::complex<double>> z(bands);
std::vector<std::complex<double>> ratio_a(bands);
std::vector<std::complex<double>> ratio_r(bands);
std::vector<std::complex<double>> product(bands, std::complex<double>(1.0, 0.0));
double maximum_x = 0.0;
for (std::size_t band = 0; band < bands; ++band) {
const double wave = 2.0 * kPi * frequencies[band] * head_radius / kSoundSpeed;
maximum_x = std::max(maximum_x, wave);
x[band] = std::complex<double>(wave, 0.0);
z[band] = std::complex<double>(wave * radius / head_radius, 0.0);
ratio_a[band] = x[band] / (1.0 + std::complex<double>(0.0, 1.0) * x[band]);
ratio_r[band] = z[band] / (1.0 + std::complex<double>(0.0, 1.0) * z[band]);
}
const double geometric = std::ceil(std::log(kScanTolerance) / std::log(head_radius / radius)) + 16.0;
const int order = static_cast<int>(std::max(std::ceil(maximum_x) + 32.0, geometric));
if (order > 4096) {
return argument_error("source too close to the sphere surface");
}
std::vector<double> legendre_previous(cosines.size(), 1.0);
std::vector<double> legendre(cosines.size(), 0.0);
std::vector<double> mu(cosines.size());
for (std::size_t row = 0; row < cosines.size(); ++row) {
mu[row] = std::clamp(cosines[row], -1.0, 1.0);
legendre[row] = mu[row];
for (std::size_t band = 0; band < bands; ++band) {
const std::complex<double> value = 1.0 / (1.0 + std::complex<double>(0.0, 1.0) * x[band]);
(*out)[row * bands + band] = value;
}
}
std::vector<std::complex<double>> term(bands);
for (int degree = 1; degree <= order; ++degree) {
for (std::size_t band = 0; band < bands; ++band) {
const std::complex<double> quotient =
std::abs(z[band]) != 0.0 ? ratio_a[band] / ratio_r[band]
: std::complex<double>(head_radius / radius, 0.0);
product[band] *= quotient;
term[band] = product[band] /
((static_cast<double>(degree) + 1.0) -
x[band] * ratio_a[band]);
}
for (std::size_t row = 0; row < cosines.size(); ++row) {
const double factor = (2.0 * static_cast<double>(degree) + 1.0) * legendre[row];
for (std::size_t band = 0; band < bands; ++band) {
(*out)[row * bands + band] += factor * term[band];
}
}
// Legendre recurrence P_{n+1} = ((2n+1) mu P_n - n P_{n-1}) / (n+1).
for (std::size_t row = 0; row < cosines.size(); ++row) {
const double next =
((2.0 * static_cast<double>(degree) + 1.0) * mu[row] * legendre[row] -
static_cast<double>(degree) * legendre_previous[row]) /
(static_cast<double>(degree) + 1.0);
legendre_previous[row] = legendre[row];
legendre[row] = next;
}
for (std::size_t band = 0; band < bands; ++band) {
const double denominator_a =
(2.0 * static_cast<double>(degree) + 1.0);
ratio_a[band] = x[band] / (denominator_a - x[band] * ratio_a[band]);
ratio_r[band] = z[band] / (denominator_a - z[band] * ratio_r[band]);
}
}
for (std::size_t band = 0; band < bands; ++band) {
const std::complex<double> phase = std::exp(std::complex<double>(0.0, 1.0) * x[band]);
for (std::size_t row = 0; row < cosines.size(); ++row) {
(*out)[row * bands + band] *= phase;
}
}
for (const std::complex<double>& value : *out) {
if (!std::isfinite(value.real()) || !std::isfinite(value.imag())) {
return field_error("sphere series failed to converge");
}
}
return Status::success();
}
Status FullHrirField::build(const CanonicalHrtf& canonical, const FullHrirOptions& options) {
method_ = options.method;
if (std::fabs(canonical.sample_rate_hz - 48000.0) > 1e-9) {
return field_error("full HRIR renderer requires 48000 Hz");
}
if (canonical.measurements == 0 || canonical.taps == 0) {
return field_error("canonical HRIR set is empty");
}
if (canonical.hrir.size() < static_cast<std::size_t>(canonical.measurements) * 2u *
canonical.taps ||
canonical.delay_samples.size() < static_cast<std::size_t>(canonical.measurements) * 2u) {
return field_error("canonical HRIR set is truncated");
}
// Shell selection: an explicit radius wins, otherwise a single shell is required.
std::vector<double> shells(canonical.measurement_radius_m.begin(),
canonical.measurement_radius_m.end());
std::sort(shells.begin(), shells.end());
shells.erase(std::unique(shells.begin(), shells.end(),
[](double a, double b) { return std::fabs(a - b) < 1e-9; }),
shells.end());
if (!options.has_shell_radius && shells.size() != 1) {
return field_error("multi-radius SOFA requires an explicit shell radius");
}
if (options.has_shell_radius && (!std::isfinite(options.shell_radius_m) ||
options.shell_radius_m <= 0.0)) {
return field_error("shell radius must be finite and positive");
}
const double requested = options.has_shell_radius ? options.shell_radius_m : shells[0];
double actual_radius = 0.0;
const std::vector<std::size_t> selected =
canonical_shell_indices(canonical, requested, &actual_radius);
// Every selected ear must carry energy; delays size the FFT budget.
double maximum_delay = 0.0;
for (const std::size_t row : selected) {
for (int ear = 0; ear < 2; ++ear) {
double energy = 0.0;
const double* taps = canonical.hrir.data() +
(row * 2u + static_cast<std::size_t>(ear)) * canonical.taps;
for (std::uint32_t tap = 0; tap < canonical.taps; ++tap) {
energy += taps[tap] * taps[tap];
}
if (!(energy > 0.0)) {
return field_error("each selected HRIR ear must contain signal energy");
}
maximum_delay = std::max(maximum_delay,
canonical.delay_samples[row * 2u +
static_cast<std::size_t>(ear)]);
}
}
taps_ = canonical.taps;
std::vector<double> radii;
radii.reserve(selected.size());
for (const std::size_t row : selected) {
radii.push_back(canonical.measurement_radius_m[row]);
}
measurement_radius_m_ = median(radii);
const double support = static_cast<double>(canonical.taps) +
std::ceil(maximum_delay) + 1.0;
std::size_t fft_size = options.fft_size;
if (fft_size == 0) {
fft_size = 2048;
while (fft_size < static_cast<std::size_t>(2.0 * support - 1.0)) {
fft_size <<= 1u;
}
if (fft_size > 16384) {
return field_error("HRIR and Data.Delay exceed the automatic FFT budget");
}
}
if (fft_size < 64 || fft_size % 2 != 0 ||
static_cast<double>(canonical.taps) + maximum_delay >=
static_cast<double>(fft_size / 2)) {
return field_error("HRIR and Data.Delay exceed the selected FFT time budget");
}
fft_size_ = fft_size;
bins_ = fft_size / 2 + 1;
// Receiver geometry: a fixed pair, centred on the listener, one radius.
if (canonical.receiver_position_cartesian_m.size() < 6u) {
return field_error("ReceiverPosition is missing");
}
const double* left = canonical.receiver_position_cartesian_m.data();
const double* right = left + 3;
const double mean[3] = {(left[0] + right[0]) * 0.5, (left[1] + right[1]) * 0.5,
(left[2] + right[2]) * 0.5};
if (std::sqrt(mean[0] * mean[0] + mean[1] * mean[1] + mean[2] * mean[2]) > 1e-6) {
return field_error("radial model requires ears centred on the listener");
}
head_radius_m_ = std::sqrt(left[0] * left[0] + left[1] * left[1] + left[2] * left[2]);
const double right_radius = std::sqrt(right[0] * right[0] + right[1] * right[1] +
right[2] * right[2]);
if (!(head_radius_m_ > 0.04 && head_radius_m_ < 0.15) ||
std::fabs(right_radius - head_radius_m_) > 1e-6) {
return field_error("unsupported receiver geometry for the radial model");
}
ear_directions_.assign(6, 0.0);
for (int axis = 0; axis < 3; ++axis) {
ear_directions_[static_cast<std::size_t>(axis)] = left[axis] / head_radius_m_;
ear_directions_[3u + static_cast<std::size_t>(axis)] = right[axis] / head_radius_m_;
}
// Frequencies and phase-fit grid.
frequencies_.resize(bins_);
omega_.resize(bins_);
for (std::size_t bin = 0; bin < bins_; ++bin) {
frequencies_[bin] = static_cast<double>(bin) * 48000.0 / static_cast<double>(fft_size_);
omega_[bin] = 2.0 * kPi * frequencies_[bin] / 48000.0;
}
std::size_t fit_begin = 0;
std::size_t fit_end = 0;
double omega_mean = 0.0;
for (std::size_t bin = 0; bin < bins_; ++bin) {
if (frequencies_[bin] >= 200.0 && frequencies_[bin] <= 1500.0) {
if (fit_end == fit_begin) {
fit_begin = bin;
}
fit_end = bin + 1;
}
}
if (fit_end <= fit_begin) {
return field_error("the phase-fit band is empty");
}
for (std::size_t bin = fit_begin; bin < fit_end; ++bin) {
omega_mean += omega_[bin];
}
omega_mean /= static_cast<double>(fit_end - fit_begin);
double x_squares = 0.0;
std::vector<double> x_fit(fit_end - fit_begin);
for (std::size_t bin = fit_begin; bin < fit_end; ++bin) {
x_fit[bin - fit_begin] = omega_[bin] - omega_mean;
x_squares += x_fit[bin - fit_begin] * x_fit[bin - fit_begin];
}
// Raw spectra, then delay estimation and alignment.
const std::size_t rows = selected.size();
std::vector<std::complex<double>> raw(rows * 2 * bins_);
for (std::size_t row = 0; row < rows; ++row) {
for (int ear = 0; ear < 2; ++ear) {
const double* taps = canonical.hrir.data() +
(selected[row] * 2u + static_cast<std::size_t>(ear)) *
canonical.taps;
std::vector<double> padded(fft_size_, 0.0);
std::memcpy(padded.data(), taps, sizeof(double) * canonical.taps);
std::vector<std::complex<double>> spectrum;
real_fft(padded.data(), fft_size_, &spectrum);
std::copy(spectrum.begin(), spectrum.end(),
raw.begin() + static_cast<std::ptrdiff_t>((row * 2u +
static_cast<std::size_t>(ear)) *
bins_));
}
}
delays_.assign(rows * 2, 0.0);
std::vector<double> residuals;
std::vector<double> wrapped(bins_);
std::vector<double> unwrapped;
for (std::size_t row = 0; row < rows; ++row) {
for (int ear = 0; ear < 2; ++ear) {
const std::complex<double>* spectrum =
raw.data() + (row * 2u + static_cast<std::size_t>(ear)) * bins_;
for (std::size_t bin = 0; bin < bins_; ++bin) {
wrapped[bin] = std::arg(spectrum[bin]);
}
unwrap_phase(wrapped, &unwrapped);
double numerator = 0.0;
for (std::size_t bin = fit_begin; bin < fit_end; ++bin) {
numerator += x_fit[bin - fit_begin] * unwrapped[bin];
}
const double data_delay =
canonical.delay_samples[selected[row] * 2u + static_cast<std::size_t>(ear)];
delays_[row * 2u + static_cast<std::size_t>(ear)] =
-numerator / x_squares + data_delay;
}
}
// Residual phase spread of the estimate (reported, not used downstream).
for (std::size_t row = 0; row < rows; ++row) {
for (int ear = 0; ear < 2; ++ear) {
const std::complex<double>* spectrum =
raw.data() + (row * 2u + static_cast<std::size_t>(ear)) * bins_;
for (std::size_t bin = 0; bin < bins_; ++bin) {
wrapped[bin] = std::arg(spectrum[bin]);
}
unwrap_phase(wrapped, &unwrapped);
const double data_delay =
canonical.delay_samples[selected[row] * 2u + static_cast<std::size_t>(ear)];
const double delay = delays_[row * 2u + static_cast<std::size_t>(ear)];
double mean = 0.0;
std::vector<double> residual(fit_end - fit_begin);
for (std::size_t bin = fit_begin; bin < fit_end; ++bin) {
residual[bin - fit_begin] = unwrapped[bin] + (delay - data_delay) * omega_[bin];
mean += residual[bin - fit_begin];
}
mean /= static_cast<double>(residual.size());
double squares = 0.0;
for (double& value : residual) {
value -= mean;
squares += value * value;
}
residuals.push_back(std::sqrt(squares / static_cast<double>(residual.size())));
}
}
std::sort(residuals.begin(), residuals.end());
phase_fit_rms_rad_p95_ = residuals.empty()
? 0.0
: residuals[static_cast<std::size_t>(
std::floor(0.95 * static_cast<double>(residuals.size())))];
// Recording origin: the median mean delay over the measurements.
std::vector<double> row_means(rows, 0.0);
for (std::size_t row = 0; row < rows; ++row) {
row_means[row] = 0.5 * (delays_[row * 2u] + delays_[row * 2u + 1u]);
}
recording_origin_samples_ = static_cast<int>(std::llround(median(row_means)));
// Physical spectra (Data.Delay removed) and the alignment delay.
std::vector<std::complex<double>> physical(raw.size());
double maximum = 0.0;
for (std::size_t row = 0; row < rows; ++row) {
for (int ear = 0; ear < 2; ++ear) {
const std::size_t base = (row * 2u + static_cast<std::size_t>(ear)) * bins_;
const double data_delay =
canonical.delay_samples[selected[row] * 2u + static_cast<std::size_t>(ear)];
for (std::size_t bin = 0; bin < bins_; ++bin) {
const std::complex<double> rotation =
std::exp(std::complex<double>(0.0, -1.0) * omega_[bin] * data_delay);
physical[base + bin] = raw[base + bin] * rotation;
maximum = std::max(maximum, std::abs(physical[base + bin]));
}
}
}
floor_ = std::max(maximum * 1e-6, 1e-15);
// Directions: deduplicate coincident measurements, keeping the first, then the
// mesh over that set.
std::vector<double> directions;
directions.reserve(rows * 3);
std::vector<std::size_t> kept_rows;
for (std::size_t row = 0; row < rows; ++row) {
const double* unit = canonical.unit_directions.data() + selected[row] * 3u;
bool merged = false;
for (std::size_t existing = 0; existing < kept_rows.size(); ++existing) {
const double* other = canonical.unit_directions.data() + kept_rows[existing] * 3u;
if (std::round(unit[0] * 1e10) == std::round(other[0] * 1e10) &&
std::round(unit[1] * 1e10) == std::round(other[1] * 1e10) &&
std::round(unit[2] * 1e10) == std::round(other[2] * 1e10)) {
// Coincident measurements must agree, as the reference requires.
for (std::size_t tap = 0; tap < canonical.taps * 2u; ++tap) {
const double a = canonical.hrir[selected[row] * 2u * canonical.taps + tap];
const double b = canonical.hrir[kept_rows[existing] * 2u * canonical.taps + tap];
if (std::fabs(a - b) > 1e-10 + 1e-8 * std::fabs(b)) {
return field_error("coincident SOFA measurements disagree");
}
}
merged = true;
break;
}
}
if (merged) {
continue;
}
kept_rows.push_back(selected[row]);
directions.push_back(unit[0]);
directions.push_back(unit[1]);
directions.push_back(unit[2]);
}
const Status mesh_status = mesh_.build(directions, kept_rows.size());
if (!mesh_status.ok()) {
return mesh_status;
}
// The measurements must enclose the listener: every hull face must sit in
// front of the unit sphere's centre.
for (std::size_t face = 0; face < mesh_.face_count(); ++face) {
const int* ids = mesh_.faces().data() + face * 3;
const double* a = mesh_.directions().data() + ids[0] * 3;
const double* b = mesh_.directions().data() + ids[1] * 3;
const double* c = mesh_.directions().data() + ids[2] * 3;
double one[3];
double two[3];
for (int axis = 0; axis < 3; ++axis) {
one[axis] = b[axis] - a[axis];
two[axis] = c[axis] - a[axis];
}
double normal[3] = {one[1] * two[2] - one[2] * two[1],
one[2] * two[0] - one[0] * two[2],
one[0] * two[1] - one[1] * two[0]};
const double length = std::sqrt(normal[0] * normal[0] + normal[1] * normal[1] +
normal[2] * normal[2]);
if (!(length > 0.0)) {
return field_error("ill-conditioned spherical interpolation mesh");
}
for (double& value : normal) {
value /= length;
}
const double distance = normal[0] * a[0] + normal[1] * a[1] + normal[2] * a[2];
if (std::fabs(distance) < 1e-9) {
return field_error("SOFA must enclose the listener");
}
if (distance < 0.0) {
return field_error("ill-conditioned spherical interpolation mesh");
}
}
// Centre spectrum from the spherical Voronoi weights.
std::vector<double> areas;
mesh_.voronoi_areas(&areas);
std::vector<double> energy(bins_, 0.0);
for (std::size_t row = 0; row < rows; ++row) {
const double weight = row < areas.size() ? areas[row] : 0.0;
for (int ear = 0; ear < 2; ++ear) {
const std::size_t base = (row * 2u + static_cast<std::size_t>(ear)) * bins_;
for (std::size_t bin = 0; bin < bins_; ++bin) {
energy[bin] += weight * std::norm(physical[base + bin]);
}
}
}
centre_spectrum_.assign(bins_, std::complex<double>(0.0, 0.0));
for (std::size_t bin = 0; bin < bins_; ++bin) {
const double magnitude = std::sqrt(energy[bin] * 0.5);
centre_spectrum_[bin] = magnitude * std::exp(std::complex<double>(
0.0, -omega_[bin] *
static_cast<double>(
recording_origin_samples_)));
}
// Aligned spectra and the magnitude representation used by the interpolation.
aligned_.assign(rows * 2 * bins_, std::complex<double>(0.0, 0.0));
log_magnitude_.assign(rows * 2 * bins_, 0.0);
for (std::size_t row = 0; row < rows; ++row) {
for (int ear = 0; ear < 2; ++ear) {
const std::size_t index = row * 2u + static_cast<std::size_t>(ear);
const double delay = delays_[index];
for (std::size_t bin = 0; bin < bins_; ++bin) {
aligned_[index * bins_ + bin] =
physical[index * bins_ + bin] *
std::exp(std::complex<double>(0.0, omega_[bin] * delay));
log_magnitude_[index * bins_ + bin] =
std::log(std::max(std::abs(physical[index * bins_ + bin]), floor_));
}
}
}
if (method_ == HrirInterpolation::kMcaZero) {
// 41 auditory bands (reference: erb-spaced centres, rounded exponential bank).
centres_hz_.resize(kMcaBands);
const auto erb = [](double frequency) {
return 21.4 * std::log10(1.0 + 0.00437 * frequency);
};
const double low = erb(50.0);
const double high = erb(20000.0);
for (int band = 0; band < kMcaBands; ++band) {
const double position = low + (high - low) * band / (kMcaBands - 1);
centres_hz_[static_cast<std::size_t>(band)] =
(std::pow(10.0, position / 21.4) - 1.0) / 0.00437;
}
bank_.assign(kMcaBands * bins_, 0.0);
for (int band = 0; band < kMcaBands; ++band) {
const double centre = centres_hz_[static_cast<std::size_t>(band)];
const double width = 1.019 * 24.7 * (1.0 + 0.00437 * centre);
double total = 0.0;
for (std::size_t bin = 0; bin < bins_; ++bin) {
const double ratio = (frequencies_[bin] - centre) / width;
double value = std::pow(1.0 + ratio * ratio, -4.0);
if (bin != 0 && bin + 1 != bins_) {
value *= 2.0;
}
bank_[static_cast<std::size_t>(band) * bins_ + bin] = value;
total += value;
}
for (std::size_t bin = 0; bin < bins_; ++bin) {
bank_[static_cast<std::size_t>(band) * bins_ + bin] /= total;
}
}
auditory_.assign(rows * 2 * kMcaBands, 0.0);
std::vector<double> power(bins_, 0.0);
for (std::size_t row = 0; row < rows; ++row) {
for (int ear = 0; ear < 2; ++ear) {
const std::size_t index = row * 2u + static_cast<std::size_t>(ear);
for (std::size_t bin = 0; bin < bins_; ++bin) {
power[bin] = std::norm(physical[index * bins_ + bin]);
}
for (int band = 0; band < kMcaBands; ++band) {
double sum = 0.0;
for (std::size_t bin = 0; bin < bins_; ++bin) {
sum += power[bin] *
bank_[static_cast<std::size_t>(band) * bins_ + bin];
}
auditory_[index * kMcaBands + static_cast<std::size_t>(band)] =
10.0 * std::log10(std::max(sum, 1e-24));
}
}
}
}
return Status::success();
}
Status FullHrirField::radial_ratio(const double direction[3], double radius,
std::vector<std::complex<double>>* out) const {
if (out == nullptr) {
return argument_error("radial ratio output is null");
}
if (std::fabs(radius - measurement_radius_m_) < 1e-10) {
out->assign(2 * bins_, std::complex<double>(1.0, 0.0));
return Status::success();
}
if (!(radius > 0.0) || !std::isfinite(radius)) {
return argument_error("radial ratio needs a positive finite radius");
}
std::vector<double> cosines(2, 0.0);
for (int ear = 0; ear < 2; ++ear) {
cosines[static_cast<std::size_t>(ear)] =
ear_directions_[static_cast<std::size_t>(ear) * 3u] * direction[0] +
ear_directions_[static_cast<std::size_t>(ear) * 3u + 1u] * direction[1] +
ear_directions_[static_cast<std::size_t>(ear) * 3u + 2u] * direction[2];
}
std::vector<std::complex<double>> source;
std::vector<std::complex<double>> target;
Status status = sphere_transfer(frequencies_, measurement_radius_m_, head_radius_m_, cosines,
&source);
if (!status.ok()) {
return status;
}
status = sphere_transfer(frequencies_, radius, head_radius_m_, cosines, &target);
if (!status.ok()) {
return status;
}
for (const std::complex<double>& value : source) {
if (std::abs(value) < 1e-10) {
return field_error("singular radial reference response");
}
}
out->resize(source.size());
for (std::size_t index = 0; index < source.size(); ++index) {
(*out)[index] = target[index] / source[index];
}
return Status::success();
}
Status FullHrirField::spectrum(const double direction[3],
std::vector<std::complex<double>>* out) {
if (out == nullptr) {
return argument_error("spectrum output is null");
}
std::vector<int> ids;
std::vector<double> weights;
const Status status = mesh_.weights(direction, &ids, &weights);
if (!status.ok()) {
return status;
}
if (ids.empty()) {
return field_error("no interpolation weights for the direction");
}
double delay[2] = {0.0, 0.0};
for (std::size_t index = 0; index < ids.size(); ++index) {
const std::size_t id = static_cast<std::size_t>(ids[index]);
for (int ear = 0; ear < 2; ++ear) {
delay[ear] += weights[index] * delays_[id * 2u + static_cast<std::size_t>(ear)];
}
}
out->assign(2 * bins_, std::complex<double>(0.0, 0.0));
for (std::size_t index = 0; index < ids.size(); ++index) {
const std::size_t id = static_cast<std::size_t>(ids[index]);
for (int ear = 0; ear < 2; ++ear) {
const std::complex<double>* aligned =
aligned_.data() + (id * 2u + static_cast<std::size_t>(ear)) * bins_;
for (std::size_t bin = 0; bin < bins_; ++bin) {
(*out)[static_cast<std::size_t>(ear) * bins_ + bin] +=
weights[index] * aligned[bin];
}
}
}
for (int ear = 0; ear < 2; ++ear) {
for (std::size_t bin = 0; bin < bins_; ++bin) {
(*out)[static_cast<std::size_t>(ear) * bins_ + bin] *=
std::exp(std::complex<double>(0.0, -omega_[bin] *
delay[static_cast<std::size_t>(ear)]));
}
}
if (ids.size() > 1) {
if (method_ == HrirInterpolation::kLogMagnitudePhase) {
for (int ear = 0; ear < 2; ++ear) {
std::vector<double> magnitude(bins_, 0.0);
for (std::size_t index = 0; index < ids.size(); ++index) {
const std::size_t id = static_cast<std::size_t>(ids[index]);
const double* values =
log_magnitude_.data() +
(id * 2u + static_cast<std::size_t>(ear)) * bins_;
for (std::size_t bin = 0; bin < bins_; ++bin) {
magnitude[bin] += weights[index] * values[bin];
}
}
for (std::size_t bin = 0; bin < bins_; ++bin) {
std::complex<double>& value =
(*out)[static_cast<std::size_t>(ear) * bins_ + bin];
const double target = std::exp(magnitude[bin]);
value = target * value /
std::max(std::abs(value), floor_);
}
}
} else {
for (int ear = 0; ear < 2; ++ear) {
std::vector<double> target(kMcaBands, 0.0);
for (std::size_t index = 0; index < ids.size(); ++index) {
const std::size_t id = static_cast<std::size_t>(ids[index]);
const double* values =
auditory_.data() +
(id * 2u + static_cast<std::size_t>(ear)) * kMcaBands;
for (int band = 0; band < kMcaBands; ++band) {
target[static_cast<std::size_t>(band)] += weights[index] * values[band];
}
}
// Auditory band levels of the interpolated spectrum.
std::vector<double> power(bins_, 0.0);
for (std::size_t bin = 0; bin < bins_; ++bin) {
power[bin] = std::norm((*out)[static_cast<std::size_t>(ear) * bins_ + bin]);
}
std::vector<double> difference(kMcaBands, 0.0);
for (int band = 0; band < kMcaBands; ++band) {
double sum = 0.0;
for (std::size_t bin = 0; bin < bins_; ++bin) {
sum += power[bin] *
bank_[static_cast<std::size_t>(band) * bins_ + bin];
}
difference[static_cast<std::size_t>(band)] =
target[static_cast<std::size_t>(band)] -
10.0 * std::log10(std::max(sum, 1e-24));
}
PchipEvaluator interpolator;
interpolator.build(centres_hz_, difference);
for (std::size_t bin = 0; bin < bins_; ++bin) {
const double frequency =
std::clamp(frequencies_[bin], centres_hz_.front(), centres_hz_.back());
const double correction = std::clamp(interpolator.evaluate(frequency),
-12.0, 12.0);
(*out)[static_cast<std::size_t>(ear) * bins_ + bin] *=
std::pow(10.0, correction / 20.0);
}
}
}
}
return Status::success();
}
} // namespace joc::hrtf
+96
View File
@@ -0,0 +1,96 @@
#pragma once
#include <complex>
#include <cstddef>
#include <cstdint>
#include <vector>
#include "foundation/status.h"
#include "hrtf/spherical_mesh.h"
// Full-HRIR directional field, ported from the reference sofa_hrir.py: the
// selected measurement shell keeps its complete FIR support, the interpolation
// works on delay-aligned complex spectra inside the containing spherical
// triangle, and the radial model is the analytic rigid-sphere series. This
// replaces the compiled 77-band/SH field for SOFA inputs.
namespace joc::hrtf {
struct CanonicalHrtf;
// Point-source pressure at `radius` over the free-field pressure at the sphere
// centre (rigid sphere, FFT sign convention) for the cosines in `cosines`.
// Output is [cosines][frequencies] complex, row-major.
Status sphere_transfer(const std::vector<double>& frequencies, double radius, double head_radius,
const std::vector<double>& cosines,
std::vector<std::complex<double>>* out);
enum class HrirInterpolation : std::uint32_t {
kLogMagnitudePhase = 0, // lf_logmag_phase: geometric mean magnitude, interpolated phase
kMcaZero = 1, // lf_mca_zero: auditory-band magnitude correction
};
struct FullHrirOptions {
HrirInterpolation method = HrirInterpolation::kLogMagnitudePhase;
bool has_shell_radius = false;
double shell_radius_m = 0.0;
std::size_t fft_size = 0; // 0 selects the automatic size
};
class FullHrirField {
public:
// Builds the field from a canonical SimpleFreeFieldHRIR set (48 kHz only).
Status build(const CanonicalHrtf& canonical, const FullHrirOptions& options);
std::size_t fft_size() const { return fft_size_; }
std::size_t frequency_bins() const { return bins_; }
const std::vector<double>& frequencies() const { return frequencies_; }
const std::vector<double>& omega() const { return omega_; }
double measurement_radius_m() const { return measurement_radius_m_; }
double head_radius_m() const { return head_radius_m_; }
const std::vector<double>& ear_directions() const { return ear_directions_; } // [2][3]
std::size_t direction_count() const { return mesh_.vertex_count(); }
std::size_t triangle_count() const { return mesh_.face_count(); }
int recording_origin_samples() const { return recording_origin_samples_; }
int common_latency_samples() const { return static_cast<int>(fft_size_ / 2); }
double max_triangle_edge_degrees() const { return mesh_.max_triangle_edge_degrees(); }
double phase_fit_rms_rad_p95() const { return phase_fit_rms_rad_p95_; }
double floor() const { return floor_; }
HrirInterpolation method() const { return method_; }
// Interpolated two-ear spectrum at a direction (`out` is [2][bins] complex).
Status spectrum(const double direction[3], std::vector<std::complex<double>>* out);
// Radial (distance) correction for a source at `radius` metres.
Status radial_ratio(const double direction[3], double radius,
std::vector<std::complex<double>>* out) const;
// Centre (omnidirectional) spectrum used when a position is inside the head.
const std::vector<std::complex<double>>& centre_spectrum() const { return centre_spectrum_; }
private:
Status build_interpolation(const CanonicalHrtf& canonical, const FullHrirOptions& options);
std::size_t fft_size_ = 0;
std::size_t bins_ = 0;
std::size_t taps_ = 0;
HrirInterpolation method_ = HrirInterpolation::kLogMagnitudePhase;
SphericalMesh mesh_;
std::vector<double> frequencies_; // [bins]
std::vector<double> omega_; // [bins]
std::vector<double> delays_; // [M][2] samples (estimated + Data.Delay)
std::vector<std::complex<double>> aligned_; // [M][2][bins]
std::vector<double> log_magnitude_; // [M][2][bins]
std::vector<double> auditory_; // [M][2][41] (MCA method only)
std::vector<double> centres_hz_; // [41] (MCA method only)
std::vector<double> bank_; // [41][bins] (MCA method only)
std::vector<std::complex<double>> centre_spectrum_; // [bins]
double measurement_radius_m_ = 0.0;
double head_radius_m_ = 0.0;
std::vector<double> ear_directions_; // [2][3]
double floor_ = 1.0e-15;
int recording_origin_samples_ = 0;
double phase_fit_rms_rad_p95_ = 0.0;
};
} // namespace joc::hrtf
+336
View File
@@ -0,0 +1,336 @@
#include "hrtf/partitioned_convolution.h"
#include <algorithm>
#include <cmath>
#include <cstring>
namespace joc::hrtf {
namespace {
using joc::dsp::Complex;
bool is_power_of_two(std::size_t value) { return value != 0 && (value & (value - 1)) == 0; }
Status argument_error(const char* message) {
return Status::fail(JOC_ERR_INVALID_ARGUMENT, joc::stage::kDsp, message);
}
} // namespace
UniformPartitionedConvolver::UniformPartitionedConvolver(std::size_t outputs,
std::size_t max_filter_taps,
std::size_t block_size) {
configure(outputs, max_filter_taps, block_size);
}
void UniformPartitionedConvolver::configure(std::size_t outputs, std::size_t max_filter_taps,
std::size_t block_size) {
outputs_ = outputs;
max_filter_taps_ = max_filter_taps;
block_size_ = block_size;
fft_size_ = 2 * block_size;
bins_ = block_size + 1;
partitions_ = block_size == 0 ? 0 : (max_filter_taps + block_size - 1) / block_size;
history_.assign(partitions_ * bins_, Complex{});
spectra_.assign(outputs_ * partitions_ * bins_, Complex{});
target_spectra_.assign(outputs_ * partitions_ * bins_, Complex{});
overlap_.assign(outputs_ * block_size, 0.0);
target_overlap_.assign(outputs_ * block_size, 0.0);
work_.assign(bins_, Complex{});
fft_buffer_.assign(fft_size_, Complex{});
time_work_.assign(fft_size_, 0.0);
ordered_.assign(partitions_ * bins_, Complex{});
if (is_power_of_two(fft_size_)) {
forward_plan_ = std::make_unique<dsp::FftPlan>(fft_size_, false);
inverse_plan_ = std::make_unique<dsp::FftPlan>(fft_size_, true);
} else {
forward_plan_.reset();
inverse_plan_.reset();
}
write_index_ = -1;
processed_blocks_ = 0;
target_active_ = false;
fade_samples_ = 0;
fade_position_ = 0;
}
void UniformPartitionedConvolver::reset() {
std::fill(history_.begin(), history_.end(), Complex{});
std::fill(overlap_.begin(), overlap_.end(), 0.0);
std::fill(target_overlap_.begin(), target_overlap_.end(), 0.0);
std::fill(target_spectra_.begin(), target_spectra_.end(), Complex{});
write_index_ = -1;
processed_blocks_ = 0;
target_active_ = false;
fade_samples_ = 0;
fade_position_ = 0;
}
void UniformPartitionedConvolver::real_spectrum(const double* time,
std::vector<Complex>* out) const {
// numpy.fft.rfft of a real block: the unnormalised forward transform, first
// block_size+1 bins of the size-2*block_size complex transform.
std::fill(fft_buffer_.begin(), fft_buffer_.end(), Complex{});
for (std::size_t i = 0; i < fft_size_; ++i) {
fft_buffer_[i] = Complex(time[i], 0.0);
}
if (forward_plan_) {
dsp::fft_radix2(&fft_buffer_, *forward_plan_);
} else {
std::vector<Complex> transformed;
dsp::fft_any(fft_buffer_, false, &transformed);
fft_buffer_ = std::move(transformed);
}
out->assign(fft_buffer_.begin(), fft_buffer_.begin() + static_cast<std::ptrdiff_t>(bins_));
}
void UniformPartitionedConvolver::real_signal(const std::vector<Complex>& spectrum,
double* out) const {
// numpy.fft.irfft: rebuild the Hermitian half, inverse transform (1/N), real part.
std::fill(fft_buffer_.begin(), fft_buffer_.end(), Complex{});
for (std::size_t bin = 0; bin < bins_; ++bin) {
fft_buffer_[bin] = spectrum[bin];
}
for (std::size_t bin = 1; bin + 1 < bins_; ++bin) {
fft_buffer_[fft_size_ - bin] = std::conj(spectrum[bin]);
}
if (inverse_plan_) {
dsp::fft_radix2(&fft_buffer_, *inverse_plan_);
} else {
std::vector<Complex> transformed;
dsp::fft_any(fft_buffer_, true, &transformed);
fft_buffer_ = std::move(transformed);
}
for (std::size_t i = 0; i < fft_size_; ++i) {
out[i] = fft_buffer_[i].real();
}
}
void UniformPartitionedConvolver::partition(const double* filters, std::size_t taps,
std::vector<Complex>* out) {
std::vector<double> padded(fft_size_);
out->assign(outputs_ * partitions_ * bins_, Complex{});
for (std::size_t partition_index = 0; partition_index < partitions_; ++partition_index) {
const std::size_t start = partition_index * block_size_;
if (start >= taps) {
break;
}
const std::size_t stop = std::min(start + block_size_, taps);
for (std::size_t output = 0; output < outputs_; ++output) {
std::fill(padded.begin(), padded.end(), 0.0);
const double* row = filters + output * taps;
std::memcpy(padded.data(), row + start, sizeof(double) * (stop - start));
real_spectrum(padded.data(), &work_);
std::copy(work_.begin(), work_.end(),
out->begin() + static_cast<std::ptrdiff_t>(
(output * partitions_ + partition_index) * bins_));
}
}
}
void UniformPartitionedConvolver::order_history() {
// index 0 is the block just written; index p is p blocks ago.
for (std::size_t partition_index = 0; partition_index < partitions_; ++partition_index) {
std::ptrdiff_t index = 0;
if (write_index_ >= 0) {
const std::ptrdiff_t count = static_cast<std::ptrdiff_t>(partitions_);
index = (write_index_ - static_cast<std::ptrdiff_t>(partition_index) + count) % count;
}
std::copy(history_.begin() + index * static_cast<std::ptrdiff_t>(bins_),
history_.begin() + (index + 1) * static_cast<std::ptrdiff_t>(bins_),
ordered_.begin() + static_cast<std::ptrdiff_t>(partition_index * bins_));
}
}
void UniformPartitionedConvolver::convolution_block(const std::vector<Complex>& spectra,
const std::vector<double>& overlap,
double* out, double* next_overlap) {
order_history();
for (std::size_t output = 0; output < outputs_; ++output) {
std::fill(work_.begin(), work_.end(), Complex{});
for (std::size_t partition_index = 0; partition_index < partitions_; ++partition_index) {
const Complex* input = ordered_.data() + partition_index * bins_;
const Complex* filter =
spectra.data() + (output * partitions_ + partition_index) * bins_;
for (std::size_t bin = 0; bin < bins_; ++bin) {
work_[bin] += input[bin] * filter[bin];
}
}
real_signal(work_, time_work_.data());
for (std::size_t sample = 0; sample < block_size_; ++sample) {
out[output * block_size_ + sample] =
time_work_[sample] + overlap[output * block_size_ + sample];
next_overlap[output * block_size_ + sample] = time_work_[block_size_ + sample];
}
}
}
void UniformPartitionedConvolver::overlap_for_previous_block(
const std::vector<Complex>& spectra, double* overlap) {
if (processed_blocks_ == 0) {
std::fill(overlap, overlap + outputs_ * block_size_, 0.0);
return;
}
order_history();
for (std::size_t output = 0; output < outputs_; ++output) {
std::fill(work_.begin(), work_.end(), Complex{});
for (std::size_t partition_index = 0; partition_index < partitions_; ++partition_index) {
const Complex* input = ordered_.data() + partition_index * bins_;
const Complex* filter =
spectra.data() + (output * partitions_ + partition_index) * bins_;
for (std::size_t bin = 0; bin < bins_; ++bin) {
work_[bin] += input[bin] * filter[bin];
}
}
real_signal(work_, time_work_.data());
std::memcpy(overlap + output * block_size_, time_work_.data() + block_size_,
sizeof(double) * block_size_);
}
}
Status UniformPartitionedConvolver::set_filter(const double* filters, std::size_t taps,
std::size_t fade_blocks) {
if ((filters == nullptr && taps != 0) || block_size_ == 0 || outputs_ == 0 ||
taps > max_filter_taps_) {
return argument_error("filter update exceeds the configured tap budget");
}
for (std::size_t i = 0; i < outputs_ * taps; ++i) {
if (!std::isfinite(filters[i])) {
return argument_error("filter update contains a non-finite value");
}
}
partition(filters, taps, &target_spectra_);
if (fade_blocks == 0) {
spectra_ = target_spectra_;
overlap_for_previous_block(spectra_, overlap_.data());
target_active_ = false;
fade_samples_ = 0;
fade_position_ = 0;
return Status::success();
}
overlap_for_previous_block(target_spectra_, target_overlap_.data());
target_active_ = true;
fade_samples_ = static_cast<std::int64_t>(fade_blocks * block_size_);
fade_position_ = 0;
return Status::success();
}
Status UniformPartitionedConvolver::process_block(const double* block, double* out) {
if (block == nullptr || out == nullptr) {
return argument_error("block pointer is null");
}
for (std::size_t i = 0; i < block_size_; ++i) {
if (!std::isfinite(block[i])) {
return argument_error("input block contains a non-finite value");
}
}
std::fill(time_work_.begin(), time_work_.end(), 0.0);
std::memcpy(time_work_.data(), block, sizeof(double) * block_size_);
real_spectrum(time_work_.data(), &work_);
write_index_ = (write_index_ + 1) % static_cast<std::ptrdiff_t>(partitions_);
std::copy(work_.begin(), work_.end(),
history_.begin() + write_index_ * static_cast<std::ptrdiff_t>(bins_));
std::vector<double> current(outputs_ * block_size_);
std::vector<double> next_current_overlap(outputs_ * block_size_);
convolution_block(spectra_, overlap_, current.data(), next_current_overlap.data());
if (!target_active_) {
overlap_ = next_current_overlap;
++processed_blocks_;
for (std::size_t sample = 0; sample < block_size_; ++sample) {
for (std::size_t output = 0; output < outputs_; ++output) {
out[sample * outputs_ + output] = current[output * block_size_ + sample];
}
}
return Status::success();
}
std::vector<double> target(outputs_ * block_size_);
std::vector<double> next_target_overlap(outputs_ * block_size_);
convolution_block(target_spectra_, target_overlap_, target.data(),
next_target_overlap.data());
const double fade = static_cast<double>(fade_samples_);
for (std::size_t sample = 0; sample < block_size_; ++sample) {
const double position =
static_cast<double>(fade_position_ + static_cast<std::int64_t>(sample) + 1);
const double amount =
std::clamp(fade > 0.0 ? position / fade : 1.0, 0.0, 1.0);
for (std::size_t output = 0; output < outputs_; ++output) {
const double dry = current[output * block_size_ + sample];
const double wet = target[output * block_size_ + sample];
out[sample * outputs_ + output] = dry * (1.0 - amount) + wet * amount;
}
}
fade_position_ += static_cast<std::int64_t>(block_size_);
overlap_ = next_current_overlap;
target_overlap_ = next_target_overlap;
if (fade_position_ >= fade_samples_) {
spectra_ = target_spectra_;
overlap_ = target_overlap_;
target_active_ = false;
fade_samples_ = 0;
fade_position_ = 0;
}
++processed_blocks_;
return Status::success();
}
MultiSourcePartitionedConvolver::MultiSourcePartitionedConvolver(
std::size_t source_count, std::size_t block_size, std::size_t max_filter_taps,
std::size_t output_channels) {
configure(source_count, block_size, max_filter_taps, output_channels);
}
void MultiSourcePartitionedConvolver::configure(std::size_t source_count,
std::size_t block_size,
std::size_t max_filter_taps,
std::size_t output_channels) {
block_size_ = block_size;
max_filter_taps_ = max_filter_taps;
output_channels_ = output_channels;
convolvers_.clear();
convolvers_.resize(source_count);
for (UniformPartitionedConvolver& convolver : convolvers_) {
convolver.configure(output_channels, max_filter_taps, block_size);
}
source_block_.assign(block_size, 0.0);
partial_.assign(block_size * output_channels, 0.0);
}
void MultiSourcePartitionedConvolver::reset() {
for (UniformPartitionedConvolver& convolver : convolvers_) {
convolver.reset();
}
}
Status MultiSourcePartitionedConvolver::set_filter(std::size_t source, const double* filters,
std::size_t taps, std::size_t fade_blocks) {
if (source >= convolvers_.size()) {
return argument_error("source index is out of range");
}
return convolvers_[source].set_filter(filters, taps, fade_blocks);
}
Status MultiSourcePartitionedConvolver::process_block(const double* sources, double* out) {
if (sources == nullptr || out == nullptr) {
return argument_error("block pointer is null");
}
std::fill(out, out + block_size_ * output_channels_, 0.0);
for (std::size_t source = 0; source < convolvers_.size(); ++source) {
for (std::size_t sample = 0; sample < block_size_; ++sample) {
source_block_[sample] = sources[sample * convolvers_.size() + source];
}
const Status status =
convolvers_[source].process_block(source_block_.data(), partial_.data());
if (!status.ok()) {
return status;
}
for (std::size_t i = 0; i < partial_.size(); ++i) {
out[i] += partial_[i];
}
}
return Status::success();
}
} // namespace joc::hrtf
+118
View File
@@ -0,0 +1,118 @@
#pragma once
#include <complex>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <vector>
#include "foundation/fft.h"
#include "foundation/status.h"
// Uniform partitioned convolution, ported from the reference
// partitioned_convolution.py. One input history is shared by the outputs of a
// source; a filter replacement can crossfade the output over a number of blocks
// while both the old and the new filter keep their own overlap tail.
namespace joc::hrtf {
class UniformPartitionedConvolver {
public:
UniformPartitionedConvolver() = default;
UniformPartitionedConvolver(std::size_t outputs, std::size_t max_filter_taps,
std::size_t block_size);
void configure(std::size_t outputs, std::size_t max_filter_taps, std::size_t block_size);
std::size_t outputs() const { return outputs_; }
std::size_t block_size() const { return block_size_; }
std::size_t fft_size() const { return fft_size_; }
std::size_t max_filter_taps() const { return max_filter_taps_; }
bool transition_active() const { return target_active_; }
// `filters` is [outputs][taps] row-major and `taps` <= max_filter_taps. A zero
// fade applies the filter immediately and rebuilds the overlap tail from the
// blocks already processed, so an impulse in flight is not dropped.
Status set_filter(const double* filters, std::size_t taps, std::size_t fade_blocks);
// `block` is block_size doubles; `out` is block_size*outputs, sample-major.
Status process_block(const double* block, double* out);
void reset();
private:
void partition(const double* filters, std::size_t taps,
std::vector<std::complex<double>>* out);
void convolution_block(const std::vector<std::complex<double>>& spectra,
const std::vector<double>& overlap, double* out,
double* next_overlap);
void overlap_for_previous_block(const std::vector<std::complex<double>>& spectra,
double* overlap);
void order_history();
void real_spectrum(const double* time, std::vector<std::complex<double>>* out) const;
void real_signal(const std::vector<std::complex<double>>& spectrum, double* out) const;
std::size_t outputs_ = 0;
std::size_t max_filter_taps_ = 0;
std::size_t block_size_ = 0;
std::size_t fft_size_ = 0;
std::size_t bins_ = 0;
std::size_t partitions_ = 0;
std::unique_ptr<dsp::FftPlan> forward_plan_;
std::unique_ptr<dsp::FftPlan> inverse_plan_;
mutable std::vector<std::complex<double>> fft_buffer_;
std::vector<std::complex<double>> history_; // [partitions][bins]
std::vector<std::complex<double>> spectra_; // [outputs][partitions][bins]
std::vector<std::complex<double>> target_spectra_;
std::vector<double> overlap_; // [outputs][block]
std::vector<double> target_overlap_; // [outputs][block]
std::vector<std::complex<double>> work_; // [bins] scratch
std::vector<double> time_work_; // [fft_size] scratch
std::vector<std::complex<double>> ordered_; // [partitions][bins] scratch
std::ptrdiff_t write_index_ = -1;
std::uint64_t processed_blocks_ = 0;
bool target_active_ = false;
std::int64_t fade_samples_ = 0;
std::int64_t fade_position_ = 0;
};
class MultiSourcePartitionedConvolver {
public:
MultiSourcePartitionedConvolver() = default;
MultiSourcePartitionedConvolver(std::size_t source_count, std::size_t block_size,
std::size_t max_filter_taps,
std::size_t output_channels = 2);
void configure(std::size_t source_count, std::size_t block_size,
std::size_t max_filter_taps, std::size_t output_channels = 2);
std::size_t source_count() const { return convolvers_.size(); }
std::size_t block_size() const { return block_size_; }
std::size_t output_channels() const { return output_channels_; }
std::size_t max_filter_taps() const { return max_filter_taps_; }
const UniformPartitionedConvolver& convolver(std::size_t source) const {
return convolvers_[source];
}
Status set_filter(std::size_t source, const double* filters, std::size_t taps,
std::size_t fade_blocks);
// `sources` is block_size*source_count (sample-major); `out` is
// block_size*output_channels and is overwritten.
Status process_block(const double* sources, double* out);
void reset();
private:
std::vector<UniformPartitionedConvolver> convolvers_;
std::size_t block_size_ = 0;
std::size_t max_filter_taps_ = 0;
std::size_t output_channels_ = 2;
std::vector<double> source_block_;
std::vector<double> partial_;
};
} // namespace joc::hrtf
+854
View File
@@ -0,0 +1,854 @@
#include "hrtf/rosella_reference.h"
#include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstring>
#include <memory>
#include <string>
#include <vector>
#include "foundation/fft.h"
#include "hrtf/public_filterbank.h"
#include "hrtf/rosella_renderer.h"
#include "simd/simd.h"
// The reference arithmetic of the Rosella ".personalized_headphone" renderer
// (rosella_model.py, rosella_direct.py and rosella_room.py). rosella_renderer.cpp
// drives these through RosellaRuntime, and a renderer built on another field format
// calls them directly; the bodies are lifted unchanged from the renderer, so their
// operation order and their literals are part of the interface.
namespace joc::hrtf {
namespace {
constexpr int kDirectionTerms = 36;
constexpr int kRoomBands = 64;
constexpr double kRoomInputGain = 0.70710677;
constexpr double kCentreEqual = 0.9998489618301392;
constexpr double kCentreAlternate = 0.7070000171661377;
// The fixed sixteen-band low-pass a special (LFE) source is rendered through; the
// constants are the float32 bit patterns of rosella_direct._SPECIAL_LFE_LOW_16.
constexpr std::uint32_t kSpecialLfeLowBits[16] = {
0x402695EAu, 0x3FE75979u, 0x3F28CAAAu, 0xBCE1FB2Eu, 0xBDD8AF65u, 0xBD8F426Eu,
0x3D996821u, 0xBC16B3A0u, 0x3B64BAF1u, 0xBC81ECFDu, 0xBA3D892Fu, 0x3AF6A9F0u,
0xB9DD1C5Fu, 0x380A193Fu, 0x38052059u, 0x351BCB34u};
Status render_fail(joc_error code, const std::string& message) {
return Status::fail(code, stage::kRender, message);
}
std::vector<double> special_lfe_low() {
std::vector<double> values(kHybridBands, 0.0);
for (int index = 0; index < 16; ++index) {
float narrowed = 0.0f;
const std::uint32_t bits = kSpecialLfeLowBits[index];
std::memcpy(&narrowed, &bits, sizeof(float));
values[static_cast<std::size_t>(index)] = static_cast<double>(narrowed);
}
return values;
}
// rosella_direct._round_away_from_zero.
double round_away_from_zero(double value) {
return value >= 0.0 ? std::floor(value + 0.5) : std::ceil(value - 0.5);
}
// rosella_direct._q15_position: ADM coordinates on the Rosella metadata grid.
void q15_position(const double position[3], int encoded[3]) {
const double raw[3] = {
std::min(std::max((position[0] + 1.0) * 0.5, 0.0), 1.0),
std::min(std::max((1.0 - position[1]) * 0.5, 0.0), 1.0),
std::min(std::max(position[2], -1.0), 1.0),
};
for (int axis = 0; axis < 3; ++axis) {
encoded[axis] = static_cast<int>(
std::min(round_away_from_zero(raw[axis] * 32768.0), 32767.0));
}
}
struct EarGeometry {
double basis_minus[kDirectionTerms] = {};
double basis_plus[kDirectionTerms] = {};
double path_minus = 0.0;
double path_plus = 0.0;
};
// rosella_direct._ear_geometry.
EarGeometry ear_geometry(const RosellaModel& model, const RosellaDistanceProfile& profile,
const double direction[3], double clamped, double offset,
double correction) {
const double x = direction[0];
const double y = direction[1];
const double z = direction[2];
const double inverse_distance = static_cast<double>(profile.inverse_distance_per_m);
const double ear = offset * inverse_distance / clamped;
const double y_minus = y - ear;
const double y_plus = y + ear;
const double common = x * x + z * z;
const double length_minus = std::sqrt(y_minus * y_minus + common);
const double length_plus = std::sqrt(y_plus * y_plus + common);
EarGeometry result;
direction_basis(x / length_minus, y_minus / length_minus, z / length_minus,
result.basis_minus);
direction_basis(x / length_plus, y_plus / length_plus, z / length_plus, result.basis_plus);
result.path_minus = length_minus * clamped;
result.path_plus = length_plus * clamped;
if (correction != 0.0) {
const double multiplier = 2.0 * correction * inverse_distance;
double left = 0.0;
double right = 0.0;
for (int term = 0; term < kDirectionTerms; ++term) {
left += static_cast<double>(model.vector_left[static_cast<std::size_t>(term)]) *
result.basis_minus[term];
right += static_cast<double>(model.vector_right[static_cast<std::size_t>(term)]) *
result.basis_plus[term];
}
result.path_minus += std::max(left, 0.0) * multiplier;
result.path_plus += std::max(right, 0.0) * multiplier;
}
return result;
}
// rosella_direct._phase_groups.
void phase_groups(const RosellaModel& model, double delay_samples, Complex* out) {
// The reference starts from np.ones(77) and only rewrites the flagged bands.
std::fill(out, out + kHybridBands, Complex(1.0, 0.0));
Complex current(1.0, 0.0);
Complex step(1.0, 0.0);
std::size_t value_index = 0u;
for (std::size_t band = 0u; band < model.hybrid_flags.size() && band < kHybridBands; ++band) {
const int flag = model.hybrid_flags[band];
if (flag != 2) {
if (flag == 1) {
const double angle =
static_cast<double>(model.hybrid_values[value_index]) * delay_samples;
++value_index;
step = Complex(std::cos(angle), std::sin(angle));
}
current *= step;
}
out[band] = current;
}
}
} // namespace
// rosella_model.direction_basis: the observed 36-term basis. The operation order is
// part of the model, so the intermediates are named after the reference's.
void direction_basis(double x, double y, double z, double* out) {
const double yz = y * z;
const double x2 = x * x;
const double y2 = y * y;
const double x2m02 = x2 - 0.2;
const double xy = x * y;
out[0] = 1.0;
out[1] = x;
out[2] = y;
out[3] = z;
out[4] = x2 - (1.0 / 3.0);
out[5] = xy;
out[6] = x * z;
out[7] = y2 - (1.0 / 3.0);
out[8] = yz;
out[9] = (x2 - 0.6) * x;
out[10] = x2m02 * y;
out[11] = x2m02 * z;
out[12] = (y2 - 0.2) * x;
out[13] = yz * x;
out[14] = (y2 - 0.6) * y;
out[15] = (y2 - 0.2) * z;
out[16] = x2 * x2 - 0.2;
out[17] = xy * x2;
out[18] = (x * z) * x2;
out[19] = y2 * x2 - (1.0 / 15.0);
out[20] = yz * x2;
out[21] = x * y2 * y;
out[22] = x * y2 * z;
out[23] = y2 * y2 - 0.2;
const double x4 = x2 * x2;
const double x2y2 = y2 * x2;
const double y4 = y2 * y2;
out[24] = yz * y2;
out[25] = (x4 - (3.0 / 7.0)) * x;
out[26] = (x4 - (3.0 / 35.0)) * y;
out[27] = (x4 - (3.0 / 35.0)) * z;
out[28] = (x2y2 - (3.0 / 35.0)) * x;
out[29] = (x2 * z) * xy;
out[30] = (x2y2 - (3.0 / 35.0)) * y;
out[31] = (x2y2 - (1.0 / 35.0)) * z;
out[32] = (y4 - (3.0 / 35.0)) * x;
out[33] = (y2 * z) * xy;
out[34] = (y4 - (3.0 / 7.0)) * y;
out[35] = (y4 - (3.0 / 35.0)) * z;
}
// rosella_direct._logical_field: the padded lane grid as [77][36][2] float64.
std::vector<double> rosella_logical_field(const std::vector<float>& padded) {
std::vector<double> out;
out.assign(static_cast<std::size_t>(kHybridBands) * kDirectionTerms * 2u, 0.0);
for (int band = 0; band < kHybridBands; ++band) {
const int block = band / 4;
const int lane = band % 4;
for (int term = 0; term < kDirectionTerms; ++term) {
for (int component = 0; component < 2; ++component) {
const std::size_t source =
static_cast<std::size_t>(lane + 4 * (term * 2 + component + 72 * block));
out[(static_cast<std::size_t>(band) * kDirectionTerms +
static_cast<std::size_t>(term)) * 2u +
static_cast<std::size_t>(component)] =
source < padded.size() ? static_cast<double>(padded[source]) : 0.0;
}
}
}
return out;
}
// rosella_direct._profile_geometry.
Status profile_geometry(const RosellaModel& model, const double position[3], int profile_index,
ProfileGeometry* out) {
const RosellaDistanceProfile& profile = model.profiles[static_cast<std::size_t>(profile_index)];
int encoded[3] = {0, 0, 0};
q15_position(position, encoded);
const double q_front = 1.0 - 2.0 * static_cast<double>(encoded[1]) / 32768.0;
const double q_x = 2.0 * static_cast<double>(encoded[0]) / 32768.0 - 1.0;
const double q_vertical = static_cast<double>(encoded[2]) / 32768.0;
double mapped_front = q_front;
double mapped_lateral = -q_x;
double mapped_vertical = q_vertical;
if (model.header_integer_fields[0] != 0) {
if (q_x == 0.0 && q_front == 0.0) {
mapped_front = 0.0;
mapped_lateral = 0.0;
mapped_vertical = q_vertical;
} else {
const double horizontal_max = std::max(std::abs(q_x), std::abs(q_front));
const double horizontal_norm = (q_x / horizontal_max) * (q_x / horizontal_max) +
(q_front / horizontal_max) * (q_front / horizontal_max);
double vertical_norm = 1.0;
if (q_vertical != 0.0) {
const double smaller = std::min(std::abs(q_vertical), horizontal_max);
const double larger = std::max(std::abs(q_vertical), horizontal_max);
vertical_norm = 1.0 + (smaller / larger) * (smaller / larger);
}
const double horizontal_factor = 1.0 / std::sqrt(horizontal_norm * vertical_norm);
const double vertical_factor = 1.0 / std::sqrt(vertical_norm);
mapped_front = q_front * horizontal_factor;
mapped_lateral = -q_x * horizontal_factor;
mapped_vertical = q_vertical * vertical_factor;
}
}
double scaled[3] = {mapped_front * static_cast<double>(profile.axis_scales_internal[2]),
mapped_lateral * static_cast<double>(profile.axis_scales_internal[0]),
mapped_vertical * static_cast<double>(profile.axis_scales_internal[1])};
double ray = 1.0;
for (int axis = 0; axis < 3; ++axis) {
const double value = scaled[axis];
const double lower = static_cast<double>(profile.bounds[static_cast<std::size_t>(axis) * 2u]);
const double upper =
static_cast<double>(profile.bounds[static_cast<std::size_t>(axis) * 2u + 1u]);
if (value < lower) {
ray = std::min(ray, lower / value);
} else if (value > upper) {
ray = std::min(ray, upper / value);
}
}
if (ray < 1.0) {
scaled[0] *= ray;
scaled[1] *= ray;
scaled[2] *= ray;
}
ProfileGeometry result;
result.radius = std::sqrt(scaled[0] * scaled[0] + scaled[1] * scaled[1] +
scaled[2] * scaled[2]);
result.clamped = std::max(result.radius, static_cast<double>(profile.minimum_normalized_radius));
result.alpha = result.radius / result.clamped;
if (result.radius > 1.0e-30) {
for (int axis = 0; axis < 3; ++axis) {
result.direction[axis] = scaled[axis] / result.radius;
}
}
*out = result;
return Status::success();
}
// rosella_direct.special_lfe_direct.
const DirectResult& special_lfe_direct() {
static const DirectResult result = [] {
DirectResult direct;
const std::vector<double> low = special_lfe_low();
for (int ear = 0; ear < 2; ++ear) {
for (int band = 0; band < kHybridBands; ++band) {
direct.gains[ear][band] = Complex(low[static_cast<std::size_t>(band)], 0.0);
}
}
return direct;
}();
return result;
}
// rosella_direct.direct_and_room_send.
Status direct_and_room_send(const RosellaModel& model, const std::vector<double>& field_left,
const std::vector<double>& field_right, const double position[3],
int profile_index, DirectResult* out) {
const RosellaDistanceProfile& profile =
model.profiles[static_cast<std::size_t>(profile_index)];
ProfileGeometry geometry;
const Status geometry_status = profile_geometry(model, position, profile_index, &geometry);
if (!geometry_status.ok()) {
return geometry_status;
}
const EarGeometry delay_ears =
ear_geometry(model, profile, geometry.direction, geometry.clamped,
static_cast<double>(model.model_scalars[1]),
static_cast<double>(model.model_scalars[2]));
const double delay = std::abs(delay_ears.path_plus - delay_ears.path_minus) *
static_cast<double>(profile.distance_scale_m) *
(static_cast<double>(model.sample_rate) / 343.3) * geometry.alpha;
int delayed_ear = -1;
if (delay_ears.path_minus > delay_ears.path_plus) {
delayed_ear = 0;
} else if (delay_ears.path_plus > delay_ears.path_minus) {
delayed_ear = 1;
}
const EarGeometry weight_ears =
ear_geometry(model, profile, geometry.direction, geometry.clamped,
static_cast<double>(model.model_scalars[3]),
static_cast<double>(model.model_scalars[4]));
const double weight_norm =
std::sqrt(weight_ears.path_minus * weight_ears.path_minus +
weight_ears.path_plus * weight_ears.path_plus);
const double weight_left = weight_ears.path_plus / weight_norm;
const double weight_right = weight_ears.path_minus / weight_norm;
const double final_offset = static_cast<double>(model.model_scalars[0]);
double basis_minus[kDirectionTerms] = {};
double basis_plus[kDirectionTerms] = {};
if (final_offset == 0.0) {
direction_basis(geometry.direction[0], geometry.direction[1], geometry.direction[2],
basis_minus);
std::copy(basis_minus, basis_minus + kDirectionTerms, basis_plus);
} else {
const double x = geometry.direction[0];
const double y = geometry.direction[1];
const double z = geometry.direction[2];
const double ear =
final_offset * static_cast<double>(profile.inverse_distance_per_m) / geometry.clamped;
const double y_minus = y - ear;
const double y_plus = y + ear;
const double common_length = x * x + z * z;
const double length_minus = std::sqrt(y_minus * y_minus + common_length);
const double length_plus = std::sqrt(y_plus * y_plus + common_length);
direction_basis(x / length_minus, y_minus / length_minus, z / length_minus, basis_minus);
direction_basis(x / length_plus, y_plus / length_plus, z / length_plus, basis_plus);
}
DirectResult result;
Complex left[kHybridBands] = {};
Complex right[kHybridBands] = {};
for (int band = 0; band < kHybridBands; ++band) {
double left_real = 0.0;
double left_imag = 0.0;
double right_real = 0.0;
double right_imag = 0.0;
for (int term = 0; term < kDirectionTerms; ++term) {
const std::size_t index =
(static_cast<std::size_t>(band) * kDirectionTerms + static_cast<std::size_t>(term)) *
2u;
left_real += field_left[index] * basis_minus[term];
left_imag += field_left[index + 1u] * basis_minus[term];
right_real += field_right[index] * basis_plus[term];
right_imag += field_right[index + 1u] * basis_plus[term];
}
left[band] = Complex(left_real, left_imag);
right[band] = Complex(right_real, right_imag);
}
if (delayed_ear >= 0) {
Complex phase[kHybridBands];
phase_groups(model, delay, phase);
Complex* target = delayed_ear == 0 ? left : right;
for (int band = 0; band < kHybridBands; ++band) {
target[band] *= phase[band];
}
}
const double effective_radius =
geometry.radius * static_cast<double>(model.header_float_scalars[0]) *
static_cast<double>(profile.distance_scale_m);
double common = 1.0;
double room_send = 0.0;
if (profile_index == static_cast<int>(RosellaProfile::Far) ||
profile_index == static_cast<int>(RosellaProfile::Mid)) {
common = 1.0 / std::sqrt(1.0 + static_cast<double>(model.header_float_scalars[1]) *
effective_radius * effective_radius);
room_send = effective_radius * common;
}
Complex left_term0[kHybridBands];
Complex right_term0[kHybridBands];
for (int band = 0; band < kHybridBands; ++band) {
const std::size_t index = static_cast<std::size_t>(band) * kDirectionTerms * 2u;
left_term0[band] = Complex(field_left[index], field_left[index + 1u]);
right_term0[band] = Complex(field_right[index], field_right[index + 1u]);
}
const bool weights_are_default_equal =
static_cast<double>(model.model_scalars[3]) == 0.0 &&
static_cast<double>(model.model_scalars[4]) == 0.0;
double centre_left = 0.0;
double centre_right = 0.0;
double right_direction_weight = weight_right;
if (weights_are_default_equal) {
centre_left = weight_left * (1.0 - geometry.alpha) * kCentreEqual;
centre_right = centre_left;
right_direction_weight = weight_left;
} else {
centre_left = (1.0 - geometry.alpha) * kCentreAlternate;
centre_right = centre_left;
}
for (int band = 0; band < kHybridBands; ++band) {
result.gains[0][band] =
common * (left[band] * (weight_left * geometry.alpha) + left_term0[band] * centre_left);
result.gains[1][band] = common * (right[band] * (right_direction_weight * geometry.alpha) +
right_term0[band] * centre_right);
}
result.room_send = room_send;
result.physical_radius_m = static_cast<double>(profile.distance_scale_m) * geometry.radius;
result.normalized_radius = geometry.radius;
result.clamped_radius = geometry.clamped;
result.delay_samples = delay;
result.delayed_ear = delayed_ear;
*out = result;
return Status::success();
}
namespace {
// rosella_room._RosellaRoomState: the recursive table-A room model.
class RoomState {
public:
explicit RoomState(const RosellaModel& model) : model_(model) {
bands_ = std::min(64, model.table_a_dimension);
delays_ = model.table_a_four_integers;
capacity_ = 0;
for (const int delay : delays_) {
capacity_ = std::max(capacity_, delay);
}
// The vectors are stored column-major (numpy's order="F").
matrix_.assign(16u, 0.0);
for (int row = 0; row < 4; ++row) {
for (int column = 0; column < 4; ++column) {
matrix_[static_cast<std::size_t>(row) + 4u * static_cast<std::size_t>(column)] =
static_cast<double>(model.table_a_vector16[static_cast<std::size_t>(row) +
4u * static_cast<std::size_t>(column)]);
}
}
const std::vector<float>& f8 = model.table_a_filter_8x64_padded;
const std::vector<float>& f4 = model.table_a_filter_4x64_padded;
const std::vector<float>& f16 = model.table_a_filter_16x64_padded;
feedback_real_.assign(static_cast<std::size_t>(bands_) * 4u, 0.0);
feedback_imag_.assign(static_cast<std::size_t>(bands_) * 4u, 0.0);
output_tap_.assign(static_cast<std::size_t>(bands_) * 4u, 0.0);
left_real_.assign(static_cast<std::size_t>(bands_) * 4u, 0.0);
left_imag_.assign(static_cast<std::size_t>(bands_) * 4u, 0.0);
right_real_.assign(static_cast<std::size_t>(bands_) * 4u, 0.0);
right_imag_.assign(static_cast<std::size_t>(bands_) * 4u, 0.0);
for (int band = 0; band < bands_; ++band) {
const int group = band / 4;
const int lane = band % 4;
for (int tap = 0; tap < 4; ++tap) {
const std::size_t target = static_cast<std::size_t>(band) * 4u +
static_cast<std::size_t>(tap);
const std::size_t g8 = ((static_cast<std::size_t>(group) * 4u +
static_cast<std::size_t>(tap)) * 2u) *
4u +
static_cast<std::size_t>(lane);
feedback_real_[target] = static_cast<double>(f8[g8]);
feedback_imag_[target] = static_cast<double>(f8[g8 + 4u]);
output_tap_[target] = static_cast<double>(
f4[(static_cast<std::size_t>(group) * 4u + static_cast<std::size_t>(tap)) * 4u +
static_cast<std::size_t>(lane)]);
const std::size_t g16 = ((static_cast<std::size_t>(group) * 4u +
static_cast<std::size_t>(tap)) * 4u) *
4u;
left_real_[target] = static_cast<double>(f16[g16 + static_cast<std::size_t>(lane)]);
left_imag_[target] =
static_cast<double>(f16[g16 + 4u + static_cast<std::size_t>(lane)]);
right_real_[target] =
static_cast<double>(f16[g16 + 8u + static_cast<std::size_t>(lane)]);
right_imag_[target] =
static_cast<double>(f16[g16 + 12u + static_cast<std::size_t>(lane)]);
}
}
allpass_gain_.resize(model.table_a_option_values.size());
for (std::size_t index = 0u; index < model.table_a_option_values.size(); ++index) {
allpass_gain_[index] = static_cast<double>(model.table_a_option_values[index]);
}
allpass_delay_ = model.table_a_option_ids;
for (const int delay : allpass_delay_) {
allpass_real_.emplace_back(static_cast<std::size_t>(delay) *
static_cast<std::size_t>(bands_),
0.0);
allpass_imag_.emplace_back(static_cast<std::size_t>(delay) *
static_cast<std::size_t>(bands_),
0.0);
}
allpass_position_.assign(allpass_real_.size(), 0);
memory_real_.assign(static_cast<std::size_t>(capacity_) * static_cast<std::size_t>(bands_) * 4u,
0.0);
memory_imag_.assign(memory_real_.size(), 0.0);
extra_matrices_.resize(model.table_a_extra_indices.size());
for (std::size_t index = 0u; index < extra_matrices_.size(); ++index) {
extra_matrices_[index].assign(16u, 0.0);
for (int row = 0; row < 4; ++row) {
for (int column = 0; column < 4; ++column) {
extra_matrices_[index][static_cast<std::size_t>(row) +
4u * static_cast<std::size_t>(column)] =
static_cast<double>(
model.table_a_extra_vectors[index * 16u + static_cast<std::size_t>(row) +
4u * static_cast<std::size_t>(column)]);
}
}
}
}
void reset() {
for (std::vector<double>& value : allpass_real_) {
std::fill(value.begin(), value.end(), 0.0);
}
for (std::vector<double>& value : allpass_imag_) {
std::fill(value.begin(), value.end(), 0.0);
}
std::fill(allpass_position_.begin(), allpass_position_.end(), 0);
std::fill(memory_real_.begin(), memory_real_.end(), 0.0);
std::fill(memory_imag_.begin(), memory_imag_.end(), 0.0);
position_ = 0;
}
Status process_slot(const Complex* room_send, Complex* output) {
if (static_cast<double>(model_.table_a_scalar) >= 0.5) {
return render_fail(JOC_ERR_NOT_SUPPORTED, "alternate Rosella table-A room mode");
}
const std::size_t bands = static_cast<std::size_t>(bands_);
std::vector<double> input_real(bands, 0.0);
std::vector<double> input_imag(bands, 0.0);
for (std::size_t band = 0u; band < bands; ++band) {
input_real[band] = room_send[band].real() * kRoomInputGain;
input_imag[band] = room_send[band].imag() * kRoomInputGain;
}
for (std::size_t index = 0u; index < allpass_gain_.size(); ++index) {
const std::size_t delay = static_cast<std::size_t>(allpass_delay_[index]);
const std::size_t position = static_cast<std::size_t>(allpass_position_[index]);
const double gain = allpass_gain_[index];
for (std::size_t band = 0u; band < bands; ++band) {
const std::size_t cell = position * bands + band;
const double previous_real = allpass_real_[index][cell];
const double previous_imag = allpass_imag_[index][cell];
const double residual_real = input_real[band] - previous_real * gain;
const double residual_imag = input_imag[band] - previous_imag * gain;
input_real[band] = residual_real * gain + previous_real;
input_imag[band] = residual_imag * gain + previous_imag;
allpass_real_[index][cell] = residual_real;
allpass_imag_[index][cell] = residual_imag;
}
allpass_position_[index] = static_cast<int>((position + 1u) % delay);
}
std::vector<double> branch_real(bands * 4u, 0.0);
std::vector<double> branch_imag(bands * 4u, 0.0);
std::vector<double> delayed_real(bands * 4u, 0.0);
std::vector<double> delayed_imag(bands * 4u, 0.0);
for (int branch = 0; branch < 4; ++branch) {
const std::size_t slot =
static_cast<std::size_t>((position_ - delays_[static_cast<std::size_t>(branch)] +
capacity_) %
capacity_);
for (std::size_t band = 0u; band < bands; ++band) {
const std::size_t source = (slot * bands + band) * 4u + static_cast<std::size_t>(branch);
delayed_real[band * 4u + static_cast<std::size_t>(branch)] = memory_real_[source];
delayed_imag[band * 4u + static_cast<std::size_t>(branch)] = memory_imag_[source];
}
}
for (std::size_t band = 0u; band < bands; ++band) {
for (int row = 0; row < 4; ++row) {
double real = input_real[band];
double imag = input_imag[band];
for (int column = 0; column < 4; ++column) {
const double coefficient =
matrix_[static_cast<std::size_t>(row) + 4u * static_cast<std::size_t>(column)];
real += delayed_real[band * 4u + static_cast<std::size_t>(column)] * coefficient;
imag += delayed_imag[band * 4u + static_cast<std::size_t>(column)] * coefficient;
}
branch_real[band * 4u + static_cast<std::size_t>(row)] = real;
branch_imag[band * 4u + static_cast<std::size_t>(row)] = imag;
}
}
const std::size_t tap_slot = static_cast<std::size_t>(
(position_ - model_.table_a_integer + capacity_) % capacity_);
std::vector<double> tap_real(bands * 4u, 0.0);
std::vector<double> tap_imag(bands * 4u, 0.0);
for (std::size_t band = 0u; band < bands; ++band) {
for (int lane = 0; lane < 4; ++lane) {
const std::size_t source = (tap_slot * bands + band) * 4u + static_cast<std::size_t>(lane);
tap_real[band * 4u + static_cast<std::size_t>(lane)] = memory_real_[source];
tap_imag[band * 4u + static_cast<std::size_t>(lane)] = memory_imag_[source];
}
}
for (std::size_t cell = 0u; cell < branch_real.size(); ++cell) {
const double real = branch_real[cell];
const double imag = branch_imag[cell];
memory_real_[(static_cast<std::size_t>(position_) * bands) * 4u + cell] =
real * feedback_real_[cell] - imag * feedback_imag_[cell];
memory_imag_[(static_cast<std::size_t>(position_) * bands) * 4u + cell] =
imag * feedback_real_[cell] + real * feedback_imag_[cell];
}
position_ = (position_ + 1) % capacity_;
std::vector<double> extra_real(bands * 4u, 0.0);
std::vector<double> extra_imag(bands * 4u, 0.0);
for (std::size_t index = 0u; index < model_.table_a_extra_indices.size(); ++index) {
const std::size_t delay =
static_cast<std::size_t>(model_.table_a_extra_indices[index]);
const std::size_t slot = static_cast<std::size_t>(
(position_ - static_cast<int>(delay) - 1 + capacity_ * 2) % capacity_);
for (std::size_t band = 0u; band < bands; ++band) {
for (int row = 0; row < 4; ++row) {
double mixed_real = 0.0;
double mixed_imag = 0.0;
for (int column = 0; column < 4; ++column) {
const std::size_t source =
(slot * bands + band) * 4u + static_cast<std::size_t>(column);
const double coefficient =
extra_matrices_[index][static_cast<std::size_t>(row) +
4u * static_cast<std::size_t>(column)];
mixed_real += memory_real_[source] * coefficient;
mixed_imag += memory_imag_[source] * coefficient;
}
const int group = static_cast<int>(band) / 4;
const int lane = static_cast<int>(band) % 4;
const std::size_t field =
(index * 20u + static_cast<std::size_t>(group)) * 2u * 4u;
const double coefficient_real = static_cast<double>(
model_.table_a_extra_fields_padded[field + static_cast<std::size_t>(lane)]);
const double coefficient_imag = static_cast<double>(
model_.table_a_extra_fields_padded[field + 4u + static_cast<std::size_t>(lane)]);
const std::size_t target = band * 4u + static_cast<std::size_t>(row);
extra_real[target] +=
mixed_real * coefficient_real - mixed_imag * coefficient_imag;
extra_imag[target] +=
mixed_imag * coefficient_real + mixed_real * coefficient_imag;
}
}
}
for (std::size_t band = 0u; band < bands; ++band) {
double left_real = 0.0;
double left_imag = 0.0;
double right_real = 0.0;
double right_imag = 0.0;
for (int lane = 0; lane < 4; ++lane) {
const std::size_t cell = band * 4u + static_cast<std::size_t>(lane);
const double real = tap_real[cell] * output_tap_[cell] + extra_real[cell];
const double imag = tap_imag[cell] * output_tap_[cell] + extra_imag[cell];
left_real += left_real_[cell] * real - left_imag_[cell] * imag;
left_imag += left_imag_[cell] * real + left_real_[cell] * imag;
right_real += right_real_[cell] * real - right_imag_[cell] * imag;
right_imag += right_imag_[cell] * real + right_real_[cell] * imag;
}
output[band] = Complex(left_real, left_imag);
output[kHybridBands + band] = Complex(right_real, right_imag);
}
return Status::success();
}
private:
const RosellaModel& model_;
int bands_ = 0;
std::array<int, 4> delays_{};
int capacity_ = 0;
std::vector<double> matrix_;
std::vector<double> feedback_real_;
std::vector<double> feedback_imag_;
std::vector<double> output_tap_;
std::vector<double> left_real_;
std::vector<double> left_imag_;
std::vector<double> right_real_;
std::vector<double> right_imag_;
std::vector<double> allpass_gain_;
std::vector<int> allpass_delay_;
std::vector<std::vector<double>> allpass_real_;
std::vector<std::vector<double>> allpass_imag_;
std::vector<int> allpass_position_;
std::vector<double> memory_real_;
std::vector<double> memory_imag_;
int position_ = 0;
std::vector<std::vector<double>> extra_matrices_;
};
} // namespace
RosellaRoomFir::RosellaRoomFir() = default;
RosellaRoomFir::~RosellaRoomFir() = default;
Status RosellaRoomFir::configure(const RosellaModel& model, int impulse_slots) {
length_ = impulse_slots;
RoomState reference(model);
kernel_.assign(static_cast<std::size_t>(length_) * 2u * kRoomBands, Complex(0.0, 0.0));
Complex slot_output[2 * kHybridBands];
for (int slot = 0; slot < length_; ++slot) {
Complex impulse[kHybridBands];
for (int band = 0; band < kHybridBands; ++band) {
impulse[band] = Complex(slot == 0 && band < kRoomBands ? 1.0 : 0.0, 0.0);
}
const Status status = reference.process_slot(impulse, slot_output);
if (!status.ok()) {
return status;
}
for (int ear = 0; ear < 2; ++ear) {
for (int band = 0; band < kRoomBands; ++band) {
kernel_[(static_cast<std::size_t>(slot) * 2u + static_cast<std::size_t>(ear)) *
kRoomBands +
static_cast<std::size_t>(band)] =
slot_output[ear * kHybridBands + band];
}
}
}
tail_.assign(static_cast<std::size_t>(length_ - 1) * 2u * kRoomBands, Complex(0.0, 0.0));
valid_ = true;
return Status::success();
}
bool RosellaRoomFir::valid() const { return valid_; }
void RosellaRoomFir::reset() {
std::fill(tail_.begin(), tail_.end(), Complex(0.0, 0.0));
fft_cache_size_ = 0u;
forward_plan_.reset();
inverse_plan_.reset();
}
// rosella_room.RosellaRoomFir.process_chunk.
Status RosellaRoomFir::process_chunk(const std::vector<std::complex<double>>& values,
std::size_t slots,
std::vector<std::complex<double>>* output) {
output->assign(slots * 2u * kHybridBands, Complex(0.0, 0.0));
if (slots == 0u) {
return Status::success();
}
const std::size_t needed = slots + static_cast<std::size_t>(length_) - 1u;
std::size_t fft_size = 1u;
while (fft_size < needed) {
fft_size <<= 1u;
}
if (fft_size != fft_cache_size_) {
kernel_fft_.assign(fft_size * 2u * kRoomBands, Complex(0.0, 0.0));
// The room transforms a fixed length for the whole chunk, so the radix-2
// twiddle recurrences are materialised once here rather than re-derived
// inside every butterfly of every one of the 3 * kRoomBands transforms.
forward_plan_ = std::make_unique<dsp::FftPlan>(fft_size, false);
inverse_plan_ = std::make_unique<dsp::FftPlan>(fft_size, true);
line_.assign(fft_size, Complex(0.0, 0.0));
for (int ear = 0; ear < 2; ++ear) {
for (int band = 0; band < kRoomBands; ++band) {
for (int slot = 0; slot < length_; ++slot) {
line_[static_cast<std::size_t>(slot)] =
kernel_[(static_cast<std::size_t>(slot) * 2u +
static_cast<std::size_t>(ear)) *
kRoomBands +
static_cast<std::size_t>(band)];
}
std::fill(line_.begin() + length_, line_.end(), Complex(0.0, 0.0));
dsp::fft_radix2(&line_, *forward_plan_);
for (std::size_t index = 0u; index < fft_size; ++index) {
// Band-major, so that the spectrum multiply below reads both
// of its operands as runs instead of striding through them
// one complex per cache line. Same values, same places.
kernel_fft_[(static_cast<std::size_t>(ear) * kRoomBands +
static_cast<std::size_t>(band)) *
fft_size +
index] = line_[index];
}
}
}
fft_cache_size_ = fft_size;
}
// input_fft_ and block_ are indexed linearly and every entry of each is written
// before it is read (the per-band forward transform fills input_fft_ column by
// column, and the inverse transform fills block_ entry by entry), so their zero
// fills were dead. The line buffer, by contrast, is handed to fft_radix2,
// which transforms exactly data->size() entries -- it therefore has to keep the
// exact length and the exact initialisation it had as a local.
if (line_.size() != fft_size) {
line_.assign(fft_size, Complex(0.0, 0.0));
}
const std::size_t input_fft_size = fft_size * kRoomBands;
if (input_fft_.size() < input_fft_size) {
input_fft_.resize(input_fft_size);
}
for (int band = 0; band < kRoomBands; ++band) {
for (std::size_t slot = 0u; slot < slots; ++slot) {
line_[slot] = values[slot * kHybridBands + static_cast<std::size_t>(band)];
}
std::fill(line_.begin() + static_cast<std::ptrdiff_t>(slots), line_.end(),
Complex(0.0, 0.0));
dsp::fft_radix2(&line_, *forward_plan_);
for (std::size_t index = 0u; index < fft_size; ++index) {
// Band-major, matching kernel_fft_, so that the spectrum multiply
// reads both operands as runs.
input_fft_[static_cast<std::size_t>(band) * fft_size + index] = line_[index];
}
}
const std::size_t block_size = needed * 2u * kRoomBands;
if (block_.size() < block_size) {
block_.resize(block_size);
}
for (int ear = 0; ear < 2; ++ear) {
for (int band = 0; band < kRoomBands; ++band) {
// Both planes are band-major now, so this is one contiguous complex
// product per (ear, band) and the dispatched kernel puts neighbouring
// complexes in its lanes; each product keeps the caller's four
// multiplies and two roundings.
simd::complex_multiply(
reinterpret_cast<double*>(line_.data()),
reinterpret_cast<const double*>(
input_fft_.data() + static_cast<std::size_t>(band) * fft_size),
reinterpret_cast<const double*>(
kernel_fft_.data() +
(static_cast<std::size_t>(ear) * kRoomBands +
static_cast<std::size_t>(band)) *
fft_size),
fft_size);
dsp::fft_radix2(&line_, *inverse_plan_);
for (std::size_t slot = 0u; slot < needed; ++slot) {
block_[(slot * 2u + static_cast<std::size_t>(ear)) * kRoomBands +
static_cast<std::size_t>(band)] = line_[slot];
}
}
}
const std::size_t tail_length = static_cast<std::size_t>(length_ - 1);
for (std::size_t index = 0u; index < tail_length * 2u * kRoomBands; ++index) {
block_[index] += tail_[index];
}
for (std::size_t slot = 0u; slot < slots; ++slot) {
for (int ear = 0; ear < 2; ++ear) {
for (int band = 0; band < kRoomBands; ++band) {
(*output)[slot * 2u * kHybridBands + static_cast<std::size_t>(ear) * kHybridBands +
static_cast<std::size_t>(band)] =
block_[(slot * 2u + static_cast<std::size_t>(ear)) * kRoomBands +
static_cast<std::size_t>(band)];
}
}
}
for (std::size_t index = 0u; index < tail_length * 2u * kRoomBands; ++index) {
tail_[index] = block_[slots * 2u * kRoomBands + index];
}
return Status::success();
}
} // namespace joc::hrtf
+107
View File
@@ -0,0 +1,107 @@
#pragma once
#include <complex>
#include <cstddef>
#include <memory>
#include <vector>
#include "foundation/status.h"
#include "hrtf/rosella_model.h"
// One of the room's transforms is a radix-2 FFT plan, so the type is named here and
// kept out of the interface.
namespace joc::dsp {
class FftPlan;
} // namespace joc::dsp
// The reference arithmetic of the Rosella ".personalized_headphone" renderer
// (rosella_model.py, rosella_direct.py and rosella_room.py): the direction basis and
// the padded lane grid, the per-source direct gains and room send, and the recursive
// table-A room model. rosella_renderer.cpp drives these through RosellaRuntime; a
// renderer built on another field format can call them directly and get the same
// samples, so the operation order and the literals in the definitions are part of
// the interface.
namespace joc::hrtf {
// rosella_direct._profile_geometry: a virtual position resolved on one distance
// profile's grid, as the direction of the direct path plus the radius factors the
// gain weights are scaled by.
struct ProfileGeometry {
double direction[3] = {1.0, 0.0, 0.0};
double radius = 0.0;
double clamped = 0.0;
double alpha = 0.0;
};
// Quantises `position` onto the profile's metadata grid, maps it through the
// profile's axis scales and clamps it to the profile bounds; `out` takes the result.
Status profile_geometry(const RosellaModel& model, const double position[3], int profile_index,
ProfileGeometry* out);
// rosella_model.direction_basis: the observed 36-term basis of one unit vector.
void direction_basis(double x, double y, double z, double out[36]);
// rosella_direct._logical_field: the padded lane grid as [77][36][2] float64.
std::vector<double> rosella_logical_field(const std::vector<float>& padded);
// One source's direct-path gains and room send, plus the radii and the interaural
// delay the caller reports. `delayed_ear` is -1 when neither ear is delayed,
// otherwise it is the ear (0 = left, 1 = right) whose phase carries
// `delay_samples`.
struct DirectResult {
std::complex<double> gains[2][77] = {};
double room_send = 0.0;
double physical_radius_m = 0.0;
double normalized_radius = 0.0;
double clamped_radius = 0.0;
double delay_samples = 0.0;
int delayed_ear = -1;
};
// rosella_direct.special_lfe_direct: the response a special (LFE) source is
// rendered with, built once.
const DirectResult& special_lfe_direct();
// rosella_direct.direct_and_room_send: the direct gains and the room send of the
// position `position` on profile `profile_index`, read through the logical field
// grids of `field_left`/`field_right`.
Status direct_and_room_send(const RosellaModel& model, const std::vector<double>& field_left,
const std::vector<double>& field_right, const double position[3],
int profile_index, DirectResult* out);
// rosella_room.RosellaRoomFir: the recursive table-A room model, its room FIR and the
// overlap-add convolution that applies the FIR in the hybrid band domain. State is
// per instance and not thread-safe.
class RosellaRoomFir {
public:
RosellaRoomFir();
~RosellaRoomFir();
RosellaRoomFir(const RosellaRoomFir&) = delete;
RosellaRoomFir& operator=(const RosellaRoomFir&) = delete;
// Builds the room impulse response from `model` over `impulse_slots` slots. The
// room can only be processed once this succeeds; the alternate table-A mode is
// rejected here, as the reference rejects it.
Status configure(const RosellaModel& model, int impulse_slots);
// `values` is [slots][2][77], `output` is [slots][2][77] and stays zero outside
// the room bands.
Status process_chunk(const std::vector<std::complex<double>>& values, std::size_t slots,
std::vector<std::complex<double>>* output);
void reset();
bool valid() const;
private:
int length_ = 0;
bool valid_ = false;
std::vector<std::complex<double>> kernel_;
std::vector<std::complex<double>> tail_;
std::vector<std::complex<double>> kernel_fft_;
std::size_t fft_cache_size_ = 0u;
std::vector<std::complex<double>> line_; // scratch, exactly fft_size entries
std::vector<std::complex<double>> input_fft_; // scratch, [fft_size][64], fully written
std::vector<std::complex<double>> block_; // scratch, [needed][2][64], fully written
std::unique_ptr<dsp::FftPlan> forward_plan_;
std::unique_ptr<dsp::FftPlan> inverse_plan_;
};
} // namespace joc::hrtf
+15 -851
View File
@@ -1,18 +1,14 @@
#include "hrtf/rosella_renderer.h" #include "hrtf/rosella_renderer.h"
#include "simd/simd.h"
#include <algorithm> #include <algorithm>
#include <array>
#include <cmath> #include <cmath>
#include <complex> #include <complex>
#include <cstring>
#include <limits> #include <limits>
#include <utility> #include <utility>
#include <vector> #include <vector>
#include "foundation/fft.h"
#include "hrtf/rosella_bank.h" #include "hrtf/rosella_bank.h"
#include "hrtf/rosella_reference.h"
namespace joc::hrtf { namespace joc::hrtf {
@@ -20,850 +16,14 @@ namespace {
constexpr int kSourceChannels = 16; constexpr int kSourceChannels = 16;
constexpr int kOutputChannels = 2; constexpr int kOutputChannels = 2;
constexpr int kDirectionTerms = 36;
constexpr int kBlockSamples = 512; constexpr int kBlockSamples = 512;
constexpr int kFrameSamples = 1536; constexpr int kFrameSamples = 1536;
constexpr int kRoomBands = 64;
constexpr double kPi = 3.14159265358979323846; constexpr double kPi = 3.14159265358979323846;
constexpr double kRoomInputGain = 0.70710677;
constexpr double kCentreEqual = 0.9998489618301392;
constexpr double kCentreAlternate = 0.7070000171661377;
// The fixed sixteen-band low-pass a special (LFE) source is rendered through; the
// constants are the float32 bit patterns of rosella_direct._SPECIAL_LFE_LOW_16.
constexpr std::uint32_t kSpecialLfeLowBits[16] = {
0x402695EAu, 0x3FE75979u, 0x3F28CAAAu, 0xBCE1FB2Eu, 0xBDD8AF65u, 0xBD8F426Eu,
0x3D996821u, 0xBC16B3A0u, 0x3B64BAF1u, 0xBC81ECFDu, 0xBA3D892Fu, 0x3AF6A9F0u,
0xB9DD1C5Fu, 0x380A193Fu, 0x38052059u, 0x351BCB34u};
Status render_fail(joc_error code, const std::string& message) { Status render_fail(joc_error code, const std::string& message) {
return Status::fail(code, stage::kRender, message); return Status::fail(code, stage::kRender, message);
} }
std::vector<double> special_lfe_low() {
std::vector<double> values(kHybridBands, 0.0);
for (int index = 0; index < 16; ++index) {
float narrowed = 0.0f;
const std::uint32_t bits = kSpecialLfeLowBits[index];
std::memcpy(&narrowed, &bits, sizeof(float));
values[static_cast<std::size_t>(index)] = static_cast<double>(narrowed);
}
return values;
}
// rosella_model.direction_basis: the observed 36-term basis. The operation order is
// part of the model, so the intermediates are named after the reference's.
void direction_basis(double x, double y, double z, double* out) {
const double yz = y * z;
const double x2 = x * x;
const double y2 = y * y;
const double x2m02 = x2 - 0.2;
const double xy = x * y;
out[0] = 1.0;
out[1] = x;
out[2] = y;
out[3] = z;
out[4] = x2 - (1.0 / 3.0);
out[5] = xy;
out[6] = x * z;
out[7] = y2 - (1.0 / 3.0);
out[8] = yz;
out[9] = (x2 - 0.6) * x;
out[10] = x2m02 * y;
out[11] = x2m02 * z;
out[12] = (y2 - 0.2) * x;
out[13] = yz * x;
out[14] = (y2 - 0.6) * y;
out[15] = (y2 - 0.2) * z;
out[16] = x2 * x2 - 0.2;
out[17] = xy * x2;
out[18] = (x * z) * x2;
out[19] = y2 * x2 - (1.0 / 15.0);
out[20] = yz * x2;
out[21] = x * y2 * y;
out[22] = x * y2 * z;
out[23] = y2 * y2 - 0.2;
const double x4 = x2 * x2;
const double x2y2 = y2 * x2;
const double y4 = y2 * y2;
out[24] = yz * y2;
out[25] = (x4 - (3.0 / 7.0)) * x;
out[26] = (x4 - (3.0 / 35.0)) * y;
out[27] = (x4 - (3.0 / 35.0)) * z;
out[28] = (x2y2 - (3.0 / 35.0)) * x;
out[29] = (x2 * z) * xy;
out[30] = (x2y2 - (3.0 / 35.0)) * y;
out[31] = (x2y2 - (1.0 / 35.0)) * z;
out[32] = (y4 - (3.0 / 35.0)) * x;
out[33] = (y2 * z) * xy;
out[34] = (y4 - (3.0 / 7.0)) * y;
out[35] = (y4 - (3.0 / 35.0)) * z;
}
// rosella_direct._logical_field: the padded lane grid as [77][36][2] float64.
void logical_field(const std::vector<float>& padded, std::vector<double>* out) {
out->assign(static_cast<std::size_t>(kHybridBands) * kDirectionTerms * 2u, 0.0);
for (int band = 0; band < kHybridBands; ++band) {
const int block = band / 4;
const int lane = band % 4;
for (int term = 0; term < kDirectionTerms; ++term) {
for (int component = 0; component < 2; ++component) {
const std::size_t source =
static_cast<std::size_t>(lane + 4 * (term * 2 + component + 72 * block));
(*out)[(static_cast<std::size_t>(band) * kDirectionTerms +
static_cast<std::size_t>(term)) * 2u +
static_cast<std::size_t>(component)] =
source < padded.size() ? static_cast<double>(padded[source]) : 0.0;
}
}
}
}
// rosella_direct._round_away_from_zero.
double round_away_from_zero(double value) {
return value >= 0.0 ? std::floor(value + 0.5) : std::ceil(value - 0.5);
}
// rosella_direct._q15_position: ADM coordinates on the Rosella metadata grid.
void q15_position(const double position[3], int encoded[3]) {
const double raw[3] = {
std::min(std::max((position[0] + 1.0) * 0.5, 0.0), 1.0),
std::min(std::max((1.0 - position[1]) * 0.5, 0.0), 1.0),
std::min(std::max(position[2], -1.0), 1.0),
};
for (int axis = 0; axis < 3; ++axis) {
encoded[axis] = static_cast<int>(
std::min(round_away_from_zero(raw[axis] * 32768.0), 32767.0));
}
}
struct ProfileGeometry {
double direction[3] = {1.0, 0.0, 0.0};
double radius = 0.0;
double clamped = 0.0;
double alpha = 0.0;
};
// rosella_direct._profile_geometry.
ProfileGeometry profile_geometry(const RosellaModel& model, const double position[3],
int profile_index) {
const RosellaDistanceProfile& profile = model.profiles[static_cast<std::size_t>(profile_index)];
int encoded[3] = {0, 0, 0};
q15_position(position, encoded);
const double q_front = 1.0 - 2.0 * static_cast<double>(encoded[1]) / 32768.0;
const double q_x = 2.0 * static_cast<double>(encoded[0]) / 32768.0 - 1.0;
const double q_vertical = static_cast<double>(encoded[2]) / 32768.0;
double mapped_front = q_front;
double mapped_lateral = -q_x;
double mapped_vertical = q_vertical;
if (model.header_integer_fields[0] != 0) {
if (q_x == 0.0 && q_front == 0.0) {
mapped_front = 0.0;
mapped_lateral = 0.0;
mapped_vertical = q_vertical;
} else {
const double horizontal_max = std::max(std::abs(q_x), std::abs(q_front));
const double horizontal_norm = (q_x / horizontal_max) * (q_x / horizontal_max) +
(q_front / horizontal_max) * (q_front / horizontal_max);
double vertical_norm = 1.0;
if (q_vertical != 0.0) {
const double smaller = std::min(std::abs(q_vertical), horizontal_max);
const double larger = std::max(std::abs(q_vertical), horizontal_max);
vertical_norm = 1.0 + (smaller / larger) * (smaller / larger);
}
const double horizontal_factor = 1.0 / std::sqrt(horizontal_norm * vertical_norm);
const double vertical_factor = 1.0 / std::sqrt(vertical_norm);
mapped_front = q_front * horizontal_factor;
mapped_lateral = -q_x * horizontal_factor;
mapped_vertical = q_vertical * vertical_factor;
}
}
double scaled[3] = {mapped_front * static_cast<double>(profile.axis_scales_internal[2]),
mapped_lateral * static_cast<double>(profile.axis_scales_internal[0]),
mapped_vertical * static_cast<double>(profile.axis_scales_internal[1])};
double ray = 1.0;
for (int axis = 0; axis < 3; ++axis) {
const double value = scaled[axis];
const double lower = static_cast<double>(profile.bounds[static_cast<std::size_t>(axis) * 2u]);
const double upper =
static_cast<double>(profile.bounds[static_cast<std::size_t>(axis) * 2u + 1u]);
if (value < lower) {
ray = std::min(ray, lower / value);
} else if (value > upper) {
ray = std::min(ray, upper / value);
}
}
if (ray < 1.0) {
scaled[0] *= ray;
scaled[1] *= ray;
scaled[2] *= ray;
}
ProfileGeometry result;
result.radius = std::sqrt(scaled[0] * scaled[0] + scaled[1] * scaled[1] +
scaled[2] * scaled[2]);
result.clamped = std::max(result.radius, static_cast<double>(profile.minimum_normalized_radius));
result.alpha = result.radius / result.clamped;
if (result.radius > 1.0e-30) {
for (int axis = 0; axis < 3; ++axis) {
result.direction[axis] = scaled[axis] / result.radius;
}
}
return result;
}
struct EarGeometry {
double basis_minus[kDirectionTerms] = {};
double basis_plus[kDirectionTerms] = {};
double path_minus = 0.0;
double path_plus = 0.0;
};
// rosella_direct._ear_geometry.
EarGeometry ear_geometry(const RosellaModel& model, const RosellaDistanceProfile& profile,
const double direction[3], double clamped, double offset,
double correction) {
const double x = direction[0];
const double y = direction[1];
const double z = direction[2];
const double inverse_distance = static_cast<double>(profile.inverse_distance_per_m);
const double ear = offset * inverse_distance / clamped;
const double y_minus = y - ear;
const double y_plus = y + ear;
const double common = x * x + z * z;
const double length_minus = std::sqrt(y_minus * y_minus + common);
const double length_plus = std::sqrt(y_plus * y_plus + common);
EarGeometry result;
direction_basis(x / length_minus, y_minus / length_minus, z / length_minus,
result.basis_minus);
direction_basis(x / length_plus, y_plus / length_plus, z / length_plus, result.basis_plus);
result.path_minus = length_minus * clamped;
result.path_plus = length_plus * clamped;
if (correction != 0.0) {
const double multiplier = 2.0 * correction * inverse_distance;
double left = 0.0;
double right = 0.0;
for (int term = 0; term < kDirectionTerms; ++term) {
left += static_cast<double>(model.vector_left[static_cast<std::size_t>(term)]) *
result.basis_minus[term];
right += static_cast<double>(model.vector_right[static_cast<std::size_t>(term)]) *
result.basis_plus[term];
}
result.path_minus += std::max(left, 0.0) * multiplier;
result.path_plus += std::max(right, 0.0) * multiplier;
}
return result;
}
// rosella_direct._phase_groups.
void phase_groups(const RosellaModel& model, double delay_samples, Complex* out) {
// The reference starts from np.ones(77) and only rewrites the flagged bands.
std::fill(out, out + kHybridBands, Complex(1.0, 0.0));
Complex current(1.0, 0.0);
Complex step(1.0, 0.0);
std::size_t value_index = 0u;
for (std::size_t band = 0u; band < model.hybrid_flags.size() && band < kHybridBands; ++band) {
const int flag = model.hybrid_flags[band];
if (flag != 2) {
if (flag == 1) {
const double angle =
static_cast<double>(model.hybrid_values[value_index]) * delay_samples;
++value_index;
step = Complex(std::cos(angle), std::sin(angle));
}
current *= step;
}
out[band] = current;
}
}
struct DirectResult {
Complex gains[2][kHybridBands] = {};
double room_send = 0.0;
double physical_radius_m = 0.0;
double normalized_radius = 0.0;
double clamped_radius = 0.0;
double delay_samples = 0.0;
int delayed_ear = -1;
};
// rosella_direct.special_lfe_direct.
const DirectResult& special_lfe_direct() {
static const DirectResult result = [] {
DirectResult direct;
const std::vector<double> low = special_lfe_low();
for (int ear = 0; ear < 2; ++ear) {
for (int band = 0; band < kHybridBands; ++band) {
direct.gains[ear][band] = Complex(low[static_cast<std::size_t>(band)], 0.0);
}
}
return direct;
}();
return result;
}
// rosella_direct.direct_and_room_send.
DirectResult direct_and_room_send(const RosellaModel& model,
const std::vector<double>& field_left,
const std::vector<double>& field_right, const double position[3],
int profile_index) {
const RosellaDistanceProfile& profile =
model.profiles[static_cast<std::size_t>(profile_index)];
const ProfileGeometry geometry = profile_geometry(model, position, profile_index);
const EarGeometry delay_ears =
ear_geometry(model, profile, geometry.direction, geometry.clamped,
static_cast<double>(model.model_scalars[1]),
static_cast<double>(model.model_scalars[2]));
const double delay = std::abs(delay_ears.path_plus - delay_ears.path_minus) *
static_cast<double>(profile.distance_scale_m) *
(static_cast<double>(model.sample_rate) / 343.3) * geometry.alpha;
int delayed_ear = -1;
if (delay_ears.path_minus > delay_ears.path_plus) {
delayed_ear = 0;
} else if (delay_ears.path_plus > delay_ears.path_minus) {
delayed_ear = 1;
}
const EarGeometry weight_ears =
ear_geometry(model, profile, geometry.direction, geometry.clamped,
static_cast<double>(model.model_scalars[3]),
static_cast<double>(model.model_scalars[4]));
const double weight_norm =
std::sqrt(weight_ears.path_minus * weight_ears.path_minus +
weight_ears.path_plus * weight_ears.path_plus);
const double weight_left = weight_ears.path_plus / weight_norm;
const double weight_right = weight_ears.path_minus / weight_norm;
const double final_offset = static_cast<double>(model.model_scalars[0]);
double basis_minus[kDirectionTerms] = {};
double basis_plus[kDirectionTerms] = {};
if (final_offset == 0.0) {
direction_basis(geometry.direction[0], geometry.direction[1], geometry.direction[2],
basis_minus);
std::copy(basis_minus, basis_minus + kDirectionTerms, basis_plus);
} else {
const double x = geometry.direction[0];
const double y = geometry.direction[1];
const double z = geometry.direction[2];
const double ear =
final_offset * static_cast<double>(profile.inverse_distance_per_m) / geometry.clamped;
const double y_minus = y - ear;
const double y_plus = y + ear;
const double common_length = x * x + z * z;
const double length_minus = std::sqrt(y_minus * y_minus + common_length);
const double length_plus = std::sqrt(y_plus * y_plus + common_length);
direction_basis(x / length_minus, y_minus / length_minus, z / length_minus, basis_minus);
direction_basis(x / length_plus, y_plus / length_plus, z / length_plus, basis_plus);
}
DirectResult result;
Complex left[kHybridBands] = {};
Complex right[kHybridBands] = {};
for (int band = 0; band < kHybridBands; ++band) {
double left_real = 0.0;
double left_imag = 0.0;
double right_real = 0.0;
double right_imag = 0.0;
for (int term = 0; term < kDirectionTerms; ++term) {
const std::size_t index =
(static_cast<std::size_t>(band) * kDirectionTerms + static_cast<std::size_t>(term)) *
2u;
left_real += field_left[index] * basis_minus[term];
left_imag += field_left[index + 1u] * basis_minus[term];
right_real += field_right[index] * basis_plus[term];
right_imag += field_right[index + 1u] * basis_plus[term];
}
left[band] = Complex(left_real, left_imag);
right[band] = Complex(right_real, right_imag);
}
if (delayed_ear >= 0) {
Complex phase[kHybridBands];
phase_groups(model, delay, phase);
Complex* target = delayed_ear == 0 ? left : right;
for (int band = 0; band < kHybridBands; ++band) {
target[band] *= phase[band];
}
}
const double effective_radius =
geometry.radius * static_cast<double>(model.header_float_scalars[0]) *
static_cast<double>(profile.distance_scale_m);
double common = 1.0;
double room_send = 0.0;
if (profile_index == static_cast<int>(RosellaProfile::Far) ||
profile_index == static_cast<int>(RosellaProfile::Mid)) {
common = 1.0 / std::sqrt(1.0 + static_cast<double>(model.header_float_scalars[1]) *
effective_radius * effective_radius);
room_send = effective_radius * common;
}
Complex left_term0[kHybridBands];
Complex right_term0[kHybridBands];
for (int band = 0; band < kHybridBands; ++band) {
const std::size_t index = static_cast<std::size_t>(band) * kDirectionTerms * 2u;
left_term0[band] = Complex(field_left[index], field_left[index + 1u]);
right_term0[band] = Complex(field_right[index], field_right[index + 1u]);
}
const bool weights_are_default_equal =
static_cast<double>(model.model_scalars[3]) == 0.0 &&
static_cast<double>(model.model_scalars[4]) == 0.0;
double centre_left = 0.0;
double centre_right = 0.0;
double right_direction_weight = weight_right;
if (weights_are_default_equal) {
centre_left = weight_left * (1.0 - geometry.alpha) * kCentreEqual;
centre_right = centre_left;
right_direction_weight = weight_left;
} else {
centre_left = (1.0 - geometry.alpha) * kCentreAlternate;
centre_right = centre_left;
}
for (int band = 0; band < kHybridBands; ++band) {
result.gains[0][band] =
common * (left[band] * (weight_left * geometry.alpha) + left_term0[band] * centre_left);
result.gains[1][band] = common * (right[band] * (right_direction_weight * geometry.alpha) +
right_term0[band] * centre_right);
}
result.room_send = room_send;
result.physical_radius_m = static_cast<double>(profile.distance_scale_m) * geometry.radius;
result.normalized_radius = geometry.radius;
result.clamped_radius = geometry.clamped;
result.delay_samples = delay;
result.delayed_ear = delayed_ear;
return result;
}
// rosella_room._RosellaRoomState: the recursive table-A room model.
class RoomState {
public:
explicit RoomState(const RosellaModel& model) : model_(model) {
bands_ = std::min(64, model.table_a_dimension);
delays_ = model.table_a_four_integers;
capacity_ = 0;
for (const int delay : delays_) {
capacity_ = std::max(capacity_, delay);
}
// The vectors are stored column-major (numpy's order="F").
matrix_.assign(16u, 0.0);
for (int row = 0; row < 4; ++row) {
for (int column = 0; column < 4; ++column) {
matrix_[static_cast<std::size_t>(row) + 4u * static_cast<std::size_t>(column)] =
static_cast<double>(model.table_a_vector16[static_cast<std::size_t>(row) +
4u * static_cast<std::size_t>(column)]);
}
}
const std::vector<float>& f8 = model.table_a_filter_8x64_padded;
const std::vector<float>& f4 = model.table_a_filter_4x64_padded;
const std::vector<float>& f16 = model.table_a_filter_16x64_padded;
feedback_real_.assign(static_cast<std::size_t>(bands_) * 4u, 0.0);
feedback_imag_.assign(static_cast<std::size_t>(bands_) * 4u, 0.0);
output_tap_.assign(static_cast<std::size_t>(bands_) * 4u, 0.0);
left_real_.assign(static_cast<std::size_t>(bands_) * 4u, 0.0);
left_imag_.assign(static_cast<std::size_t>(bands_) * 4u, 0.0);
right_real_.assign(static_cast<std::size_t>(bands_) * 4u, 0.0);
right_imag_.assign(static_cast<std::size_t>(bands_) * 4u, 0.0);
for (int band = 0; band < bands_; ++band) {
const int group = band / 4;
const int lane = band % 4;
for (int tap = 0; tap < 4; ++tap) {
const std::size_t target = static_cast<std::size_t>(band) * 4u +
static_cast<std::size_t>(tap);
const std::size_t g8 = ((static_cast<std::size_t>(group) * 4u +
static_cast<std::size_t>(tap)) * 2u) *
4u +
static_cast<std::size_t>(lane);
feedback_real_[target] = static_cast<double>(f8[g8]);
feedback_imag_[target] = static_cast<double>(f8[g8 + 4u]);
output_tap_[target] = static_cast<double>(
f4[(static_cast<std::size_t>(group) * 4u + static_cast<std::size_t>(tap)) * 4u +
static_cast<std::size_t>(lane)]);
const std::size_t g16 = ((static_cast<std::size_t>(group) * 4u +
static_cast<std::size_t>(tap)) * 4u) *
4u;
left_real_[target] = static_cast<double>(f16[g16 + static_cast<std::size_t>(lane)]);
left_imag_[target] =
static_cast<double>(f16[g16 + 4u + static_cast<std::size_t>(lane)]);
right_real_[target] =
static_cast<double>(f16[g16 + 8u + static_cast<std::size_t>(lane)]);
right_imag_[target] =
static_cast<double>(f16[g16 + 12u + static_cast<std::size_t>(lane)]);
}
}
allpass_gain_.resize(model.table_a_option_values.size());
for (std::size_t index = 0u; index < model.table_a_option_values.size(); ++index) {
allpass_gain_[index] = static_cast<double>(model.table_a_option_values[index]);
}
allpass_delay_ = model.table_a_option_ids;
for (const int delay : allpass_delay_) {
allpass_real_.emplace_back(static_cast<std::size_t>(delay) *
static_cast<std::size_t>(bands_),
0.0);
allpass_imag_.emplace_back(static_cast<std::size_t>(delay) *
static_cast<std::size_t>(bands_),
0.0);
}
allpass_position_.assign(allpass_real_.size(), 0);
memory_real_.assign(static_cast<std::size_t>(capacity_) * static_cast<std::size_t>(bands_) * 4u,
0.0);
memory_imag_.assign(memory_real_.size(), 0.0);
extra_matrices_.resize(model.table_a_extra_indices.size());
for (std::size_t index = 0u; index < extra_matrices_.size(); ++index) {
extra_matrices_[index].assign(16u, 0.0);
for (int row = 0; row < 4; ++row) {
for (int column = 0; column < 4; ++column) {
extra_matrices_[index][static_cast<std::size_t>(row) +
4u * static_cast<std::size_t>(column)] =
static_cast<double>(
model.table_a_extra_vectors[index * 16u + static_cast<std::size_t>(row) +
4u * static_cast<std::size_t>(column)]);
}
}
}
}
void reset() {
for (std::vector<double>& value : allpass_real_) {
std::fill(value.begin(), value.end(), 0.0);
}
for (std::vector<double>& value : allpass_imag_) {
std::fill(value.begin(), value.end(), 0.0);
}
std::fill(allpass_position_.begin(), allpass_position_.end(), 0);
std::fill(memory_real_.begin(), memory_real_.end(), 0.0);
std::fill(memory_imag_.begin(), memory_imag_.end(), 0.0);
position_ = 0;
}
Status process_slot(const Complex* room_send, Complex* output) {
if (static_cast<double>(model_.table_a_scalar) >= 0.5) {
return render_fail(JOC_ERR_NOT_SUPPORTED, "alternate Rosella table-A room mode");
}
const std::size_t bands = static_cast<std::size_t>(bands_);
std::vector<double> input_real(bands, 0.0);
std::vector<double> input_imag(bands, 0.0);
for (std::size_t band = 0u; band < bands; ++band) {
input_real[band] = room_send[band].real() * kRoomInputGain;
input_imag[band] = room_send[band].imag() * kRoomInputGain;
}
for (std::size_t index = 0u; index < allpass_gain_.size(); ++index) {
const std::size_t delay = static_cast<std::size_t>(allpass_delay_[index]);
const std::size_t position = static_cast<std::size_t>(allpass_position_[index]);
const double gain = allpass_gain_[index];
for (std::size_t band = 0u; band < bands; ++band) {
const std::size_t cell = position * bands + band;
const double previous_real = allpass_real_[index][cell];
const double previous_imag = allpass_imag_[index][cell];
const double residual_real = input_real[band] - previous_real * gain;
const double residual_imag = input_imag[band] - previous_imag * gain;
input_real[band] = residual_real * gain + previous_real;
input_imag[band] = residual_imag * gain + previous_imag;
allpass_real_[index][cell] = residual_real;
allpass_imag_[index][cell] = residual_imag;
}
allpass_position_[index] = static_cast<int>((position + 1u) % delay);
}
std::vector<double> branch_real(bands * 4u, 0.0);
std::vector<double> branch_imag(bands * 4u, 0.0);
std::vector<double> delayed_real(bands * 4u, 0.0);
std::vector<double> delayed_imag(bands * 4u, 0.0);
for (int branch = 0; branch < 4; ++branch) {
const std::size_t slot =
static_cast<std::size_t>((position_ - delays_[static_cast<std::size_t>(branch)] +
capacity_) %
capacity_);
for (std::size_t band = 0u; band < bands; ++band) {
const std::size_t source = (slot * bands + band) * 4u + static_cast<std::size_t>(branch);
delayed_real[band * 4u + static_cast<std::size_t>(branch)] = memory_real_[source];
delayed_imag[band * 4u + static_cast<std::size_t>(branch)] = memory_imag_[source];
}
}
for (std::size_t band = 0u; band < bands; ++band) {
for (int row = 0; row < 4; ++row) {
double real = input_real[band];
double imag = input_imag[band];
for (int column = 0; column < 4; ++column) {
const double coefficient =
matrix_[static_cast<std::size_t>(row) + 4u * static_cast<std::size_t>(column)];
real += delayed_real[band * 4u + static_cast<std::size_t>(column)] * coefficient;
imag += delayed_imag[band * 4u + static_cast<std::size_t>(column)] * coefficient;
}
branch_real[band * 4u + static_cast<std::size_t>(row)] = real;
branch_imag[band * 4u + static_cast<std::size_t>(row)] = imag;
}
}
const std::size_t tap_slot = static_cast<std::size_t>(
(position_ - model_.table_a_integer + capacity_) % capacity_);
std::vector<double> tap_real(bands * 4u, 0.0);
std::vector<double> tap_imag(bands * 4u, 0.0);
for (std::size_t band = 0u; band < bands; ++band) {
for (int lane = 0; lane < 4; ++lane) {
const std::size_t source = (tap_slot * bands + band) * 4u + static_cast<std::size_t>(lane);
tap_real[band * 4u + static_cast<std::size_t>(lane)] = memory_real_[source];
tap_imag[band * 4u + static_cast<std::size_t>(lane)] = memory_imag_[source];
}
}
for (std::size_t cell = 0u; cell < branch_real.size(); ++cell) {
const double real = branch_real[cell];
const double imag = branch_imag[cell];
memory_real_[(static_cast<std::size_t>(position_) * bands) * 4u + cell] =
real * feedback_real_[cell] - imag * feedback_imag_[cell];
memory_imag_[(static_cast<std::size_t>(position_) * bands) * 4u + cell] =
imag * feedback_real_[cell] + real * feedback_imag_[cell];
}
position_ = (position_ + 1) % capacity_;
std::vector<double> extra_real(bands * 4u, 0.0);
std::vector<double> extra_imag(bands * 4u, 0.0);
for (std::size_t index = 0u; index < model_.table_a_extra_indices.size(); ++index) {
const std::size_t delay =
static_cast<std::size_t>(model_.table_a_extra_indices[index]);
const std::size_t slot = static_cast<std::size_t>(
(position_ - static_cast<int>(delay) - 1 + capacity_ * 2) % capacity_);
for (std::size_t band = 0u; band < bands; ++band) {
for (int row = 0; row < 4; ++row) {
double mixed_real = 0.0;
double mixed_imag = 0.0;
for (int column = 0; column < 4; ++column) {
const std::size_t source =
(slot * bands + band) * 4u + static_cast<std::size_t>(column);
const double coefficient =
extra_matrices_[index][static_cast<std::size_t>(row) +
4u * static_cast<std::size_t>(column)];
mixed_real += memory_real_[source] * coefficient;
mixed_imag += memory_imag_[source] * coefficient;
}
const int group = static_cast<int>(band) / 4;
const int lane = static_cast<int>(band) % 4;
const std::size_t field =
(index * 20u + static_cast<std::size_t>(group)) * 2u * 4u;
const double coefficient_real = static_cast<double>(
model_.table_a_extra_fields_padded[field + static_cast<std::size_t>(lane)]);
const double coefficient_imag = static_cast<double>(
model_.table_a_extra_fields_padded[field + 4u + static_cast<std::size_t>(lane)]);
const std::size_t target = band * 4u + static_cast<std::size_t>(row);
extra_real[target] +=
mixed_real * coefficient_real - mixed_imag * coefficient_imag;
extra_imag[target] +=
mixed_imag * coefficient_real + mixed_real * coefficient_imag;
}
}
}
for (std::size_t band = 0u; band < bands; ++band) {
double left_real = 0.0;
double left_imag = 0.0;
double right_real = 0.0;
double right_imag = 0.0;
for (int lane = 0; lane < 4; ++lane) {
const std::size_t cell = band * 4u + static_cast<std::size_t>(lane);
const double real = tap_real[cell] * output_tap_[cell] + extra_real[cell];
const double imag = tap_imag[cell] * output_tap_[cell] + extra_imag[cell];
left_real += left_real_[cell] * real - left_imag_[cell] * imag;
left_imag += left_imag_[cell] * real + left_real_[cell] * imag;
right_real += right_real_[cell] * real - right_imag_[cell] * imag;
right_imag += right_imag_[cell] * real + right_real_[cell] * imag;
}
output[band] = Complex(left_real, left_imag);
output[kHybridBands + band] = Complex(right_real, right_imag);
}
return Status::success();
}
private:
const RosellaModel& model_;
int bands_ = 0;
std::array<int, 4> delays_{};
int capacity_ = 0;
std::vector<double> matrix_;
std::vector<double> feedback_real_;
std::vector<double> feedback_imag_;
std::vector<double> output_tap_;
std::vector<double> left_real_;
std::vector<double> left_imag_;
std::vector<double> right_real_;
std::vector<double> right_imag_;
std::vector<double> allpass_gain_;
std::vector<int> allpass_delay_;
std::vector<std::vector<double>> allpass_real_;
std::vector<std::vector<double>> allpass_imag_;
std::vector<int> allpass_position_;
std::vector<double> memory_real_;
std::vector<double> memory_imag_;
int position_ = 0;
std::vector<std::vector<double>> extra_matrices_;
};
// rosella_room.RosellaRoomFir: the room FIR plus its overlap-add convolution.
class RoomFir {
public:
RoomFir(const RosellaModel& model, int impulse_slots) : length_(impulse_slots) {
RoomState reference(model);
kernel_.assign(static_cast<std::size_t>(length_) * 2u * kRoomBands, Complex(0.0, 0.0));
Complex slot_output[2 * kHybridBands];
for (int slot = 0; slot < length_; ++slot) {
Complex impulse[kHybridBands];
for (int band = 0; band < kHybridBands; ++band) {
impulse[band] = Complex(slot == 0 && band < kRoomBands ? 1.0 : 0.0, 0.0);
}
const Status status = reference.process_slot(impulse, slot_output);
if (!status.ok()) {
return;
}
for (int ear = 0; ear < 2; ++ear) {
for (int band = 0; band < kRoomBands; ++band) {
kernel_[(static_cast<std::size_t>(slot) * 2u + static_cast<std::size_t>(ear)) *
kRoomBands +
static_cast<std::size_t>(band)] =
slot_output[ear * kHybridBands + band];
}
}
}
tail_.assign(static_cast<std::size_t>(length_ - 1) * 2u * kRoomBands, Complex(0.0, 0.0));
valid_ = true;
}
bool valid() const { return valid_; }
void reset() {
std::fill(tail_.begin(), tail_.end(), Complex(0.0, 0.0));
fft_cache_size_ = 0u;
forward_plan_.reset();
inverse_plan_.reset();
}
// rosella_room.RosellaRoomFir.process_chunk.
Status process_chunk(const std::vector<Complex>& values, std::size_t slots,
std::vector<Complex>* output) {
output->assign(slots * 2u * kHybridBands, Complex(0.0, 0.0));
if (slots == 0u) {
return Status::success();
}
const std::size_t needed = slots + static_cast<std::size_t>(length_) - 1u;
std::size_t fft_size = 1u;
while (fft_size < needed) {
fft_size <<= 1u;
}
if (fft_size != fft_cache_size_) {
kernel_fft_.assign(fft_size * 2u * kRoomBands, Complex(0.0, 0.0));
// The room transforms a fixed length for the whole chunk, so the radix-2
// twiddle recurrences are materialised once here rather than re-derived
// inside every butterfly of every one of the 3 * kRoomBands transforms.
forward_plan_ = std::make_unique<dsp::FftPlan>(fft_size, false);
inverse_plan_ = std::make_unique<dsp::FftPlan>(fft_size, true);
line_.assign(fft_size, Complex(0.0, 0.0));
for (int ear = 0; ear < 2; ++ear) {
for (int band = 0; band < kRoomBands; ++band) {
for (int slot = 0; slot < length_; ++slot) {
line_[static_cast<std::size_t>(slot)] =
kernel_[(static_cast<std::size_t>(slot) * 2u +
static_cast<std::size_t>(ear)) *
kRoomBands +
static_cast<std::size_t>(band)];
}
std::fill(line_.begin() + length_, line_.end(), Complex(0.0, 0.0));
dsp::fft_radix2(&line_, *forward_plan_);
for (std::size_t index = 0u; index < fft_size; ++index) {
// Band-major, so that the spectrum multiply below reads both
// of its operands as runs instead of striding through them
// one complex per cache line. Same values, same places.
kernel_fft_[(static_cast<std::size_t>(ear) * kRoomBands +
static_cast<std::size_t>(band)) *
fft_size +
index] = line_[index];
}
}
}
fft_cache_size_ = fft_size;
}
// input_fft_ and block_ are indexed linearly and every entry of each is written
// before it is read (the per-band forward transform fills input_fft_ column by
// column, and the inverse transform fills block_ entry by entry), so their zero
// fills were dead. The line buffer, by contrast, is handed to fft_radix2,
// which transforms exactly data->size() entries -- it therefore has to keep the
// exact length and the exact initialisation it had as a local.
if (line_.size() != fft_size) {
line_.assign(fft_size, Complex(0.0, 0.0));
}
const std::size_t input_fft_size = fft_size * kRoomBands;
if (input_fft_.size() < input_fft_size) {
input_fft_.resize(input_fft_size);
}
for (int band = 0; band < kRoomBands; ++band) {
for (std::size_t slot = 0u; slot < slots; ++slot) {
line_[slot] = values[slot * kHybridBands + static_cast<std::size_t>(band)];
}
std::fill(line_.begin() + static_cast<std::ptrdiff_t>(slots), line_.end(),
Complex(0.0, 0.0));
dsp::fft_radix2(&line_, *forward_plan_);
for (std::size_t index = 0u; index < fft_size; ++index) {
// Band-major, matching kernel_fft_, so that the spectrum multiply
// reads both operands as runs.
input_fft_[static_cast<std::size_t>(band) * fft_size + index] = line_[index];
}
}
const std::size_t block_size = needed * 2u * kRoomBands;
if (block_.size() < block_size) {
block_.resize(block_size);
}
for (int ear = 0; ear < 2; ++ear) {
for (int band = 0; band < kRoomBands; ++band) {
// Both planes are band-major now, so this is one contiguous complex
// product per (ear, band) and the dispatched kernel puts neighbouring
// complexes in its lanes; each product keeps the caller's four
// multiplies and two roundings.
simd::complex_multiply(
reinterpret_cast<double*>(line_.data()),
reinterpret_cast<const double*>(
input_fft_.data() + static_cast<std::size_t>(band) * fft_size),
reinterpret_cast<const double*>(
kernel_fft_.data() +
(static_cast<std::size_t>(ear) * kRoomBands +
static_cast<std::size_t>(band)) *
fft_size),
fft_size);
dsp::fft_radix2(&line_, *inverse_plan_);
for (std::size_t slot = 0u; slot < needed; ++slot) {
block_[(slot * 2u + static_cast<std::size_t>(ear)) * kRoomBands +
static_cast<std::size_t>(band)] = line_[slot];
}
}
}
const std::size_t tail_length = static_cast<std::size_t>(length_ - 1);
for (std::size_t index = 0u; index < tail_length * 2u * kRoomBands; ++index) {
block_[index] += tail_[index];
}
for (std::size_t slot = 0u; slot < slots; ++slot) {
for (int ear = 0; ear < 2; ++ear) {
for (int band = 0; band < kRoomBands; ++band) {
(*output)[slot * 2u * kHybridBands + static_cast<std::size_t>(ear) * kHybridBands +
static_cast<std::size_t>(band)] =
block_[(slot * 2u + static_cast<std::size_t>(ear)) * kRoomBands +
static_cast<std::size_t>(band)];
}
}
}
for (std::size_t index = 0u; index < tail_length * 2u * kRoomBands; ++index) {
tail_[index] = block_[slots * 2u * kRoomBands + index];
}
return Status::success();
}
private:
int length_ = 0;
bool valid_ = false;
std::vector<Complex> kernel_;
std::vector<Complex> tail_;
std::vector<Complex> kernel_fft_;
std::size_t fft_cache_size_ = 0u;
std::vector<Complex> line_; // scratch, exactly fft_size entries
std::vector<Complex> input_fft_; // scratch, [fft_size][kRoomBands], fully written
std::vector<Complex> block_; // scratch, [needed][2][kRoomBands], fully written
std::unique_ptr<dsp::FftPlan> forward_plan_;
std::unique_ptr<dsp::FftPlan> inverse_plan_;
};
// rosella_core.RosellaRenderer: per-source direct gains plus the room send. // rosella_core.RosellaRenderer: per-source direct gains plus the room send.
class Core { class Core {
public: public:
@@ -872,9 +32,10 @@ public:
model_ = &model; model_ = &model;
field_left_ = &field_left; field_left_ = &field_left;
field_right_ = &field_right; field_right_ = &field_right;
room_ = std::make_unique<RoomFir>(model, room_impulse_slots); room_ = std::make_unique<RosellaRoomFir>();
if (!room_->valid()) { const Status room_status = room_->configure(model, room_impulse_slots);
return render_fail(JOC_ERR_NOT_SUPPORTED, "alternate Rosella table-A room mode"); if (!room_status.ok()) {
return room_status;
} }
gains_.assign(static_cast<std::size_t>(kSourceChannels) * 2u * kHybridBands, gains_.assign(static_cast<std::size_t>(kSourceChannels) * 2u * kHybridBands,
Complex(0.0, 0.0)); Complex(0.0, 0.0));
@@ -908,8 +69,11 @@ public:
if (special_lfe) { if (special_lfe) {
result = special_lfe_direct(); result = special_lfe_direct();
} else { } else {
result = direct_and_room_send(*model_, *field_left_, *field_right_, position, const Status status = direct_and_room_send(*model_, *field_left_, *field_right_,
effective_profile); position, effective_profile, &result);
if (!status.ok()) {
return status;
}
} }
for (int ear = 0; ear < 2; ++ear) { for (int ear = 0; ear < 2; ++ear) {
for (int band = 0; band < kHybridBands; ++band) { for (int band = 0; band < kHybridBands; ++band) {
@@ -989,7 +153,7 @@ private:
const RosellaModel* model_ = nullptr; const RosellaModel* model_ = nullptr;
const std::vector<double>* field_left_ = nullptr; const std::vector<double>* field_left_ = nullptr;
const std::vector<double>* field_right_ = nullptr; const std::vector<double>* field_right_ = nullptr;
std::unique_ptr<RoomFir> room_; std::unique_ptr<RosellaRoomFir> room_;
std::vector<Complex> gains_; std::vector<Complex> gains_;
std::vector<double> room_sends_; std::vector<double> room_sends_;
std::vector<Key> keys_; std::vector<Key> keys_;
@@ -1080,8 +244,8 @@ struct RosellaRuntime::Impl {
static_cast<std::ptrdiff_t>(first_slot * kHybridBands)); static_cast<std::ptrdiff_t>(first_slot * kHybridBands));
} }
// The room runs once for the whole chunk, as the reference does. Its output // The room runs once for the whole chunk, as the reference does. Its output
// keeps a zero fill of its own: only the first kRoomBands of each ear are // keeps a zero fill of its own: only the first 64 of the 77 bands of each ear
// written, and the caller adds the whole 77-band slot back into `rendered`. // are written, and the caller adds the whole 77-band slot back into `rendered`.
Status status = core.room_process(room_sends_buffer_, slots, &room_out_); Status status = core.room_process(room_sends_buffer_, slots, &room_out_);
if (!status.ok()) { if (!status.ok()) {
return status; return status;
@@ -1196,8 +360,8 @@ Status RosellaRuntime::open(const RosellaModel& model, const RosellaRenderOption
} }
impl_->model = model; impl_->model = model;
impl_->options = options; impl_->options = options;
logical_field(impl_->model.field_left_padded, &impl_->field_left); impl_->field_left = rosella_logical_field(impl_->model.field_left_padded);
logical_field(impl_->model.field_right_padded, &impl_->field_right); impl_->field_right = rosella_logical_field(impl_->model.field_right_padded);
// The core and the room keep references, so they must point at this runtime's // The core and the room keep references, so they must point at this runtime's
// own copy of the model rather than at the caller's. // own copy of the model rather than at the caller's.
Status status = impl_->core.configure(impl_->model, impl_->field_left, impl_->field_right, Status status = impl_->core.configure(impl_->model, impl_->field_left, impl_->field_right,
+8
View File
@@ -1447,6 +1447,14 @@ Status canonicalize_sofa(const SofaHrir& sofa, CanonicalHrtf* out) {
canonical.taps = static_cast<std::uint32_t>(taps); canonical.taps = static_cast<std::uint32_t>(taps);
canonical.left_receiver_index = left_index; canonical.left_receiver_index = left_index;
canonical.right_receiver_index = right_index; canonical.right_receiver_index = right_index;
canonical.receiver_position_cartesian_m.assign(6u, 0.0);
for (int ear = 0; ear < 2; ++ear) {
const int receiver = ear == 0 ? left_index : right_index;
for (int axis = 0; axis < 3; ++axis) {
canonical.receiver_position_cartesian_m[static_cast<std::size_t>(ear * 3 + axis)] =
receiver_cartesian[static_cast<std::size_t>(receiver * 3 + axis)];
}
}
canonical.source_position_cartesian_m = source_local; canonical.source_position_cartesian_m = source_local;
canonical.unit_directions.resize(measurements * 3u, 0.0); canonical.unit_directions.resize(measurements * 3u, 0.0);
for (std::size_t row = 0u; row < measurements; ++row) { for (std::size_t row = 0u; row < measurements; ++row) {
+3
View File
@@ -55,6 +55,9 @@ struct CanonicalHrtf {
std::vector<double> measurement_radius_m; // [M] std::vector<double> measurement_radius_m; // [M]
std::vector<double> hrir; // [M,2,N] canonical L/R std::vector<double> hrir; // [M,2,N] canonical L/R
std::vector<double> delay_samples; // [M,2], not applied std::vector<double> delay_samples; // [M,2], not applied
// ReceiverPosition in listener-local metres, left then right (the SOFA
// variable is one constant pair for the whole file).
std::vector<double> receiver_position_cartesian_m; // [2,3]
}; };
// Port of load_simple_free_field_hrir(): strict SimpleFreeFieldHRIR import. // Port of load_simple_free_field_hrir(): strict SimpleFreeFieldHRIR import.
+531
View File
@@ -0,0 +1,531 @@
#include "hrtf/spherical_mesh.h"
#include <algorithm>
#include <cmath>
#include <cstring>
#include <limits>
namespace joc::hrtf {
namespace {
constexpr double kPi = 3.141592653589793238462643383279502884;
Status mesh_error(const char* message) {
return Status::fail(JOC_ERR_INVALID_ARGUMENT, joc::stage::kRender, message);
}
void normalize(double vector[3]) {
const double length = std::sqrt(vector[0] * vector[0] + vector[1] * vector[1] +
vector[2] * vector[2]);
if (length > 0.0) {
vector[0] /= length;
vector[1] /= length;
vector[2] /= length;
}
}
void cross(const double a[3], const double b[3], double out[3]) {
out[0] = a[1] * b[2] - a[2] * b[1];
out[1] = a[2] * b[0] - a[0] * b[2];
out[2] = a[0] * b[1] - a[1] * b[0];
}
double dot(const double a[3], const double b[3]) {
return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
}
// Solid angle of the spherical triangle (a, b, c), Van Oosterom & Strackee.
double triangle_area(const double a[3], const double b[3], const double c[3]) {
const double determinant = a[0] * (b[1] * c[2] - b[2] * c[1]) -
a[1] * (b[0] * c[2] - b[2] * c[0]) +
a[2] * (b[0] * c[1] - b[1] * c[0]);
const double denominator = 1.0 + dot(a, b) + dot(b, c) + dot(c, a);
return 2.0 * std::atan2(std::fabs(determinant), denominator);
}
// In-place inverse of a row-major 3x3 matrix. Returns false when singular.
bool invert3(const double matrix[9], double out[9]) {
const double c00 = matrix[4] * matrix[8] - matrix[5] * matrix[7];
const double c01 = matrix[5] * matrix[6] - matrix[3] * matrix[8];
const double c02 = matrix[3] * matrix[7] - matrix[4] * matrix[6];
const double determinant = matrix[0] * c00 + matrix[1] * c01 + matrix[2] * c02;
if (!std::isfinite(determinant) || std::fabs(determinant) < 1e-12) {
return false;
}
const double inverse = 1.0 / determinant;
out[0] = c00 * inverse;
out[1] = (matrix[2] * matrix[7] - matrix[1] * matrix[8]) * inverse;
out[2] = (matrix[1] * matrix[5] - matrix[2] * matrix[4]) * inverse;
out[3] = c01 * inverse;
out[4] = (matrix[0] * matrix[8] - matrix[2] * matrix[6]) * inverse;
out[5] = (matrix[2] * matrix[3] - matrix[0] * matrix[5]) * inverse;
out[6] = c02 * inverse;
out[7] = (matrix[1] * matrix[6] - matrix[0] * matrix[7]) * inverse;
out[8] = (matrix[0] * matrix[4] - matrix[1] * matrix[3]) * inverse;
return true;
}
struct HullFace {
int vertex[3] = {0, 0, 0};
double normal[3] = {0.0, 0.0, 0.0};
bool alive = true;
};
} // namespace
Status SphericalMesh::build(const std::vector<double>& directions, std::size_t count) {
if (count < 4 || directions.size() < count * 3) {
return mesh_error("spherical mesh needs at least four directions");
}
directions_.clear();
faces_.clear();
inverse_.clear();
max_triangle_edge_degrees_ = 0.0;
// Merge coincident directions, keeping the first occurrence (reference order).
std::vector<double> rounded(count * 3);
for (std::size_t index = 0; index < count * 3; ++index) {
rounded[index] = std::round(directions[index] * 1e10) / 1e10;
}
std::vector<std::size_t> kept;
std::size_t slot_count = 0;
for (std::size_t index = 0; index < count; ++index) {
std::size_t found = slot_count;
for (std::size_t slot = 0; slot < kept.size(); ++slot) {
const std::size_t first = kept[slot];
if (rounded[first * 3] == rounded[index * 3] &&
rounded[first * 3 + 1] == rounded[index * 3 + 1] &&
rounded[first * 3 + 2] == rounded[index * 3 + 2]) {
found = slot;
break;
}
}
if (found == slot_count) {
kept.push_back(index);
++slot_count;
}
}
if (kept.size() < 4) {
return mesh_error("spherical mesh needs four distinct directions");
}
directions_.resize(kept.size() * 3);
for (std::size_t slot = 0; slot < kept.size(); ++slot) {
double value[3] = {directions[kept[slot] * 3], directions[kept[slot] * 3 + 1],
directions[kept[slot] * 3 + 2]};
if (!std::isfinite(value[0]) || !std::isfinite(value[1]) || !std::isfinite(value[2])) {
return mesh_error("measurement direction is not finite");
}
normalize(value);
std::copy(value, value + 3, directions_.begin() + static_cast<std::ptrdiff_t>(slot * 3));
}
build_faces();
compute_face_inverses();
return Status::success();
}
void SphericalMesh::build_faces() {
const std::size_t count = vertex_count();
const auto point = [this](std::size_t index) {
return directions_.data() + index * 3;
};
// Initial tetrahedron: the farthest pair, then the farthest point from that
// line, then the farthest point from that plane.
std::size_t i0 = 0;
std::size_t i1 = 0;
double best = -1.0;
for (std::size_t index = 0; index < count; ++index) {
const double dx = point(index)[0] - point(i0)[0];
const double dy = point(index)[1] - point(i0)[1];
const double dz = point(index)[2] - point(i0)[2];
const double distance = dx * dx + dy * dy + dz * dz;
if (distance > best) {
best = distance;
i1 = index;
}
}
if (best <= 0.0) {
return;
}
std::size_t i2 = 0;
best = -1.0;
double edge[3];
for (std::size_t index = 0; index < count; ++index) {
double a[3];
double b[3];
for (int axis = 0; axis < 3; ++axis) {
a[axis] = point(i1)[axis] - point(i0)[axis];
b[axis] = point(index)[axis] - point(i0)[axis];
}
cross(a, b, edge);
const double area = dot(edge, edge);
if (area > best) {
best = area;
i2 = index;
}
}
if (best <= 1e-24) {
return;
}
std::size_t i3 = 0;
best = -1.0;
double plane[3];
{
double a[3];
double b[3];
for (int axis = 0; axis < 3; ++axis) {
a[axis] = point(i1)[axis] - point(i0)[axis];
b[axis] = point(i2)[axis] - point(i0)[axis];
}
cross(a, b, plane);
}
for (std::size_t index = 0; index < count; ++index) {
double delta[3];
for (int axis = 0; axis < 3; ++axis) {
delta[axis] = point(index)[axis] - point(i0)[axis];
}
const double volume = std::fabs(dot(plane, delta));
if (volume > best) {
best = volume;
i3 = index;
}
}
if (best <= 1e-24) {
return;
}
// Centroid of the tetrahedron is strictly inside the hull, so a face normal is
// outward when it points away from it.
double centroid[3] = {0.0, 0.0, 0.0};
const std::size_t seed[4] = {i0, i1, i2, i3};
for (std::size_t index = 0; index < 4; ++index) {
for (int axis = 0; axis < 3; ++axis) {
centroid[axis] += point(seed[index])[axis] * 0.25;
}
}
std::vector<HullFace> faces;
faces.reserve(count * 2);
const int seed_index[4] = {static_cast<int>(i0), static_cast<int>(i1),
static_cast<int>(i2), static_cast<int>(i3)};
const int initial[4][3] = {{0, 1, 2}, {0, 1, 3}, {0, 2, 3}, {1, 2, 3}};
for (const int* triple : initial) {
HullFace face;
for (int corner = 0; corner < 3; ++corner) {
face.vertex[corner] = seed_index[triple[corner]];
}
double a[3];
double b[3];
for (int axis = 0; axis < 3; ++axis) {
a[axis] = point(face.vertex[1])[axis] - point(face.vertex[0])[axis];
b[axis] = point(face.vertex[2])[axis] - point(face.vertex[0])[axis];
}
cross(a, b, face.normal);
double to_center[3];
for (int axis = 0; axis < 3; ++axis) {
to_center[axis] = centroid[axis] - point(face.vertex[0])[axis];
}
if (dot(face.normal, to_center) > 0.0) {
std::swap(face.vertex[1], face.vertex[2]);
for (int axis = 0; axis < 3; ++axis) {
face.normal[axis] = -face.normal[axis];
}
}
faces.push_back(face);
}
struct Edge {
int a;
int b;
int count;
};
std::vector<Edge> boundary;
std::vector<std::size_t> visible;
for (std::size_t index = 0; index < count; ++index) {
const double* p = point(index);
bool seed_point = false;
for (int corner = 0; corner < 4; ++corner) {
if (seed_index[corner] == static_cast<int>(index)) {
seed_point = true;
break;
}
}
if (seed_point) {
continue;
}
visible.clear();
for (std::size_t face_index = 0; face_index < faces.size(); ++face_index) {
HullFace& face = faces[face_index];
if (!face.alive) {
continue;
}
double delta[3];
for (int axis = 0; axis < 3; ++axis) {
delta[axis] = p[axis] - point(face.vertex[0])[axis];
}
if (dot(face.normal, delta) > 1e-12) {
visible.push_back(face_index);
}
}
if (visible.empty()) {
continue;
}
boundary.clear();
const auto add_edge = [&boundary](int a, int b) {
for (Edge& edge : boundary) {
if ((edge.a == a && edge.b == b) || (edge.a == b && edge.b == a)) {
++edge.count;
return;
}
}
boundary.push_back(Edge{a, b, 1});
};
for (const std::size_t face_index : visible) {
const HullFace& face = faces[face_index];
add_edge(face.vertex[0], face.vertex[1]);
add_edge(face.vertex[1], face.vertex[2]);
add_edge(face.vertex[2], face.vertex[0]);
}
for (const std::size_t face_index : visible) {
faces[face_index].alive = false;
}
for (const Edge& edge : boundary) {
if (edge.count != 1) {
continue;
}
HullFace face;
face.vertex[0] = edge.a;
face.vertex[1] = edge.b;
face.vertex[2] = static_cast<int>(index);
double a[3];
double b[3];
for (int axis = 0; axis < 3; ++axis) {
a[axis] = point(face.vertex[1])[axis] - point(face.vertex[0])[axis];
b[axis] = point(face.vertex[2])[axis] - point(face.vertex[0])[axis];
}
cross(a, b, face.normal);
double inside[3];
for (int axis = 0; axis < 3; ++axis) {
inside[axis] = centroid[axis] - point(face.vertex[0])[axis];
}
if (dot(face.normal, inside) > 0.0) {
std::swap(face.vertex[1], face.vertex[2]);
for (int axis = 0; axis < 3; ++axis) {
face.normal[axis] = -face.normal[axis];
}
}
faces.push_back(face);
}
}
faces_.clear();
max_triangle_edge_degrees_ = 0.0;
for (const HullFace& face : faces) {
if (!face.alive) {
continue;
}
faces_.push_back(face.vertex[0]);
faces_.push_back(face.vertex[1]);
faces_.push_back(face.vertex[2]);
const double* a = point(face.vertex[0]);
const double* b = point(face.vertex[1]);
const double* c = point(face.vertex[2]);
for (int first = 0; first < 3; ++first) {
for (int second = first + 1; second < 3; ++second) {
const double* u = point(face.vertex[first]);
const double* v = point(face.vertex[second]);
const double edge_dot = std::clamp(dot(u, v), -1.0, 1.0);
const double degrees = std::acos(edge_dot) * 180.0 / kPi;
max_triangle_edge_degrees_ = std::max(max_triangle_edge_degrees_, degrees);
}
}
}
}
void SphericalMesh::compute_face_inverses() {
inverse_.assign(face_count() * 9, 0.0);
std::vector<int> kept;
for (std::size_t face_index = 0; face_index < face_count(); ++face_index) {
const int* ids = faces_.data() + face_index * 3;
double matrix[9];
// Columns are the vertices: the barycentric weights of q are the solution
// of matrix * w = q, so the inverse is applied to the query afterwards.
for (int corner = 0; corner < 3; ++corner) {
const double* vertex = directions_.data() + ids[corner] * 3;
for (int axis = 0; axis < 3; ++axis) {
matrix[axis * 3 + corner] = vertex[axis];
}
}
if (!invert3(matrix, inverse_.data() + face_index * 9)) {
continue;
}
kept.push_back(static_cast<int>(face_index));
}
if (kept.size() != face_count()) {
// Drop singular faces: they cannot contain a query direction strictly.
std::vector<int> compact;
std::vector<double> compact_inverse;
for (const int face_index : kept) {
for (int corner = 0; corner < 3; ++corner) {
compact.push_back(faces_[face_index * 3 + corner]);
}
for (int value = 0; value < 9; ++value) {
compact_inverse.push_back(inverse_[face_index * 9 + value]);
}
}
faces_ = compact;
inverse_ = compact_inverse;
}
}
std::size_t SphericalMesh::nearest(const double direction[3], double* distance) const {
const std::size_t count = vertex_count();
std::size_t best = 0;
double best_distance = std::numeric_limits<double>::infinity();
for (std::size_t index = 0; index < count; ++index) {
const double* vertex = directions_.data() + index * 3;
const double dx = vertex[0] - direction[0];
const double dy = vertex[1] - direction[1];
const double dz = vertex[2] - direction[2];
const double squared = dx * dx + dy * dy + dz * dz;
if (squared < best_distance) {
best_distance = squared;
best = index;
}
}
if (distance != nullptr) {
*distance = std::sqrt(best_distance);
}
return best;
}
Status SphericalMesh::weights(const double direction[3], std::vector<int>* ids,
std::vector<double>* weights) const {
if (ids == nullptr || weights == nullptr) {
return mesh_error("weight output is null");
}
double query[3] = {direction[0], direction[1], direction[2]};
const double length = std::sqrt(dot(query, query));
if (!std::isfinite(length) || length <= 1e-12) {
return mesh_error("query direction is degenerate");
}
normalize(query);
double distance = 0.0;
const std::size_t nearest_index = nearest(query, &distance);
ids->clear();
weights->clear();
if (distance < 1e-10) {
ids->push_back(static_cast<int>(nearest_index));
weights->push_back(1.0);
return Status::success();
}
for (std::size_t face_index = 0; face_index < face_count(); ++face_index) {
const double* inverse = inverse_.data() + face_index * 9;
const double barycentric[3] = {
inverse[0] * query[0] + inverse[1] * query[1] + inverse[2] * query[2],
inverse[3] * query[0] + inverse[4] * query[1] + inverse[5] * query[2],
inverse[6] * query[0] + inverse[7] * query[1] + inverse[8] * query[2]};
if (std::min({barycentric[0], barycentric[1], barycentric[2]}) < -1e-10) {
continue;
}
double total = 0.0;
double clamped[3];
for (int corner = 0; corner < 3; ++corner) {
clamped[corner] = std::max(barycentric[corner], 0.0);
total += clamped[corner];
}
if (total <= 0.0) {
continue;
}
for (int corner = 0; corner < 3; ++corner) {
ids->push_back(faces_[face_index * 3 + corner]);
weights->push_back(clamped[corner] / total);
}
return Status::success();
}
// The query fell outside every triangle (only possible on numerical margins).
ids->push_back(static_cast<int>(nearest_index));
weights->push_back(1.0);
return Status::success();
}
void SphericalMesh::voronoi_areas(std::vector<double>* areas) const {
const std::size_t vertices = vertex_count();
const std::size_t face_total = face_count();
areas->assign(vertices, 0.0);
if (vertices == 0 || face_total == 0) {
return;
}
// Circumcenter of a triangle of unit vectors is its normalized face normal.
std::vector<double> circumcenters(face_total * 3, 0.0);
for (std::size_t face_index = 0; face_index < face_total; ++face_index) {
const int* ids = faces_.data() + face_index * 3;
const double* a = directions_.data() + ids[0] * 3;
const double* b = directions_.data() + ids[1] * 3;
const double* c = directions_.data() + ids[2] * 3;
double normal[3];
double edge_one[3];
double edge_two[3];
for (int axis = 0; axis < 3; ++axis) {
edge_one[axis] = b[axis] - a[axis];
edge_two[axis] = c[axis] - a[axis];
}
cross(edge_one, edge_two, normal);
normalize(normal);
std::copy(normal, normal + 3,
circumcenters.begin() + static_cast<std::ptrdiff_t>(face_index * 3));
}
std::vector<std::vector<std::size_t>> incident(vertices);
for (std::size_t face_index = 0; face_index < face_total; ++face_index) {
for (int corner = 0; corner < 3; ++corner) {
incident[static_cast<std::size_t>(faces_[face_index * 3 + corner])]
.push_back(face_index);
}
}
std::vector<std::pair<double, std::size_t>> ordered;
double total = 0.0;
for (std::size_t vertex = 0; vertex < vertices; ++vertex) {
const double* centre = directions_.data() + vertex * 3;
if (incident[vertex].size() < 3) {
continue;
}
// Tangent basis at the vertex.
double tangent[3] = {0.0, 0.0, 0.0};
if (std::fabs(centre[0]) < 0.9) {
tangent[0] = 1.0;
} else {
tangent[1] = 1.0;
}
const double projection = dot(tangent, centre);
double axis_one[3];
double axis_two[3];
for (int axis = 0; axis < 3; ++axis) {
axis_one[axis] = tangent[axis] - projection * centre[axis];
}
normalize(axis_one);
cross(centre, axis_one, axis_two);
ordered.clear();
for (const std::size_t face_index : incident[vertex]) {
const double* point = circumcenters.data() + face_index * 3;
const double angle = std::atan2(dot(point, axis_two), dot(point, axis_one));
ordered.emplace_back(angle, face_index);
}
std::sort(ordered.begin(), ordered.end());
double area = 0.0;
for (std::size_t index = 0; index < ordered.size(); ++index) {
const double* first = circumcenters.data() + ordered[index].second * 3;
const double* second =
circumcenters.data() + ordered[(index + 1) % ordered.size()].second * 3;
area += triangle_area(centre, first, second);
}
(*areas)[vertex] = area;
total += area;
}
if (total > 0.0) {
for (double& value : *areas) {
value /= total;
}
}
}
} // namespace joc::hrtf
+50
View File
@@ -0,0 +1,50 @@
#pragma once
#include <cstddef>
#include <vector>
#include "foundation/status.h"
// Spherical interpolation mesh over the measurement directions, ported from the
// reference sofa_hrir.FullHrirField: the convex hull of the unit directions gives
// the containing spherical triangle, its barycentric weights give the local
// interpolation, and the spherical Voronoi cells give the centre weighting.
namespace joc::hrtf {
class SphericalMesh {
public:
// `directions` is [count][3]; entries need not be unit length. Coincident
// directions are merged (first occurrence wins) and their duplicates must be
// identical, as the reference requires.
Status build(const std::vector<double>& directions, std::size_t count);
std::size_t vertex_count() const { return directions_.size() / 3; }
std::size_t face_count() const { return faces_.size() / 3; }
const std::vector<double>& directions() const { return directions_; }
const std::vector<int>& faces() const { return faces_; }
double max_triangle_edge_degrees() const { return max_triangle_edge_degrees_; }
// Barycentric interpolation weights of a query direction: an exact measurement
// returns one id with weight 1, otherwise the containing triangle's vertices
// with non-negative weights summing to one.
Status weights(const double direction[3], std::vector<int>* ids,
std::vector<double>* weights) const;
// Spherical Voronoi area of every vertex, normalized to sum to one.
void voronoi_areas(std::vector<double>* areas) const;
// Nearest measurement direction (exact search; the vertex count is small).
std::size_t nearest(const double direction[3], double* distance) const;
private:
void build_faces();
void compute_face_inverses();
std::vector<double> directions_; // [V][3] unit
std::vector<int> faces_; // [F][3]
std::vector<double> inverse_; // [F][9] row-major inverse of the vertex matrix
double max_triangle_edge_degrees_ = 0.0;
};
} // namespace joc::hrtf
+20 -95
View File
@@ -3,8 +3,6 @@
#include <cstring> #include <cstring>
#include "speaker/speaker_layouts.h"
namespace joc::joc { namespace joc::joc {
namespace { namespace {
@@ -31,16 +29,16 @@ constexpr StandardBit kStandardBits[10] = {
{BedChannel::kLfe2, BedChannel::kCount}, {BedChannel::kLfe2, BedChannel::kCount},
}; };
// Table 13 的 17 bit 非标准掩码(LSB 在前)。 // Table 13 的 17 bit 非标准掩码,按 channel order 排列:RC_L 是最先的声道
// (array position 16),落在 LSB;RC_LFE2 最后(array position 0)。
constexpr BedChannel kNonStandardBits[17] = { constexpr BedChannel kNonStandardBits[17] = {
BedChannel::kLfe2, BedChannel::kRightWide, BedChannel::kLeftWide, BedChannel::kLeft, BedChannel::kRight, BedChannel::kCenter,
BedChannel::kTopBackRight, BedChannel::kTopBackLeft, BedChannel::kLfe, BedChannel::kLeftSurround, BedChannel::kRightSurround,
BedChannel::kTopSideRight, BedChannel::kTopSideLeft, BedChannel::kLeftRearSurround, BedChannel::kRightRearSurround,
BedChannel::kTopFrontRight, BedChannel::kTopFrontLeft, BedChannel::kTopFrontLeft, BedChannel::kTopFrontRight,
BedChannel::kRightRearSurround, BedChannel::kLeftRearSurround, BedChannel::kTopSideLeft, BedChannel::kTopSideRight,
BedChannel::kRightSurround, BedChannel::kLeftSurround, BedChannel::kTopBackLeft, BedChannel::kTopBackRight,
BedChannel::kLfe, BedChannel::kCenter, BedChannel::kRight, BedChannel::kLeftWide, BedChannel::kRightWide, BedChannel::kLfe2,
BedChannel::kLeft,
}; };
struct ChannelSpec { struct ChannelSpec {
@@ -50,24 +48,27 @@ struct ChannelSpec {
double xyz[3]; double xyz[3];
}; };
// 固定方位:ETSI TS 103 420 V1.2.1 clause B.2.1.4 Table B.10 的 ADM 笛卡尔坐标
// (x 右、y 前、z 上)。bed 声道的位置只由声道标签决定,与目标输出布局无关。
// Table B.10 把 Lw/Rw 的 Y 记作 0,677419,即 ADM 62 级网格上的 42/62 = 21/31。
constexpr ChannelSpec kChannels[] = { constexpr ChannelSpec kChannels[] = {
{BedChannel::kLeft, "L", "RC_L", {-1.0, 1.0, 0.0}}, {BedChannel::kLeft, "L", "RC_L", {-1.0, 1.0, 0.0}},
{BedChannel::kRight, "R", "RC_R", {1.0, 1.0, 0.0}}, {BedChannel::kRight, "R", "RC_R", {1.0, 1.0, 0.0}},
{BedChannel::kCenter, "C", "RC_C", {0.0, 1.0, 0.0}}, {BedChannel::kCenter, "C", "RC_C", {0.0, 1.0, 0.0}},
{BedChannel::kLfe, "LFE", "RC_LFE", {0.0, 0.0, 0.0}}, {BedChannel::kLfe, "LFE", "RC_LFE", {-1.0, 1.0, -1.0}},
{BedChannel::kLeftSurround, "Ls", "RC_LS", {-1.0, 0.0, 0.0}}, {BedChannel::kLeftSurround, "Ls", "RC_LS", {-1.0, 0.0, 0.0}},
{BedChannel::kRightSurround, "Rs", "RC_RS", {1.0, 0.0, 0.0}}, {BedChannel::kRightSurround, "Rs", "RC_RS", {1.0, 0.0, 0.0}},
{BedChannel::kLeftRearSurround, "Lrs", "RC_LB", {-1.0, -1.0, 0.0}}, {BedChannel::kLeftRearSurround, "Lrs", "RC_LB", {-1.0, -1.0, 0.0}},
{BedChannel::kRightRearSurround, "Rrs", "RC_RB", {1.0, -1.0, 0.0}}, {BedChannel::kRightRearSurround, "Rrs", "RC_RB", {1.0, -1.0, 0.0}},
{BedChannel::kTopFrontLeft, "Ltf", "RC_TFL", {-0.5, 0.5, 1.0}}, {BedChannel::kTopFrontLeft, "Ltf", "RC_TFL", {-1.0, 1.0, 1.0}},
{BedChannel::kTopFrontRight, "Rtf", "RC_TFR", {0.5, 0.5, 1.0}}, {BedChannel::kTopFrontRight, "Rtf", "RC_TFR", {1.0, 1.0, 1.0}},
{BedChannel::kTopSideLeft, "Ltm", "RC_TSL", {-1.0, 0.0, 1.0}}, {BedChannel::kTopSideLeft, "Ltm", "RC_TSL", {-1.0, 0.0, 1.0}},
{BedChannel::kTopSideRight, "Rtm", "RC_TSR", {1.0, 0.0, 1.0}}, {BedChannel::kTopSideRight, "Rtm", "RC_TSR", {1.0, 0.0, 1.0}},
{BedChannel::kTopBackLeft, "Ltr", "RC_TBL", {-0.5, -0.5, 1.0}}, {BedChannel::kTopBackLeft, "Ltr", "RC_TBL", {-1.0, -1.0, 1.0}},
{BedChannel::kTopBackRight, "Rtr", "RC_TBR", {0.5, -0.5, 1.0}}, {BedChannel::kTopBackRight, "Rtr", "RC_TBR", {1.0, -1.0, 1.0}},
{BedChannel::kLeftWide, "Lw", "RC_LW", {-1.0, 0.5, 0.0}}, {BedChannel::kLeftWide, "Lw", "RC_LW", {-1.0, 21.0 / 31.0, 0.0}},
{BedChannel::kRightWide, "Rw", "RC_RW", {1.0, 0.5, 0.0}}, {BedChannel::kRightWide, "Rw", "RC_RW", {1.0, 21.0 / 31.0, 0.0}},
{BedChannel::kLfe2, "LFE2", "RC_LFE2", {0.0, 0.0, 0.0}}, {BedChannel::kLfe2, "LFE2", "RC_LFE2", {1.0, 1.0, -1.0}},
}; };
const ChannelSpec* spec_of(BedChannel channel) { const ChannelSpec* spec_of(BedChannel channel) {
@@ -168,38 +169,6 @@ const char* layout_name_for(std::uint32_t mask) {
return ""; return "";
} }
// 每个扬声器布局的标准声道名(按该布局的标准声道顺序排列)。
struct LayoutChannels {
std::uint32_t out_ch_config;
std::uint32_t count;
const char* names[16];
};
constexpr LayoutChannels kLayoutChannels[] = {
{0, 2, {"L", "R"}},
{3, 4, {"L", "R", "C", "LFE"}},
{255, 4, {"L", "R", "Lrs", "Rrs"}},
{7, 6, {"L", "R", "C", "LFE", "Ls", "Rs"}},
{11, 8, {"L", "R", "C", "LFE", "Ls", "Rs", "Lrs", "Rrs"}},
{13, 8, {"L", "R", "C", "LFE", "Ls", "Rs", "Ltm", "Rtm"}},
{14, 10, {"L", "R", "C", "LFE", "Ls", "Rs", "Ltf", "Rtf", "Ltr", "Rtr"}},
{15, 10, {"L", "R", "C", "LFE", "Ls", "Rs", "Lrs", "Rrs", "Ltm", "Rtm"}},
{16, 12, {"L", "R", "C", "LFE", "Ls", "Rs", "Lrs", "Rrs", "Ltf", "Rtf", "Ltr", "Rtr"}},
{19, 14, {"L", "R", "C", "LFE", "Ls", "Rs", "Lrs", "Rrs", "Lw", "Rw",
"Ltf", "Rtf", "Ltr", "Rtr"}},
{20, 16, {"L", "R", "C", "LFE", "Ls", "Rs", "Lrs", "Rrs", "Lw", "Rw",
"Ltf", "Rtf", "Ltm", "Rtm", "Ltr", "Rtr"}},
};
const ejoc::speaker_tables::LayoutGeometry* geometry_for(std::uint32_t out_ch_config) {
for (const ejoc::speaker_tables::LayoutGeometry& layout : ejoc::speaker_tables::kLayouts) {
if (layout.out_ch_config == out_ch_config) {
return &layout;
}
}
return nullptr;
}
} // namespace } // namespace
BedLayout resolve_bed_layout(const std::vector<oamd::BedAssignment>& assignments, BedLayout resolve_bed_layout(const std::vector<oamd::BedAssignment>& assignments,
@@ -284,48 +253,4 @@ bool bed_channel_q15(BedChannel channel, std::uint16_t q15[3]) {
return true; return true;
} }
bool layout_bed_anchor(std::uint32_t out_ch_config, BedChannel channel,
std::uint16_t q15[3]) {
if (q15 == nullptr) {
return false;
}
const char* name = bed_channel_short_name(channel);
if (name == nullptr || name[0] == '\0' || std::strcmp(name, "LFE") == 0) {
return false;
}
const LayoutChannels* table = nullptr;
for (const LayoutChannels& entry : kLayoutChannels) {
if (entry.out_ch_config == out_ch_config) {
table = &entry;
break;
}
}
const ejoc::speaker_tables::LayoutGeometry* geometry = geometry_for(out_ch_config);
if (table == nullptr || geometry == nullptr) {
return false;
}
int standard_index = -1;
for (std::uint32_t index = 0; index < table->count; ++index) {
if (std::strcmp(table->names[index], name) == 0) {
standard_index = static_cast<int>(index);
break;
}
}
if (standard_index < 0) {
return false;
}
const std::uint8_t internal = geometry->standard_from_internal[standard_index];
const ejoc::speaker_tables::RegionGeometry& region = geometry->regions[0];
for (std::uint32_t point = 0; point < region.point_count; ++point) {
if (region.points[point].speaker_id != internal) {
continue;
}
for (int axis = 0; axis < 3; ++axis) {
q15[axis] = region.points[point].coordinate_q15[axis];
}
return true;
}
return false;
}
} // namespace joc::joc } // namespace joc::joc
+1 -5
View File
@@ -57,12 +57,8 @@ const char* bed_channel_short_name(BedChannel channel);
const char* bed_channel_label(BedChannel channel); const char* bed_channel_label(BedChannel channel);
// 固定方位:ADM 笛卡尔坐标(x 右、y 前、z 上)与渲染器使用的 Q15 方位。 // 固定方位:ADM 笛卡尔坐标(x 右、y 前、z 上)与渲染器使用的 Q15 方位。
// 位置只由声道标签决定(ETSI TS 103 420 Table B.10),与目标输出布局无关。
bool bed_channel_adm_position(BedChannel channel, double xyz[3]); bool bed_channel_adm_position(BedChannel channel, double xyz[3]);
bool bed_channel_q15(BedChannel channel, std::uint16_t q15[3]); bool bed_channel_q15(BedChannel channel, std::uint16_t q15[3]);
// 目标布局里同名扬声器的 Q15 方位:bed 声道直连到该扬声器,而不是参与声像。
// 目标布局没有这个声道时返回 false。
bool layout_bed_anchor(std::uint32_t out_ch_config, BedChannel channel,
std::uint16_t q15[3]);
} // namespace joc::joc } // namespace joc::joc
+2 -2
View File
@@ -221,8 +221,8 @@ void Stream::apply_bed_positions(const FrameMetadata& entry) {
continue; continue;
} }
std::uint16_t q15[3] = {0, 0, 0}; std::uint16_t q15[3] = {0, 0, 0};
if (!::joc::joc::layout_bed_anchor(speaker_.layout.out_ch_config, channel, q15) && // bed 声道是固定位置的源:方位由声道标签决定,与目标布局无关。
!::joc::joc::bed_channel_q15(channel, q15)) { if (!::joc::joc::bed_channel_q15(channel, q15)) {
continue; continue;
} }
speaker_.bed_override[slot] = true; speaker_.bed_override[slot] = true;
+141 -63
View File
@@ -29,6 +29,7 @@
#include "adm/adm_metadata.h" #include "adm/adm_metadata.h"
#include "adm/adm_tracks.h" #include "adm/adm_tracks.h"
#include "binaural/binaural_runtime.h" #include "binaural/binaural_runtime.h"
#include "binaural/sofa_reference_runtime.h"
#include "eac3_transport/eac3_reader.h" #include "eac3_transport/eac3_reader.h"
#include "emdf/emdf_parser.h" #include "emdf/emdf_parser.h"
#include "foundation/mini_json.h" #include "foundation/mini_json.h"
@@ -95,6 +96,9 @@ struct Settings {
std::string hrtf_path; std::string hrtf_path;
std::string kernels_path; std::string kernels_path;
std::string hrtf_sofa_path; std::string hrtf_sofa_path;
std::string reference_config_path;
std::uint32_t sofa_interpolation = JOC_SOFA_INTERPOLATION_LOGMAG_PHASE;
bool hrtf_compile = false;
std::string personalized_headphone_path; std::string personalized_headphone_path;
std::string hrtf_cache_dir; std::string hrtf_cache_dir;
std::uint32_t hrtf_cache_policy = JOC_HRTF_CACHE_MEMORY; std::uint32_t hrtf_cache_policy = JOC_HRTF_CACHE_MEMORY;
@@ -145,6 +149,11 @@ Settings normalise(const joc_task_config& raw) {
if (raw.speaker_layout_name != nullptr) { cfg.layout = raw.speaker_layout_name; } if (raw.speaker_layout_name != nullptr) { cfg.layout = raw.speaker_layout_name; }
if (raw.hrtf_path != nullptr) { cfg.hrtf_path = raw.hrtf_path; } if (raw.hrtf_path != nullptr) { cfg.hrtf_path = raw.hrtf_path; }
if (raw.hrtf_sofa_path != nullptr) { cfg.hrtf_sofa_path = raw.hrtf_sofa_path; } if (raw.hrtf_sofa_path != nullptr) { cfg.hrtf_sofa_path = raw.hrtf_sofa_path; }
if (raw.reference_config_path != nullptr) {
cfg.reference_config_path = raw.reference_config_path;
}
cfg.sofa_interpolation = raw.sofa_interpolation;
cfg.hrtf_compile = raw.hrtf_compile != 0u;
if (raw.personalized_headphone_path != nullptr) { if (raw.personalized_headphone_path != nullptr) {
cfg.personalized_headphone_path = raw.personalized_headphone_path; cfg.personalized_headphone_path = raw.personalized_headphone_path;
} }
@@ -1099,9 +1108,9 @@ Status validate(const joc_task_config& raw, std::vector<joc_validation_issue>* i
fail(JOC_ERR_INVALID_CONFIG, "hrtf_cache_dir", fail(JOC_ERR_INVALID_CONFIG, "hrtf_cache_dir",
"the disk cache policy needs a cache directory"); "the disk cache policy needs a cache directory");
} }
if (!std::isfinite(cfg.hrtf_radius_m) || cfg.hrtf_radius_m <= 0.0) { if (!std::isfinite(cfg.hrtf_radius_m) || cfg.hrtf_radius_m < 0.0) {
fail(JOC_ERR_INVALID_CONFIG, "hrtf_radius_m", fail(JOC_ERR_INVALID_CONFIG, "hrtf_radius_m",
"hrtf_radius_m must be positive and finite"); "hrtf_radius_m must be finite and not negative");
} }
} }
// The filterbank tables are compiled in; a path is only a verification override. // The filterbank tables are compiled in; a path is only a verification override.
@@ -1355,6 +1364,8 @@ Status run(const joc_task_config& raw, const joc_event_sink* sink, joc_task_resu
} }
::joc::binaural::SofaBinauralRuntime binaural; ::joc::binaural::SofaBinauralRuntime binaural;
::joc::binaural::SofaReferenceRuntime binaural_reference;
bool use_reference = false;
::joc::hrtf::RosellaRuntime rosella; ::joc::hrtf::RosellaRuntime rosella;
const bool binaural_enabled = cfg.operation == JOC_OP_BINAURAL; const bool binaural_enabled = cfg.operation == JOC_OP_BINAURAL;
const bool rosella_enabled = !cfg.personalized_headphone_path.empty(); const bool rosella_enabled = !cfg.personalized_headphone_path.empty();
@@ -1398,50 +1409,85 @@ Status run(const joc_task_config& raw, const joc_event_sink* sink, joc_task_resu
::joc::hrtf::Kernels kernels; ::joc::hrtf::Kernels kernels;
::joc::binaural::Profile profile = ::joc::binaural::Profile::Mid; ::joc::binaural::Profile profile = ::joc::binaural::Profile::Mid;
Status status = Status::success(); Status status = Status::success();
if (!cfg.hrtf_sofa_path.empty()) { if (!cfg.hrtf_sofa_path.empty() && !cfg.hrtf_compile) {
// The .jochrtf is an internal cache: the SOFA is the user-facing input. // The SOFA keeps its full HRIRs: the direct path renders through the
::joc::hrtf::SofaFieldRequest request; // reference environment, and a .jochrtf stays an explicit input below.
request.sofa_path = cfg.hrtf_sofa_path; ::joc::binaural::SofaReferenceOptions options;
request.options.shell_radius_m = cfg.hrtf_radius_m; options.mode_specified = cfg.binaural_mode != JOC_BINAURAL_MID;
request.cache_dir = cfg.hrtf_cache_dir; options.mode_index = cfg.binaural_mode == JOC_BINAURAL_NEAR
switch (cfg.hrtf_cache_policy) { ? ::joc::binaural::kProfileNear
case JOC_HRTF_CACHE_NONE: request.policy = ::joc::hrtf::CachePolicy::None; break; : (cfg.binaural_mode == JOC_BINAURAL_FAR
case JOC_HRTF_CACHE_DISK: request.policy = ::joc::hrtf::CachePolicy::Disk; break; ? ::joc::binaural::kProfileFar
default: request.policy = ::joc::hrtf::CachePolicy::Memory; break; : ::joc::binaural::kProfileMid);
} options.reference_config = cfg.reference_config_path;
std::string cache_path; options.interpolation =
status = ::joc::hrtf::load_or_compile_sofa_field(request, &field, &cache_path); cfg.sofa_interpolation == JOC_SOFA_INTERPOLATION_MCA_ZERO
? ::joc::hrtf::HrirInterpolation::kMcaZero
: ::joc::hrtf::HrirInterpolation::kLogMagnitudePhase;
options.has_shell_radius = cfg.hrtf_radius_m > 0.0;
options.shell_radius_m = cfg.hrtf_radius_m;
options.object_delay_samples = cfg.object_delay_samples;
options.tail_seconds = cfg.tail_seconds;
status = binaural_reference.open(cfg.hrtf_sofa_path, options);
use_reference = status.ok();
if (status.ok()) { if (status.ok()) {
bus.emit(JOC_EV_HRTF_LOADED, JOC_STAGE_RENDER, JOC_LOG_INFO, bus.emit(JOC_EV_HRTF_LOADED, JOC_STAGE_RENDER, JOC_LOG_INFO,
"SOFA HRTF compiled: " + field.source_sha256.substr(0, 16) + fmt("SOFA full-HRIR field: %zu bins, %zu directions, %zu triangles, "
(cache_path.empty() ? std::string() : " -> " + cache_path)); "latency %d samples",
binaural_reference.field().fft_size(),
binaural_reference.field().direction_count(),
binaural_reference.field().triangle_count(),
binaural_reference.latency_samples()));
} }
} else { } else {
if (!cfg.hrtf_sofa_path.empty()) {
// Explicit legacy compile: the SOFA becomes a .jochrtf cache.
::joc::hrtf::SofaFieldRequest request;
request.sofa_path = cfg.hrtf_sofa_path;
request.options.shell_radius_m =
cfg.hrtf_radius_m > 0.0 ? cfg.hrtf_radius_m : 1.0;
request.cache_dir = cfg.hrtf_cache_dir;
switch (cfg.hrtf_cache_policy) {
case JOC_HRTF_CACHE_NONE: request.policy = ::joc::hrtf::CachePolicy::None; break;
case JOC_HRTF_CACHE_DISK: request.policy = ::joc::hrtf::CachePolicy::Disk; break;
default: request.policy = ::joc::hrtf::CachePolicy::Memory; break;
}
std::string cache_path;
status = ::joc::hrtf::load_or_compile_sofa_field(request, &field, &cache_path);
if (status.ok()) {
bus.emit(JOC_EV_HRTF_LOADED, JOC_STAGE_RENDER, JOC_LOG_INFO,
"SOFA HRTF compiled: " + field.source_sha256.substr(0, 16) +
(cache_path.empty() ? std::string() : " -> " + cache_path));
}
} else {
status = ::joc::hrtf::load_jochrtf(cfg.hrtf_path, &field); status = ::joc::hrtf::load_jochrtf(cfg.hrtf_path, &field);
if (status.ok()) { if (status.ok()) {
bus.emit(JOC_EV_HRTF_LOADED, JOC_STAGE_RENDER, JOC_LOG_INFO, bus.emit(JOC_EV_HRTF_LOADED, JOC_STAGE_RENDER, JOC_LOG_INFO,
"compiled HRTF: " + field.source_sha256.substr(0, 16)); "compiled HRTF: " + field.source_sha256.substr(0, 16));
} }
} }
if (status.ok()) { if (status.ok()) {
status = cfg.kernels_path.empty() status = cfg.kernels_path.empty()
? (kernels = ::joc::hrtf::builtin_kernels(), Status::success()) ? (kernels = ::joc::hrtf::builtin_kernels(), Status::success())
: ::joc::hrtf::load_kernels(cfg.kernels_path, &kernels); : ::joc::hrtf::load_kernels(cfg.kernels_path, &kernels);
} }
if (status.ok() && cfg.binaural_mode == JOC_BINAURAL_NEAR) { if (status.ok() && cfg.binaural_mode == JOC_BINAURAL_NEAR) {
profile = ::joc::binaural::Profile::Near; profile = ::joc::binaural::Profile::Near;
} else if (status.ok() && cfg.binaural_mode == JOC_BINAURAL_FAR) { } else if (status.ok() && cfg.binaural_mode == JOC_BINAURAL_FAR) {
profile = ::joc::binaural::Profile::Far; profile = ::joc::binaural::Profile::Far;
} }
if (status.ok()) { if (status.ok()) {
status = binaural.open(field, kernels, profile); status = binaural.open(field, kernels, profile);
}
} }
if (!status.ok()) { if (!status.ok()) {
return finalize_with_error(status.code(), "render", return finalize_with_error(status.code(), "render",
"binaural setup failed: " + status.message()); "binaural setup failed: " + status.message());
} }
bus.emit(JOC_EV_RENDERER_INITIALIZED, JOC_STAGE_RENDER, JOC_LOG_INFO, bus.emit(JOC_EV_RENDERER_INITIALIZED, JOC_STAGE_RENDER, JOC_LOG_INFO,
"binaural runtime ready (the first 961 samples are the kernel latency)"); use_reference
? "binaural runtime ready (full-HRIR SOFA reference path)"
: "binaural runtime ready (the first 961 samples are the kernel latency)");
} }
} }
@@ -1798,8 +1844,13 @@ Status run(const joc_task_config& raw, const joc_event_sink* sink, joc_task_resu
static_cast<int>(slot) + 1, xyz[0], xyz[1], static_cast<int>(slot) + 1, xyz[0], xyz[1],
xyz[2]); xyz[2]);
if (binaural_enabled) { if (binaural_enabled) {
binaural.set_fixed_position( if (use_reference) {
static_cast<int>(slot) + 1, xyz); binaural_reference.set_fixed_position(
static_cast<int>(slot) + 1, xyz);
} else {
binaural.set_fixed_position(
static_cast<int>(slot) + 1, xyz);
}
} }
if (rosella_enabled) { if (rosella_enabled) {
rosella.set_fixed_position( rosella.set_fixed_position(
@@ -1809,11 +1860,10 @@ Status run(const joc_task_config& raw, const joc_event_sink* sink, joc_task_resu
if (!speaker_enabled) { if (!speaker_enabled) {
continue; continue;
} }
// 目标布局有同名扬声器时直连该声道,否则按标准方位声像。 // bed 声道是固定位置的源:方位由声道标签决定,
// 与目标布局无关,按对象路径声像。
std::uint16_t q15[3] = {0, 0, 0}; std::uint16_t q15[3] = {0, 0, 0};
if (!::joc::joc::layout_bed_anchor( if (!::joc::joc::bed_channel_q15(channel, q15)) {
speaker.layout.out_ch_config, channel, q15) &&
!::joc::joc::bed_channel_q15(channel, q15)) {
continue; continue;
} }
speaker.bed_override[slot] = true; speaker.bed_override[slot] = true;
@@ -1977,19 +2027,26 @@ Status run(const joc_task_config& raw, const joc_event_sink* sink, joc_task_resu
failed = true; failed = true;
} }
} else { } else {
const Status submitted = Status submitted = Status::success();
rosella_enabled if (rosella_enabled) {
? rosella.submit_frame(frame.objects16.data(), submitted = rosella.submit_frame(
frame.has_update ? &frame.update : nullptr, frame.objects16.data(),
static_cast<std::int64_t>(frame.index), frame.has_update ? &frame.update : nullptr,
frame.outer_offset, static_cast<std::int64_t>(frame.index), frame.outer_offset,
static_cast<std::int64_t>(cfg.object_delay_samples)) static_cast<std::int64_t>(cfg.object_delay_samples));
: binaural.submit_frame(frame.objects16.data(), } else if (use_reference) {
frame.has_update ? &frame.update : nullptr, submitted = binaural_reference.submit_frame(
static_cast<std::int64_t>(frame.index), frame.objects16.data(),
frame.outer_offset, frame.has_update ? &frame.update : nullptr,
static_cast<std::int64_t>( static_cast<std::int64_t>(frame.index), frame.outer_offset,
cfg.object_delay_samples)); static_cast<std::int64_t>(cfg.object_delay_samples));
} else {
submitted = binaural.submit_frame(
frame.objects16.data(),
frame.has_update ? &frame.update : nullptr,
static_cast<std::int64_t>(frame.index), frame.outer_offset,
static_cast<std::int64_t>(cfg.object_delay_samples));
}
if (!submitted.ok()) { if (!submitted.ok()) {
failures.record(frame.index, StageRank::kDsp, submitted.code(), "render", failures.record(frame.index, StageRank::kDsp, submitted.code(), "render",
"frame " + std::to_string(frame.index) + ": " + "frame " + std::to_string(frame.index) + ": " +
@@ -2031,6 +2088,8 @@ Status run(const joc_task_config& raw, const joc_event_sink* sink, joc_task_resu
} else { } else {
if (rosella_enabled) { if (rosella_enabled) {
rosella.take_output(&pending.dsp); rosella.take_output(&pending.dsp);
} else if (use_reference) {
binaural_reference.take_output(&pending.dsp);
} else { } else {
binaural.take_output(&pending.dsp); binaural.take_output(&pending.dsp);
} }
@@ -2069,13 +2128,18 @@ Status run(const joc_task_config& raw, const joc_event_sink* sink, joc_task_resu
static_cast<double>(written_samples) / 48000.0); static_cast<double>(written_samples) / 48000.0);
bus.emit(JOC_EV_OAMD_STATS, JOC_STAGE_METADATA, JOC_LOG_DEBUG, bus.emit(JOC_EV_OAMD_STATS, JOC_STAGE_METADATA, JOC_LOG_DEBUG,
fmt("oamd payloads=%llu transitions=%llu", fmt("oamd payloads=%llu transitions=%llu",
static_cast<unsigned long long>(binaural_enabled static_cast<unsigned long long>(
? binaural.timeline().payload_count() !binaural_enabled
: 0ull), ? 0ull
static_cast<unsigned long long>(binaural_enabled : (use_reference
? binaural.timeline() ? binaural_reference.timeline().payload_count()
.transition_count() : binaural.timeline().payload_count())),
: 0ull))); static_cast<unsigned long long>(
!binaural_enabled
? 0ull
: (use_reference
? binaural_reference.timeline().transition_count()
: binaural.timeline().transition_count()))));
} }
} }
@@ -2181,10 +2245,17 @@ Status run(const joc_task_config& raw, const joc_event_sink* sink, joc_task_resu
const std::uint64_t program_samples = written_samples; const std::uint64_t program_samples = written_samples;
if (binaural_enabled) { if (binaural_enabled) {
std::vector<double> tail; std::vector<double> tail;
const Status drained_tail = Status drained_tail = Status::success();
rosella_enabled if (rosella_enabled) {
? rosella.finish(rosella.finish_capacity(cfg.tail_seconds), &tail) drained_tail =
: binaural.finish(binaural.finish_capacity(cfg.tail_seconds), &tail); rosella.finish(rosella.finish_capacity(cfg.tail_seconds), &tail);
} else if (use_reference) {
drained_tail = binaural_reference.finish(
binaural_reference.finish_capacity(cfg.tail_seconds), &tail);
} else {
drained_tail =
binaural.finish(binaural.finish_capacity(cfg.tail_seconds), &tail);
}
if (!drained_tail.ok()) { if (!drained_tail.ok()) {
return finalize_with_error(drained_tail.code(), "output", return finalize_with_error(drained_tail.code(), "output",
drained_tail.message()); drained_tail.message());
@@ -2291,9 +2362,16 @@ Status run(const joc_task_config& raw, const joc_event_sink* sink, joc_task_resu
out->output_over_unity_values = over_unity; out->output_over_unity_values = over_unity;
out->output_file_bytes = file_bytes; out->output_file_bytes = file_bytes;
std::snprintf(out->output_sha256, sizeof(out->output_sha256), "%s", digest.c_str()); std::snprintf(out->output_sha256, sizeof(out->output_sha256), "%s", digest.c_str());
out->oamd_payloads = binaural_enabled ? binaural.timeline().payload_count() : out->oamd_payloads; out->oamd_payloads =
!binaural_enabled
? out->oamd_payloads
: (use_reference ? binaural_reference.timeline().payload_count()
: binaural.timeline().payload_count());
out->oamd_transitions = out->oamd_transitions =
binaural_enabled ? binaural.timeline().transition_count() : out->oamd_transitions; !binaural_enabled
? out->oamd_transitions
: (use_reference ? binaural_reference.timeline().transition_count()
: binaural.timeline().transition_count());
out->t_decode_bed = t_decode; out->t_decode_bed = t_decode;
out->t_render = t_render; out->t_render = t_render;
out->t_write = write_seconds; out->t_write = write_seconds;
+276
View File
@@ -17,11 +17,14 @@
#include "foundation/fs_utf8.h" #include "foundation/fs_utf8.h"
#include "foundation/geometry.h" #include "foundation/geometry.h"
#include "hrtf/jochrtf.h" #include "hrtf/jochrtf.h"
#include "hrtf/full_hrir_field.h"
#include "hrtf/partitioned_convolution.h"
#include "hrtf/sofa.h" #include "hrtf/sofa.h"
#include "hrtf/sofa_cache.h" #include "hrtf/sofa_cache.h"
#include "hrtf/rosella_model.h" #include "hrtf/rosella_model.h"
#include "hrtf/rosella_renderer.h" #include "hrtf/rosella_renderer.h"
#include "hrtf/sofa_field.h" #include "hrtf/sofa_field.h"
#include "hrtf/spherical_mesh.h"
#include "foundation/mini_json.h" #include "foundation/mini_json.h"
#include "foundation/sha256.h" #include "foundation/sha256.h"
#include "io/inflate.h" #include "io/inflate.h"
@@ -31,6 +34,7 @@
#include "io/process.h" #include "io/process.h"
#include "io/wav_writer.h" #include "io/wav_writer.h"
#include "io/zip_reader.h" #include "io/zip_reader.h"
#include "joc_bitstream/bed_layout_map.h"
#include "oamd/oamd_parser.h" #include "oamd/oamd_parser.h"
#include "stream/stream.h" #include "stream/stream.h"
#include "task/task.h" #include "task/task.h"
@@ -294,6 +298,94 @@ void test_oamd_and_adm_helpers() {
// DBMD segment 10: the nine configuration trims must default to automatic (bit 0 // DBMD segment 10: the nine configuration trims must default to automatic (bit 0
// of each trim's first byte), and every other field of the block must keep the // of each trim's first byte), and every other field of the block must keep the
// layout the writer has always produced. // layout the writer has always produced.
// Spherical interpolation mesh: a 200-point Fibonacci sphere exercises the hull,
// the barycentric weights and the Voronoi areas against values captured from the
// reference implementation.
void test_spherical_mesh() {
constexpr int kPoints = 200;
const double pi = 3.14159265358979323846;
std::vector<double> directions;
directions.reserve(static_cast<std::size_t>(kPoints) * 3u);
for (int index = 0; index < kPoints; ++index) {
const double z = 1.0 - 2.0 * (static_cast<double>(index) + 0.5) / kPoints;
const double phi = static_cast<double>(index) * pi * (3.0 - std::sqrt(5.0));
const double radius = std::sqrt(std::max(0.0, 1.0 - z * z));
directions.push_back(radius * std::cos(phi));
directions.push_back(radius * std::sin(phi));
directions.push_back(z);
}
joc::hrtf::SphericalMesh mesh;
joc::Status status = mesh.build(directions, kPoints);
CHECK(status.ok());
CHECK(mesh.vertex_count() == 200u);
CHECK(mesh.face_count() == 396u);
const double query[3] = {0.30304576336566319, 0.5050762722761053, 0.80812203564176865};
const int expected_ids[3] = {16, 11, 24};
const double expected_weights[3] = {0.18552244832037465, 0.23319383531074916,
0.5812837163688762};
std::vector<int> ids;
std::vector<double> weights;
status = mesh.weights(query, &ids, &weights);
CHECK(status.ok());
CHECK(ids.size() == 3u);
double difference = 0.0;
for (std::size_t index = 0; index < ids.size(); ++index) {
double expected = 0.0;
for (int corner = 0; corner < 3; ++corner) {
if (expected_ids[corner] == ids[index]) {
expected = expected_weights[corner];
}
}
difference += std::fabs(weights[index] - expected);
}
CHECK(difference < 1e-9);
CHECK(std::fabs(weights[0] + weights[1] + weights[2] - 1.0) < 1e-12);
std::vector<double> areas;
mesh.voronoi_areas(&areas);
CHECK(areas.size() == 200u);
double smallest = areas[0];
double largest = areas[0];
double total = 0.0;
for (const double area : areas) {
smallest = std::min(smallest, area);
largest = std::max(largest, area);
total += area;
}
CHECK(std::fabs(total - 1.0) < 1e-12);
CHECK(std::fabs(largest / smallest - 1.1197648114672005) < 1e-9);
}
// Rigid-sphere radial model: values captured from the reference implementation.
void test_sphere_transfer() {
const std::vector<double> frequencies = {100.0, 1000.0, 10000.0};
const std::vector<double> cosines = {1.0, -1.0, 0.0};
std::vector<std::complex<double>> transfer;
const joc::Status status =
joc::hrtf::sphere_transfer(frequencies, 1.0, 0.0875, cosines, &transfer);
CHECK(status.ok());
CHECK(transfer.size() == 9u);
const double expected[9][2] = {
{1.1168983535509718, 0.2665696486002471},
{-0.510805763797141, 1.6128537943222743},
{-2.028923793661157, -0.7781755079388825},
{0.8548955324773564, -0.21699922414442047},
{-0.8363832921619323, -0.5012251963562975},
{0.03287720702899299, -0.7655728018349265},
{0.9881471826293796, -0.01028038096534477},
{1.0740047354266093, 0.11688911754407418},
{0.9394042077254096, -0.7927884777210633},
};
for (std::size_t index = 0; index < 9u; ++index) {
const double real = expected[index][0];
const double imaginary = expected[index][1];
CHECK(std::fabs(transfer[index].real() - real) < 1e-9 * (1.0 + std::fabs(real)));
CHECK(std::fabs(transfer[index].imag() - imaginary) <
1e-9 * (1.0 + std::fabs(imaginary)));
}
}
void test_dbmd_auto_trim() { void test_dbmd_auto_trim() {
std::string dbmd; std::string dbmd;
CHECK(joc::adm::build_dbmd(25, joc::adm::BinauralMode::Mid, &dbmd).ok()); CHECK(joc::adm::build_dbmd(25, joc::adm::BinauralMode::Mid, &dbmd).ok());
@@ -1133,6 +1225,186 @@ void test_clipgain_reset_clears_the_previous_gain() {
sizeof(float) * after_reset.size()) == 0); sizeof(float) * after_reset.size()) == 0);
} }
// CBA bed:每个声道的方位来自它的标签(ETSI TS 103 420 V1.2.1 table B.10),
// 声道顺序来自 table 12/13,因此 bed 声道不会随输出布局移动。
void test_bed_layout_map() {
using joc::joc::BedChannel;
using joc::joc::BedLayout;
double xyz[3] = {0.0, 0.0, 0.0};
CHECK(joc::joc::bed_channel_adm_position(BedChannel::kLeft, xyz));
CHECK(xyz[0] == -1.0 && xyz[1] == 1.0 && xyz[2] == 0.0);
CHECK(joc::joc::bed_channel_adm_position(BedChannel::kCenter, xyz));
CHECK(xyz[0] == 0.0 && xyz[1] == 1.0 && xyz[2] == 0.0);
CHECK(joc::joc::bed_channel_adm_position(BedChannel::kTopFrontLeft, xyz));
CHECK(xyz[0] == -1.0 && xyz[1] == 1.0 && xyz[2] == 1.0);
CHECK(joc::joc::bed_channel_adm_position(BedChannel::kTopFrontRight, xyz));
CHECK(xyz[0] == 1.0 && xyz[1] == 1.0 && xyz[2] == 1.0);
CHECK(joc::joc::bed_channel_adm_position(BedChannel::kTopSideLeft, xyz));
CHECK(xyz[0] == -1.0 && xyz[1] == 0.0 && xyz[2] == 1.0);
CHECK(joc::joc::bed_channel_adm_position(BedChannel::kTopBackLeft, xyz));
CHECK(xyz[0] == -1.0 && xyz[1] == -1.0 && xyz[2] == 1.0);
CHECK(joc::joc::bed_channel_adm_position(BedChannel::kTopBackRight, xyz));
CHECK(xyz[0] == 1.0 && xyz[1] == -1.0 && xyz[2] == 1.0);
CHECK(joc::joc::bed_channel_adm_position(BedChannel::kLeftWide, xyz));
CHECK(xyz[0] == -1.0 && xyz[1] == 21.0 / 31.0 && xyz[2] == 0.0);
CHECK(joc::joc::bed_channel_adm_position(BedChannel::kRightWide, xyz));
CHECK(xyz[0] == 1.0 && xyz[1] == 21.0 / 31.0 && xyz[2] == 0.0);
CHECK(joc::joc::bed_channel_adm_position(BedChannel::kLfe, xyz));
CHECK(xyz[0] == -1.0 && xyz[1] == 1.0 && xyz[2] == -1.0);
CHECK(joc::joc::bed_channel_adm_position(BedChannel::kLfe2, xyz));
CHECK(xyz[0] == 1.0 && xyz[1] == 1.0 && xyz[2] == -1.0);
std::uint16_t q15[3] = {0, 0, 0};
CHECK(joc::joc::bed_channel_q15(BedChannel::kLeft, q15));
CHECK(q15[0] == 0 && q15[1] == 0 && q15[2] == 0);
CHECK(joc::joc::bed_channel_q15(BedChannel::kTopFrontLeft, q15));
CHECK(q15[0] == 0 && q15[1] == 0 && q15[2] == 32767);
CHECK(joc::joc::bed_channel_q15(BedChannel::kLeftWide, q15));
CHECK(q15[0] == 0 && q15[1] == 5285 && q15[2] == 0);
CHECK(joc::joc::bed_channel_q15(BedChannel::kTopBackLeft, q15));
CHECK(q15[0] == 0 && q15[1] == 32767 && q15[2] == 32767);
// table 12:0x0F 是 5.1,0x1FF 是 9.1.6(不含 LFE2)。
std::vector<joc::oamd::BedAssignment> standard(1);
standard[0].standard = true;
standard[0].mask = 0x0Fu;
const BedLayout five_one = joc::joc::resolve_bed_layout(standard, true);
CHECK(five_one.present && five_one.bed_only && five_one.complete);
CHECK(std::string(five_one.name) == "5.1");
CHECK(five_one.channels.size() == 5);
CHECK(five_one.channels[0] == BedChannel::kLeft);
CHECK(five_one.channels[1] == BedChannel::kRight);
CHECK(five_one.channels[2] == BedChannel::kCenter);
CHECK(five_one.channels[3] == BedChannel::kLeftSurround);
CHECK(five_one.channels[4] == BedChannel::kRightSurround);
standard[0].mask = 0x1FFu;
const BedLayout nine_six = joc::joc::resolve_bed_layout(standard, true);
CHECK(std::string(nine_six.name) == "9.1.6");
CHECK(nine_six.channels.size() == 15);
CHECK(nine_six.channels[0] == BedChannel::kLeft);
CHECK(nine_six.channels[2] == BedChannel::kCenter);
CHECK(nine_six.channels[3] == BedChannel::kLeftSurround);
CHECK(nine_six.channels[7] == BedChannel::kTopFrontLeft);
CHECK(nine_six.channels[9] == BedChannel::kTopSideLeft);
CHECK(nine_six.channels[11] == BedChannel::kTopBackLeft);
CHECK(nine_six.channels[13] == BedChannel::kLeftWide);
CHECK(nine_six.channels[14] == BedChannel::kRightWide);
// LFE 留在声明掩码里,但不占 JOC 对象槽。
CHECK(joc::joc::bed_layout_has(nine_six, BedChannel::kLfe));
bool lfe_slot = false;
for (const BedChannel channel : nine_six.channels) {
lfe_slot = lfe_slot || channel == BedChannel::kLfe ||
channel == BedChannel::kLfe2;
}
CHECK(!lfe_slot);
CHECK(joc::joc::bed_layout_has(nine_six, BedChannel::kRightWide));
// table 13:17 bit 掩码的 channel order 与 table 12 相同。
std::vector<joc::oamd::BedAssignment> nonstandard(1);
nonstandard[0].standard = false;
nonstandard[0].mask = 0x3Fu;
const BedLayout ns_five = joc::joc::resolve_bed_layout(nonstandard, true);
CHECK(ns_five.channels.size() == 5);
CHECK(ns_five.channels[0] == BedChannel::kLeft);
CHECK(ns_five.channels[4] == BedChannel::kRightSurround);
nonstandard[0].mask = 0xFFFFu;
const BedLayout ns_nine = joc::joc::resolve_bed_layout(nonstandard, true);
CHECK(ns_nine.channels.size() == 15);
CHECK(ns_nine.channels[0] == BedChannel::kLeft);
CHECK(ns_nine.channels[13] == BedChannel::kLeftWide);
CHECK(ns_nine.channels[14] == BedChannel::kRightWide);
}
// Partitioned convolution: overlap-add with a shared input history and a filter
// crossfade. The expected values come from the reference
// partitioned_convolution.py running the same filters and blocks.
void test_partitioned_convolution() {
constexpr std::size_t kBlock = 128;
constexpr std::size_t kTaps = 300;
constexpr std::size_t kMaxTaps = 512;
constexpr std::size_t kOutputs = 2;
auto make_filter = [](double step, double decay, bool cosine, double offset) {
std::vector<double> values(kOutputs * kTaps);
for (std::size_t output = 0; output < kOutputs; ++output) {
for (std::size_t tap = 0; tap < kTaps; ++tap) {
const double angle = step * static_cast<double>(tap + 1) *
(static_cast<double>(output) + offset);
const double trig = cosine ? std::cos(angle) : std::sin(angle);
values[output * kTaps + tap] = trig * std::exp(-static_cast<double>(tap) / decay);
}
}
return values;
};
joc::hrtf::UniformPartitionedConvolver convolver(kOutputs, kMaxTaps, kBlock);
const std::vector<double> first = make_filter(0.017, 100.0, false, 1.0);
CHECK(convolver.set_filter(first.data(), kTaps, 0).ok());
CHECK(!convolver.transition_active());
std::vector<double> block(kBlock);
std::vector<double> out(kBlock * kOutputs);
std::vector<double> rendered;
for (std::size_t index = 0; index < 8; ++index) {
for (std::size_t sample = 0; sample < kBlock; ++sample) {
const double n = static_cast<double>(index * kBlock + sample);
block[sample] = std::sin(0.01 * n) + 0.5 * std::cos(0.003 * n);
}
CHECK(convolver.process_block(block.data(), out.data()).ok());
rendered.insert(rendered.end(), out.begin(), out.end());
}
CHECK(rendered.size() == 8 * kBlock * kOutputs);
CHECK(std::fabs(rendered[0] - 0.0084995905892490953) < 1e-9);
CHECK(std::fabs(rendered[1] - 0.016996724855971479) < 1e-9);
CHECK(std::fabs(rendered[2] - 0.025497145937656285) < 1e-9);
CHECK(std::fabs(rendered[63] - 8.1367456949245849) < 1e-9);
CHECK(std::fabs(rendered[64] - 4.6183248807335495) < 1e-9);
CHECK(std::fabs(rendered[65] - 8.5945567424849969) < 1e-9);
CHECK(std::fabs(rendered[127] - 24.744288415490566) < 1e-8);
CHECK(std::fabs(rendered[128] - 16.21718594261781) < 1e-8);
CHECK(std::fabs(rendered[129] - 25.258064041591062) < 1e-8);
CHECK(std::fabs(rendered[255] - 42.867139711879446) < 1e-8);
CHECK(std::fabs(rendered[256] - 47.087759632531053) < 1e-8);
CHECK(std::fabs(rendered[511] - 30.307479702394744) < 1e-8);
CHECK(std::fabs(rendered[512] - 64.6869976138059) < 1e-8);
CHECK(std::fabs(rendered[700] - 26.847289638199864) < 1e-8);
CHECK(std::fabs(rendered[701] - 2.9756928363101984) < 1e-8);
CHECK(std::fabs(rendered[1023] - -25.703654152948225) < 1e-8);
CHECK(std::fabs(rendered[1024] - -43.300148318757053) < 1e-8);
// A two-block crossfade keeps both filters' overlap tails alive.
const std::vector<double> second = make_filter(0.011, 140.0, true, 2.0);
CHECK(convolver.set_filter(second.data(), kTaps, 2).ok());
CHECK(convolver.transition_active());
std::vector<double> faded;
for (std::size_t index = 0; index < 4; ++index) {
for (std::size_t sample = 0; sample < kBlock; ++sample) {
const double n = 1000.0 + static_cast<double>(index * kBlock + sample);
block[sample] = std::sin(0.02 * n) + 0.3;
}
CHECK(convolver.process_block(block.data(), out.data()).ok());
faded.insert(faded.end(), out.begin(), out.end());
}
CHECK(!convolver.transition_active());
CHECK(std::fabs(faded[0] - -31.254215789646686) < 1e-8);
CHECK(std::fabs(faded[1] - -30.520784088408671) < 1e-8);
CHECK(std::fabs(faded[2] - -31.64727283056877) < 1e-8);
CHECK(std::fabs(faded[127] - 45.044850086774559) < 1e-8);
CHECK(std::fabs(faded[128] - 16.242938783563034) < 1e-8);
CHECK(std::fabs(faded[129] - 45.566945939182197) < 1e-8);
CHECK(std::fabs(faded[255] - -11.640284877460564) < 1e-8);
CHECK(std::fabs(faded[256] - 20.660738168974696) < 1e-8);
CHECK(std::fabs(faded[383] - -24.027948887675439) < 1e-8);
CHECK(std::fabs(faded[384] - -41.675076381317034) < 1e-8);
CHECK(std::fabs(faded[511] - 34.95547294171444) < 1e-8);
CHECK(std::fabs(faded[512] - -4.9486250951335764) < 1e-8);
convolver.reset();
CHECK(!convolver.transition_active());
}
int main() { int main() {
test_sha256(); test_sha256();
test_crc32_and_inflate(); test_crc32_and_inflate();
@@ -1144,6 +1416,10 @@ int main() {
test_task_result_json(); test_task_result_json();
test_npy(); test_npy();
test_oamd_and_adm_helpers(); test_oamd_and_adm_helpers();
test_bed_layout_map();
test_partitioned_convolution();
test_spherical_mesh();
test_sphere_transfer();
test_dbmd_auto_trim(); test_dbmd_auto_trim();
test_int24_packing(); test_int24_packing();
test_utf8_paths(); test_utf8_paths();