Support JOC downmix configurations 0..4 and update the vendored kernel
This commit is contained in:
1 parent
cb840af52f
commit
d683a3f1c0
32 files changed
+2055
-300
No files matched your search
+7
-2
@@ -3,8 +3,9 @@
|
|||||||
[简体中文](README.md) · [Install](#install) · [Settings](#settings) · [Building](#building) · [Known limitations](#known-limitations)
|
[简体中文](README.md) · [Install](#install) · [Settings](#settings) · [Building](#building) · [Known limitations](#known-limitations)
|
||||||
|
|
||||||
A foobar2000 input component for **E-AC-3 JOC (Dolby Atmos)** files: the JOC object and OAMD
|
A foobar2000 input component for **E-AC-3 JOC (Dolby Atmos)** files: the JOC object and OAMD
|
||||||
metadata is taken from the E-AC-3 syncframes and paired with the 5.1 core PCM that ffmpeg
|
metadata is taken from the E-AC-3 syncframes and paired with the core PCM that ffmpeg decodes
|
||||||
decodes, then rendered in real time to headphones (HRTF) or to a speaker layout up to 7.1. The
|
(5.1 or 7 channels, following $joc\_dmx\_config\_idx$), then rendered in real time to headphones
|
||||||
|
(HRTF) or to a speaker layout up to 7.1. The
|
||||||
rendering core is compiled into the component, so there is nothing to install beside
|
rendering core is compiled into the component, so there is nothing to install beside
|
||||||
`foo_input_joc.dll`.
|
`foo_input_joc.dll`.
|
||||||
|
|
||||||
@@ -112,6 +113,10 @@ every container in the library, which is where the volume comes from.
|
|||||||
## Known limitations
|
## Known limitations
|
||||||
|
|
||||||
* ADM BWF output is not implemented.
|
* ADM BWF output is not implemented.
|
||||||
|
* All five $joc\_dmx\_config\_idx$ configurations are supported: the bed is paired per audio
|
||||||
|
frame, and its channel count follows the configuration (6 channels for 0/3, 8 for 1/2/4), with
|
||||||
|
`-ac 6` passed to ffmpeg only for the 6-channel ones. An AC-3 core plus a dependent substream
|
||||||
|
(`strmtyp=1`) and a first audio frame without JOC are both normal cases.
|
||||||
* A container is only claimed when this component is ahead of the built-in container reader in
|
* A container is only claimed when this component is ahead of the built-in container reader in
|
||||||
Preferences → Decoding (see [Install](#containers-need-one-look-at-the-decoder-list)); the core
|
Preferences → Decoding (see [Install](#containers-need-one-look-at-the-decoder-list)); the core
|
||||||
does not let a decoder ask for a file another entry has already taken. Such a file's tags stay
|
does not let a decoder ask for a file another entry has already taken. Such a file's tags stay
|
||||||
|
|||||||
@@ -3,7 +3,7 @@
|
|||||||
[English](README.en.md) · [安装](#安装) · [设置](#设置) · [构建](#构建) · [已知限制](#已知限制)
|
[English](README.en.md) · [安装](#安装) · [设置](#设置) · [构建](#构建) · [已知限制](#已知限制)
|
||||||
|
|
||||||
foobar2000 输入组件,播放 **E-AC-3 JOC(Dolby Atmos)** 文件:从 E-AC-3 同步帧里取出 JOC
|
foobar2000 输入组件,播放 **E-AC-3 JOC(Dolby Atmos)** 文件:从 E-AC-3 同步帧里取出 JOC
|
||||||
对象与 OAMD 元数据,与 ffmpeg 解出的 5.1 核心 PCM 配对后实时渲染,输出双耳(HRTF)或最多
|
对象与 OAMD 元数据,与 ffmpeg 解出的核心 PCM(按 $joc\_dmx\_config\_idx$ 为 5.1 或 7 通道)配对后实时渲染,输出双耳(HRTF)或最多
|
||||||
7.1 的扬声器布局。渲染内核直接编译进组件,除 `foo_input_joc.dll` 之外不需要安装任何东西。
|
7.1 的扬声器布局。渲染内核直接编译进组件,除 `foo_input_joc.dll` 之外不需要安装任何东西。
|
||||||
|
|
||||||
输入是裸流 `.eac3` / `.ec3`,或容器里的 E-AC-3 JOC 轨道(`.mp4` `.m4a` `.m4b` `.m4p`
|
输入是裸流 `.eac3` / `.ec3`,或容器里的 E-AC-3 JOC 轨道(`.mp4` `.m4a` `.m4b` `.m4p`
|
||||||
@@ -95,6 +95,9 @@ pwsh -File tools/package.ps1 # 两个架构,打包到 dist\*.fb2k-c
|
|||||||
## 已知限制
|
## 已知限制
|
||||||
|
|
||||||
* 不实现 ADM BWF 输出。
|
* 不实现 ADM BWF 输出。
|
||||||
|
* $joc\_dmx\_config\_idx$ 全部五个档位都支持:取床按音频帧配对,床通道数由档位决定(0/3
|
||||||
|
为 6 通道,1/2/4 为 8 通道),ffmpeg 只在 6 通道档位传 `-ac 6`。AC-3 核心 + 依赖子流
|
||||||
|
(`strmtyp=1`)与"首个音频帧没有 JOC"都按正常情况处理。
|
||||||
* 容器只有在它排在内置容器读取器之前时才会被接管(见[安装](#容器需要调一次解码器顺序));核心
|
* 容器只有在它排在内置容器读取器之前时才会被接管(见[安装](#容器需要调一次解码器顺序));核心
|
||||||
不允许某个解码器去要一个已经被别的条目拿走的文件。这类文件的标签也仍旧归那个读取器。
|
不允许某个解码器去要一个已经被别的条目拿走的文件。这类文件的标签也仍旧归那个读取器。
|
||||||
* 裸流 `.eac3` / `.ec3` 的标签(流前面的 ID3v2,或后面的 APEv2/ID3v1)**能读不能写**:没有
|
* 裸流 `.eac3` / `.ec3` 的标签(流前面的 ID3v2,或后面的 APEv2/ID3v1)**能读不能写**:没有
|
||||||
|
|||||||
@@ -30,6 +30,14 @@ $$Y_p = \sum_{q\in C_p}\Bigl(\mathrm{Re}X_q + j\,s_q\,\mathrm{Im}X_q\Bigr),\qqua
|
|||||||
|
|
||||||
相同数值可在 FFmpeg(`aacps_tablegen.h`、`aacsbrdata.h`)等公开实现中查到。
|
相同数值可在 FFmpeg(`aacps_tablegen.h`、`aacsbrdata.h`)等公开实现中查到。
|
||||||
|
|
||||||
|
### AC-3 / E-AC-3 传输层与通道码表
|
||||||
|
|
||||||
|
`kernel/src/eac3_transport/eac3_reader.cpp` 的 AC-3 同步帧长度表由 A/52 的
|
||||||
|
`fscod`/`frmsizecod` 比特率表换算得到(48/44.1/32 kHz 三列),E-AC-3 帧长用标准
|
||||||
|
`frmsiz` 字段;`kernel/src/joc_bitstream/joc_parser.cpp` 的 16 bit `chanmap` 位表与
|
||||||
|
A/52 `acmod` 通道序来自 **ATSC A/52 Annex E**(等同 ETSI TS 102 366 Annex E)的
|
||||||
|
Table E2.5 / `chanmap` 定义。这些表是按公开标准写的数值,不含任何第三方实现代码。
|
||||||
|
|
||||||
## HRTF 数据与 `.jochrtf`
|
## HRTF 数据与 `.jochrtf`
|
||||||
|
|
||||||
`.jochrtf` 含有特定源 SOFA/HRTF 数据集的变换系数与 delay;其使用、复制与再分发仍受源
|
`.jochrtf` 含有特定源 SOFA/HRTF 数据集的变换系数与 delay;其使用、复制与再分发仍受源
|
||||||
|
|||||||
@@ -23,11 +23,12 @@ extern "C" {
|
|||||||
#endif
|
#endif
|
||||||
|
|
||||||
enum {
|
enum {
|
||||||
EJOC_ABI_VERSION = 1,
|
EJOC_ABI_VERSION = 2,
|
||||||
EJOC_FRAME_SAMPLES = 1536,
|
EJOC_FRAME_SAMPLES = 1536,
|
||||||
EJOC_TIMESLOTS = 24,
|
EJOC_TIMESLOTS = 24,
|
||||||
EJOC_SUBBANDS = 64,
|
EJOC_SUBBANDS = 64,
|
||||||
EJOC_CORE_CHANNELS = 5,
|
EJOC_CORE_CHANNELS = 5, /* downmix configurations 0 and 3 */
|
||||||
|
EJOC_MAX_CORE_CHANNELS = 7, /* downmix configurations 1, 2 and 4 */
|
||||||
EJOC_OUTPUT_CHANNELS = 16,
|
EJOC_OUTPUT_CHANNELS = 16,
|
||||||
EJOC_MAX_OBJECTS = 15,
|
EJOC_MAX_OBJECTS = 15,
|
||||||
EJOC_MAX_DPOINTS = 2,
|
EJOC_MAX_DPOINTS = 2,
|
||||||
@@ -47,15 +48,18 @@ typedef void* ejoc_binaural_renderer_handle;
|
|||||||
|
|
||||||
/*
|
/*
|
||||||
Fixed array layouts used by ejoc_renderer_process():
|
Fixed array layouts used by ejoc_renderer_process():
|
||||||
bed5_planar [5][1536]
|
bed_planar [core_channel_count][1536]
|
||||||
lfe [1536] or NULL
|
lfe [1536] or NULL
|
||||||
n_bands [15]
|
n_bands [15]
|
||||||
n_dpoints [15]
|
n_dpoints [15]
|
||||||
slope_idx [15]
|
slope_idx [15]
|
||||||
offset_ts [15][2]
|
offset_ts [15][2]
|
||||||
dq [15][2][5][23]
|
dq [15][2][7][23]
|
||||||
output16 [16][1536]
|
output16 [16][1536]
|
||||||
|
|
||||||
|
core_channel_count comes from ejoc_renderer_set_core_channels() and defaults to
|
||||||
|
EJOC_CORE_CHANNELS; the dq stride is always EJOC_MAX_CORE_CHANNELS.
|
||||||
|
|
||||||
Only objects selected by object_mask are read from the descriptor arrays.
|
Only objects selected by object_mask are read from the descriptor arrays.
|
||||||
dq carries already dequantized matrix coefficients in double precision; the
|
dq carries already dequantized matrix coefficients in double precision; the
|
||||||
caller performs the JOC bitstream differential decoding for both dense and
|
caller performs the JOC bitstream differential decoding for both dense and
|
||||||
@@ -69,21 +73,24 @@ EJOC_API void EJOC_CALL ejoc_renderer_destroy(ejoc_renderer_handle handle);
|
|||||||
EJOC_API int EJOC_CALL ejoc_renderer_reset(ejoc_renderer_handle handle);
|
EJOC_API int EJOC_CALL ejoc_renderer_reset(ejoc_renderer_handle handle);
|
||||||
EJOC_API int EJOC_CALL ejoc_renderer_set_threads(ejoc_renderer_handle handle, uint32_t total_threads);
|
EJOC_API int EJOC_CALL ejoc_renderer_set_threads(ejoc_renderer_handle handle, uint32_t total_threads);
|
||||||
/*
|
/*
|
||||||
Enables or disables the Ls/Rs band-0 21-tap DC compensation. The caller derives
|
core_channel_count comes from joc_dmx_config_idx: 5 for configurations 0 and 3,
|
||||||
it from the JOC downmix configuration: only configurations 3 and 4 enable the
|
7 for 1, 2 and 4. bed_planar is then [core_channel_count][1536] and only channels
|
||||||
filter. When disabled, band 0 keeps the common per-band processing (surround
|
below core_channel_count are read from dq, whose stride stays [15][2][7][23].
|
||||||
delay plus -j rotation) instead of being overwritten by the FIR. The delay line
|
|
||||||
and DC history advance either way, so the flag may change between frames.
|
phase_shift is sigma(k) = (k in {3,4}): it enables the Ls/Rs -j rotation of
|
||||||
Defaults to enabled when never called.
|
subbands above 0 together with the band-0 21-tap DC compensation. With the switch
|
||||||
|
off, channels 3 and 4 only take the common ten-slot surround delay. The delay
|
||||||
|
line and DC history advance either way, so the flag may change between frames.
|
||||||
*/
|
*/
|
||||||
EJOC_API int EJOC_CALL ejoc_renderer_set_dc_filter(ejoc_renderer_handle handle, uint32_t enabled);
|
|
||||||
EJOC_API uint32_t EJOC_CALL ejoc_renderer_thread_count(ejoc_renderer_handle handle);
|
EJOC_API uint32_t EJOC_CALL ejoc_renderer_thread_count(ejoc_renderer_handle handle);
|
||||||
EJOC_API const char* EJOC_CALL ejoc_renderer_last_error(ejoc_renderer_handle handle);
|
EJOC_API const char* EJOC_CALL ejoc_renderer_last_error(ejoc_renderer_handle handle);
|
||||||
|
|
||||||
EJOC_API int EJOC_CALL ejoc_renderer_process(
|
EJOC_API int EJOC_CALL ejoc_renderer_process(
|
||||||
ejoc_renderer_handle handle,
|
ejoc_renderer_handle handle,
|
||||||
const float* bed5_planar,
|
const float* bed_planar,
|
||||||
const float* lfe,
|
const float* lfe,
|
||||||
|
uint32_t core_channel_count,
|
||||||
|
uint32_t phase_shift,
|
||||||
uint32_t object_mask,
|
uint32_t object_mask,
|
||||||
const uint8_t* n_bands,
|
const uint8_t* n_bands,
|
||||||
const uint8_t* n_dpoints,
|
const uint8_t* n_dpoints,
|
||||||
|
|||||||
@@ -34,7 +34,9 @@
|
|||||||
#include <stdint.h>
|
#include <stdint.h>
|
||||||
#include <stddef.h>
|
#include <stddef.h>
|
||||||
|
|
||||||
#define JOC_ABI_VERSION 3u
|
#include "joc_version.h"
|
||||||
|
|
||||||
|
#define JOC_ABI_VERSION 5u
|
||||||
#define JOC_FRAME_PARAMS_VERSION 1u
|
#define JOC_FRAME_PARAMS_VERSION 1u
|
||||||
#define JOC_EMDF_INFO_VERSION 1u
|
#define JOC_EMDF_INFO_VERSION 1u
|
||||||
#define JOC_TASK_CONFIG_VERSION 3u
|
#define JOC_TASK_CONFIG_VERSION 3u
|
||||||
@@ -193,7 +195,7 @@ typedef struct joc_frame_params {
|
|||||||
uint8_t n_channels; /* 5 or 7 */
|
uint8_t n_channels; /* 5 or 7 */
|
||||||
uint8_t clipgain_x_bits;
|
uint8_t clipgain_x_bits;
|
||||||
uint8_t clipgain_y_bits;
|
uint8_t clipgain_y_bits;
|
||||||
uint8_t reserved;
|
uint8_t objects_clamped; /* num_objects_bits+1 exceeded 15 */
|
||||||
uint32_t seq_count; /* 10-bit JOC sequence counter, parsed only */
|
uint32_t seq_count; /* 10-bit JOC sequence counter, parsed only */
|
||||||
uint32_t present_mask; /* bit i == object i present */
|
uint32_t present_mask; /* bit i == object i present */
|
||||||
uint32_t data_end_bits; /* bit position just after joc_data */
|
uint32_t data_end_bits; /* bit position just after joc_data */
|
||||||
|
|||||||
@@ -102,6 +102,16 @@ typedef struct joc_stream_status_info {
|
|||||||
uint64_t buffered_samples; /* rendered but not yet pulled, per channel */
|
uint64_t buffered_samples; /* rendered but not yet pulled, per channel */
|
||||||
uint64_t oamd_payloads;
|
uint64_t oamd_payloads;
|
||||||
uint64_t oamd_transitions;
|
uint64_t oamd_transitions;
|
||||||
|
/* Metadata the renderer had to work around, per audio frame: no JOC payload at
|
||||||
|
* all, a declared object count clamped to 15, and a syncframe carrying a second
|
||||||
|
* EMDF container that is not this frame's JOC metadata. */
|
||||||
|
uint64_t missing_joc_frames;
|
||||||
|
uint64_t objects_clamped_frames;
|
||||||
|
uint64_t extra_container_frames;
|
||||||
|
/* Extra-pair identity disagreements across layers (spec 11.2 checks 1 and 2).
|
||||||
|
* The identity is metadata only, so those frames still render. */
|
||||||
|
uint64_t chanmap_pair_mismatch_frames;
|
||||||
|
uint64_t bed_mask_mismatch_frames;
|
||||||
uint32_t output_channels;
|
uint32_t output_channels;
|
||||||
uint32_t ended; /* 1 after flush() */
|
uint32_t ended; /* 1 after flush() */
|
||||||
} joc_stream_status_info;
|
} joc_stream_status_info;
|
||||||
|
|||||||
@@ -0,0 +1,16 @@
|
|||||||
|
/* Product version of joc_core and joc_cli.
|
||||||
|
*
|
||||||
|
* This file is the single source of truth: CMakeLists.txt reads these numbers for
|
||||||
|
* project(VERSION ...), joc_version_string() returns JOC_VERSION_STRING, and the
|
||||||
|
* release workflow refuses a tag that does not match it. Bump the three numbers
|
||||||
|
* and the string together, then tag the commit with v<JOC_VERSION_STRING>.
|
||||||
|
*/
|
||||||
|
#ifndef JOC_VERSION_H
|
||||||
|
#define JOC_VERSION_H
|
||||||
|
|
||||||
|
#define JOC_VERSION_MAJOR 0
|
||||||
|
#define JOC_VERSION_MINOR 1
|
||||||
|
#define JOC_VERSION_PATCH 0
|
||||||
|
#define JOC_VERSION_STRING "0.1.0"
|
||||||
|
|
||||||
|
#endif /* JOC_VERSION_H */
|
||||||
@@ -219,6 +219,7 @@
|
|||||||
<ClInclude Include="include\eac3joc_core.h" />
|
<ClInclude Include="include\eac3joc_core.h" />
|
||||||
<ClInclude Include="include\joc_core.h" />
|
<ClInclude Include="include\joc_core.h" />
|
||||||
<ClInclude Include="include\joc_stream.h" />
|
<ClInclude Include="include\joc_stream.h" />
|
||||||
|
<ClInclude Include="include\joc_version.h" />
|
||||||
<ClInclude Include="src\adm\adm_metadata.h" />
|
<ClInclude Include="src\adm\adm_metadata.h" />
|
||||||
<ClInclude Include="src\adm\adm_tracks.h" />
|
<ClInclude Include="src\adm\adm_tracks.h" />
|
||||||
<ClInclude Include="src\binaural\binaural_runtime.h" />
|
<ClInclude Include="src\binaural\binaural_runtime.h" />
|
||||||
|
|||||||
@@ -11,16 +11,8 @@
|
|||||||
|
|
||||||
namespace {
|
namespace {
|
||||||
|
|
||||||
thread_local std::string g_detail;
|
|
||||||
|
|
||||||
joc_error finish(const joc::Status& status) {
|
joc_error finish(const joc::Status& status) {
|
||||||
if (status.ok()) {
|
joc::record_error_detail(status);
|
||||||
g_detail.clear();
|
|
||||||
return JOC_OK;
|
|
||||||
}
|
|
||||||
g_detail.assign(status.stage());
|
|
||||||
g_detail.append(": ");
|
|
||||||
g_detail.append(status.message());
|
|
||||||
return status.code();
|
return status.code();
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -49,7 +41,7 @@ extern "C" {
|
|||||||
|
|
||||||
std::uint32_t JOC_CALL joc_abi_version(void) { return JOC_ABI_VERSION; }
|
std::uint32_t JOC_CALL joc_abi_version(void) { return JOC_ABI_VERSION; }
|
||||||
|
|
||||||
const char* JOC_CALL joc_version_string(void) { return "0.1.0-m1"; }
|
const char* JOC_CALL joc_version_string(void) { return JOC_VERSION_STRING; }
|
||||||
|
|
||||||
std::uint32_t JOC_CALL joc_event_size(void) { return static_cast<std::uint32_t>(sizeof(joc_event)); }
|
std::uint32_t JOC_CALL joc_event_size(void) { return static_cast<std::uint32_t>(sizeof(joc_event)); }
|
||||||
std::uint32_t JOC_CALL joc_task_config_size(void) {
|
std::uint32_t JOC_CALL joc_task_config_size(void) {
|
||||||
@@ -167,7 +159,7 @@ const char* JOC_CALL joc_error_stage(joc_error code) {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
const char* JOC_CALL joc_last_error_detail(void) { return g_detail.c_str(); }
|
const char* JOC_CALL joc_last_error_detail(void) { return joc::last_error_detail.c_str(); }
|
||||||
|
|
||||||
joc_error JOC_CALL joc_parse_id14(const std::uint8_t* payload, std::size_t payload_size,
|
joc_error JOC_CALL joc_parse_id14(const std::uint8_t* payload, std::size_t payload_size,
|
||||||
joc_frame_params* out_params) {
|
joc_frame_params* out_params) {
|
||||||
|
|||||||
@@ -13,6 +13,9 @@ struct joc_stream {
|
|||||||
namespace {
|
namespace {
|
||||||
|
|
||||||
joc_error finish_stream(const joc::Status& status) {
|
joc_error finish_stream(const joc::Status& status) {
|
||||||
|
// The structured detail is not dropped here: joc_last_error_detail() reports
|
||||||
|
// it for the streaming entry points as well as for the task API.
|
||||||
|
joc::record_error_detail(status);
|
||||||
return status.code();
|
return status.code();
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -93,12 +96,14 @@ joc_error JOC_CALL joc_stream_push(joc_stream* stream, const joc_stream_buffer*
|
|||||||
return pushed;
|
return pushed;
|
||||||
}
|
}
|
||||||
std::size_t consumed = 0;
|
std::size_t consumed = 0;
|
||||||
|
const std::uint32_t channels = input->channels != 0u ? input->channels : 6u;
|
||||||
const joc::Status pushed =
|
const joc::Status pushed =
|
||||||
stream->instance.push_bed(input->pcm, input->sample_count, &consumed);
|
stream->instance.push_bed(input->pcm, input->sample_count, channels, &consumed);
|
||||||
if (consumed_samples != nullptr) {
|
if (consumed_samples != nullptr) {
|
||||||
*consumed_samples = static_cast<std::uint32_t>(consumed);
|
*consumed_samples = static_cast<std::uint32_t>(consumed);
|
||||||
}
|
}
|
||||||
return pushed; }();
|
return pushed;
|
||||||
|
}();
|
||||||
return finish_stream(status);
|
return finish_stream(status);
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -149,6 +154,11 @@ joc_error JOC_CALL joc_stream_status(const joc_stream* stream, joc_stream_status
|
|||||||
out->buffered_samples = stream->instance.buffered_samples();
|
out->buffered_samples = stream->instance.buffered_samples();
|
||||||
out->oamd_payloads = info.oamd_payloads;
|
out->oamd_payloads = info.oamd_payloads;
|
||||||
out->oamd_transitions = info.oamd_transitions;
|
out->oamd_transitions = info.oamd_transitions;
|
||||||
|
out->missing_joc_frames = info.missing_joc_frames;
|
||||||
|
out->objects_clamped_frames = info.objects_clamped_frames;
|
||||||
|
out->extra_container_frames = info.extra_container_frames;
|
||||||
|
out->chanmap_pair_mismatch_frames = info.chanmap_pair_mismatch_frames;
|
||||||
|
out->bed_mask_mismatch_frames = info.bed_mask_mismatch_frames;
|
||||||
out->output_channels = info.output_channels;
|
out->output_channels = info.output_channels;
|
||||||
out->ended = info.ended;
|
out->ended = info.ended;
|
||||||
return JOC_OK;
|
return JOC_OK;
|
||||||
|
|||||||
@@ -80,6 +80,7 @@ struct Options {
|
|||||||
bool dry_run = false;
|
bool dry_run = false;
|
||||||
bool quiet = false;
|
bool quiet = false;
|
||||||
bool help = false;
|
bool help = false;
|
||||||
|
bool version = false;
|
||||||
};
|
};
|
||||||
|
|
||||||
const char* kLayoutChoices =
|
const char* kLayoutChoices =
|
||||||
@@ -88,6 +89,8 @@ const char* kLayoutChoices =
|
|||||||
void print_usage() {
|
void print_usage() {
|
||||||
std::printf(
|
std::printf(
|
||||||
"usage: joc_cli [options] input\n"
|
"usage: joc_cli [options] input\n"
|
||||||
|
" -h, --help 显示本帮助\n"
|
||||||
|
" --version 显示版本并退出\n"
|
||||||
"\n"
|
"\n"
|
||||||
"JustOneCacophony (JOC):E-AC-3 JOC → 25ch ADM BWF、扬声器 WAV 或双耳 WAV\n"
|
"JustOneCacophony (JOC):E-AC-3 JOC → 25ch ADM BWF、扬声器 WAV 或双耳 WAV\n"
|
||||||
"\n"
|
"\n"
|
||||||
@@ -210,6 +213,7 @@ void parse_args(const std::vector<std::string>& arguments, Options* options) {
|
|||||||
for (int index = 1; index < argc; ++index) {
|
for (int index = 1; index < argc; ++index) {
|
||||||
const std::string arg = arguments[static_cast<std::size_t>(index)];
|
const std::string arg = arguments[static_cast<std::size_t>(index)];
|
||||||
if (arg == "-h" || arg == "--help") { options->help = true; }
|
if (arg == "-h" || arg == "--help") { options->help = true; }
|
||||||
|
else if (arg == "--version") { options->version = true; }
|
||||||
else if (arg == "-o" || arg == "--output") { options->output = require_value(arguments, &index); }
|
else if (arg == "-o" || arg == "--output") { options->output = require_value(arguments, &index); }
|
||||||
else if (arg == "--speaker-output") { options->speaker_output = require_value(arguments, &index); }
|
else if (arg == "--speaker-output") { options->speaker_output = require_value(arguments, &index); }
|
||||||
else if (arg == "--binaural-output") { options->binaural_output = require_value(arguments, &index); }
|
else if (arg == "--binaural-output") { options->binaural_output = require_value(arguments, &index); }
|
||||||
@@ -530,6 +534,11 @@ int main(int argc, char** argv) {
|
|||||||
std::fprintf(stderr, "joc_cli: error: %s\n", error.what());
|
std::fprintf(stderr, "joc_cli: error: %s\n", error.what());
|
||||||
return 2;
|
return 2;
|
||||||
}
|
}
|
||||||
|
if (options.version) {
|
||||||
|
std::printf("joc_cli %s (joc_core ABI %u)\n", joc_version_string(),
|
||||||
|
static_cast<unsigned>(joc_abi_version()));
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
if (options.help) {
|
if (options.help) {
|
||||||
print_usage();
|
print_usage();
|
||||||
return 0;
|
return 0;
|
||||||
|
|||||||
@@ -7,9 +7,111 @@
|
|||||||
namespace joc::eac3 {
|
namespace joc::eac3 {
|
||||||
|
|
||||||
namespace {
|
namespace {
|
||||||
|
|
||||||
constexpr std::size_t kHeaderBytes = 4;
|
constexpr std::size_t kHeaderBytes = 4;
|
||||||
|
constexpr std::size_t kHeaderBytesAc3 = 6;
|
||||||
|
|
||||||
|
// AC-3 syncframe length in 16-bit words, indexed by fscod (0 = 48 kHz,
|
||||||
|
// 1 = 44.1 kHz, 2 = 32 kHz) and then frmsizecod (A/52 5.4.1.2).
|
||||||
|
constexpr std::uint16_t kAc3FrameWords[3][38] = {
|
||||||
|
{64, 64, 80, 80, 96, 96, 112, 112, 128, 128, 160, 160, 192, 192, 224, 224,
|
||||||
|
256, 256, 320, 320, 384, 384, 448, 448, 512, 512, 640, 640, 768, 768,
|
||||||
|
896, 896, 1024, 1024, 1152, 1152, 1280, 1280},
|
||||||
|
{69, 70, 87, 88, 104, 105, 121, 122, 139, 140, 174, 175, 208, 209, 243, 244,
|
||||||
|
278, 278, 348, 348, 417, 418, 487, 487, 557, 557, 696, 696, 835, 835,
|
||||||
|
975, 975, 1114, 1114, 1253, 1253, 1393, 1393},
|
||||||
|
{96, 96, 120, 120, 144, 144, 168, 168, 192, 192, 240, 240, 288, 288, 336, 336,
|
||||||
|
384, 384, 480, 480, 576, 576, 672, 672, 768, 768, 960, 960, 1152, 1152,
|
||||||
|
1344, 1344, 1536, 1536, 1728, 1728, 1920, 1920},
|
||||||
|
};
|
||||||
|
|
||||||
|
std::uint32_t read_bits(const std::uint8_t* data, std::size_t start, std::size_t count) {
|
||||||
|
std::uint32_t value = 0;
|
||||||
|
for (std::size_t index = start; index < start + count; ++index) {
|
||||||
|
const std::uint32_t bit = (data[index >> 3] >> (7u - (index & 7u))) & 1u;
|
||||||
|
value = (value << 1) | bit;
|
||||||
|
}
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
|
||||||
} // namespace
|
} // namespace
|
||||||
|
|
||||||
|
bool parse_syncframe_header(const std::uint8_t* data, std::size_t size, std::size_t offset,
|
||||||
|
Frame* out) {
|
||||||
|
if (data == nullptr || offset + kHeaderBytesAc3 > size) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
if (static_cast<std::uint16_t>((static_cast<std::uint16_t>(data[offset]) << 8) |
|
||||||
|
data[offset + 1]) != FrameReader::kSyncword) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
Frame frame;
|
||||||
|
frame.data = data + offset;
|
||||||
|
frame.offset = offset;
|
||||||
|
const std::size_t base = offset * 8u;
|
||||||
|
const std::uint32_t bsid = read_bits(data, base + 40u, 5u);
|
||||||
|
frame.bsid = static_cast<std::uint8_t>(bsid);
|
||||||
|
|
||||||
|
if (bsid <= 8u) {
|
||||||
|
frame.codec = 0;
|
||||||
|
const std::uint32_t fscod = read_bits(data, base + 32u, 2u);
|
||||||
|
const std::uint32_t frmsizecod = read_bits(data, base + 34u, 6u);
|
||||||
|
if (fscod > 2u || frmsizecod >= 38u) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
frame.size = static_cast<std::size_t>(kAc3FrameWords[fscod][frmsizecod]) * 2u;
|
||||||
|
frame.acmod = static_cast<std::uint8_t>(read_bits(data, base + 48u, 3u));
|
||||||
|
std::size_t bit = 51u;
|
||||||
|
if ((frame.acmod & 0x1u) != 0u && frame.acmod != 0x1u) {
|
||||||
|
bit += 2u; // cmixlev
|
||||||
|
}
|
||||||
|
if ((frame.acmod & 0x4u) != 0u) {
|
||||||
|
bit += 2u; // surmixlev
|
||||||
|
}
|
||||||
|
if (frame.acmod == 0x2u) {
|
||||||
|
bit += 2u; // dsurmod
|
||||||
|
}
|
||||||
|
frame.lfeon = static_cast<std::uint8_t>(read_bits(data, base + bit, 1u));
|
||||||
|
if (out != nullptr) {
|
||||||
|
*out = frame;
|
||||||
|
}
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
frame.codec = 1;
|
||||||
|
frame.strmtyp = static_cast<std::uint8_t>(read_bits(data, base + 16u, 2u));
|
||||||
|
frame.substreamid = static_cast<std::uint8_t>(read_bits(data, base + 18u, 3u));
|
||||||
|
const std::uint32_t frmsiz = read_bits(data, base + 21u, 11u);
|
||||||
|
frame.size = (static_cast<std::size_t>(frmsiz) + 1u) * 2u;
|
||||||
|
// fscod==3 also consumes two bits (fscod2), so acmod always starts at bit 36.
|
||||||
|
frame.acmod = static_cast<std::uint8_t>(read_bits(data, base + 36u, 3u));
|
||||||
|
frame.lfeon = static_cast<std::uint8_t>(read_bits(data, base + 39u, 1u));
|
||||||
|
std::size_t bit = 45u + 5u; // bsid, then dialnorm
|
||||||
|
const std::uint32_t compre = read_bits(data, base + bit, 1u);
|
||||||
|
++bit;
|
||||||
|
if (compre != 0u) {
|
||||||
|
bit += 8u; // compr
|
||||||
|
}
|
||||||
|
if (frame.acmod == 0u) {
|
||||||
|
bit += 5u; // dialnorm2
|
||||||
|
const std::uint32_t compr2 = read_bits(data, base + bit, 1u);
|
||||||
|
++bit;
|
||||||
|
if (compr2 != 0u) {
|
||||||
|
bit += 8u;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (frame.strmtyp == 1u) {
|
||||||
|
if (read_bits(data, base + bit, 1u) != 0u) {
|
||||||
|
frame.has_chanmap = 1;
|
||||||
|
frame.chanmap = static_cast<std::uint16_t>(read_bits(data, base + bit + 1u, 16u));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (out != nullptr) {
|
||||||
|
*out = frame;
|
||||||
|
}
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
void FrameReader::push(const std::uint8_t* data, std::size_t size) {
|
void FrameReader::push(const std::uint8_t* data, std::size_t size) {
|
||||||
if (failed_ || data == nullptr || size == 0) {
|
if (failed_ || data == nullptr || size == 0) {
|
||||||
return;
|
return;
|
||||||
@@ -45,44 +147,43 @@ FrameReader::Next FrameReader::next(Frame* out) {
|
|||||||
}
|
}
|
||||||
const std::uint8_t* p = buffer_.data() + consumed_;
|
const std::uint8_t* p = buffer_.data() + consumed_;
|
||||||
|
|
||||||
// The reference implementation rejects a frame whose header does not fit,
|
// A frame whose header does not fit is rejected rather than silently
|
||||||
// rather than silently resynchronising on the next 0x0B77.
|
// resynchronised on the next 0x0B77.
|
||||||
if (available < kHeaderBytes) {
|
if (available < kHeaderBytes) {
|
||||||
if (finished_) {
|
if (finished_) {
|
||||||
fail(JOC_ERR_EAC3_SYNCFRAME, "E-AC-3 syncframe header truncated at end of input");
|
fail(JOC_ERR_EAC3_SYNCFRAME, "syncframe header truncated at end of input");
|
||||||
return Next::Fail;
|
return Next::Fail;
|
||||||
}
|
}
|
||||||
return Next::End;
|
return Next::End;
|
||||||
}
|
}
|
||||||
|
|
||||||
const std::uint16_t syncword = static_cast<std::uint16_t>((static_cast<std::uint16_t>(p[0]) << 8) | p[1]);
|
Frame frame;
|
||||||
if (syncword != kSyncword) {
|
if (!parse_syncframe_header(p, available, 0, &frame) || frame.size == 0u) {
|
||||||
fail(JOC_ERR_EAC3_SYNCFRAME, "invalid E-AC-3 syncword (silent resynchronisation is not allowed)");
|
if (available < kHeaderBytesAc3 && !finished_) {
|
||||||
|
return Next::End;
|
||||||
|
}
|
||||||
|
fail(JOC_ERR_EAC3_SYNCFRAME,
|
||||||
|
"invalid syncframe header (silent resynchronisation is not allowed)");
|
||||||
return Next::Fail;
|
return Next::Fail;
|
||||||
}
|
}
|
||||||
|
|
||||||
// frmsiz: 11 bits spread over the low 3 bits of byte 2 and all of byte 3,
|
if (frame.size > available) {
|
||||||
const std::size_t words =
|
|
||||||
static_cast<std::size_t>(((p[2] & 0x07u) << 8) | p[3]) + 1u;
|
|
||||||
const std::size_t frame_bytes = words * 2u;
|
|
||||||
|
|
||||||
if (frame_bytes > available) {
|
|
||||||
if (!finished_) {
|
if (!finished_) {
|
||||||
return Next::End;
|
return Next::End;
|
||||||
}
|
}
|
||||||
fail(JOC_ERR_BITSTREAM_TRUNCATED,
|
fail(JOC_ERR_BITSTREAM_TRUNCATED,
|
||||||
"last E-AC-3 syncframe extends past end of input (declared " +
|
"last syncframe extends past end of input (declared " +
|
||||||
std::to_string(frame_bytes) + " bytes, remaining " +
|
std::to_string(frame.size) + " bytes, remaining " +
|
||||||
std::to_string(available) + ")");
|
std::to_string(available) + ")");
|
||||||
return Next::Fail;
|
return Next::Fail;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (out != nullptr) {
|
if (out != nullptr) {
|
||||||
out->data = p;
|
frame.data = p;
|
||||||
out->size = frame_bytes;
|
frame.offset = base_offset_ + consumed_;
|
||||||
out->offset = base_offset_ + consumed_;
|
*out = frame;
|
||||||
}
|
}
|
||||||
consumed_ += frame_bytes;
|
consumed_ += frame.size;
|
||||||
stream_offset_ = base_offset_ + consumed_;
|
stream_offset_ = base_offset_ + consumed_;
|
||||||
++frames_emitted_;
|
++frames_emitted_;
|
||||||
return Next::Ok;
|
return Next::Ok;
|
||||||
@@ -93,20 +194,15 @@ joc_error FrameReader::frame_bytes(const std::uint8_t* data, std::size_t size, s
|
|||||||
if (data == nullptr || out_frame_bytes == nullptr) {
|
if (data == nullptr || out_frame_bytes == nullptr) {
|
||||||
return JOC_ERR_INVALID_ARGUMENT;
|
return JOC_ERR_INVALID_ARGUMENT;
|
||||||
}
|
}
|
||||||
if (offset + kHeaderBytes > size) {
|
Frame frame;
|
||||||
return JOC_ERR_EAC3_SYNCFRAME;
|
if (!parse_syncframe_header(data, size, offset, &frame)) {
|
||||||
|
return offset + kHeaderBytes > size ? JOC_ERR_EAC3_SYNCFRAME
|
||||||
|
: JOC_ERR_EAC3_SYNCFRAME;
|
||||||
}
|
}
|
||||||
if (static_cast<std::uint16_t>((static_cast<std::uint16_t>(data[offset]) << 8) | data[offset + 1]) !=
|
if (offset + frame.size > size) {
|
||||||
kSyncword) {
|
|
||||||
return JOC_ERR_EAC3_SYNCFRAME;
|
|
||||||
}
|
|
||||||
const std::size_t words =
|
|
||||||
static_cast<std::size_t>(((data[offset + 2] & 0x07u) << 8) | data[offset + 3]) + 1u;
|
|
||||||
const std::size_t frame_bytes = words * 2u;
|
|
||||||
if (offset + frame_bytes > size) {
|
|
||||||
return JOC_ERR_BITSTREAM_TRUNCATED;
|
return JOC_ERR_BITSTREAM_TRUNCATED;
|
||||||
}
|
}
|
||||||
*out_frame_bytes = frame_bytes;
|
*out_frame_bytes = frame.size;
|
||||||
return JOC_OK;
|
return JOC_OK;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -1,4 +1,3 @@
|
|||||||
|
|
||||||
#pragma once
|
#pragma once
|
||||||
|
|
||||||
#include <cstddef>
|
#include <cstddef>
|
||||||
@@ -10,12 +9,34 @@
|
|||||||
|
|
||||||
namespace joc::eac3 {
|
namespace joc::eac3 {
|
||||||
|
|
||||||
|
// One syncframe plus its transport-layer (L2) header. codec/strmtyp/substreamid
|
||||||
|
// identify the substream: within one audio frame each combination appears once.
|
||||||
struct Frame {
|
struct Frame {
|
||||||
const std::uint8_t* data = nullptr;
|
const std::uint8_t* data = nullptr;
|
||||||
std::size_t size = 0;
|
std::size_t size = 0;
|
||||||
std::size_t offset = 0; // byte offset of the frame start in the fed stream
|
std::size_t offset = 0; // byte offset of the frame start in the fed stream
|
||||||
|
std::uint8_t codec = 0; // 0 = AC-3, 1 = E-AC-3
|
||||||
|
std::uint8_t strmtyp = 0;
|
||||||
|
std::uint8_t substreamid = 0;
|
||||||
|
std::uint8_t acmod = 0;
|
||||||
|
std::uint8_t lfeon = 0;
|
||||||
|
std::uint8_t bsid = 0;
|
||||||
|
std::uint8_t has_chanmap = 0;
|
||||||
|
std::uint16_t chanmap = 0;
|
||||||
|
|
||||||
|
bool same_stream(const Frame& other) const {
|
||||||
|
return codec == other.codec && strmtyp == other.strmtyp &&
|
||||||
|
substreamid == other.substreamid;
|
||||||
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
|
// Parses the syncframe header at `offset`. Returns false when the syncword is
|
||||||
|
// missing or the declared size cannot be derived. `out` may be null to query
|
||||||
|
// only the size. AC-3 and E-AC-3 are told apart by bsid (bits 40..44): <= 8 is
|
||||||
|
// AC-3, whose frame size comes from fscod/frmsizecod, everything above is E-AC-3.
|
||||||
|
bool parse_syncframe_header(const std::uint8_t* data, std::size_t size, std::size_t offset,
|
||||||
|
Frame* out);
|
||||||
|
|
||||||
class FrameReader {
|
class FrameReader {
|
||||||
public:
|
public:
|
||||||
enum class Next {
|
enum class Next {
|
||||||
|
|||||||
@@ -113,12 +113,16 @@ Status parse_at(const std::uint8_t* data, std::size_t size, std::size_t start_bi
|
|||||||
: syntax_fail(reader.error_message());
|
: syntax_fail(reader.error_message());
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
std::uint8_t group_id = 0;
|
||||||
|
std::uint8_t has_group_id = 0;
|
||||||
if (reader.read(1) != 0u) {
|
if (reader.read(1) != 0u) {
|
||||||
std::uint32_t ignored = 0;
|
std::uint32_t value = 0;
|
||||||
if (!bits::variable_bits(reader, 2, 8, &ignored)) {
|
if (!bits::variable_bits(reader, 2, 8, &value)) {
|
||||||
return reader.error() == JOC_ERR_BITSTREAM_TRUNCATED ? truncated_fail(reader)
|
return reader.error() == JOC_ERR_BITSTREAM_TRUNCATED ? truncated_fail(reader)
|
||||||
: syntax_fail(reader.error_message());
|
: syntax_fail(reader.error_message());
|
||||||
}
|
}
|
||||||
|
group_id = static_cast<std::uint8_t>(value);
|
||||||
|
has_group_id = 1;
|
||||||
}
|
}
|
||||||
if (reader.read(1) != 0u) {
|
if (reader.read(1) != 0u) {
|
||||||
if (!reader.skip(8)) {
|
if (!reader.skip(8)) {
|
||||||
@@ -160,6 +164,8 @@ Status parse_at(const std::uint8_t* data, std::size_t size, std::size_t start_bi
|
|||||||
Payload& entry = container.payloads[container.payload_count++];
|
Payload& entry = container.payloads[container.payload_count++];
|
||||||
entry.id = static_cast<std::uint8_t>(payload_id);
|
entry.id = static_cast<std::uint8_t>(payload_id);
|
||||||
entry.sample_offset = sample_offset;
|
entry.sample_offset = sample_offset;
|
||||||
|
entry.group_id = group_id;
|
||||||
|
entry.has_group_id = has_group_id;
|
||||||
entry.bit_offset = reader.position();
|
entry.bit_offset = reader.position();
|
||||||
entry.size = payload_size;
|
entry.size = payload_size;
|
||||||
|
|
||||||
@@ -206,7 +212,8 @@ void marker_offsets(const std::uint8_t* data, std::size_t size, std::vector<std:
|
|||||||
std::sort(out->begin(), out->end());
|
std::sort(out->begin(), out->end());
|
||||||
}
|
}
|
||||||
|
|
||||||
Status find_joc_emdf(const std::uint8_t* data, std::size_t size, Container* out) {
|
Status find_joc_emdf(const std::uint8_t* data, std::size_t size, Container* out,
|
||||||
|
ContainerPredicate usable, bool* ignored_extra) {
|
||||||
if (data == nullptr || out == nullptr) {
|
if (data == nullptr || out == nullptr) {
|
||||||
return Status::fail(JOC_ERR_INVALID_ARGUMENT, stage::kEmdf, "null buffer or output");
|
return Status::fail(JOC_ERR_INVALID_ARGUMENT, stage::kEmdf, "null buffer or output");
|
||||||
}
|
}
|
||||||
@@ -264,6 +271,31 @@ Status find_joc_emdf(const std::uint8_t* data, std::size_t size, Container* out)
|
|||||||
}
|
}
|
||||||
|
|
||||||
if (top_level.size() != 1u) {
|
if (top_level.size() != 1u) {
|
||||||
|
// Several containers can be genuine: a real stream carries a second
|
||||||
|
// container whose ID14 is a different structure altogether. The predicate
|
||||||
|
// tells those apart; what it leaves ambiguous stays an error.
|
||||||
|
if (usable != nullptr) {
|
||||||
|
int best = 0;
|
||||||
|
const Container* winner = nullptr;
|
||||||
|
int winners = 0;
|
||||||
|
for (const Container& candidate : top_level) {
|
||||||
|
const int score = usable(data, size, candidate);
|
||||||
|
if (score > best) {
|
||||||
|
best = score;
|
||||||
|
winner = &candidate;
|
||||||
|
winners = 1;
|
||||||
|
} else if (score == best && score > 0) {
|
||||||
|
++winners;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (best > 0 && winners == 1 && winner != nullptr) {
|
||||||
|
if (ignored_extra != nullptr) {
|
||||||
|
*ignored_extra = true;
|
||||||
|
}
|
||||||
|
*out = *winner;
|
||||||
|
return Status::success();
|
||||||
|
}
|
||||||
|
}
|
||||||
return Status::fail(JOC_ERR_EMDF_TRANSPORT, stage::kEmdf,
|
return Status::fail(JOC_ERR_EMDF_TRANSPORT, stage::kEmdf,
|
||||||
"multiple top-level JOC EMDF containers (" +
|
"multiple top-level JOC EMDF containers (" +
|
||||||
std::to_string(top_level.size()) +
|
std::to_string(top_level.size()) +
|
||||||
@@ -273,6 +305,31 @@ Status find_joc_emdf(const std::uint8_t* data, std::size_t size, Container* out)
|
|||||||
return Status::success();
|
return Status::success();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
Status find_joc_emdf_optional(const std::uint8_t* data, std::size_t size, bool* present,
|
||||||
|
Container* out, ContainerPredicate usable, bool* ignored_extra) {
|
||||||
|
if (present == nullptr) {
|
||||||
|
return Status::fail(JOC_ERR_INVALID_ARGUMENT, stage::kEmdf, "null presence flag");
|
||||||
|
}
|
||||||
|
const Status status = find_joc_emdf(data, size, out, usable, ignored_extra);
|
||||||
|
if (status.ok()) {
|
||||||
|
*present = true;
|
||||||
|
return status;
|
||||||
|
}
|
||||||
|
if (status.code() != JOC_ERR_EMDF_TRANSPORT) {
|
||||||
|
return status;
|
||||||
|
}
|
||||||
|
// find_joc_emdf reports "no usable container in this syncframe" and "several
|
||||||
|
// usable containers" with the same code. Only the former is normal for a
|
||||||
|
// core syncframe (audio data can contain bytes that look like a marker);
|
||||||
|
// an ambiguous frame stays an error.
|
||||||
|
static constexpr const char* kAmbiguous = "multiple top-level";
|
||||||
|
if (status.message().rfind(kAmbiguous, 0) == 0) {
|
||||||
|
return status;
|
||||||
|
}
|
||||||
|
*present = false;
|
||||||
|
return Status::success();
|
||||||
|
}
|
||||||
|
|
||||||
void extract_container_bytes(const std::uint8_t* data, std::size_t size, const Container& container,
|
void extract_container_bytes(const std::uint8_t* data, std::size_t size, const Container& container,
|
||||||
std::vector<std::uint8_t>* out) {
|
std::vector<std::uint8_t>* out) {
|
||||||
out->assign(container.raw_size, 0u);
|
out->assign(container.raw_size, 0u);
|
||||||
|
|||||||
@@ -20,6 +20,11 @@ struct Payload {
|
|||||||
std::uint16_t sample_offset = 0;
|
std::uint16_t sample_offset = 0;
|
||||||
std::size_t bit_offset = 0; // MSB-first bit position of the payload bytes
|
std::size_t bit_offset = 0; // MSB-first bit position of the payload bytes
|
||||||
std::size_t size = 0; // payload byte count
|
std::size_t size = 0; // payload byte count
|
||||||
|
// Payload configuration data (ETSI TS 102 366 H.2.2.3). Spec section 8.2 and
|
||||||
|
// its Table 56 associate the OAMD and JOC payloads of one frame by an equal
|
||||||
|
// group id, which is how several containers in one syncframe are told apart.
|
||||||
|
std::uint8_t group_id = 0;
|
||||||
|
std::uint8_t has_group_id = 0;
|
||||||
};
|
};
|
||||||
|
|
||||||
struct Container {
|
struct Container {
|
||||||
@@ -43,7 +48,26 @@ Status parse_at(const std::uint8_t* data, std::size_t size, std::size_t start_bi
|
|||||||
// All candidate 0x5838 bit offsets over the eight alignments, ascending.
|
// All candidate 0x5838 bit offsets over the eight alignments, ascending.
|
||||||
void marker_offsets(const std::uint8_t* data, std::size_t size, std::vector<std::size_t>* out);
|
void marker_offsets(const std::uint8_t* data, std::size_t size, std::vector<std::size_t>* out);
|
||||||
|
|
||||||
Status find_joc_emdf(const std::uint8_t* data, std::size_t size, Container* out);
|
// Scores how well a candidate container can serve as the frame's metadata when a
|
||||||
|
// syncframe carries more than one: 0 = not at all, higher = more credible. A null
|
||||||
|
// predicate keeps the strict behaviour: several top-level candidates are an error,
|
||||||
|
// never a choice.
|
||||||
|
using ContainerPredicate = int (*)(const std::uint8_t* data, std::size_t size,
|
||||||
|
const Container& container);
|
||||||
|
|
||||||
|
// When a syncframe holds several top-level candidates and `usable` leaves exactly
|
||||||
|
// one with the highest non-zero score, that one is returned and `ignored_extra` is
|
||||||
|
// set; otherwise the frame stays an ambiguity error.
|
||||||
|
Status find_joc_emdf(const std::uint8_t* data, std::size_t size, Container* out,
|
||||||
|
ContainerPredicate usable = nullptr, bool* ignored_extra = nullptr);
|
||||||
|
|
||||||
|
// Like find_joc_emdf(), but a syncframe that carries no EMDF marker at all is a
|
||||||
|
// normal "absent" result rather than an error. A syncframe that does carry
|
||||||
|
// markers but no usable JOC container still fails, so a real transport problem
|
||||||
|
// is never mistaken for a core substream.
|
||||||
|
Status find_joc_emdf_optional(const std::uint8_t* data, std::size_t size, bool* present,
|
||||||
|
Container* out, ContainerPredicate usable = nullptr,
|
||||||
|
bool* ignored_extra = nullptr);
|
||||||
|
|
||||||
// Extract the container's bytes exactly as the bit reader sees them (identical
|
// Extract the container's bytes exactly as the bit reader sees them (identical
|
||||||
// to a memcpy for byte-aligned containers).
|
// to a memcpy for byte-aligned containers).
|
||||||
|
|||||||
@@ -21,8 +21,8 @@ bool variable_bits(BitReader& reader, unsigned width, unsigned max_groups, std::
|
|||||||
}
|
}
|
||||||
value = (value + 1u) << width;
|
value = (value + 1u) << width;
|
||||||
}
|
}
|
||||||
// Same failure mode as the reference implementation: an extension chain
|
// An extension chain that never terminates is a syntax error, not a
|
||||||
// that never terminates is a syntax error, not a truncation.
|
// truncation.
|
||||||
reader.fail(JOC_ERR_EMDF_SYNTAX, "variable_bits extension groups exceeded");
|
reader.fail(JOC_ERR_EMDF_SYNTAX, "variable_bits extension groups exceeded");
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -33,6 +33,22 @@ private:
|
|||||||
std::string message_;
|
std::string message_;
|
||||||
};
|
};
|
||||||
|
|
||||||
|
// Structured detail of the most recent failing call, as returned by
|
||||||
|
// joc_last_error_detail(). It is one instance per thread across the whole
|
||||||
|
// library, so every C entry point -- the task API and the streaming API alike --
|
||||||
|
// reports through the same string.
|
||||||
|
inline thread_local std::string last_error_detail;
|
||||||
|
|
||||||
|
inline void record_error_detail(const Status& status) {
|
||||||
|
if (status.ok()) {
|
||||||
|
last_error_detail.clear();
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
last_error_detail.assign(status.stage());
|
||||||
|
last_error_detail.append(": ");
|
||||||
|
last_error_detail.append(status.message());
|
||||||
|
}
|
||||||
|
|
||||||
// Stage names are kept as plain literals so that C++ and the Python frontend
|
// Stage names are kept as plain literals so that C++ and the Python frontend
|
||||||
namespace stage {
|
namespace stage {
|
||||||
inline constexpr const char* kFoundation = "foundation";
|
inline constexpr const char* kFoundation = "foundation";
|
||||||
|
|||||||
@@ -199,28 +199,25 @@ Status parse_id14(const std::uint8_t* payload, std::size_t payload_size, joc_fra
|
|||||||
out->num_objects_bits = static_cast<std::uint8_t>(reader.read(6));
|
out->num_objects_bits = static_cast<std::uint8_t>(reader.read(6));
|
||||||
out->ext_config_idx = static_cast<std::uint8_t>(reader.read(3));
|
out->ext_config_idx = static_cast<std::uint8_t>(reader.read(3));
|
||||||
|
|
||||||
const std::uint32_t n_objects = static_cast<std::uint32_t>(out->num_objects_bits) + 1u;
|
const std::uint32_t declared_objects = static_cast<std::uint32_t>(out->num_objects_bits) + 1u;
|
||||||
const std::int16_t n_channels = num_channels_for_config(out->dmx_config_idx);
|
const std::int16_t n_channels = num_channels_for_config(out->dmx_config_idx);
|
||||||
if (n_channels < 0) {
|
if (n_channels < 0) {
|
||||||
return syntax_fail("unknown JOC downmix configuration " +
|
return syntax_fail("unknown JOC downmix configuration " +
|
||||||
std::to_string(out->dmx_config_idx));
|
std::to_string(out->dmx_config_idx));
|
||||||
}
|
}
|
||||||
out->n_channels = static_cast<std::uint8_t>(n_channels);
|
out->n_channels = static_cast<std::uint8_t>(n_channels);
|
||||||
if (n_objects > JOC_MAX_OBJECTS) {
|
// A declared object count above 15 is clamped to 15: the frame is parsed for
|
||||||
// The reference implementation has no check here and fails later inside
|
// 15 objects only, and the clamp is reported separately.
|
||||||
// NumPy; the port reports it explicitly (plan 28.2).
|
out->objects_clamped = declared_objects > JOC_MAX_OBJECTS ? 1u : 0u;
|
||||||
return Status::fail(JOC_ERR_JOC_UNSUPPORTED_VARIANT, stage::kJoc,
|
const std::uint32_t n_objects =
|
||||||
"JOC frame declares " + std::to_string(n_objects) +
|
std::min<std::uint32_t>(declared_objects, JOC_MAX_OBJECTS);
|
||||||
" objects, the ABI supports at most " +
|
|
||||||
std::to_string(static_cast<int>(JOC_MAX_OBJECTS)));
|
|
||||||
}
|
|
||||||
out->n_objects = static_cast<std::uint8_t>(n_objects);
|
out->n_objects = static_cast<std::uint8_t>(n_objects);
|
||||||
|
|
||||||
out->clipgain_x_bits = static_cast<std::uint8_t>(reader.read(3));
|
out->clipgain_x_bits = static_cast<std::uint8_t>(reader.read(3));
|
||||||
out->clipgain_y_bits = static_cast<std::uint8_t>(reader.read(5));
|
out->clipgain_y_bits = static_cast<std::uint8_t>(reader.read(5));
|
||||||
out->seq_count = reader.read(10);
|
out->seq_count = reader.read(10);
|
||||||
// clipgain = 1 + (y/32) * 2^(x-4). The reference multiplies by an exact
|
// clipgain = 1 + (y/32) * 2^(x-4); ldexp builds the power of two exactly
|
||||||
// exactly for the whole legal range.
|
// over the whole legal range.
|
||||||
out->clipgain = 1.0 + static_cast<double>(out->clipgain_y_bits) / 32.0 *
|
out->clipgain = 1.0 + static_cast<double>(out->clipgain_y_bits) / 32.0 *
|
||||||
std::ldexp(1.0, static_cast<int>(out->clipgain_x_bits) - 4);
|
std::ldexp(1.0, static_cast<int>(out->clipgain_x_bits) - 4);
|
||||||
|
|
||||||
@@ -361,13 +358,36 @@ Status parse_id14(const std::uint8_t* payload, std::size_t payload_size, joc_fra
|
|||||||
return Status::success();
|
return Status::success();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
int score_container_as_joc(const std::uint8_t* data, std::size_t size,
|
||||||
|
const emdf::Container& container) {
|
||||||
|
const emdf::Payload* payload = container.find(emdf::kIdJoc);
|
||||||
|
const emdf::Payload* oamd = container.find(emdf::kIdOamd);
|
||||||
|
if (payload == nullptr || oamd == nullptr) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
bool parses = false;
|
||||||
|
std::vector<std::uint8_t> bytes;
|
||||||
|
if (emdf::extract_payload_bytes(data, size, *payload, &bytes).ok()) {
|
||||||
|
joc_frame_params params;
|
||||||
|
FrameSymbols symbols;
|
||||||
|
parses = parse_id14(bytes.data(), bytes.size(), ¶ms, &symbols).ok();
|
||||||
|
}
|
||||||
|
const bool associated = oamd->has_group_id != 0u && payload->has_group_id != 0u &&
|
||||||
|
oamd->group_id == payload->group_id;
|
||||||
|
if (associated && parses) {
|
||||||
|
return 2;
|
||||||
|
}
|
||||||
|
return parses ? 1 : 0;
|
||||||
|
}
|
||||||
|
|
||||||
Status parse_eac3_frame(const std::uint8_t* frame, std::size_t frame_size, joc_frame_params* out,
|
Status parse_eac3_frame(const std::uint8_t* frame, std::size_t frame_size, joc_frame_params* out,
|
||||||
emdf::Container* container, FrameSymbols* symbols) {
|
emdf::Container* container, FrameSymbols* symbols) {
|
||||||
if (frame == nullptr || out == nullptr) {
|
if (frame == nullptr || out == nullptr) {
|
||||||
return Status::fail(JOC_ERR_INVALID_ARGUMENT, stage::kJoc, "null frame or output");
|
return Status::fail(JOC_ERR_INVALID_ARGUMENT, stage::kJoc, "null frame or output");
|
||||||
}
|
}
|
||||||
emdf::Container local;
|
emdf::Container local;
|
||||||
const Status status = emdf::find_joc_emdf(frame, frame_size, &local);
|
const Status status =
|
||||||
|
emdf::find_joc_emdf(frame, frame_size, &local, &score_container_as_joc, nullptr);
|
||||||
if (!status.ok()) {
|
if (!status.ok()) {
|
||||||
return status;
|
return status;
|
||||||
}
|
}
|
||||||
@@ -412,4 +432,516 @@ Status check_id14_padding(const std::uint8_t* payload, std::size_t payload_size,
|
|||||||
return Status::success();
|
return Status::success();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void make_silent_frame_params(joc_frame_params* out) {
|
||||||
|
if (out == nullptr) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
std::memset(out, 0, sizeof(*out));
|
||||||
|
out->struct_size = sizeof(joc_frame_params);
|
||||||
|
out->struct_version = JOC_FRAME_PARAMS_VERSION;
|
||||||
|
out->dmx_config_idx = 0u;
|
||||||
|
out->n_channels = static_cast<std::uint8_t>(JOC_CORE_CHANNELS);
|
||||||
|
out->n_objects = static_cast<std::uint8_t>(JOC_MAX_OBJECTS);
|
||||||
|
out->present_mask = (1u << JOC_MAX_OBJECTS) - 1u;
|
||||||
|
out->clipgain = 1.0;
|
||||||
|
for (unsigned object = 0; object < JOC_MAX_OBJECTS; ++object) {
|
||||||
|
out->objects[object].present = 1u;
|
||||||
|
out->objects[object].num_bands_idx = 0u; // one parameter band
|
||||||
|
out->objects[object].n_bands = 1u;
|
||||||
|
out->objects[object].sparse = 0u;
|
||||||
|
out->objects[object].quant_idx = 0u;
|
||||||
|
out->objects[object].slope_idx = 0u;
|
||||||
|
out->objects[object].num_dpoints_bits = 0u;
|
||||||
|
out->objects[object].n_dpoints = 1u;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
// Channel identity / bed layout (spec sections 3, 10.2, 10.4)
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
namespace {
|
||||||
|
|
||||||
|
struct PositionBit {
|
||||||
|
Position position;
|
||||||
|
std::uint32_t bit;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Position -> ffmpeg channel bit. A decoded bed frame lists its channels in
|
||||||
|
// ascending bit order, so sorting the positions by bit reproduces the decoder's
|
||||||
|
// channel order without asking the decoder.
|
||||||
|
constexpr PositionBit kPositionBits[] = {
|
||||||
|
{Position::kLeft, 0x1u},
|
||||||
|
{Position::kRight, 0x2u},
|
||||||
|
{Position::kCenter, 0x4u},
|
||||||
|
{Position::kLfe, 0x8u},
|
||||||
|
{Position::kLeftRearSurround, 0x10u},
|
||||||
|
{Position::kRightRearSurround, 0x20u},
|
||||||
|
{Position::kCenterSurround, 0x100u},
|
||||||
|
{Position::kLeftSurround, 0x200u},
|
||||||
|
{Position::kRightSurround, 0x400u},
|
||||||
|
{Position::kTopSurround, 0x800u},
|
||||||
|
{Position::kVerticalHeightLeft, 0x1000u},
|
||||||
|
{Position::kVerticalHeightCenter, 0x2000u},
|
||||||
|
{Position::kVerticalHeightRight, 0x4000u},
|
||||||
|
{Position::kTopSurroundLeft, 0x8000u},
|
||||||
|
{Position::kTopSurroundRight, 0x20000u},
|
||||||
|
};
|
||||||
|
|
||||||
|
std::uint32_t position_bit(Position position) {
|
||||||
|
for (const PositionBit& entry : kPositionBits) {
|
||||||
|
if (entry.position == position) {
|
||||||
|
return entry.bit;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return 0u;
|
||||||
|
}
|
||||||
|
|
||||||
|
void push_unique(std::vector<Position>* positions, Position position) {
|
||||||
|
if (position == Position::kNone) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
for (const Position existing : *positions) {
|
||||||
|
if (existing == position) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
positions->push_back(position);
|
||||||
|
}
|
||||||
|
|
||||||
|
// ADM 10-slot skeleton placement of the extra pair, indexed by joc_dmx_config_idx.
|
||||||
|
constexpr int kExtraPairSlots[5][2] = {
|
||||||
|
{-1, -1}, {6, 7}, {8, 9}, {-1, -1}, {8, 9},
|
||||||
|
};
|
||||||
|
|
||||||
|
Status variant_error(const char* stage_name, const char* name, const std::string& message,
|
||||||
|
std::string* error) {
|
||||||
|
const std::string text = std::string(name) + ": " + message;
|
||||||
|
if (error != nullptr) {
|
||||||
|
*error = text;
|
||||||
|
}
|
||||||
|
return Status::fail(JOC_ERR_JOC_UNSUPPORTED_VARIANT, stage_name, text);
|
||||||
|
}
|
||||||
|
|
||||||
|
std::string position_name(Position position) {
|
||||||
|
switch (position) {
|
||||||
|
case Position::kLeft: return "L";
|
||||||
|
case Position::kRight: return "R";
|
||||||
|
case Position::kCenter: return "C";
|
||||||
|
case Position::kLfe: return "LFE";
|
||||||
|
case Position::kLeftSurround: return "Ls";
|
||||||
|
case Position::kRightSurround: return "Rs";
|
||||||
|
case Position::kLeftRearSurround: return "Lrs";
|
||||||
|
case Position::kRightRearSurround: return "Rrs";
|
||||||
|
case Position::kVerticalHeightLeft: return "Vhl";
|
||||||
|
case Position::kVerticalHeightRight: return "Vhr";
|
||||||
|
case Position::kTopSurroundLeft: return "Lts";
|
||||||
|
case Position::kTopSurroundRight: return "Rts";
|
||||||
|
case Position::kCenterSurround: return "Cs";
|
||||||
|
case Position::kTopSurround: return "Ts";
|
||||||
|
case Position::kVerticalHeightCenter: return "Vhc";
|
||||||
|
case Position::kLfe2: return "LFE2";
|
||||||
|
default: return "?";
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
std::string position_list(const std::vector<Position>& positions) {
|
||||||
|
std::string text = "[";
|
||||||
|
for (std::size_t index = 0; index < positions.size(); ++index) {
|
||||||
|
if (index != 0) {
|
||||||
|
text += ",";
|
||||||
|
}
|
||||||
|
text += position_name(positions[index]);
|
||||||
|
}
|
||||||
|
return text + "]";
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace
|
||||||
|
|
||||||
|
void expand_chanmap(std::uint16_t chanmap, std::vector<Position>* out) {
|
||||||
|
if (out == nullptr) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
// Table E2.5; bit 0 sits in the field's most significant bit.
|
||||||
|
static const Position kSingles[16] = {
|
||||||
|
Position::kLeft, Position::kCenter, Position::kRight,
|
||||||
|
Position::kLeftSurround, Position::kRightSurround, Position::kNone,
|
||||||
|
Position::kNone, Position::kCenterSurround, Position::kTopSurround,
|
||||||
|
Position::kNone, Position::kNone, Position::kNone,
|
||||||
|
Position::kVerticalHeightCenter, Position::kNone, Position::kLfe2,
|
||||||
|
Position::kLfe,
|
||||||
|
};
|
||||||
|
for (int bit = 0; bit < 16; ++bit) {
|
||||||
|
if (((chanmap >> (15 - bit)) & 1u) == 0u) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
switch (bit) {
|
||||||
|
case 5:
|
||||||
|
out->push_back(Position::kLeftSurround);
|
||||||
|
out->push_back(Position::kRightSurround);
|
||||||
|
break;
|
||||||
|
case 6:
|
||||||
|
out->push_back(Position::kLeftRearSurround);
|
||||||
|
out->push_back(Position::kRightRearSurround);
|
||||||
|
break;
|
||||||
|
case 9:
|
||||||
|
case 10:
|
||||||
|
// Lsd/Rsd and Lw/Rw have no JOC counterpart and stay unmapped.
|
||||||
|
break;
|
||||||
|
case 11:
|
||||||
|
out->push_back(Position::kVerticalHeightLeft);
|
||||||
|
out->push_back(Position::kVerticalHeightRight);
|
||||||
|
break;
|
||||||
|
case 13:
|
||||||
|
out->push_back(Position::kTopSurroundLeft);
|
||||||
|
out->push_back(Position::kTopSurroundRight);
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
out->push_back(kSingles[bit]);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void acmod_positions(std::uint8_t acmod, std::vector<Position>* out) {
|
||||||
|
if (out == nullptr) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
switch (acmod) {
|
||||||
|
case 0:
|
||||||
|
case 1:
|
||||||
|
out->push_back(Position::kCenter);
|
||||||
|
break;
|
||||||
|
case 2:
|
||||||
|
out->push_back(Position::kLeft);
|
||||||
|
out->push_back(Position::kRight);
|
||||||
|
break;
|
||||||
|
case 3:
|
||||||
|
out->push_back(Position::kLeft);
|
||||||
|
out->push_back(Position::kCenter);
|
||||||
|
out->push_back(Position::kRight);
|
||||||
|
break;
|
||||||
|
case 4:
|
||||||
|
out->push_back(Position::kLeft);
|
||||||
|
out->push_back(Position::kRight);
|
||||||
|
out->push_back(Position::kCenterSurround);
|
||||||
|
break;
|
||||||
|
case 5:
|
||||||
|
out->push_back(Position::kLeft);
|
||||||
|
out->push_back(Position::kCenter);
|
||||||
|
out->push_back(Position::kRight);
|
||||||
|
out->push_back(Position::kCenterSurround);
|
||||||
|
break;
|
||||||
|
case 6:
|
||||||
|
out->push_back(Position::kLeft);
|
||||||
|
out->push_back(Position::kRight);
|
||||||
|
out->push_back(Position::kLeftSurround);
|
||||||
|
out->push_back(Position::kRightSurround);
|
||||||
|
break;
|
||||||
|
case 7:
|
||||||
|
default:
|
||||||
|
out->push_back(Position::kLeft);
|
||||||
|
out->push_back(Position::kCenter);
|
||||||
|
out->push_back(Position::kRight);
|
||||||
|
out->push_back(Position::kLeftSurround);
|
||||||
|
out->push_back(Position::kRightSurround);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void expected_pair(std::uint8_t dmx_config_idx, std::vector<Position>* out) {
|
||||||
|
if (out == nullptr) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
if (dmx_config_idx == 1u) {
|
||||||
|
out->push_back(Position::kLeftRearSurround);
|
||||||
|
out->push_back(Position::kRightRearSurround);
|
||||||
|
} else if (dmx_config_idx == 2u || dmx_config_idx == 4u) {
|
||||||
|
out->push_back(Position::kVerticalHeightLeft);
|
||||||
|
out->push_back(Position::kVerticalHeightRight);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void chanmap_extra_pair(const std::vector<Position>& core, std::uint16_t chanmap,
|
||||||
|
std::vector<Position>* out) {
|
||||||
|
if (out == nullptr) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
std::vector<Position> declared;
|
||||||
|
expand_chanmap(chanmap, &declared);
|
||||||
|
for (const Position position : declared) {
|
||||||
|
bool in_core = false;
|
||||||
|
for (const Position existing : core) {
|
||||||
|
if (existing == position) {
|
||||||
|
in_core = true;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (!in_core) {
|
||||||
|
push_unique(out, position);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
int bed_channels_for_core(int core_channels) {
|
||||||
|
return core_channels == 7 ? 8 : 6;
|
||||||
|
}
|
||||||
|
|
||||||
|
Status compute_bed_plan(const eac3::Frame* core_frame, bool has_core, bool has_dependent,
|
||||||
|
bool has_chanmap, std::uint16_t chanmap, std::uint8_t dmx_config_idx,
|
||||||
|
BedPlan* out) {
|
||||||
|
if (out == nullptr) {
|
||||||
|
return Status::fail(JOC_ERR_INVALID_ARGUMENT, stage::kJoc, "null bed plan");
|
||||||
|
}
|
||||||
|
const std::int16_t core_channels = num_channels_for_config(dmx_config_idx);
|
||||||
|
if (core_channels < 0) {
|
||||||
|
return variant_error("joc", "unsupported_configuration",
|
||||||
|
"unknown JOC downmix configuration " +
|
||||||
|
std::to_string(dmx_config_idx), nullptr);
|
||||||
|
}
|
||||||
|
std::vector<Position> core_positions;
|
||||||
|
if (has_core && core_frame != nullptr) {
|
||||||
|
acmod_positions(core_frame->acmod, &core_positions);
|
||||||
|
if (core_frame->lfeon != 0u) {
|
||||||
|
core_positions.push_back(Position::kLfe);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
std::vector<Position> extra;
|
||||||
|
std::vector<Position> locations = core_positions;
|
||||||
|
if (has_dependent && has_chanmap) {
|
||||||
|
std::vector<Position> declared;
|
||||||
|
expand_chanmap(chanmap, &declared);
|
||||||
|
chanmap_extra_pair(core_positions, chanmap, &extra);
|
||||||
|
locations.insert(locations.end(), declared.begin(), declared.end());
|
||||||
|
}
|
||||||
|
|
||||||
|
std::vector<Position> ordered;
|
||||||
|
for (const Position position : locations) {
|
||||||
|
push_unique(&ordered, position);
|
||||||
|
}
|
||||||
|
std::sort(ordered.begin(), ordered.end(), [](Position left, Position right) {
|
||||||
|
return position_bit(left) < position_bit(right);
|
||||||
|
});
|
||||||
|
for (const Position position : ordered) {
|
||||||
|
if (position_bit(position) == 0u) {
|
||||||
|
return variant_error("eac3", "bed_channel_mapping_unsupported",
|
||||||
|
"unmapped channel position " + position_name(position),
|
||||||
|
nullptr);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
BedPlan plan;
|
||||||
|
plan.channels = static_cast<int>(ordered.size());
|
||||||
|
const int expected_channels = bed_channels_for_core(core_channels);
|
||||||
|
if (plan.channels != expected_channels) {
|
||||||
|
return variant_error("eac3", "core_channel_count_mismatch",
|
||||||
|
"the bed declares " + std::to_string(plan.channels) +
|
||||||
|
" channels, configuration " + std::to_string(dmx_config_idx) +
|
||||||
|
" needs " + std::to_string(expected_channels),
|
||||||
|
nullptr);
|
||||||
|
}
|
||||||
|
for (int index = 0; index < plan.channels; ++index) {
|
||||||
|
if (ordered[index] == Position::kLfe) {
|
||||||
|
plan.lfe_channel = index;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
std::vector<Position> wanted = {Position::kLeft, Position::kRight, Position::kCenter,
|
||||||
|
Position::kLeftSurround, Position::kRightSurround};
|
||||||
|
wanted.insert(wanted.end(), extra.begin(), extra.end());
|
||||||
|
if (wanted.size() != static_cast<std::size_t>(core_channels)) {
|
||||||
|
return variant_error("eac3", "chanmap_cfg_mismatch",
|
||||||
|
"the bed cannot supply " + std::to_string(core_channels) +
|
||||||
|
" JOC core channels (found " + std::to_string(wanted.size()) +
|
||||||
|
")",
|
||||||
|
nullptr);
|
||||||
|
}
|
||||||
|
for (std::size_t lane = 0; lane < wanted.size(); ++lane) {
|
||||||
|
int found = -1;
|
||||||
|
for (int index = 0; index < plan.channels; ++index) {
|
||||||
|
if (ordered[index] == wanted[lane]) {
|
||||||
|
found = index;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (found < 0) {
|
||||||
|
return variant_error("eac3", "bed_channel_mapping_unsupported",
|
||||||
|
"channel " + position_name(wanted[lane]) +
|
||||||
|
" is missing from the bed " + position_list(ordered),
|
||||||
|
nullptr);
|
||||||
|
}
|
||||||
|
plan.lane[lane] = found;
|
||||||
|
}
|
||||||
|
if (dmx_config_idx < 5u) {
|
||||||
|
plan.extra_pair_slot[0] = kExtraPairSlots[dmx_config_idx][0];
|
||||||
|
plan.extra_pair_slot[1] = kExtraPairSlots[dmx_config_idx][1];
|
||||||
|
}
|
||||||
|
*out = plan;
|
||||||
|
return Status::success();
|
||||||
|
}
|
||||||
|
|
||||||
|
Status compute_bed_plan_for_config(std::uint8_t dmx_config_idx, BedPlan* out) {
|
||||||
|
if (out == nullptr) {
|
||||||
|
return Status::fail(JOC_ERR_INVALID_ARGUMENT, stage::kJoc, "null bed plan");
|
||||||
|
}
|
||||||
|
const std::int16_t core_channels = num_channels_for_config(dmx_config_idx);
|
||||||
|
if (core_channels < 0) {
|
||||||
|
return variant_error("joc", "unsupported_configuration",
|
||||||
|
"unknown JOC downmix configuration " +
|
||||||
|
std::to_string(dmx_config_idx), nullptr);
|
||||||
|
}
|
||||||
|
std::vector<Position> extra;
|
||||||
|
expected_pair(dmx_config_idx, &extra);
|
||||||
|
std::vector<Position> wanted = {Position::kLeft, Position::kRight, Position::kCenter,
|
||||||
|
Position::kLeftSurround, Position::kRightSurround};
|
||||||
|
wanted.insert(wanted.end(), extra.begin(), extra.end());
|
||||||
|
|
||||||
|
std::vector<Position> ordered = {Position::kLeft, Position::kRight, Position::kCenter,
|
||||||
|
Position::kLfe, Position::kLeftSurround,
|
||||||
|
Position::kRightSurround};
|
||||||
|
ordered.insert(ordered.end(), extra.begin(), extra.end());
|
||||||
|
std::sort(ordered.begin(), ordered.end(), [](Position left, Position right) {
|
||||||
|
return position_bit(left) < position_bit(right);
|
||||||
|
});
|
||||||
|
ordered.erase(std::unique(ordered.begin(), ordered.end()), ordered.end());
|
||||||
|
|
||||||
|
BedPlan plan;
|
||||||
|
plan.channels = static_cast<int>(ordered.size());
|
||||||
|
for (int index = 0; index < plan.channels; ++index) {
|
||||||
|
if (ordered[index] == Position::kLfe) {
|
||||||
|
plan.lfe_channel = index;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
for (std::size_t lane = 0; lane < wanted.size(); ++lane) {
|
||||||
|
for (int index = 0; index < plan.channels; ++index) {
|
||||||
|
if (ordered[index] == wanted[lane]) {
|
||||||
|
plan.lane[lane] = index;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (plan.lane[lane] < 0) {
|
||||||
|
return variant_error("eac3", "bed_channel_mapping_unsupported",
|
||||||
|
"channel " + position_name(wanted[lane]) +
|
||||||
|
" is missing from the bed " + position_list(ordered),
|
||||||
|
nullptr);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (dmx_config_idx < 5u) {
|
||||||
|
plan.extra_pair_slot[0] = kExtraPairSlots[dmx_config_idx][0];
|
||||||
|
plan.extra_pair_slot[1] = kExtraPairSlots[dmx_config_idx][1];
|
||||||
|
}
|
||||||
|
*out = plan;
|
||||||
|
return Status::success();
|
||||||
|
}
|
||||||
|
|
||||||
|
Status check_cross_layer(const joc_frame_params& params, const eac3::Frame* core_frame,
|
||||||
|
bool has_core, bool has_dependent, bool has_chanmap,
|
||||||
|
std::uint16_t chanmap,
|
||||||
|
const std::vector<oamd::BedAssignment>* bed_assignments,
|
||||||
|
std::string* error, CrossLayerNotes* notes) {
|
||||||
|
const std::uint8_t config_idx = params.dmx_config_idx;
|
||||||
|
const int core_channels = params.n_channels;
|
||||||
|
std::vector<Position> wanted;
|
||||||
|
expected_pair(config_idx, &wanted);
|
||||||
|
|
||||||
|
if (params.ext_config_idx != 0u) {
|
||||||
|
return variant_error("joc", "ext_config_idx_unsupported",
|
||||||
|
"joc_ext_config_idx=" + std::to_string(params.ext_config_idx) +
|
||||||
|
" has no mapping in this implementation",
|
||||||
|
error);
|
||||||
|
}
|
||||||
|
if (core_channels != JOC_CORE_CHANNELS && core_channels != JOC_MAX_CORE_CHANNELS) {
|
||||||
|
return variant_error("joc", "unsupported_configuration",
|
||||||
|
"unsupported JOC core channel count " +
|
||||||
|
std::to_string(core_channels),
|
||||||
|
error);
|
||||||
|
}
|
||||||
|
|
||||||
|
std::vector<Position> core_positions;
|
||||||
|
if (has_core && core_frame != nullptr) {
|
||||||
|
acmod_positions(core_frame->acmod, &core_positions);
|
||||||
|
if (core_frame->lfeon != 0u) {
|
||||||
|
core_positions.push_back(Position::kLfe);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (core_channels == JOC_MAX_CORE_CHANNELS) {
|
||||||
|
if (!has_core || !has_chanmap) {
|
||||||
|
return variant_error(
|
||||||
|
"eac3", "core_extension_pair",
|
||||||
|
"a 7-channel configuration needs both an independent substream and a "
|
||||||
|
"dependent-substream chanmap",
|
||||||
|
error);
|
||||||
|
}
|
||||||
|
std::vector<Position> pair;
|
||||||
|
chanmap_extra_pair(core_positions, chanmap, &pair);
|
||||||
|
if (pair != wanted) {
|
||||||
|
// The bed mapping follows the chanmap's channel codes; the name a
|
||||||
|
// configuration implies does not reach the DSP, so the frame renders
|
||||||
|
// and the disagreement is reported instead.
|
||||||
|
if (notes != nullptr) {
|
||||||
|
notes->chanmap_pair_mismatch = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} else if (has_chanmap) {
|
||||||
|
std::vector<Position> pair;
|
||||||
|
chanmap_extra_pair(core_positions, chanmap, &pair);
|
||||||
|
if (!pair.empty()) {
|
||||||
|
return variant_error("eac3", "core_channel_count_mismatch",
|
||||||
|
"a 5-channel configuration declares extra dependent "
|
||||||
|
"channels " + position_list(pair),
|
||||||
|
error);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
std::vector<Position> declared = core_positions;
|
||||||
|
if (has_chanmap) {
|
||||||
|
std::vector<Position> expanded;
|
||||||
|
expand_chanmap(chanmap, &expanded);
|
||||||
|
for (const Position position : expanded) {
|
||||||
|
push_unique(&declared, position);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
int full_band = 0;
|
||||||
|
for (const Position position : declared) {
|
||||||
|
if (position != Position::kLfe && position != Position::kLfe2) {
|
||||||
|
++full_band;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (!declared.empty() && full_band != core_channels) {
|
||||||
|
return variant_error("eac3", "core_channel_count_mismatch",
|
||||||
|
"the substreams declare " + std::to_string(full_band) +
|
||||||
|
" full-band channels, joc_dmx_config_idx=" +
|
||||||
|
std::to_string(config_idx) + " declares " +
|
||||||
|
std::to_string(core_channels),
|
||||||
|
error);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (bed_assignments != nullptr) {
|
||||||
|
static constexpr std::uint32_t kBedBitLeftRear = 1u << 4; // RC_LB/RC_RB
|
||||||
|
static constexpr std::uint32_t kBedBitTopFront = 1u << 5; // RC_TFL/RC_TFR
|
||||||
|
std::vector<Position> declared_pair;
|
||||||
|
for (const oamd::BedAssignment& assignment : *bed_assignments) {
|
||||||
|
if (!assignment.standard || assignment.mask == 0u) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
if ((assignment.mask & kBedBitLeftRear) != 0u) {
|
||||||
|
push_unique(&declared_pair, Position::kLeftRearSurround);
|
||||||
|
push_unique(&declared_pair, Position::kRightRearSurround);
|
||||||
|
}
|
||||||
|
if ((assignment.mask & kBedBitTopFront) != 0u) {
|
||||||
|
push_unique(&declared_pair, Position::kVerticalHeightLeft);
|
||||||
|
push_unique(&declared_pair, Position::kVerticalHeightRight);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (!declared_pair.empty() && declared_pair != wanted) {
|
||||||
|
if (notes != nullptr) {
|
||||||
|
notes->bed_mask_mismatch = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return Status::success();
|
||||||
|
}
|
||||||
|
|
||||||
} // namespace joc::joc
|
} // namespace joc::joc
|
||||||
|
|
||||||
@@ -6,9 +6,11 @@
|
|||||||
#include <cstdint>
|
#include <cstdint>
|
||||||
#include <vector>
|
#include <vector>
|
||||||
|
|
||||||
|
#include "eac3_transport/eac3_reader.h"
|
||||||
#include "joc_core.h"
|
#include "joc_core.h"
|
||||||
#include "emdf/emdf_parser.h"
|
#include "emdf/emdf_parser.h"
|
||||||
#include "foundation/status.h"
|
#include "foundation/status.h"
|
||||||
|
#include "oamd/oamd_parser.h"
|
||||||
|
|
||||||
namespace joc::joc {
|
namespace joc::joc {
|
||||||
|
|
||||||
@@ -39,8 +41,99 @@ Status parse_eac3_frame(const std::uint8_t* frame, std::size_t frame_size, joc_f
|
|||||||
Status check_id14_padding(const std::uint8_t* payload, std::size_t payload_size,
|
Status check_id14_padding(const std::uint8_t* payload, std::size_t payload_size,
|
||||||
std::uint32_t* out_trailing_bits);
|
std::uint32_t* out_trailing_bits);
|
||||||
|
|
||||||
|
// Scores this container as the frame's JOC metadata when the syncframe holds more
|
||||||
|
// than one (spec section 8.2 and its Table 56 associate the OAMD and JOC payloads
|
||||||
|
// of one frame by an equal group id). 2 = the two payloads share a group id and
|
||||||
|
// ID14 parses as a complete joc() payload, 1 = ID14 parses, 0 = neither. A
|
||||||
|
// container whose ID14 declares far more objects than its bytes could hold, or
|
||||||
|
// whose ID11 carries no group id at all, is some other structure.
|
||||||
|
int score_container_as_joc(const std::uint8_t* data, std::size_t size,
|
||||||
|
const emdf::Container& container);
|
||||||
|
|
||||||
|
// Parameters for an audio frame that carries no JOC payload: every object is
|
||||||
|
// "present" with an all-zero matrix, so the kernel renders silence while its
|
||||||
|
// analysis and synthesis state keep advancing in step with the stream.
|
||||||
|
void make_silent_frame_params(joc_frame_params* out);
|
||||||
|
|
||||||
std::int16_t num_channels_for_config(std::uint32_t dmx_config_idx);
|
std::int16_t num_channels_for_config(std::uint32_t dmx_config_idx);
|
||||||
|
|
||||||
std::int16_t num_bands_for_index(std::uint32_t num_bands_idx);
|
std::int16_t num_bands_for_index(std::uint32_t num_bands_idx);
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
// Channel identity / bed layout (spec sections 3, 10.2, 10.4)
|
||||||
|
//
|
||||||
|
// This is the position layer only: it decides which decoded bed channel feeds
|
||||||
|
// which JOC input lane and which ADM bed slot the extra pair occupies. The DSP
|
||||||
|
// never reads it.
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
enum class Position : std::uint8_t {
|
||||||
|
kNone = 0,
|
||||||
|
kLeft,
|
||||||
|
kRight,
|
||||||
|
kCenter,
|
||||||
|
kLfe,
|
||||||
|
kLeftSurround,
|
||||||
|
kRightSurround,
|
||||||
|
kLeftRearSurround,
|
||||||
|
kRightRearSurround,
|
||||||
|
kVerticalHeightLeft,
|
||||||
|
kVerticalHeightRight,
|
||||||
|
kTopSurroundLeft,
|
||||||
|
kTopSurroundRight,
|
||||||
|
kCenterSurround,
|
||||||
|
kTopSurround,
|
||||||
|
kVerticalHeightCenter,
|
||||||
|
kLfe2,
|
||||||
|
};
|
||||||
|
|
||||||
|
// Table E2.5 expansion; the field's most significant bit is table bit 0.
|
||||||
|
void expand_chanmap(std::uint16_t chanmap, std::vector<Position>* out);
|
||||||
|
|
||||||
|
// A/52 acmod -> full-band positions in decoding order (LFE excluded).
|
||||||
|
void acmod_positions(std::uint8_t acmod, std::vector<Position>* out);
|
||||||
|
|
||||||
|
// The pair joc_dmx_config_idx declares; empty for configurations 0 and 3.
|
||||||
|
void expected_pair(std::uint8_t dmx_config_idx, std::vector<Position>* out);
|
||||||
|
|
||||||
|
// The extra pair a dependent-substream chanmap adds on top of the core channels.
|
||||||
|
void chanmap_extra_pair(const std::vector<Position>& core, std::uint16_t chanmap,
|
||||||
|
std::vector<Position>* out);
|
||||||
|
|
||||||
|
// Decoded-bed channel count implied by the JOC core channel count.
|
||||||
|
int bed_channels_for_core(int core_channels);
|
||||||
|
|
||||||
|
// bed[lane] = decoded PCM channel index feeding JOC lane 'lane'.
|
||||||
|
struct BedPlan {
|
||||||
|
int channels = 0; // 6 or 8
|
||||||
|
int lfe_channel = -1;
|
||||||
|
int lane[JOC_MAX_CORE_CHANNELS] = {-1, -1, -1, -1, -1, -1, -1};
|
||||||
|
int extra_pair_slot[2] = {-1, -1}; // ADM skeleton
|
||||||
|
};
|
||||||
|
|
||||||
|
Status compute_bed_plan(const eac3::Frame* core_frame, bool has_core, bool has_dependent,
|
||||||
|
bool has_chanmap, std::uint16_t chanmap, std::uint8_t dmx_config_idx,
|
||||||
|
BedPlan* out);
|
||||||
|
|
||||||
|
// Bed plan driven by joc_dmx_config_idx alone, for callers that hold no L2
|
||||||
|
// header: the extra pair is the one the configuration declares.
|
||||||
|
Status compute_bed_plan_for_config(std::uint8_t dmx_config_idx, BedPlan* out);
|
||||||
|
|
||||||
|
// Identity disagreements that leave the DSP input unchanged (spec section 10.1:
|
||||||
|
// channel identity never enters the DSP): the extra pair's name is metadata only,
|
||||||
|
// so a mismatch is reported through CrossLayerNotes instead of refusing the frame.
|
||||||
|
struct CrossLayerNotes {
|
||||||
|
bool chanmap_pair_mismatch = false; // spec 11.2 check 1: chanmap vs k
|
||||||
|
bool bed_mask_mismatch = false; // spec 11.2 check 2: OAMD bed mask vs k
|
||||||
|
};
|
||||||
|
|
||||||
|
// Spec section 11.2 cross-layer consistency. A mismatch in the core channel count
|
||||||
|
// or in joc_ext_config_idx changes the DSP input and is a variant error; the two
|
||||||
|
// identity checks are recorded in `notes` and the frame still renders.
|
||||||
|
Status check_cross_layer(const joc_frame_params& params, const eac3::Frame* core_frame,
|
||||||
|
bool has_core, bool has_dependent, bool has_chanmap,
|
||||||
|
std::uint16_t chanmap,
|
||||||
|
const std::vector<oamd::BedAssignment>* bed_assignments,
|
||||||
|
std::string* error, CrossLayerNotes* notes = nullptr);
|
||||||
|
|
||||||
} // namespace joc::joc
|
} // namespace joc::joc
|
||||||
@@ -69,7 +69,9 @@ public:
|
|||||||
std::memset(synthesis_state_, 0, sizeof(synthesis_state_));
|
std::memset(synthesis_state_, 0, sizeof(synthesis_state_));
|
||||||
std::memset(x_, 0, sizeof(x_));
|
std::memset(x_, 0, sizeof(x_));
|
||||||
std::memset(z_, 0, sizeof(z_));
|
std::memset(z_, 0, sizeof(z_));
|
||||||
analysis_phase_ = 0.0625f;
|
// Sentinel: the first frame after reset takes the new scalar directly,
|
||||||
|
// without an intra-frame transition.
|
||||||
|
analysis_phase_ = -0.5f;
|
||||||
error_[0] = '\0';
|
error_[0] = '\0';
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
@@ -125,13 +127,11 @@ public:
|
|||||||
return error_[0] ? error_ : "";
|
return error_[0] ? error_ : "";
|
||||||
}
|
}
|
||||||
|
|
||||||
void set_dc_filter(const bool enabled) noexcept {
|
|
||||||
dc_filter_enabled_ = enabled;
|
|
||||||
}
|
|
||||||
|
|
||||||
int process(
|
int process(
|
||||||
const float* bed5,
|
const float* bed_planar,
|
||||||
const float* lfe,
|
const float* lfe,
|
||||||
|
const uint32_t core_channel_count,
|
||||||
|
const uint32_t phase_shift,
|
||||||
const uint32_t object_mask,
|
const uint32_t object_mask,
|
||||||
const uint8_t* n_bands,
|
const uint8_t* n_bands,
|
||||||
const uint8_t* n_dpoints,
|
const uint8_t* n_dpoints,
|
||||||
@@ -144,9 +144,14 @@ public:
|
|||||||
float* output16) noexcept {
|
float* output16) noexcept {
|
||||||
|
|
||||||
error_[0] = '\0';
|
error_[0] = '\0';
|
||||||
if (!bed5 || !n_bands || !n_dpoints || !slope_idx || !offset_ts || !dq || !output16) {
|
if (!bed_planar || !n_bands || !n_dpoints || !slope_idx || !offset_ts || !dq || !output16) {
|
||||||
return fail("null pointer passed to ejoc_renderer_process");
|
return fail("null pointer passed to ejoc_renderer_process");
|
||||||
}
|
}
|
||||||
|
if (core_channel_count < EJOC_CORE_CHANNELS || core_channel_count > EJOC_MAX_CORE_CHANNELS) {
|
||||||
|
return fail("core_channel_count must be 5 or 7");
|
||||||
|
}
|
||||||
|
core_channels_ = core_channel_count;
|
||||||
|
phase_shift_enabled_ = phase_shift != 0u;
|
||||||
if (object_mask & ~((1u << EJOC_MAX_OBJECTS) - 1u)) {
|
if (object_mask & ~((1u << EJOC_MAX_OBJECTS) - 1u)) {
|
||||||
return fail("object_mask contains an object index above 14");
|
return fail("object_mask contains an object index above 14");
|
||||||
}
|
}
|
||||||
@@ -169,7 +174,7 @@ public:
|
|||||||
}
|
}
|
||||||
|
|
||||||
std::memset(output16, 0, sizeof(float) * EJOC_OUTPUT_CHANNELS * EJOC_FRAME_SAMPLES);
|
std::memset(output16, 0, sizeof(float) * EJOC_OUTPUT_CHANNELS * EJOC_FRAME_SAMPLES);
|
||||||
analysis(bed5, phase_new);
|
analysis(bed_planar, phase_new);
|
||||||
render_lfe(lfe, output_scale, output16);
|
render_lfe(lfe, output_scale, output16);
|
||||||
process_objects(object_mask, n_bands, n_dpoints, slope_idx, offset_ts,
|
process_objects(object_mask, n_bands, n_dpoints, slope_idx, offset_ts,
|
||||||
dq, clipgain, output_scale, output16);
|
dq, clipgain, output_scale, output16);
|
||||||
@@ -299,7 +304,8 @@ private:
|
|||||||
for (int band = 0; band < 64; ++band) {
|
for (int band = 0; band < 64; ++band) {
|
||||||
current[slot][band] = x_[channel][band][group + slot];
|
current[slot][band] = x_[channel][band][group + slot];
|
||||||
const Complex delayed = surround_delay_[surround][slot][band];
|
const Complex delayed = surround_delay_[surround][slot][band];
|
||||||
x_[channel][band][group + slot] = {delayed.im, -delayed.re};
|
x_[channel][band][group + slot] =
|
||||||
|
phase_shift_enabled_ ? Complex{delayed.im, -delayed.re} : delayed;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -309,7 +315,7 @@ private:
|
|||||||
for (int i = 0; i < 4; ++i) {
|
for (int i = 0; i < 4; ++i) {
|
||||||
dc_buffer[20 + i] = current[i][0];
|
dc_buffer[20 + i] = current[i][0];
|
||||||
}
|
}
|
||||||
if (dc_filter_enabled_) {
|
if (phase_shift_enabled_) {
|
||||||
for (int slot = 0; slot < 4; ++slot) {
|
for (int slot = 0; slot < 4; ++slot) {
|
||||||
Complex sum{0.0, 0.0};
|
Complex sum{0.0, 0.0};
|
||||||
for (int tap = 0; tap < 21; ++tap) {
|
for (int tap = 0; tap < 21; ++tap) {
|
||||||
@@ -338,7 +344,7 @@ private:
|
|||||||
}
|
}
|
||||||
|
|
||||||
void analysis_channel(const int channel) noexcept {
|
void analysis_channel(const int channel) noexcept {
|
||||||
const float* bed5 = job_bed5_;
|
const float* bed_planar = job_bed_;
|
||||||
const float phase_old = job_phase_old_;
|
const float phase_old = job_phase_old_;
|
||||||
const float phase_new = job_phase_new_;
|
const float phase_new = job_phase_new_;
|
||||||
const bool ramp_phase = phase_old != phase_new;
|
const bool ramp_phase = phase_old != phase_new;
|
||||||
@@ -354,37 +360,49 @@ private:
|
|||||||
const float product = static_cast<float>(static_cast<float>(frame_sample) * phase_step);
|
const float product = static_cast<float>(static_cast<float>(frame_sample) * phase_step);
|
||||||
gain = static_cast<float>(phase_old + product);
|
gain = static_cast<float>(phase_old + product);
|
||||||
}
|
}
|
||||||
scaled[sample] = static_cast<float>(bed5[channel * 1536 + frame_sample] * gain);
|
scaled[sample] = static_cast<float>(bed_planar[channel * 1536 + frame_sample] * gain);
|
||||||
}
|
}
|
||||||
|
// L/R/C and, for 7 core channels, the extra pair (5 and 6) take the
|
||||||
|
// ten-slot delay here; Ls/Rs take the same delay inside surround_post().
|
||||||
const float* analysis_input = scaled;
|
const float* analysis_input = scaled;
|
||||||
if (channel < 3) {
|
const int delay_lane = channel < 3 ? channel : channel - 2;
|
||||||
std::memcpy(delayed, analysis_delay_[channel][0], sizeof(delayed));
|
if (channel < 3 || channel >= 5) {
|
||||||
std::memmove(&analysis_delay_[channel][0][0],
|
std::memcpy(delayed, analysis_delay_[delay_lane][0], sizeof(delayed));
|
||||||
&analysis_delay_[channel][1][0],
|
std::memmove(&analysis_delay_[delay_lane][0][0],
|
||||||
|
&analysis_delay_[delay_lane][1][0],
|
||||||
sizeof(float) * 9 * 64);
|
sizeof(float) * 9 * 64);
|
||||||
std::memcpy(analysis_delay_[channel][9], scaled, sizeof(scaled));
|
std::memcpy(analysis_delay_[delay_lane][9], scaled, sizeof(scaled));
|
||||||
analysis_input = delayed;
|
analysis_input = delayed;
|
||||||
}
|
}
|
||||||
analysis_slot(channel, analysis_input, timeslot);
|
analysis_slot(channel, analysis_input, timeslot);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void analysis(const float* bed5, const float phase_new) noexcept {
|
void analysis(const float* bed_planar, const float phase_new) noexcept {
|
||||||
job_bed5_ = bed5;
|
job_bed_ = bed_planar;
|
||||||
|
// Analysis-side scalar = the structural 1/16 times this frame's clipgain.
|
||||||
|
// clipgain enters the analysis at this stage and the x16 at the output
|
||||||
|
// cancels the 1/16, so the net effect is a multiply by joc_clipgain; the
|
||||||
|
// previous frame's scalar is the ramp start.
|
||||||
|
const float scalar = static_cast<float>(phase_new * job_clipgain_);
|
||||||
job_phase_old_ = analysis_phase_;
|
job_phase_old_ = analysis_phase_;
|
||||||
job_phase_new_ = phase_new;
|
if (job_phase_old_ <= 0.0f && job_phase_old_ != 0.0f) {
|
||||||
|
job_phase_old_ = scalar;
|
||||||
|
}
|
||||||
|
job_phase_new_ = scalar;
|
||||||
job_kind_ = JobKind::Analysis;
|
job_kind_ = JobKind::Analysis;
|
||||||
job_count_ = 5;
|
job_count_ = static_cast<int>(core_channels_);
|
||||||
for (int channel = 0; channel < 5; ++channel) {
|
for (uint32_t channel = 0; channel < core_channels_; ++channel) {
|
||||||
job_objects_[channel] = channel;
|
job_objects_[channel] = static_cast<int>(channel);
|
||||||
}
|
}
|
||||||
dispatch_jobs();
|
dispatch_jobs();
|
||||||
analysis_phase_ = phase_new;
|
analysis_phase_ = scalar;
|
||||||
surround_post();
|
surround_post();
|
||||||
}
|
}
|
||||||
|
|
||||||
static std::size_t dq_index(const int object, const int point, const int channel, const int band) noexcept {
|
static std::size_t dq_index(const int object, const int point, const int channel, const int band) noexcept {
|
||||||
return static_cast<std::size_t>((((object * 2 + point) * 5 + channel) * kMaxBands) + band);
|
return static_cast<std::size_t>(
|
||||||
|
(((object * 2 + point) * EJOC_MAX_CORE_CHANNELS + channel) * kMaxBands) + band);
|
||||||
}
|
}
|
||||||
|
|
||||||
void matrix_object(
|
void matrix_object(
|
||||||
@@ -401,7 +419,7 @@ private:
|
|||||||
const int slope = slope_idx[object];
|
const int slope = slope_idx[object];
|
||||||
const uint8_t* pb_map = parameter_band_map(bands);
|
const uint8_t* pb_map = parameter_band_map(bands);
|
||||||
|
|
||||||
for (int channel = 0; channel < 5; ++channel) {
|
for (uint32_t channel = 0; channel < core_channels_; ++channel) {
|
||||||
for (int subband = 0; subband < 64; ++subband) {
|
for (int subband = 0; subband < 64; ++subband) {
|
||||||
const int parameter_band = pb_map[subband];
|
const int parameter_band = pb_map[subband];
|
||||||
const double previous = matrix_previous_[object][channel][subband];
|
const double previous = matrix_previous_[object][channel][subband];
|
||||||
@@ -465,7 +483,6 @@ private:
|
|||||||
|
|
||||||
void synthesis_object(
|
void synthesis_object(
|
||||||
const int object,
|
const int object,
|
||||||
const double clipgain,
|
|
||||||
const float output_scale,
|
const float output_scale,
|
||||||
float* output16) noexcept {
|
float* output16) noexcept {
|
||||||
|
|
||||||
@@ -493,8 +510,10 @@ private:
|
|||||||
qmf5_step(state, rotated, pcm64);
|
qmf5_step(state, rotated, pcm64);
|
||||||
for (int sample = 0; sample < 64; ++sample) {
|
for (int sample = 0; sample < 64; ++sample) {
|
||||||
const double clipped = clamp_unit(16.0 * pcm64[sample]);
|
const double clipped = clamp_unit(16.0 * pcm64[sample]);
|
||||||
const float value = static_cast<float>(clipped * clipgain);
|
// joc_clipgain already entered the analysis (see analysis()); what
|
||||||
destination[timeslot * 64 + sample] = static_cast<float>(value * output_scale);
|
// remains here is the user output gain.
|
||||||
|
const float value = static_cast<float>(clipped * output_scale);
|
||||||
|
destination[timeslot * 64 + sample] = value;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -502,7 +521,7 @@ private:
|
|||||||
void process_one_object(const int object) noexcept {
|
void process_one_object(const int object) noexcept {
|
||||||
matrix_object(object, job_n_bands_, job_n_dpoints_, job_slope_idx_,
|
matrix_object(object, job_n_bands_, job_n_dpoints_, job_slope_idx_,
|
||||||
job_offset_ts_, job_dq_);
|
job_offset_ts_, job_dq_);
|
||||||
synthesis_object(object, job_clipgain_, job_output_scale_, job_output16_);
|
synthesis_object(object, job_output_scale_, job_output16_);
|
||||||
}
|
}
|
||||||
|
|
||||||
void execute_job_loop() noexcept {
|
void execute_job_loop() noexcept {
|
||||||
@@ -630,7 +649,7 @@ private:
|
|||||||
int job_objects_[EJOC_MAX_OBJECTS]{};
|
int job_objects_[EJOC_MAX_OBJECTS]{};
|
||||||
int job_count_ = 0;
|
int job_count_ = 0;
|
||||||
JobKind job_kind_ = JobKind::Objects;
|
JobKind job_kind_ = JobKind::Objects;
|
||||||
const float* job_bed5_ = nullptr;
|
const float* job_bed_ = nullptr;
|
||||||
float job_phase_old_ = 0.0625f;
|
float job_phase_old_ = 0.0625f;
|
||||||
float job_phase_new_ = 0.0625f;
|
float job_phase_new_ = 0.0625f;
|
||||||
const uint8_t* job_n_bands_ = nullptr;
|
const uint8_t* job_n_bands_ = nullptr;
|
||||||
@@ -642,17 +661,19 @@ private:
|
|||||||
float job_output_scale_ = 1.0f;
|
float job_output_scale_ = 1.0f;
|
||||||
float* job_output16_ = nullptr;
|
float* job_output16_ = nullptr;
|
||||||
|
|
||||||
alignas(64) double analysis_fifo_[5][9][64];
|
uint32_t core_channels_ = EJOC_CORE_CHANNELS;
|
||||||
alignas(64) float analysis_delay_[3][10][64];
|
alignas(64) double analysis_fifo_[EJOC_MAX_CORE_CHANNELS][9][64];
|
||||||
float analysis_phase_;
|
// Delay lanes: 0..2 hold L/R/C, 3..4 hold the extra pair of a 7-channel frame.
|
||||||
|
alignas(64) float analysis_delay_[5][10][64];
|
||||||
|
float analysis_phase_ = -0.5f;
|
||||||
alignas(64) Complex surround_delay_[2][10][64];
|
alignas(64) Complex surround_delay_[2][10][64];
|
||||||
alignas(64) Complex surround_history_[2][20];
|
alignas(64) Complex surround_history_[2][20];
|
||||||
// band-0 的 21-tap DC 补偿开关;仅 downmix 配置 3/4 由调用方置位。
|
// sigma(k) switch; the caller sets it for downmix configurations 3 and 4.
|
||||||
bool dc_filter_enabled_ = true;
|
bool phase_shift_enabled_ = true;
|
||||||
alignas(64) double lfe_delay_[kLfeDelay];
|
alignas(64) double lfe_delay_[kLfeDelay];
|
||||||
alignas(64) double matrix_previous_[15][5][64];
|
alignas(64) double matrix_previous_[15][EJOC_MAX_CORE_CHANNELS][64];
|
||||||
alignas(64) double synthesis_state_[15][640];
|
alignas(64) double synthesis_state_[15][640];
|
||||||
alignas(64) Complex x_[5][64][24];
|
alignas(64) Complex x_[EJOC_MAX_CORE_CHANNELS][64][24];
|
||||||
alignas(64) Complex z_[15][64][24];
|
alignas(64) Complex z_[15][64][24];
|
||||||
|
|
||||||
uint8_t bit_reverse_[64];
|
uint8_t bit_reverse_[64];
|
||||||
@@ -704,14 +725,6 @@ int EJOC_CALL ejoc_renderer_set_threads(ejoc_renderer_handle handle, uint32_t to
|
|||||||
return static_cast<ejoc::Renderer*>(handle)->set_threads(total_threads);
|
return static_cast<ejoc::Renderer*>(handle)->set_threads(total_threads);
|
||||||
}
|
}
|
||||||
|
|
||||||
int EJOC_CALL ejoc_renderer_set_dc_filter(ejoc_renderer_handle handle, uint32_t enabled) {
|
|
||||||
if (!handle) {
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
static_cast<ejoc::Renderer*>(handle)->set_dc_filter(enabled != 0);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
uint32_t EJOC_CALL ejoc_renderer_thread_count(ejoc_renderer_handle handle) {
|
uint32_t EJOC_CALL ejoc_renderer_thread_count(ejoc_renderer_handle handle) {
|
||||||
if (!handle) {
|
if (!handle) {
|
||||||
return 0;
|
return 0;
|
||||||
@@ -728,8 +741,10 @@ const char* EJOC_CALL ejoc_renderer_last_error(ejoc_renderer_handle handle) {
|
|||||||
|
|
||||||
int EJOC_CALL ejoc_renderer_process(
|
int EJOC_CALL ejoc_renderer_process(
|
||||||
ejoc_renderer_handle handle,
|
ejoc_renderer_handle handle,
|
||||||
const float* bed5_planar,
|
const float* bed_planar,
|
||||||
const float* lfe,
|
const float* lfe,
|
||||||
|
const uint32_t core_channel_count,
|
||||||
|
const uint32_t phase_shift,
|
||||||
const uint32_t object_mask,
|
const uint32_t object_mask,
|
||||||
const uint8_t* n_bands,
|
const uint8_t* n_bands,
|
||||||
const uint8_t* n_dpoints,
|
const uint8_t* n_dpoints,
|
||||||
@@ -744,8 +759,8 @@ int EJOC_CALL ejoc_renderer_process(
|
|||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
return static_cast<ejoc::Renderer*>(handle)->process(
|
return static_cast<ejoc::Renderer*>(handle)->process(
|
||||||
bed5_planar, lfe, object_mask, n_bands, n_dpoints, slope_idx,
|
bed_planar, lfe, core_channel_count, phase_shift, object_mask, n_bands, n_dpoints,
|
||||||
offset_ts, dq, clipgain, phase_new, output_scale, output16_planar);
|
slope_idx, offset_ts, dq, clipgain, phase_new, output_scale, output16_planar);
|
||||||
}
|
}
|
||||||
|
|
||||||
} // extern "C"
|
} // extern "C"
|
||||||
@@ -6,21 +6,22 @@
|
|||||||
namespace joc::joc {
|
namespace joc::joc {
|
||||||
|
|
||||||
Status rebuild_objects16(ejoc_renderer_handle handle, const joc_frame_params& params,
|
Status rebuild_objects16(ejoc_renderer_handle handle, const joc_frame_params& params,
|
||||||
const float* bed5_planar, const float* lfe, float gain,
|
const float* bed_planar, const float* lfe, float gain,
|
||||||
std::vector<float>* out16, std::string* error) {
|
std::vector<float>* out16, std::string* error) {
|
||||||
if (handle == nullptr || bed5_planar == nullptr || out16 == nullptr) {
|
if (handle == nullptr || bed_planar == nullptr || out16 == nullptr) {
|
||||||
return Status::fail(JOC_ERR_INVALID_ARGUMENT, stage::kDsp, "null argument");
|
return Status::fail(JOC_ERR_INVALID_ARGUMENT, stage::kDsp, "null argument");
|
||||||
}
|
}
|
||||||
if (params.n_channels != JOC_CORE_CHANNELS) {
|
if (params.n_channels != JOC_CORE_CHANNELS &&
|
||||||
|
params.n_channels != JOC_MAX_CORE_CHANNELS) {
|
||||||
if (error != nullptr) {
|
if (error != nullptr) {
|
||||||
*error = "the reused JOC kernel requires 5 core channels, frame declares " +
|
*error = "the reused JOC kernel requires 5 or 7 core channels, frame declares " +
|
||||||
std::to_string(static_cast<unsigned>(params.n_channels));
|
std::to_string(static_cast<unsigned>(params.n_channels));
|
||||||
}
|
}
|
||||||
return Status::fail(JOC_ERR_JOC_UNSUPPORTED_VARIANT, stage::kDsp, *error);
|
return Status::fail(JOC_ERR_JOC_UNSUPPORTED_VARIANT, stage::kDsp, *error);
|
||||||
}
|
}
|
||||||
|
|
||||||
std::vector<double> dq(static_cast<std::size_t>(JOC_MAX_OBJECTS) * JOC_MAX_DPOINTS *
|
std::vector<double> dq(static_cast<std::size_t>(JOC_MAX_OBJECTS) * JOC_MAX_DPOINTS *
|
||||||
JOC_CORE_CHANNELS * JOC_MAX_PARAMETER_BANDS,
|
JOC_MAX_CORE_CHANNELS * JOC_MAX_PARAMETER_BANDS,
|
||||||
0.0);
|
0.0);
|
||||||
std::uint8_t n_bands[JOC_MAX_OBJECTS] = {};
|
std::uint8_t n_bands[JOC_MAX_OBJECTS] = {};
|
||||||
std::uint8_t n_dpoints[JOC_MAX_OBJECTS] = {};
|
std::uint8_t n_dpoints[JOC_MAX_OBJECTS] = {};
|
||||||
@@ -38,10 +39,11 @@ Status rebuild_objects16(ejoc_renderer_handle handle, const joc_frame_params& pa
|
|||||||
offset_ts[obj * JOC_MAX_DPOINTS + dp] = object.offset_ts[dp];
|
offset_ts[obj * JOC_MAX_DPOINTS + dp] = object.offset_ts[dp];
|
||||||
}
|
}
|
||||||
for (unsigned dp = 0; dp < object.n_dpoints; ++dp) {
|
for (unsigned dp = 0; dp < object.n_dpoints; ++dp) {
|
||||||
for (unsigned ch = 0; ch < JOC_CORE_CHANNELS; ++ch) {
|
for (unsigned ch = 0; ch < params.n_channels; ++ch) {
|
||||||
for (unsigned pb = 0; pb < object.n_bands; ++pb) {
|
for (unsigned pb = 0; pb < object.n_bands; ++pb) {
|
||||||
const std::size_t index =
|
const std::size_t index =
|
||||||
((static_cast<std::size_t>(obj) * JOC_MAX_DPOINTS + dp) * JOC_CORE_CHANNELS +
|
((static_cast<std::size_t>(obj) * JOC_MAX_DPOINTS + dp) *
|
||||||
|
JOC_MAX_CORE_CHANNELS +
|
||||||
ch) *
|
ch) *
|
||||||
JOC_MAX_PARAMETER_BANDS +
|
JOC_MAX_PARAMETER_BANDS +
|
||||||
pb;
|
pb;
|
||||||
@@ -52,18 +54,14 @@ Status rebuild_objects16(ejoc_renderer_handle handle, const joc_frame_params& pa
|
|||||||
}
|
}
|
||||||
|
|
||||||
out16->assign(static_cast<std::size_t>(JOC_OUTPUT_CHANNELS) * JOC_FRAME_SAMPLES, 0.0f);
|
out16->assign(static_cast<std::size_t>(JOC_OUTPUT_CHANNELS) * JOC_FRAME_SAMPLES, 0.0f);
|
||||||
// band-0 的 21-tap DC 补偿只在 downmix 配置 3/4 下启用,其余配置 band 0
|
// sigma(k) = (k in {3,4}) gates the Ls/Rs -j rotation and the band-0 21-tap
|
||||||
// 走与其他 band 相同的处理。
|
// DC compensation together; other configurations keep the common processing.
|
||||||
const bool dc_filter = params.dmx_config_idx == 3 || params.dmx_config_idx == 4;
|
const std::uint32_t phase_shift =
|
||||||
if (ejoc_renderer_set_dc_filter(handle, dc_filter ? 1u : 0u) != 0) {
|
(params.dmx_config_idx == 3 || params.dmx_config_idx == 4) ? 1u : 0u;
|
||||||
if (error != nullptr) {
|
|
||||||
*error = "ejoc_renderer_set_dc_filter failed";
|
|
||||||
}
|
|
||||||
return Status::fail(JOC_ERR_RENDER_FAILED, stage::kDsp, "ejoc_renderer_set_dc_filter failed");
|
|
||||||
}
|
|
||||||
const int result = ejoc_renderer_process(
|
const int result = ejoc_renderer_process(
|
||||||
handle, bed5_planar, lfe, params.present_mask, n_bands, n_dpoints, slope_idx, offset_ts,
|
handle, bed_planar, lfe, params.n_channels, phase_shift, params.present_mask, n_bands,
|
||||||
dq.data(), params.clipgain, 0.0625f, gain, out16->data());
|
n_dpoints, slope_idx, offset_ts, dq.data(), params.clipgain, 0.0625f, gain,
|
||||||
|
out16->data());
|
||||||
if (result != 0) {
|
if (result != 0) {
|
||||||
const char* detail = ejoc_renderer_last_error(handle);
|
const char* detail = ejoc_renderer_last_error(handle);
|
||||||
const std::string message =
|
const std::string message =
|
||||||
|
|||||||
@@ -10,9 +10,10 @@
|
|||||||
|
|
||||||
namespace joc::joc {
|
namespace joc::joc {
|
||||||
|
|
||||||
// [16][1536] planar float32. The kernel requires exactly 5 core channels.
|
// [16][1536] planar float32. bed_planar is [params.n_channels][1536], where
|
||||||
|
// n_channels comes from joc_dmx_config_idx (5 or 7).
|
||||||
Status rebuild_objects16(ejoc_renderer_handle handle, const joc_frame_params& params,
|
Status rebuild_objects16(ejoc_renderer_handle handle, const joc_frame_params& params,
|
||||||
const float* bed5_planar, const float* lfe, float gain,
|
const float* bed_planar, const float* lfe, float gain,
|
||||||
std::vector<float>* out16, std::string* error);
|
std::vector<float>* out16, std::string* error);
|
||||||
|
|
||||||
} // namespace joc::joc
|
} // namespace joc::joc
|
||||||
@@ -335,6 +335,42 @@ Status parse_id11(const std::uint8_t* payload, std::size_t payload_size, OamdUpd
|
|||||||
return parse_id11_verbose(payload, payload_size, out, nullptr);
|
return parse_id11_verbose(payload, payload_size, out, nullptr);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
Status parse_id11_bed_assignments(const std::uint8_t* payload, std::size_t payload_size,
|
||||||
|
std::vector<BedAssignment>* out) {
|
||||||
|
if (payload == nullptr || out == nullptr) {
|
||||||
|
return Status::fail(JOC_ERR_INVALID_ARGUMENT, stage::kOamd, "null payload or output");
|
||||||
|
}
|
||||||
|
if (payload_size == 0) {
|
||||||
|
return variant("header_truncated", "OAMD payload is empty");
|
||||||
|
}
|
||||||
|
out->clear();
|
||||||
|
bits::BitReader reader(payload, payload_size);
|
||||||
|
std::uint32_t version = reader.read(2);
|
||||||
|
if (reader.failed()) {
|
||||||
|
return variant("header_truncated", "OAMD payload cannot hold the 2-bit version");
|
||||||
|
}
|
||||||
|
if (version == 3u) {
|
||||||
|
version += reader.read(3);
|
||||||
|
if (reader.failed()) {
|
||||||
|
return syntax("OAMD version extension truncated");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
std::uint32_t object_count_bits = reader.read(5);
|
||||||
|
if (object_count_bits == 0x1Fu) {
|
||||||
|
object_count_bits += reader.read(7);
|
||||||
|
}
|
||||||
|
if (reader.failed()) {
|
||||||
|
return syntax("OAMD object count truncated");
|
||||||
|
}
|
||||||
|
ProgramInfo program;
|
||||||
|
const Status status = parse_program_assignment(reader, &program);
|
||||||
|
if (!status.ok()) {
|
||||||
|
return status;
|
||||||
|
}
|
||||||
|
*out = program.bed_assignments;
|
||||||
|
return Status::success();
|
||||||
|
}
|
||||||
|
|
||||||
Status parse_id11_verbose(const std::uint8_t* payload, std::size_t payload_size, OamdUpdate* out,
|
Status parse_id11_verbose(const std::uint8_t* payload, std::size_t payload_size, OamdUpdate* out,
|
||||||
ParseTrace* trace) {
|
ParseTrace* trace) {
|
||||||
if (payload == nullptr || out == nullptr) {
|
if (payload == nullptr || out == nullptr) {
|
||||||
|
|||||||
@@ -100,4 +100,9 @@ struct ParseTrace {
|
|||||||
Status parse_id11_verbose(const std::uint8_t* payload, std::size_t payload_size, OamdUpdate* out,
|
Status parse_id11_verbose(const std::uint8_t* payload, std::size_t payload_size, OamdUpdate* out,
|
||||||
ParseTrace* trace);
|
ParseTrace* trace);
|
||||||
|
|
||||||
|
// Parses only the OAMD header and program_assignment(), which is all the
|
||||||
|
// cross-layer bed-mask check (spec section 11.2 item 2) needs.
|
||||||
|
Status parse_id11_bed_assignments(const std::uint8_t* payload, std::size_t payload_size,
|
||||||
|
std::vector<BedAssignment>* out);
|
||||||
|
|
||||||
} // namespace joc::oamd
|
} // namespace joc::oamd
|
||||||
+209
-25
@@ -17,9 +17,6 @@ namespace joc::stream {
|
|||||||
namespace {
|
namespace {
|
||||||
|
|
||||||
constexpr std::size_t kFrameSamples = JOC_FRAME_SAMPLES;
|
constexpr std::size_t kFrameSamples = JOC_FRAME_SAMPLES;
|
||||||
constexpr std::size_t kBedChannels = 6;
|
|
||||||
constexpr int kCoreChannels[5] = {0, 1, 2, 4, 5};
|
|
||||||
constexpr int kLfeChannel = 3;
|
|
||||||
|
|
||||||
} // namespace
|
} // namespace
|
||||||
|
|
||||||
@@ -37,6 +34,14 @@ Stream::~Stream() {
|
|||||||
void Stream::reset_state() {
|
void Stream::reset_state() {
|
||||||
reader_ = eac3::FrameReader();
|
reader_ = eac3::FrameReader();
|
||||||
metadata_.clear();
|
metadata_.clear();
|
||||||
|
pending_frame_ = FrameMetadata();
|
||||||
|
bed_plan_ = joc::BedPlan();
|
||||||
|
bed_channels_ = 0;
|
||||||
|
config_idx_ = -1;
|
||||||
|
core_channels_ = 0;
|
||||||
|
bed_plan_failed_ = false;
|
||||||
|
bed_plan_error_ = Status::success();
|
||||||
|
bed_input_channels_ = 0;
|
||||||
bed_pending_.clear();
|
bed_pending_.clear();
|
||||||
bed_read_offset_ = 0;
|
bed_read_offset_ = 0;
|
||||||
objects16_.clear();
|
objects16_.clear();
|
||||||
@@ -181,6 +186,43 @@ Status Stream::create(const Config& config) {
|
|||||||
return Status::success();
|
return Status::success();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
Status Stream::flush_pending_frame() {
|
||||||
|
if (pending_frame_.streams.empty()) {
|
||||||
|
return Status::success();
|
||||||
|
}
|
||||||
|
FrameMetadata entry = pending_frame_;
|
||||||
|
pending_frame_ = FrameMetadata();
|
||||||
|
if (entry.has_joc) {
|
||||||
|
std::string error;
|
||||||
|
joc::CrossLayerNotes notes;
|
||||||
|
const Status checked = joc::check_cross_layer(
|
||||||
|
entry.params, entry.has_core ? &entry.core_frame : nullptr, entry.has_core,
|
||||||
|
entry.has_dependent, entry.has_chanmap, entry.chanmap,
|
||||||
|
entry.bed_assignments.empty() ? nullptr : &entry.bed_assignments, &error, ¬es);
|
||||||
|
if (!checked.ok()) {
|
||||||
|
return Status::fail(checked.code(), checked.stage(),
|
||||||
|
error.empty() ? checked.message() : error);
|
||||||
|
}
|
||||||
|
if (notes.chanmap_pair_mismatch) {
|
||||||
|
++info_.chanmap_pair_mismatch_frames;
|
||||||
|
}
|
||||||
|
if (notes.bed_mask_mismatch) {
|
||||||
|
++info_.bed_mask_mismatch_frames;
|
||||||
|
}
|
||||||
|
if (entry.params.objects_clamped != 0u) {
|
||||||
|
++info_.objects_clamped_frames;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
// No JOC metadata for this audio frame: the object channels stay silent
|
||||||
|
// while the kernel state still advances for the frame.
|
||||||
|
++info_.missing_joc_frames;
|
||||||
|
joc::make_silent_frame_params(&entry.params);
|
||||||
|
entry.has_update = false;
|
||||||
|
}
|
||||||
|
metadata_.push_back(entry);
|
||||||
|
return Status::success();
|
||||||
|
}
|
||||||
|
|
||||||
Status Stream::push_eac3(const std::uint8_t* data, std::size_t size, std::size_t* consumed) {
|
Status Stream::push_eac3(const std::uint8_t* data, std::size_t size, std::size_t* consumed) {
|
||||||
if (rebuilder_ == nullptr) {
|
if (rebuilder_ == nullptr) {
|
||||||
return Status::fail(JOC_ERR_STATE, stage::kEmdf, "stream is not an E-AC-3 input");
|
return Status::fail(JOC_ERR_STATE, stage::kEmdf, "stream is not an E-AC-3 input");
|
||||||
@@ -201,13 +243,65 @@ Status Stream::push_eac3(const std::uint8_t* data, std::size_t size, std::size_t
|
|||||||
if (state == eac3::FrameReader::Next::Fail) {
|
if (state == eac3::FrameReader::Next::Fail) {
|
||||||
return Status::fail(reader_.error(), stage::kEac3, reader_.error_message());
|
return Status::fail(reader_.error(), stage::kEac3, reader_.error_message());
|
||||||
}
|
}
|
||||||
FrameMetadata entry;
|
// A repeated (codec, strmtyp, substreamid) combination starts the next
|
||||||
|
// audio frame, so the group that is still open is complete.
|
||||||
|
bool repeats = false;
|
||||||
|
for (const eac3::Frame& prior : pending_frame_.streams) {
|
||||||
|
if (prior.same_stream(frame)) {
|
||||||
|
repeats = true;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (repeats) {
|
||||||
|
const Status flushed = flush_pending_frame();
|
||||||
|
if (!flushed.ok()) {
|
||||||
|
return flushed;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
eac3::Frame header = frame;
|
||||||
|
header.data = nullptr;
|
||||||
|
header.size = 0;
|
||||||
|
header.offset = frame.offset;
|
||||||
|
pending_frame_.streams.push_back(header);
|
||||||
|
if (frame.codec == 0u || frame.strmtyp == 0u) {
|
||||||
|
pending_frame_.core_frame = header;
|
||||||
|
pending_frame_.has_core = true;
|
||||||
|
} else {
|
||||||
|
pending_frame_.has_dependent = true;
|
||||||
|
if (frame.has_chanmap != 0u) {
|
||||||
|
pending_frame_.has_chanmap = true;
|
||||||
|
pending_frame_.chanmap = frame.chanmap;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
bool present = false;
|
||||||
|
bool ignored_extra = false;
|
||||||
emdf::Container container;
|
emdf::Container container;
|
||||||
|
const Status found = emdf::find_joc_emdf_optional(
|
||||||
|
frame.data, frame.size, &present, &container, &joc::score_container_as_joc,
|
||||||
|
&ignored_extra);
|
||||||
|
if (!found.ok()) {
|
||||||
|
return found;
|
||||||
|
}
|
||||||
|
if (ignored_extra) {
|
||||||
|
++info_.extra_container_frames;
|
||||||
|
}
|
||||||
|
if (!present) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
if (container.find(emdf::kIdJoc) == nullptr) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
joc_frame_params params;
|
||||||
const Status parsed =
|
const Status parsed =
|
||||||
joc::parse_eac3_frame(frame.data, frame.size, &entry.params, &container, nullptr);
|
joc::parse_eac3_frame(frame.data, frame.size, ¶ms, &container, nullptr);
|
||||||
if (!parsed.ok()) {
|
if (!parsed.ok()) {
|
||||||
return parsed;
|
return parsed;
|
||||||
}
|
}
|
||||||
|
pending_frame_.params = params;
|
||||||
|
pending_frame_.has_joc = true;
|
||||||
|
pending_frame_.syncframe_offset = frame.offset;
|
||||||
|
pending_frame_.syncframe_size = frame.size;
|
||||||
if (const emdf::Payload* payload = container.find(emdf::kIdOamd)) {
|
if (const emdf::Payload* payload = container.find(emdf::kIdOamd)) {
|
||||||
std::vector<std::uint8_t> bytes;
|
std::vector<std::uint8_t> bytes;
|
||||||
const Status extracted =
|
const Status extracted =
|
||||||
@@ -215,32 +309,82 @@ Status Stream::push_eac3(const std::uint8_t* data, std::size_t size, std::size_t
|
|||||||
if (!extracted.ok()) {
|
if (!extracted.ok()) {
|
||||||
return extracted;
|
return extracted;
|
||||||
}
|
}
|
||||||
const Status oamd = oamd::parse_id11(bytes.data(), bytes.size(), &entry.update);
|
const Status oamd = oamd::parse_id11(bytes.data(), bytes.size(), &pending_frame_.update);
|
||||||
if (!oamd.ok()) {
|
if (!oamd.ok()) {
|
||||||
return oamd;
|
return oamd;
|
||||||
}
|
}
|
||||||
entry.has_update = true;
|
pending_frame_.has_update = true;
|
||||||
entry.outer_offset = static_cast<std::int64_t>(payload->sample_offset);
|
pending_frame_.outer_offset = static_cast<std::int64_t>(payload->sample_offset);
|
||||||
|
const Status bed = oamd::parse_id11_bed_assignments(
|
||||||
|
bytes.data(), bytes.size(), &pending_frame_.bed_assignments);
|
||||||
|
if (!bed.ok()) {
|
||||||
|
return bed;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
metadata_.push_back(entry);
|
|
||||||
}
|
}
|
||||||
|
resolve_bed_plan();
|
||||||
return process_ready_frames(false);
|
return process_ready_frames(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Status Stream::push_bed(const float* interleaved6, std::size_t samples, std::size_t* consumed) {
|
Status Stream::push_bed(const float* interleaved, std::size_t samples, std::uint32_t channels,
|
||||||
|
std::size_t* consumed) {
|
||||||
if (rebuilder_ == nullptr) {
|
if (rebuilder_ == nullptr) {
|
||||||
return Status::fail(JOC_ERR_STATE, stage::kDsp, "stream is not an E-AC-3 input");
|
return Status::fail(JOC_ERR_STATE, stage::kDsp, "stream is not an E-AC-3 input");
|
||||||
}
|
}
|
||||||
|
if (channels != 6u && channels != 8u) {
|
||||||
|
return Status::fail(JOC_ERR_INVALID_ARGUMENT, stage::kDsp,
|
||||||
|
"the core PCM must be interleaved as 6 or 8 channels, got " +
|
||||||
|
std::to_string(channels));
|
||||||
|
}
|
||||||
|
if (bed_input_channels_ == 0u) {
|
||||||
|
bed_input_channels_ = channels;
|
||||||
|
} else if (bed_input_channels_ != channels) {
|
||||||
|
return Status::fail(JOC_ERR_INVALID_ARGUMENT, stage::kDsp,
|
||||||
|
"the core PCM channel count changed from " +
|
||||||
|
std::to_string(bed_input_channels_) + " to " +
|
||||||
|
std::to_string(channels));
|
||||||
|
}
|
||||||
if (consumed != nullptr) {
|
if (consumed != nullptr) {
|
||||||
*consumed = samples;
|
*consumed = samples;
|
||||||
}
|
}
|
||||||
if (interleaved6 != nullptr && samples != 0u) {
|
if (interleaved != nullptr && samples != 0u) {
|
||||||
bed_pending_.insert(bed_pending_.end(), interleaved6,
|
bed_pending_.insert(bed_pending_.end(), interleaved,
|
||||||
interleaved6 + samples * kBedChannels);
|
interleaved + samples * static_cast<std::size_t>(channels));
|
||||||
}
|
}
|
||||||
return process_ready_frames(false);
|
return process_ready_frames(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
bool Stream::resolve_bed_plan() {
|
||||||
|
if (bed_channels_ != 0u) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
const FrameMetadata* joc_entry = nullptr;
|
||||||
|
for (const FrameMetadata& candidate : metadata_) {
|
||||||
|
if (candidate.has_joc) {
|
||||||
|
joc_entry = &candidate;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (joc_entry == nullptr) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
joc::BedPlan plan;
|
||||||
|
const Status status = joc::compute_bed_plan(
|
||||||
|
joc_entry->has_core ? &joc_entry->core_frame : nullptr, joc_entry->has_core,
|
||||||
|
joc_entry->has_dependent, joc_entry->has_chanmap, joc_entry->chanmap,
|
||||||
|
joc_entry->params.dmx_config_idx, &plan);
|
||||||
|
if (!status.ok()) {
|
||||||
|
bed_plan_failed_ = true;
|
||||||
|
bed_plan_error_ = status;
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
bed_plan_ = plan;
|
||||||
|
bed_channels_ = static_cast<std::size_t>(plan.channels);
|
||||||
|
config_idx_ = static_cast<int>(joc_entry->params.dmx_config_idx);
|
||||||
|
core_channels_ = static_cast<int>(joc_entry->params.n_channels);
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
Status Stream::push_objects16(const float* planar16, std::size_t samples, std::size_t* consumed) {
|
Status Stream::push_objects16(const float* planar16, std::size_t samples, std::size_t* consumed) {
|
||||||
if (consumed != nullptr) {
|
if (consumed != nullptr) {
|
||||||
*consumed = samples;
|
*consumed = samples;
|
||||||
@@ -299,26 +443,62 @@ Status Stream::process_objects16_frames(bool drain_all) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
Status Stream::process_ready_frames(bool drain_all) {
|
Status Stream::process_ready_frames(bool drain_all) {
|
||||||
while (bed_pending_.size() - bed_read_offset_ >= kFrameSamples * kBedChannels &&
|
if (bed_plan_failed_) {
|
||||||
|
return bed_plan_error_;
|
||||||
|
}
|
||||||
|
resolve_bed_plan();
|
||||||
|
if (bed_channels_ == 0u) {
|
||||||
|
if (!drain_all || metadata_.empty()) {
|
||||||
|
return Status::success(); // waiting for the first JOC-bearing frame
|
||||||
|
}
|
||||||
|
return Status::fail(JOC_ERR_EMDF_TRANSPORT, stage::kEmdf,
|
||||||
|
"no_contiguous_joc_container: the input carries no JOC EMDF "
|
||||||
|
"container in any audio frame");
|
||||||
|
}
|
||||||
|
if (bed_input_channels_ != 0u && bed_input_channels_ != bed_channels_) {
|
||||||
|
return Status::fail(JOC_ERR_JOC_UNSUPPORTED_VARIANT, "eac3",
|
||||||
|
"core_channel_count_mismatch: the caller pushed " +
|
||||||
|
std::to_string(bed_input_channels_) +
|
||||||
|
"-channel bed PCM but joc_dmx_config_idx=" +
|
||||||
|
std::to_string(config_idx_) + " decodes to " +
|
||||||
|
std::to_string(bed_channels_) + " channels");
|
||||||
|
}
|
||||||
|
while (bed_pending_.size() - bed_read_offset_ >= kFrameSamples * bed_channels_ &&
|
||||||
!metadata_.empty()) {
|
!metadata_.empty()) {
|
||||||
// Leave the rest queued, in order, for a later push or for flush().
|
// Leave the rest queued, in order, for a later push or for flush().
|
||||||
if (!drain_all && buffered_samples() >= kMaxRenderAheadSamples) {
|
if (!drain_all && buffered_samples() >= kMaxRenderAheadSamples) {
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
const FrameMetadata entry = metadata_.front();
|
FrameMetadata entry = metadata_.front();
|
||||||
metadata_.pop_front();
|
metadata_.pop_front();
|
||||||
|
|
||||||
const float* bed = bed_pending_.data() + bed_read_offset_;
|
const int core_channels = entry.has_joc ? static_cast<int>(entry.params.n_channels)
|
||||||
bed5_.resize(static_cast<std::size_t>(JOC_CORE_CHANNELS) * kFrameSamples);
|
: core_channels_;
|
||||||
lfe_.resize(kFrameSamples);
|
if (core_channels <= 0) {
|
||||||
for (std::size_t sample = 0; sample < kFrameSamples; ++sample) {
|
return Status::fail(JOC_ERR_STATE, stage::kDsp,
|
||||||
for (std::size_t channel = 0; channel < JOC_CORE_CHANNELS; ++channel) {
|
"the JOC core channel count is not known yet");
|
||||||
bed5_[channel * kFrameSamples + sample] =
|
|
||||||
bed[sample * kBedChannels + kCoreChannels[channel]];
|
|
||||||
}
|
|
||||||
lfe_[sample] = bed[sample * kBedChannels + kLfeChannel];
|
|
||||||
}
|
}
|
||||||
bed_read_offset_ += kFrameSamples * kBedChannels;
|
if (!entry.has_joc) {
|
||||||
|
entry.params.dmx_config_idx = static_cast<std::uint8_t>(config_idx_);
|
||||||
|
entry.params.n_channels = static_cast<std::uint8_t>(core_channels);
|
||||||
|
}
|
||||||
|
const float* bed = bed_pending_.data() + bed_read_offset_;
|
||||||
|
bed5_.assign(static_cast<std::size_t>(core_channels) * kFrameSamples, 0.0f);
|
||||||
|
lfe_.assign(kFrameSamples, 0.0f);
|
||||||
|
for (std::size_t sample = 0; sample < kFrameSamples; ++sample) {
|
||||||
|
for (int lane = 0; lane < core_channels; ++lane) {
|
||||||
|
const int source = bed_plan_.lane[lane];
|
||||||
|
if (source >= 0) {
|
||||||
|
bed5_[static_cast<std::size_t>(lane) * kFrameSamples + sample] =
|
||||||
|
bed[sample * bed_channels_ + static_cast<std::size_t>(source)];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (bed_plan_.lfe_channel >= 0) {
|
||||||
|
lfe_[sample] = bed[sample * bed_channels_ +
|
||||||
|
static_cast<std::size_t>(bed_plan_.lfe_channel)];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
bed_read_offset_ += kFrameSamples * bed_channels_;
|
||||||
compact_bed_pending();
|
compact_bed_pending();
|
||||||
|
|
||||||
std::string error;
|
std::string error;
|
||||||
@@ -484,6 +664,10 @@ Status Stream::pull(float* destination, std::size_t capacity_samples, std::size_
|
|||||||
Status Stream::flush() {
|
Status Stream::flush() {
|
||||||
// Input has ended, so drain what the cap held back: nothing else will
|
// Input has ended, so drain what the cap held back: nothing else will
|
||||||
// trigger rendering.
|
// trigger rendering.
|
||||||
|
const Status pending = flush_pending_frame();
|
||||||
|
if (!pending.ok()) {
|
||||||
|
return pending;
|
||||||
|
}
|
||||||
const Status remaining = process_ready_frames(true);
|
const Status remaining = process_ready_frames(true);
|
||||||
if (!remaining.ok()) {
|
if (!remaining.ok()) {
|
||||||
return remaining;
|
return remaining;
|
||||||
|
|||||||
@@ -10,6 +10,7 @@
|
|||||||
#include "eac3_transport/eac3_reader.h"
|
#include "eac3_transport/eac3_reader.h"
|
||||||
#include "foundation/status.h"
|
#include "foundation/status.h"
|
||||||
#include "hrtf/rosella_renderer.h"
|
#include "hrtf/rosella_renderer.h"
|
||||||
|
#include "joc_bitstream/joc_parser.h"
|
||||||
#include "joc_core.h"
|
#include "joc_core.h"
|
||||||
#include "joc_stream.h"
|
#include "joc_stream.h"
|
||||||
#include "oamd/oamd_parser.h"
|
#include "oamd/oamd_parser.h"
|
||||||
@@ -46,16 +47,41 @@ struct Info {
|
|||||||
std::uint64_t bytes_in = 0;
|
std::uint64_t bytes_in = 0;
|
||||||
std::uint64_t oamd_payloads = 0;
|
std::uint64_t oamd_payloads = 0;
|
||||||
std::uint64_t oamd_transitions = 0;
|
std::uint64_t oamd_transitions = 0;
|
||||||
|
std::uint64_t missing_joc_frames = 0;
|
||||||
|
std::uint64_t objects_clamped_frames = 0;
|
||||||
|
// Audio frames whose syncframe held more than one top-level JOC container and
|
||||||
|
// were decoded from the single one that carries a complete joc() payload.
|
||||||
|
std::uint64_t extra_container_frames = 0;
|
||||||
|
// Audio frames whose extra-pair identity disagreed across layers (spec 11.2
|
||||||
|
// checks 1 and 2). The identity is metadata only, so these still render.
|
||||||
|
std::uint64_t chanmap_pair_mismatch_frames = 0;
|
||||||
|
std::uint64_t bed_mask_mismatch_frames = 0;
|
||||||
std::uint32_t output_channels = 0;
|
std::uint32_t output_channels = 0;
|
||||||
std::uint32_t ended = 0;
|
std::uint32_t ended = 0;
|
||||||
};
|
};
|
||||||
|
|
||||||
// One frame's metadata, queued while the matching core PCM arrives.
|
// One audio frame's metadata, queued while the matching core PCM arrives.
|
||||||
|
//
|
||||||
|
// One audio frame is the group of syncframes up to (and excluding) the first
|
||||||
|
// repeated (codec, strmtyp, substreamid) combination; the JOC payload usually
|
||||||
|
// lives in the dependent substream while the independent substream carries only
|
||||||
|
// the 5.1 core. The L2 fields below feed the spec section 11.2 cross-layer
|
||||||
|
// checks.
|
||||||
struct FrameMetadata {
|
struct FrameMetadata {
|
||||||
joc_frame_params params{};
|
joc_frame_params params{};
|
||||||
oamd::OamdUpdate update{};
|
oamd::OamdUpdate update{};
|
||||||
bool has_update = false;
|
bool has_update = false;
|
||||||
std::int64_t outer_offset = 0;
|
std::int64_t outer_offset = 0;
|
||||||
|
bool has_joc = false;
|
||||||
|
eac3::Frame core_frame{}; // independent substream header (codec/strmtyp=0)
|
||||||
|
bool has_core = false;
|
||||||
|
bool has_dependent = false;
|
||||||
|
bool has_chanmap = false;
|
||||||
|
std::uint16_t chanmap = 0;
|
||||||
|
std::size_t syncframe_offset = 0;
|
||||||
|
std::size_t syncframe_size = 0;
|
||||||
|
std::vector<eac3::Frame> streams;
|
||||||
|
std::vector<oamd::BedAssignment> bed_assignments;
|
||||||
};
|
};
|
||||||
|
|
||||||
class Stream {
|
class Stream {
|
||||||
@@ -68,7 +94,8 @@ public:
|
|||||||
|
|
||||||
Status create(const Config& config);
|
Status create(const Config& config);
|
||||||
Status push_eac3(const std::uint8_t* data, std::size_t size, std::size_t* consumed);
|
Status push_eac3(const std::uint8_t* data, std::size_t size, std::size_t* consumed);
|
||||||
Status push_bed(const float* interleaved6, std::size_t samples, std::size_t* consumed);
|
Status push_bed(const float* interleaved, std::size_t samples, std::uint32_t channels,
|
||||||
|
std::size_t* consumed);
|
||||||
Status push_objects16(const float* planar16, std::size_t samples, std::size_t* consumed);
|
Status push_objects16(const float* planar16, std::size_t samples, std::size_t* consumed);
|
||||||
Status pull(float* destination, std::size_t capacity_samples, std::size_t* produced);
|
Status pull(float* destination, std::size_t capacity_samples, std::size_t* produced);
|
||||||
Status flush();
|
Status flush();
|
||||||
@@ -103,6 +130,11 @@ private:
|
|||||||
void reset_state();
|
void reset_state();
|
||||||
// Drops the bed samples that have already been rendered, keeping the rest.
|
// Drops the bed samples that have already been rendered, keeping the rest.
|
||||||
void compact_bed_pending();
|
void compact_bed_pending();
|
||||||
|
// Closes the audio frame currently being assembled and queues it.
|
||||||
|
Status flush_pending_frame();
|
||||||
|
// Resolves the bed layout from the first queued frame that carries JOC;
|
||||||
|
// returns false while it is still unknown and more input may arrive.
|
||||||
|
bool resolve_bed_plan();
|
||||||
// Renders the queued objects16 frames, bounded by kMaxRenderAheadSamples.
|
// Renders the queued objects16 frames, bounded by kMaxRenderAheadSamples.
|
||||||
Status process_objects16_frames(bool drain_all);
|
Status process_objects16_frames(bool drain_all);
|
||||||
|
|
||||||
@@ -111,6 +143,14 @@ private:
|
|||||||
eac3::FrameReader reader_;
|
eac3::FrameReader reader_;
|
||||||
std::deque<FrameMetadata> metadata_;
|
std::deque<FrameMetadata> metadata_;
|
||||||
FrameMetadata pending_metadata_;
|
FrameMetadata pending_metadata_;
|
||||||
|
FrameMetadata pending_frame_;
|
||||||
|
joc::BedPlan bed_plan_;
|
||||||
|
std::size_t bed_channels_ = 0;
|
||||||
|
int config_idx_ = -1;
|
||||||
|
int core_channels_ = 0;
|
||||||
|
bool bed_plan_failed_ = false;
|
||||||
|
Status bed_plan_error_;
|
||||||
|
std::uint32_t bed_input_channels_ = 0;
|
||||||
std::vector<float> bed_pending_;
|
std::vector<float> bed_pending_;
|
||||||
std::size_t bed_read_offset_ = 0;
|
std::size_t bed_read_offset_ = 0;
|
||||||
std::vector<float> bed5_;
|
std::vector<float> bed5_;
|
||||||
|
|||||||
+361
-51
@@ -53,11 +53,8 @@ namespace {
|
|||||||
namespace fs = std::filesystem;
|
namespace fs = std::filesystem;
|
||||||
using Clock = std::chrono::steady_clock;
|
using Clock = std::chrono::steady_clock;
|
||||||
|
|
||||||
constexpr std::size_t kBedFrameBytes = static_cast<std::size_t>(JOC_FRAME_SAMPLES) * 6u * 4u;
|
|
||||||
constexpr std::size_t kReadChunk = 1u << 20;
|
constexpr std::size_t kReadChunk = 1u << 20;
|
||||||
constexpr double kDefaultTailThreshold = 1.0e-8;
|
constexpr double kDefaultTailThreshold = 1.0e-8;
|
||||||
constexpr int kCoreChannels[5] = {0, 1, 2, 4, 5};
|
|
||||||
constexpr int kLfeChannel = 3;
|
|
||||||
|
|
||||||
std::string lower(std::string text) {
|
std::string lower(std::string text) {
|
||||||
for (char& c : text) {
|
for (char& c : text) {
|
||||||
@@ -210,6 +207,9 @@ std::string create_temp_dir(const Settings& cfg) { const fs::path base = cfg.
|
|||||||
return fs_utf8::from_path(target);
|
return fs_utf8::from_path(target);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// One audio frame is every syncframe up to (and excluding) the first repeated
|
||||||
|
// (codec, strmtyp, substreamid) combination: a 7-channel program interleaves an
|
||||||
|
// independent substream with a dependent one, and an AC-3 core may come first.
|
||||||
std::uint64_t count_frames(const std::string& path) {
|
std::uint64_t count_frames(const std::string& path) {
|
||||||
std::ifstream input = fs_utf8::open_input(path);
|
std::ifstream input = fs_utf8::open_input(path);
|
||||||
if (!input) {
|
if (!input) {
|
||||||
@@ -219,6 +219,7 @@ std::uint64_t count_frames(const std::string& path) {
|
|||||||
std::vector<char> chunk(kReadChunk);
|
std::vector<char> chunk(kReadChunk);
|
||||||
std::uint64_t frames = 0;
|
std::uint64_t frames = 0;
|
||||||
bool done = false;
|
bool done = false;
|
||||||
|
std::vector<::joc::eac3::Frame> group;
|
||||||
while (!done) {
|
while (!done) {
|
||||||
input.read(chunk.data(), static_cast<std::streamsize>(chunk.size()));
|
input.read(chunk.data(), static_cast<std::streamsize>(chunk.size()));
|
||||||
const std::streamsize got = input.gcount();
|
const std::streamsize got = input.gcount();
|
||||||
@@ -232,16 +233,29 @@ std::uint64_t count_frames(const std::string& path) {
|
|||||||
for (;;) {
|
for (;;) {
|
||||||
::joc::eac3::Frame frame;
|
::joc::eac3::Frame frame;
|
||||||
const ::joc::eac3::FrameReader::Next state = reader.next(&frame);
|
const ::joc::eac3::FrameReader::Next state = reader.next(&frame);
|
||||||
if (state == ::joc::eac3::FrameReader::Next::Ok) {
|
if (state == ::joc::eac3::FrameReader::Next::End) {
|
||||||
++frames;
|
break;
|
||||||
continue;
|
|
||||||
}
|
}
|
||||||
if (state == ::joc::eac3::FrameReader::Next::Fail) {
|
if (state == ::joc::eac3::FrameReader::Next::Fail) {
|
||||||
return frames;
|
return frames + (group.empty() ? 0u : 1u);
|
||||||
}
|
}
|
||||||
break;
|
bool repeats = false;
|
||||||
|
for (const ::joc::eac3::Frame& prior : group) {
|
||||||
|
if (prior.same_stream(frame)) {
|
||||||
|
repeats = true;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (repeats) {
|
||||||
|
++frames;
|
||||||
|
group.clear();
|
||||||
|
}
|
||||||
|
group.push_back(frame);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
if (!group.empty()) {
|
||||||
|
++frames;
|
||||||
|
}
|
||||||
return frames;
|
return frames;
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -253,6 +267,53 @@ bool stdin_is_interactive() {
|
|||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Reads joc_dmx_config_idx from the first syncframe that carries a JOC payload,
|
||||||
|
// without decoding anything else. Returns -1 when the stream has no JOC.
|
||||||
|
int probe_config_idx(const std::string& path) {
|
||||||
|
std::ifstream input = fs_utf8::open_input(path);
|
||||||
|
if (!input) {
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
::joc::eac3::FrameReader reader;
|
||||||
|
std::vector<char> chunk(1u << 16);
|
||||||
|
int config = -1;
|
||||||
|
bool done = false;
|
||||||
|
while (!done && config < 0) {
|
||||||
|
input.read(chunk.data(), static_cast<std::streamsize>(chunk.size()));
|
||||||
|
const std::streamsize got = input.gcount();
|
||||||
|
if (got > 0) {
|
||||||
|
reader.push(reinterpret_cast<const std::uint8_t*>(chunk.data()),
|
||||||
|
static_cast<std::size_t>(got));
|
||||||
|
} else {
|
||||||
|
reader.finish();
|
||||||
|
done = true;
|
||||||
|
}
|
||||||
|
for (;;) {
|
||||||
|
::joc::eac3::Frame frame;
|
||||||
|
const ::joc::eac3::FrameReader::Next state = reader.next(&frame);
|
||||||
|
if (state != ::joc::eac3::FrameReader::Next::Ok) {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
bool present = false;
|
||||||
|
::joc::emdf::Container container;
|
||||||
|
if (!::joc::emdf::find_joc_emdf_optional(
|
||||||
|
frame.data, frame.size, &present, &container,
|
||||||
|
&::joc::joc::score_container_as_joc, nullptr)
|
||||||
|
.ok() ||
|
||||||
|
!present) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
joc_frame_params params{};
|
||||||
|
if (::joc::joc::parse_eac3_frame(frame.data, frame.size, ¶ms, &container, nullptr)
|
||||||
|
.ok()) {
|
||||||
|
config = static_cast<int>(params.dmx_config_idx);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return config;
|
||||||
|
}
|
||||||
|
|
||||||
// Rendered PCM is spooled to a float32 file so the output format can be decided
|
// Rendered PCM is spooled to a float32 file so the output format can be decided
|
||||||
// once the peak is known, which is what makes --clip-action possible; the
|
// once the peak is known, which is what makes --clip-action possible; the
|
||||||
// reference CLI spools for the same reason.
|
// reference CLI spools for the same reason.
|
||||||
@@ -480,6 +541,7 @@ Status report_metadata(const Settings& cfg, telemetry::EventBus* bus, const std:
|
|||||||
double clipgain_max = 0.0;
|
double clipgain_max = 0.0;
|
||||||
bool stream_done = false;
|
bool stream_done = false;
|
||||||
Status failure = Status::success();
|
Status failure = Status::success();
|
||||||
|
std::vector<::joc::eac3::Frame> group;
|
||||||
while (!stream_done && frames < total_frames) {
|
while (!stream_done && frames < total_frames) {
|
||||||
input.read(chunk.data(), static_cast<std::streamsize>(chunk.size()));
|
input.read(chunk.data(), static_cast<std::streamsize>(chunk.size()));
|
||||||
const std::streamsize got = input.gcount();
|
const std::streamsize got = input.gcount();
|
||||||
@@ -503,8 +565,36 @@ Status report_metadata(const Settings& cfg, telemetry::EventBus* bus, const std:
|
|||||||
stream_done = true;
|
stream_done = true;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
joc_frame_params params{};
|
// Count audio frames, not syncframes: a 7-channel program interleaves
|
||||||
|
// two substreams and one bed frame covers both.
|
||||||
|
bool repeats = false;
|
||||||
|
for (const ::joc::eac3::Frame& prior : group) {
|
||||||
|
if (prior.same_stream(frame)) {
|
||||||
|
repeats = true;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (repeats) {
|
||||||
|
++frames;
|
||||||
|
group.clear();
|
||||||
|
if (frames >= total_frames) {
|
||||||
|
stream_done = true;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
group.push_back(frame);
|
||||||
|
bool present = false;
|
||||||
::joc::emdf::Container container;
|
::joc::emdf::Container container;
|
||||||
|
const Status found = ::joc::emdf::find_joc_emdf_optional(
|
||||||
|
frame.data, frame.size, &present, &container,
|
||||||
|
&::joc::joc::score_container_as_joc, nullptr);
|
||||||
|
if (!found.ok()) {
|
||||||
|
return Status::fail(found.code(), found.stage(), found.message());
|
||||||
|
}
|
||||||
|
if (!present || container.find(::joc::emdf::kIdJoc) == nullptr) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
joc_frame_params params{};
|
||||||
const Status parsed = ::joc::joc::parse_eac3_frame(frame.data, frame.size, ¶ms,
|
const Status parsed = ::joc::joc::parse_eac3_frame(frame.data, frame.size, ¶ms,
|
||||||
&container, nullptr);
|
&container, nullptr);
|
||||||
if (!parsed.ok()) {
|
if (!parsed.ok()) {
|
||||||
@@ -593,35 +683,51 @@ Status report_metadata(const Settings& cfg, telemetry::EventBus* bus, const std:
|
|||||||
return failure;
|
return failure;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// The decoded core PCM, read one frame at a time and laid out for the JOC
|
||||||
|
// kernel according to the bed plan (spec section 3: map by channel code, not by
|
||||||
|
// bed channel number).
|
||||||
class BedSource {
|
class BedSource {
|
||||||
public:
|
public:
|
||||||
bool open(const std::string& path) {
|
bool open(const std::string& path, std::size_t channels) {
|
||||||
|
channels_ = channels;
|
||||||
file_.open(path, std::ios::binary);
|
file_.open(path, std::ios::binary);
|
||||||
return static_cast<bool>(file_);
|
return static_cast<bool>(file_);
|
||||||
}
|
}
|
||||||
|
|
||||||
bool read_frame(std::uint64_t index, std::vector<float>* bed5, std::vector<float>* lfe) {
|
bool read_frame(std::uint64_t index, int core_channels, const ::joc::joc::BedPlan& plan,
|
||||||
bed5->assign(static_cast<std::size_t>(JOC_CORE_CHANNELS) * JOC_FRAME_SAMPLES, 0.0f);
|
std::vector<float>* bed, std::vector<float>* lfe) {
|
||||||
|
bed->assign(static_cast<std::size_t>(core_channels) * JOC_FRAME_SAMPLES, 0.0f);
|
||||||
lfe->assign(JOC_FRAME_SAMPLES, 0.0f);
|
lfe->assign(JOC_FRAME_SAMPLES, 0.0f);
|
||||||
|
const std::size_t frame_values = static_cast<std::size_t>(JOC_FRAME_SAMPLES) * channels_;
|
||||||
|
interleaved_.assign(frame_values, 0.0f);
|
||||||
file_.clear();
|
file_.clear();
|
||||||
file_.seekg(static_cast<std::streamoff>(index * kBedFrameBytes), std::ios::beg);
|
file_.seekg(static_cast<std::streamoff>(index * frame_values * sizeof(float)),
|
||||||
std::vector<float> interleaved(static_cast<std::size_t>(JOC_FRAME_SAMPLES) * 6u);
|
std::ios::beg);
|
||||||
file_.read(reinterpret_cast<char*>(interleaved.data()),
|
file_.read(reinterpret_cast<char*>(interleaved_.data()),
|
||||||
static_cast<std::streamsize>(interleaved.size() * sizeof(float)));
|
static_cast<std::streamsize>(frame_values * sizeof(float)));
|
||||||
if (file_.gcount() != static_cast<std::streamsize>(interleaved.size() * sizeof(float))) {
|
if (file_.gcount() != static_cast<std::streamsize>(frame_values * sizeof(float))) {
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
for (std::size_t n = 0; n < JOC_FRAME_SAMPLES; ++n) {
|
for (std::size_t n = 0; n < JOC_FRAME_SAMPLES; ++n) {
|
||||||
for (std::size_t c = 0; c < JOC_CORE_CHANNELS; ++c) {
|
for (int lane = 0; lane < core_channels; ++lane) {
|
||||||
(*bed5)[c * JOC_FRAME_SAMPLES + n] = interleaved[n * 6u + kCoreChannels[c]];
|
const int source = plan.lane[lane];
|
||||||
|
if (source >= 0) {
|
||||||
|
(*bed)[static_cast<std::size_t>(lane) * JOC_FRAME_SAMPLES + n] =
|
||||||
|
interleaved_[n * channels_ + static_cast<std::size_t>(source)];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (plan.lfe_channel >= 0) {
|
||||||
|
(*lfe)[n] = interleaved_[n * channels_ +
|
||||||
|
static_cast<std::size_t>(plan.lfe_channel)];
|
||||||
}
|
}
|
||||||
(*lfe)[n] = interleaved[n * 6u + kLfeChannel];
|
|
||||||
}
|
}
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
private:
|
private:
|
||||||
std::ifstream file_;
|
std::ifstream file_;
|
||||||
|
std::size_t channels_ = 6;
|
||||||
|
std::vector<float> interleaved_;
|
||||||
};
|
};
|
||||||
|
|
||||||
// ---------------------------------------------------------------------------
|
// ---------------------------------------------------------------------------
|
||||||
@@ -1115,17 +1221,37 @@ Status run(const joc_task_config& raw, const joc_event_sink* sink, joc_task_resu
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// The stream itself decides how many channels the decoded bed has; the same
|
||||||
|
// answer feeds the ffmpeg decode below and the bed reader.
|
||||||
|
const int stream_config_idx = probe_config_idx(eac3_path);
|
||||||
|
const int stream_core_channels =
|
||||||
|
stream_config_idx >= 0
|
||||||
|
? static_cast<int>(::joc::joc::num_channels_for_config(
|
||||||
|
static_cast<std::uint32_t>(stream_config_idx)))
|
||||||
|
: static_cast<int>(JOC_CORE_CHANNELS);
|
||||||
|
const std::size_t stream_bed_channels =
|
||||||
|
stream_core_channels == JOC_MAX_CORE_CHANNELS ? 8u : 6u;
|
||||||
|
|
||||||
std::string bed_path = cfg.bed_path;
|
std::string bed_path = cfg.bed_path;
|
||||||
if (bed_path.empty() && !cfg.metadata_only) {
|
if (bed_path.empty() && !cfg.metadata_only) {
|
||||||
if (temp_dir.empty()) {
|
if (temp_dir.empty()) {
|
||||||
temp_dir = create_temp_dir(cfg);
|
temp_dir = create_temp_dir(cfg);
|
||||||
}
|
}
|
||||||
bed_path = fs_utf8::from_path(fs_utf8::to_path(temp_dir) / "core51_f32le.raw");
|
bed_path = fs_utf8::from_path(fs_utf8::to_path(temp_dir) / "core_f32le.raw");
|
||||||
bus.stage(JOC_STAGE_DECODE, "decoding the 5.1 core PCM with ffmpeg");
|
// A 7-channel program decodes to 8 bed channels; -ac 6 would downmix
|
||||||
|
// 5.1.2/7.1 into 5.1 and drop the extra pair, and -ac 8 would remap
|
||||||
|
// 5.1.2 into 7.1, so the native decoder layout is what we want there.
|
||||||
|
const bool native_bed = stream_core_channels == JOC_MAX_CORE_CHANNELS;
|
||||||
|
bus.stage(JOC_STAGE_DECODE, native_bed
|
||||||
|
? "decoding the core PCM with ffmpeg (native layout)"
|
||||||
|
: "decoding the 5.1 core PCM with ffmpeg");
|
||||||
std::vector<std::string> argv = {cfg.ffmpeg_path, "-hide_banner", "-loglevel", "error", "-y",
|
std::vector<std::string> argv = {cfg.ffmpeg_path, "-hide_banner", "-loglevel", "error", "-y",
|
||||||
"-i", eac3_path};
|
"-i", eac3_path};
|
||||||
argv.insert(argv.end(), {"-map", "0:a:0", "-vn", "-ac", "6", "-ar", "48000",
|
argv.insert(argv.end(), {"-map", "0:a:0", "-vn"});
|
||||||
"-c:a", "pcm_f32le", "-f", "f32le", bed_path});
|
if (!native_bed) {
|
||||||
|
argv.insert(argv.end(), {"-ac", "6"});
|
||||||
|
}
|
||||||
|
argv.insert(argv.end(), {"-ar", "48000", "-c:a", "pcm_f32le", "-f", "f32le", bed_path});
|
||||||
argv.insert(argv.begin() + 4, {"-drc_scale", fmt("%.10g", cfg.drc_scale)});
|
argv.insert(argv.begin() + 4, {"-drc_scale", fmt("%.10g", cfg.drc_scale)});
|
||||||
if (cfg.target_level != 0) {
|
if (cfg.target_level != 0) {
|
||||||
argv.insert(argv.begin() + 4, {"-target_level", std::to_string(cfg.target_level)});
|
argv.insert(argv.begin() + 4, {"-target_level", std::to_string(cfg.target_level)});
|
||||||
@@ -1336,7 +1462,7 @@ Status run(const joc_task_config& raw, const joc_event_sink* sink, joc_task_resu
|
|||||||
}
|
}
|
||||||
|
|
||||||
BedSource bed;
|
BedSource bed;
|
||||||
if (!bed.open(bed_path)) {
|
if (!bed.open(bed_path, stream_bed_channels)) {
|
||||||
return finalize_with_error(JOC_ERR_INPUT_NOT_FOUND, "bed_path",
|
return finalize_with_error(JOC_ERR_INPUT_NOT_FOUND, "bed_path",
|
||||||
"cannot open the core PCM: " + bed_path);
|
"cannot open the core PCM: " + bed_path);
|
||||||
}
|
}
|
||||||
@@ -1370,6 +1496,15 @@ Status run(const joc_task_config& raw, const joc_event_sink* sink, joc_task_resu
|
|||||||
std::thread producer;
|
std::thread producer;
|
||||||
std::thread writer;
|
std::thread writer;
|
||||||
StageJoiner joiner(&joc_ring, &output_ring, &stop, &producer, &writer);
|
StageJoiner joiner(&joc_ring, &output_ring, &stop, &producer, &writer);
|
||||||
|
// Metadata the JOC stage had to work around, counted there and reported after
|
||||||
|
// the stages join: frames with no JOC payload, frames whose declared object
|
||||||
|
// count was clamped to 15, and frames whose syncframe carried a second EMDF
|
||||||
|
// container that is not this frame's JOC metadata.
|
||||||
|
std::uint64_t missing_joc_frames = 0;
|
||||||
|
std::uint64_t objects_clamped_frames = 0;
|
||||||
|
std::uint64_t extra_container_frames = 0;
|
||||||
|
std::uint64_t chanmap_pair_mismatch_frames = 0;
|
||||||
|
std::uint64_t bed_mask_mismatch_frames = 0;
|
||||||
|
|
||||||
// ---- stage 1: the bitstream, on its own thread ------------------------ //
|
// ---- stage 1: the bitstream, on its own thread ------------------------ //
|
||||||
// The serial loop's read/decode/JOC section, verbatim apart from its error
|
// The serial loop's read/decode/JOC section, verbatim apart from its error
|
||||||
@@ -1380,9 +1515,116 @@ Status run(const joc_task_config& raw, const joc_event_sink* sink, joc_task_resu
|
|||||||
bool stream_done = false;
|
bool stream_done = false;
|
||||||
double seconds = 0.0;
|
double seconds = 0.0;
|
||||||
JocJob job;
|
JocJob job;
|
||||||
|
// Audio-frame assembly state (kept across chunk reads).
|
||||||
|
std::vector<::joc::eac3::Frame> group;
|
||||||
|
::joc::eac3::Frame group_core;
|
||||||
|
bool group_has_core = false;
|
||||||
|
bool group_has_dependent = false;
|
||||||
|
bool group_has_chanmap = false;
|
||||||
|
bool group_has_joc = false;
|
||||||
|
std::uint16_t group_chanmap = 0;
|
||||||
|
joc_frame_params group_params{};
|
||||||
|
std::vector<::joc::oamd::BedAssignment> group_bed_assignments;
|
||||||
|
::joc::joc::BedPlan plan;
|
||||||
|
bool plan_ready = false;
|
||||||
|
int resolved_core_channels = 0;
|
||||||
try {
|
try {
|
||||||
while (!stream_done && !stop.requested()) {
|
while (!stream_done && !stop.requested()) {
|
||||||
auto stage_started = Clock::now();
|
auto stage_started = Clock::now();
|
||||||
|
|
||||||
|
// Emits the audio frame the group has accumulated so far.
|
||||||
|
auto emit_group = [&]() -> Status {
|
||||||
|
const bool has_joc = group_has_joc;
|
||||||
|
joc_frame_params params = group_params;
|
||||||
|
const bool has_core = group_has_core;
|
||||||
|
const eac3::Frame core_header = group_core;
|
||||||
|
const bool has_dependent = group_has_dependent;
|
||||||
|
const bool has_chanmap = group_has_chanmap;
|
||||||
|
const std::uint16_t chanmap = group_chanmap;
|
||||||
|
std::vector<::joc::oamd::BedAssignment> assignments =
|
||||||
|
std::move(group_bed_assignments);
|
||||||
|
group.clear();
|
||||||
|
group_has_core = false;
|
||||||
|
group_has_dependent = false;
|
||||||
|
group_has_chanmap = false;
|
||||||
|
group_has_joc = false;
|
||||||
|
group_chanmap = 0;
|
||||||
|
group_params = joc_frame_params{};
|
||||||
|
group_bed_assignments.clear();
|
||||||
|
|
||||||
|
if (has_joc) {
|
||||||
|
std::string error;
|
||||||
|
::joc::joc::CrossLayerNotes notes;
|
||||||
|
const Status checked = ::joc::joc::check_cross_layer(
|
||||||
|
params, has_core ? &core_header : nullptr, has_core, has_dependent,
|
||||||
|
has_chanmap, chanmap,
|
||||||
|
assignments.empty() ? nullptr : &assignments, &error, ¬es);
|
||||||
|
if (!checked.ok()) {
|
||||||
|
return Status::fail(checked.code(), checked.stage(),
|
||||||
|
error.empty() ? checked.message() : error);
|
||||||
|
}
|
||||||
|
if (notes.chanmap_pair_mismatch) {
|
||||||
|
++chanmap_pair_mismatch_frames;
|
||||||
|
}
|
||||||
|
if (notes.bed_mask_mismatch) {
|
||||||
|
++bed_mask_mismatch_frames;
|
||||||
|
}
|
||||||
|
if (params.objects_clamped != 0u) {
|
||||||
|
++objects_clamped_frames;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
++missing_joc_frames;
|
||||||
|
}
|
||||||
|
if (!plan_ready) {
|
||||||
|
if (stream_config_idx < 0) {
|
||||||
|
return Status::fail(JOC_ERR_EMDF_TRANSPORT, "emdf",
|
||||||
|
"no_contiguous_joc_container: the input carries "
|
||||||
|
"no JOC EMDF container in any audio frame");
|
||||||
|
}
|
||||||
|
const Status planned = ::joc::joc::compute_bed_plan(
|
||||||
|
has_core ? &core_header : nullptr, has_core, has_dependent,
|
||||||
|
has_chanmap, chanmap,
|
||||||
|
static_cast<std::uint8_t>(stream_config_idx), &plan);
|
||||||
|
if (!planned.ok()) {
|
||||||
|
return planned;
|
||||||
|
}
|
||||||
|
resolved_core_channels = stream_core_channels;
|
||||||
|
plan_ready = true;
|
||||||
|
}
|
||||||
|
if (!has_joc) {
|
||||||
|
::joc::joc::make_silent_frame_params(¶ms);
|
||||||
|
}
|
||||||
|
params.dmx_config_idx = static_cast<std::uint8_t>(stream_config_idx);
|
||||||
|
params.n_channels = static_cast<std::uint8_t>(resolved_core_channels);
|
||||||
|
if (!bed.read_frame(produced, resolved_core_channels, plan, &bed5, &lfe)) {
|
||||||
|
return Status::fail(JOC_ERR_INPUT_FORMAT, "bed_path",
|
||||||
|
"core PCM ended before frame " +
|
||||||
|
std::to_string(produced));
|
||||||
|
}
|
||||||
|
std::string dsp_error;
|
||||||
|
const Status rebuilt = ::joc::joc::rebuild_objects16(
|
||||||
|
rebuilder, params, bed5.data(), lfe.data(), gain, &objects16,
|
||||||
|
&dsp_error);
|
||||||
|
if (!rebuilt.ok()) {
|
||||||
|
return Status::fail(rebuilt.code(), "joc", dsp_error);
|
||||||
|
}
|
||||||
|
job.index = produced;
|
||||||
|
job.objects = params.n_objects;
|
||||||
|
job.clipgain = params.clipgain;
|
||||||
|
job.objects16.swap(objects16);
|
||||||
|
// The clock stops before the handoff, so the stage's number is
|
||||||
|
// its own work (including the chunk read) and never the time it
|
||||||
|
// spent waiting for the DSP to make room in the ring.
|
||||||
|
seconds +=
|
||||||
|
std::chrono::duration<double>(Clock::now() - stage_started).count();
|
||||||
|
if (!joc_ring.push(&job)) {
|
||||||
|
return Status::fail(JOC_ERR_STATE, "output",
|
||||||
|
"the output ring closed while rendering");
|
||||||
|
}
|
||||||
|
++produced;
|
||||||
|
stage_started = Clock::now();
|
||||||
|
return Status::success();
|
||||||
|
};
|
||||||
input.read(chunk.data(), static_cast<std::streamsize>(chunk.size()));
|
input.read(chunk.data(), static_cast<std::streamsize>(chunk.size()));
|
||||||
const std::streamsize got = input.gcount();
|
const std::streamsize got = input.gcount();
|
||||||
if (got > 0) {
|
if (got > 0) {
|
||||||
@@ -1408,14 +1650,63 @@ Status run(const joc_task_config& raw, const joc_event_sink* sink, joc_task_resu
|
|||||||
stream_done = true;
|
stream_done = true;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
if (!bed.read_frame(produced, &bed5, &lfe)) {
|
// A repeated (codec, strmtyp, substreamid) combination closes the
|
||||||
failures.record(produced, StageRank::kJoc, JOC_ERR_INPUT_FORMAT, "bed_path",
|
// audio frame the group is holding.
|
||||||
"core PCM ended before frame " + std::to_string(produced));
|
bool repeats = false;
|
||||||
|
for (const ::joc::eac3::Frame& prior : group) {
|
||||||
|
if (prior.same_stream(frame)) {
|
||||||
|
repeats = true;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (repeats) {
|
||||||
|
const Status emitted = emit_group();
|
||||||
|
if (!emitted.ok()) {
|
||||||
|
failures.record(produced, StageRank::kJoc, emitted.code(),
|
||||||
|
emitted.stage(), emitted.message());
|
||||||
|
stream_done = true;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if (produced >= total_frames) {
|
||||||
|
stream_done = true;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
::joc::eac3::Frame header = frame;
|
||||||
|
header.data = nullptr;
|
||||||
|
header.size = 0;
|
||||||
|
group.push_back(header);
|
||||||
|
if (frame.codec == 0u || frame.strmtyp == 0u) {
|
||||||
|
group_core = header;
|
||||||
|
group_has_core = true;
|
||||||
|
} else {
|
||||||
|
group_has_dependent = true;
|
||||||
|
if (frame.has_chanmap != 0u) {
|
||||||
|
group_has_chanmap = true;
|
||||||
|
group_chanmap = frame.chanmap;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
bool present = false;
|
||||||
|
bool extra_container_ignored = false;
|
||||||
|
::joc::emdf::Container container;
|
||||||
|
const Status found = ::joc::emdf::find_joc_emdf_optional(
|
||||||
|
frame.data, frame.size, &present, &container,
|
||||||
|
&::joc::joc::score_container_as_joc, &extra_container_ignored);
|
||||||
|
if (extra_container_ignored) {
|
||||||
|
++extra_container_frames;
|
||||||
|
}
|
||||||
|
if (!found.ok()) {
|
||||||
|
failures.record(produced, StageRank::kJoc, found.code(), found.stage(),
|
||||||
|
"frame " + std::to_string(produced) + ": " +
|
||||||
|
found.message());
|
||||||
stream_done = true;
|
stream_done = true;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
if (!present || container.find(::joc::emdf::kIdJoc) == nullptr) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
joc_frame_params params{};
|
joc_frame_params params{};
|
||||||
::joc::emdf::Container container;
|
|
||||||
const Status parsed = ::joc::joc::parse_eac3_frame(frame.data, frame.size,
|
const Status parsed = ::joc::joc::parse_eac3_frame(frame.data, frame.size,
|
||||||
¶ms, &container, nullptr);
|
¶ms, &container, nullptr);
|
||||||
if (!parsed.ok()) {
|
if (!parsed.ok()) {
|
||||||
@@ -1425,6 +1716,8 @@ Status run(const joc_task_config& raw, const joc_event_sink* sink, joc_task_resu
|
|||||||
stream_done = true;
|
stream_done = true;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
group_params = params;
|
||||||
|
group_has_joc = true;
|
||||||
job.update = ::joc::oamd::OamdUpdate{};
|
job.update = ::joc::oamd::OamdUpdate{};
|
||||||
job.has_update = false;
|
job.has_update = false;
|
||||||
job.outer_offset = 0;
|
job.outer_offset = 0;
|
||||||
@@ -1449,30 +1742,24 @@ Status run(const joc_task_config& raw, const joc_event_sink* sink, joc_task_resu
|
|||||||
}
|
}
|
||||||
job.has_update = true;
|
job.has_update = true;
|
||||||
job.outer_offset = static_cast<std::int64_t>(payload->sample_offset);
|
job.outer_offset = static_cast<std::int64_t>(payload->sample_offset);
|
||||||
|
const Status bed_ok = ::joc::oamd::parse_id11_bed_assignments(
|
||||||
|
bytes.data(), bytes.size(), &group_bed_assignments);
|
||||||
|
if (!bed_ok.ok()) {
|
||||||
|
failures.record(produced, StageRank::kJoc, bed_ok.code(),
|
||||||
|
bed_ok.stage(), bed_ok.message());
|
||||||
|
stream_done = true;
|
||||||
|
break;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
std::string dsp_error;
|
}
|
||||||
const Status rebuilt = ::joc::joc::rebuild_objects16(
|
// The final frame of an input that ends exactly on a group boundary
|
||||||
rebuilder, params, bed5.data(), lfe.data(), gain, &objects16, &dsp_error);
|
// has already been emitted above.
|
||||||
if (!rebuilt.ok()) {
|
if (stream_done && !group.empty() && produced < total_frames) {
|
||||||
failures.record(produced, StageRank::kJoc, rebuilt.code(), "joc",
|
const Status emitted = emit_group();
|
||||||
"frame " + std::to_string(produced) + ": " + dsp_error);
|
if (!emitted.ok()) {
|
||||||
stream_done = true;
|
failures.record(produced, StageRank::kJoc, emitted.code(),
|
||||||
break;
|
emitted.stage(), emitted.message());
|
||||||
}
|
}
|
||||||
job.index = produced;
|
|
||||||
job.objects = params.n_objects;
|
|
||||||
job.clipgain = params.clipgain;
|
|
||||||
job.objects16.swap(objects16);
|
|
||||||
// The clock stops before the handoff, so the stage's number is
|
|
||||||
// its own work (including the chunk read) and never the time it
|
|
||||||
// spent waiting for the DSP to make room in the ring.
|
|
||||||
seconds += std::chrono::duration<double>(Clock::now() - stage_started).count();
|
|
||||||
if (!joc_ring.push(&job)) {
|
|
||||||
stream_done = true;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
++produced;
|
|
||||||
stage_started = Clock::now();
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
} catch (...) {
|
} catch (...) {
|
||||||
@@ -1733,6 +2020,29 @@ Status run(const joc_task_config& raw, const joc_event_sink* sink, joc_task_resu
|
|||||||
// frames and join it. Every in-loop write is finished before the finalize
|
// frames and join it. Every in-loop write is finished before the finalize
|
||||||
// (tail flush, spool -> WAV, SHA-256, report) looks at the output.
|
// (tail flush, spool -> WAV, SHA-256, report) looks at the output.
|
||||||
joiner.shutdown(false);
|
joiner.shutdown(false);
|
||||||
|
if (missing_joc_frames != 0u) {
|
||||||
|
bus.warning(std::to_string(missing_joc_frames) +
|
||||||
|
" audio frame(s) carried no JOC payload; their object channels stay silent");
|
||||||
|
}
|
||||||
|
if (objects_clamped_frames != 0u) {
|
||||||
|
bus.warning(std::to_string(objects_clamped_frames) +
|
||||||
|
" audio frame(s) declared more than 15 objects; the count was clamped to 15");
|
||||||
|
}
|
||||||
|
if (extra_container_frames != 0u) {
|
||||||
|
bus.warning(std::to_string(extra_container_frames) +
|
||||||
|
" audio frame(s) carried a second EMDF container; the container whose OAMD "
|
||||||
|
"and JOC payloads share a group id (and whose JOC payload parses) was used");
|
||||||
|
}
|
||||||
|
if (chanmap_pair_mismatch_frames != 0u) {
|
||||||
|
bus.warning(std::to_string(chanmap_pair_mismatch_frames) +
|
||||||
|
" audio frame(s): the chanmap declares a different extra pair than "
|
||||||
|
"joc_dmx_config_idx; the bed mapping follows the chanmap");
|
||||||
|
}
|
||||||
|
if (bed_mask_mismatch_frames != 0u) {
|
||||||
|
bus.warning(std::to_string(bed_mask_mismatch_frames) +
|
||||||
|
" audio frame(s): the OAMD bed mask declares a different extra pair than "
|
||||||
|
"joc_dmx_config_idx; the bed mask only affects metadata");
|
||||||
|
}
|
||||||
StageFailure recorded;
|
StageFailure recorded;
|
||||||
if (failures.earliest(&recorded)) {
|
if (failures.earliest(&recorded)) {
|
||||||
return finalize_with_error(recorded.code, recorded.stage_text, recorded.message);
|
return finalize_with_error(recorded.code, recorded.stage_text, recorded.message);
|
||||||
|
|||||||
+112
-5
@@ -249,16 +249,120 @@ bool contains_payload(const std::uint8_t* frame, std::size_t size, std::uint8_t
|
|||||||
|
|
||||||
} // namespace
|
} // namespace
|
||||||
|
|
||||||
std::size_t frame_bytes_at(const std::uint8_t* data, std::size_t size, std::size_t offset) {
|
namespace {
|
||||||
if (data == nullptr || offset + 4u > size) return 0;
|
|
||||||
|
std::uint32_t read_bits(const std::uint8_t* data, std::size_t start, std::size_t count) {
|
||||||
|
std::uint32_t value = 0;
|
||||||
|
for (std::size_t index = start; index < start + count; ++index) {
|
||||||
|
value = (value << 1) | ((data[index >> 3] >> (7u - (index & 7u))) & 1u);
|
||||||
|
}
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
|
||||||
|
// AC-3 syncframe length in 16-bit words, indexed by fscod then frmsizecod.
|
||||||
|
const std::uint16_t kAc3FrameWords[3][38] = {
|
||||||
|
{64, 64, 80, 80, 96, 96, 112, 112, 128, 128, 160, 160, 192, 192, 224, 224,
|
||||||
|
256, 256, 320, 320, 384, 384, 448, 448, 512, 512, 640, 640, 768, 768,
|
||||||
|
896, 896, 1024, 1024, 1152, 1152, 1280, 1280},
|
||||||
|
{69, 70, 87, 88, 104, 105, 121, 122, 139, 140, 174, 175, 208, 209, 243, 244,
|
||||||
|
278, 278, 348, 348, 417, 418, 487, 487, 557, 557, 696, 696, 835, 835,
|
||||||
|
975, 975, 1114, 1114, 1253, 1253, 1393, 1393},
|
||||||
|
{96, 96, 120, 120, 144, 144, 168, 168, 192, 192, 240, 240, 288, 288, 336, 336,
|
||||||
|
384, 384, 480, 480, 576, 576, 672, 672, 768, 768, 960, 960, 1152, 1152,
|
||||||
|
1344, 1344, 1536, 1536, 1728, 1728, 1920, 1920},
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace
|
||||||
|
|
||||||
|
std::size_t frame_header_at(const std::uint8_t* data, std::size_t size, std::size_t offset,
|
||||||
|
FrameHeader* out) {
|
||||||
|
if (data == nullptr || offset + 6u > size) return 0;
|
||||||
const std::uint16_t syncword =
|
const std::uint16_t syncword =
|
||||||
static_cast<std::uint16_t>((static_cast<std::uint16_t>(data[offset]) << 8) | data[offset + 1]);
|
static_cast<std::uint16_t>((static_cast<std::uint16_t>(data[offset]) << 8) | data[offset + 1]);
|
||||||
if (syncword != kEac3Syncword) return 0;
|
if (syncword != kEac3Syncword) return 0;
|
||||||
|
const std::size_t base = offset * 8u;
|
||||||
|
const std::uint32_t bsid = read_bits(data, base + 40u, 5u);
|
||||||
|
if (bsid <= 8u) {
|
||||||
|
const std::uint32_t fscod = read_bits(data, base + 32u, 2u);
|
||||||
|
const std::uint32_t frmsizecod = read_bits(data, base + 34u, 6u);
|
||||||
|
if (fscod > 2u || frmsizecod >= 38u) return 0;
|
||||||
|
if (out != nullptr) {
|
||||||
|
out->frame_bytes = static_cast<std::size_t>(kAc3FrameWords[fscod][frmsizecod]) * 2u;
|
||||||
|
out->offset = offset;
|
||||||
|
out->codec = 0;
|
||||||
|
out->strmtyp = 0;
|
||||||
|
out->substreamid = 0;
|
||||||
|
}
|
||||||
|
return static_cast<std::size_t>(kAc3FrameWords[fscod][frmsizecod]) * 2u;
|
||||||
|
}
|
||||||
const std::size_t words =
|
const std::size_t words =
|
||||||
(static_cast<std::size_t>(data[offset + 2] & 0x07u) << 8) | data[offset + 3];
|
(static_cast<std::size_t>(data[offset + 2] & 0x07u) << 8) | data[offset + 3];
|
||||||
|
if (out != nullptr) {
|
||||||
|
out->frame_bytes = (words + 1u) * 2u;
|
||||||
|
out->offset = offset;
|
||||||
|
out->codec = 1;
|
||||||
|
out->strmtyp = static_cast<std::uint8_t>(read_bits(data, base + 16u, 2u));
|
||||||
|
out->substreamid = static_cast<std::uint8_t>(read_bits(data, base + 18u, 3u));
|
||||||
|
}
|
||||||
return (words + 1u) * 2u;
|
return (words + 1u) * 2u;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
std::size_t frame_bytes_at(const std::uint8_t* data, std::size_t size, std::size_t offset) {
|
||||||
|
return frame_header_at(data, size, offset, nullptr);
|
||||||
|
}
|
||||||
|
|
||||||
|
std::size_t audio_frame_bytes_at(const std::uint8_t* data, std::size_t size, std::size_t offset,
|
||||||
|
bool end_of_stream) {
|
||||||
|
constexpr std::size_t kMaxSubstreams = 8;
|
||||||
|
FrameHeader seen[kMaxSubstreams];
|
||||||
|
std::size_t count = 0;
|
||||||
|
std::size_t consumed = 0;
|
||||||
|
while (count < kMaxSubstreams) {
|
||||||
|
FrameHeader header;
|
||||||
|
const std::size_t bytes = frame_header_at(data, size, offset + consumed, &header);
|
||||||
|
if (bytes == 0 || offset + consumed + bytes > size) break;
|
||||||
|
bool repeats = false;
|
||||||
|
for (std::size_t index = 0; index < count; ++index) {
|
||||||
|
if (seen[index].same_stream(header)) {
|
||||||
|
repeats = true;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (repeats) return consumed;
|
||||||
|
seen[count++] = header;
|
||||||
|
consumed += bytes;
|
||||||
|
}
|
||||||
|
if (count != 0u && consumed != 0u && end_of_stream) return consumed;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool joc_config_idx(const std::uint8_t* frame, std::size_t frame_bytes, unsigned* out) {
|
||||||
|
if (out == nullptr || frame == nullptr || frame_bytes < 8u) return false;
|
||||||
|
std::size_t offsets[4096];
|
||||||
|
std::size_t count = 0;
|
||||||
|
marker_offsets(frame, frame_bytes, offsets, 4096, &count);
|
||||||
|
for (std::size_t i = 0; i < count; ++i) {
|
||||||
|
Container candidate;
|
||||||
|
if (!parse_container(frame, frame_bytes * 8u, offsets[i], &candidate)) continue;
|
||||||
|
if (!candidate.has(kIdOamd) || !candidate.has(kIdJoc)) continue;
|
||||||
|
for (std::size_t p = 0; p < candidate.payload_count; ++p) {
|
||||||
|
if (candidate.payloads[p].id != kIdJoc) continue;
|
||||||
|
// joc_dmx_config_idx is the first 3 bits of the JOC payload, followed by
|
||||||
|
// joc_num_objects_bits (6) and joc_ext_config_idx (3).
|
||||||
|
const std::size_t bit = candidate.payloads[p].bit_offset;
|
||||||
|
std::uint32_t value = 0;
|
||||||
|
for (unsigned index = 0; index < 3u; ++index) {
|
||||||
|
const std::size_t position = bit + index;
|
||||||
|
if (position / 8u >= frame_bytes) return false;
|
||||||
|
value = (value << 1) | ((frame[position / 8u] >> (7u - (position % 8u))) & 1u);
|
||||||
|
}
|
||||||
|
*out = value;
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
bool frame_has_joc(const std::uint8_t* frame, std::size_t frame_bytes) {
|
bool frame_has_joc(const std::uint8_t* frame, std::size_t frame_bytes) {
|
||||||
if (frame == nullptr || frame_bytes < 8u) return false;
|
if (frame == nullptr || frame_bytes < 8u) return false;
|
||||||
|
|
||||||
@@ -333,12 +437,15 @@ ScanResult scan(const std::uint8_t* data, std::size_t size, std::size_t max_fram
|
|||||||
if (frames == 0) {
|
if (frames == 0) {
|
||||||
result.joc = JocState::kUnknown;
|
result.joc = JocState::kUnknown;
|
||||||
if (result.detail[0] == '\0') result.detail = "no syncframes";
|
if (result.detail[0] == '\0') result.detail = "no syncframes";
|
||||||
} else if (with_joc == frames) {
|
} else if (with_joc != 0) {
|
||||||
result.joc = JocState::kYes;
|
result.joc = JocState::kYes;
|
||||||
result.detail = "every examined syncframe carries the JOC EMDF container";
|
result.detail = (with_joc == frames)
|
||||||
|
? "every examined syncframe carries the JOC EMDF container"
|
||||||
|
: "the JOC EMDF container is present in part of the examined "
|
||||||
|
"audio frames (dependent substream or a late first frame)";
|
||||||
} else {
|
} else {
|
||||||
result.joc = JocState::kNo;
|
result.joc = JocState::kNo;
|
||||||
result.detail = "at least one examined syncframe has no JOC EMDF container";
|
result.detail = "no examined syncframe carries a JOC EMDF container";
|
||||||
}
|
}
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|||||||
+43
-11
@@ -4,12 +4,14 @@
|
|||||||
// because container metadata (MP4 dec3, Matroska A_EAC3) says only "E-AC-3" and
|
// because container metadata (MP4 dec3, Matroska A_EAC3) says only "E-AC-3" and
|
||||||
// the JOC flag inside it is frequently missing.
|
// the JOC flag inside it is frequently missing.
|
||||||
//
|
//
|
||||||
// The criterion implemented here is deliberately the same one the rendering core
|
// A syncframe carries JOC when it holds exactly one top-level EMDF container
|
||||||
// applies before it will render a frame: a syncframe carries JOC when it holds
|
// (syncword 0x5838, any of the eight bit alignments) whose payload list contains
|
||||||
// exactly one top-level EMDF container (syncword 0x5838, any of the eight bit
|
// both ID11 (OAMD) and ID14 (JOC) — the same per-frame test the rendering core
|
||||||
// alignments) whose payload list contains both ID11 (OAMD) and ID14 (JOC).
|
// applies. The stream counts as JOC when at least one examined audio frame
|
||||||
// Agreeing with the core matters: a looser test would claim files the core then
|
// carries one: in a 7-channel program the JOC payload lives in the dependent
|
||||||
// refuses, which is worse than declining them.
|
// substream while the independent substream is a plain 5.1 core, and an AC-3
|
||||||
|
// core may precede it, so "every syncframe carries JOC" is not a valid rule.
|
||||||
|
// The first audio frame may also carry no metadata at all.
|
||||||
#pragma once
|
#pragma once
|
||||||
|
|
||||||
#include <cstddef>
|
#include <cstddef>
|
||||||
@@ -17,16 +19,26 @@
|
|||||||
|
|
||||||
namespace joc_eac3 {
|
namespace joc_eac3 {
|
||||||
|
|
||||||
// E-AC-3 syncframe header fields the plugin needs.
|
// Syncframe header fields the plugin needs. codec/strmtyp/substreamid identify
|
||||||
|
// the substream: within one audio frame each combination appears once, which is
|
||||||
|
// what turns a syncframe stream into audio frames.
|
||||||
struct FrameHeader {
|
struct FrameHeader {
|
||||||
std::size_t frame_bytes = 0;
|
std::size_t frame_bytes = 0;
|
||||||
std::size_t offset = 0;
|
std::size_t offset = 0;
|
||||||
|
std::uint8_t codec = 0; // 0 = AC-3, 1 = E-AC-3
|
||||||
|
std::uint8_t strmtyp = 0;
|
||||||
|
std::uint8_t substreamid = 0;
|
||||||
|
|
||||||
|
bool same_stream(const FrameHeader& other) const {
|
||||||
|
return codec == other.codec && strmtyp == other.strmtyp &&
|
||||||
|
substreamid == other.substreamid;
|
||||||
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
enum class JocState {
|
enum class JocState {
|
||||||
kYes, // every frame examined carried a JOC EMDF container
|
kYes, // at least one examined syncframe carried a JOC EMDF container
|
||||||
kNo, // at least one frame examined did not
|
kNo, // no examined syncframe carried one
|
||||||
kUnknown, // not enough data, or the stream is not walkable E-AC-3
|
kUnknown, // not enough data, or the stream is not walkable ac3/eac3
|
||||||
};
|
};
|
||||||
|
|
||||||
struct ScanResult {
|
struct ScanResult {
|
||||||
@@ -42,9 +54,29 @@ struct ScanResult {
|
|||||||
ScanResult scan(const std::uint8_t* data, std::size_t size, std::size_t max_frames);
|
ScanResult scan(const std::uint8_t* data, std::size_t size, std::size_t max_frames);
|
||||||
|
|
||||||
// Length of the syncframe starting at data[offset], or 0 when there is no valid
|
// Length of the syncframe starting at data[offset], or 0 when there is no valid
|
||||||
// header there. Mirrors the core's frmsiz handling exactly.
|
// header there. AC-3 and E-AC-3 are told apart by bsid exactly as the core does:
|
||||||
|
// bsid <= 8 sizes the frame from fscod/frmsizecod, anything above uses frmsiz.
|
||||||
std::size_t frame_bytes_at(const std::uint8_t* data, std::size_t size, std::size_t offset);
|
std::size_t frame_bytes_at(const std::uint8_t* data, std::size_t size, std::size_t offset);
|
||||||
|
|
||||||
|
// Same, and fills the substream identity. Returns 0 when no header is there.
|
||||||
|
std::size_t frame_header_at(const std::uint8_t* data, std::size_t size, std::size_t offset,
|
||||||
|
FrameHeader* out);
|
||||||
|
|
||||||
|
// Length of the whole audio frame starting at data[offset]: every syncframe up to
|
||||||
|
// (and excluding) the first repeated (codec, strmtyp, substreamid) combination.
|
||||||
|
// A 7-channel program interleaves an independent and a dependent substream, so one
|
||||||
|
// audio frame is two syncframes and one bed frame.
|
||||||
|
//
|
||||||
|
// Returns 0 when the group is still open inside the buffer -- the caller has to ask
|
||||||
|
// again with more data -- unless `end_of_stream` says no more bytes will arrive, in
|
||||||
|
// which case the trailing group is complete by definition.
|
||||||
|
std::size_t audio_frame_bytes_at(const std::uint8_t* data, std::size_t size, std::size_t offset,
|
||||||
|
bool end_of_stream);
|
||||||
|
|
||||||
|
// Reads joc_dmx_config_idx (the first 3 bits of the JOC payload) out of one
|
||||||
|
// syncframe. False when the frame carries no JOC payload.
|
||||||
|
bool joc_config_idx(const std::uint8_t* frame, std::size_t frame_bytes, unsigned* out);
|
||||||
|
|
||||||
// True when this single syncframe carries the JOC EMDF container.
|
// True when this single syncframe carries the JOC EMDF container.
|
||||||
bool frame_has_joc(const std::uint8_t* frame, std::size_t frame_bytes);
|
bool frame_has_joc(const std::uint8_t* frame, std::size_t frame_bytes);
|
||||||
|
|
||||||
|
|||||||
+177
-49
@@ -27,7 +27,11 @@ constexpr std::uint64_t kEac3FramesPerRead = 3u;
|
|||||||
// Rendered audio the caller has not taken yet.
|
// Rendered audio the caller has not taken yet.
|
||||||
constexpr std::size_t kMaxRenderedAheadSamples = 4096u;
|
constexpr std::size_t kMaxRenderedAheadSamples = 4096u;
|
||||||
constexpr std::size_t kBedFramesChunk = 8192u; // staging capacity, in frames
|
constexpr std::size_t kBedFramesChunk = 8192u; // staging capacity, in frames
|
||||||
constexpr std::size_t kBedChannels = 6; // ffmpeg -ac 6
|
// The bed channel count follows joc_dmx_config_idx: the 5.1 configurations
|
||||||
|
// (0 and 3) decode to 6 channels through `ffmpeg -ac 6`, the 7-channel ones
|
||||||
|
// (1, 2 and 4) to 8 channels in the decoder's own layout. See bed_channels.
|
||||||
|
constexpr std::size_t kDefaultBedChannels = 6;
|
||||||
|
constexpr std::size_t kMaxBedChannels = 8;
|
||||||
// A read on an anonymous pipe only completes once the whole request is available,
|
// A read on an anonymous pipe only completes once the whole request is available,
|
||||||
// so each read asks for a slice ffmpeg can always fill, and the pipe buffer is
|
// so each read asks for a slice ffmpeg can always fill, and the pipe buffer is
|
||||||
// sized well above that slice. Requesting the whole staging buffer deadlocks:
|
// sized well above that slice. Requesting the whole staging buffer deadlocks:
|
||||||
@@ -63,6 +67,30 @@ bool has_mov_timeline(const std::string& path) {
|
|||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// joc_dmx_config_idx of the first syncframe in the window that carries JOC, or -1
|
||||||
|
// when the window holds none. Only the first three bits of the JOC payload are
|
||||||
|
// read, so this costs nothing next to a decode.
|
||||||
|
int scan_config_idx(const std::uint8_t* data, std::size_t size) {
|
||||||
|
std::size_t offset = 0;
|
||||||
|
while (offset + 6u <= size) {
|
||||||
|
const std::size_t bytes = joc_eac3::frame_bytes_at(data, size, offset);
|
||||||
|
if (bytes == 0 || offset + bytes > size) break;
|
||||||
|
if (joc_eac3::frame_has_joc(data + offset, bytes)) {
|
||||||
|
unsigned config = 0;
|
||||||
|
if (joc_eac3::joc_config_idx(data + offset, bytes, &config)) {
|
||||||
|
return static_cast<int>(config);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
offset += bytes;
|
||||||
|
}
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
// True when the JOC configuration declares 7 core channels.
|
||||||
|
bool seven_channel_config(int config) {
|
||||||
|
return config == 1 || config == 2 || config == 4;
|
||||||
|
}
|
||||||
|
|
||||||
// ---------------------------------------------------------------------------
|
// ---------------------------------------------------------------------------
|
||||||
// Kernel entry points.
|
// Kernel entry points.
|
||||||
//
|
//
|
||||||
@@ -83,6 +111,7 @@ struct CoreApi {
|
|||||||
std::uint32_t(JOC_CALL* abi_version)() = joc_abi_version;
|
std::uint32_t(JOC_CALL* abi_version)() = joc_abi_version;
|
||||||
const char*(JOC_CALL* version_string)() = joc_version_string;
|
const char*(JOC_CALL* version_string)() = joc_version_string;
|
||||||
const char*(JOC_CALL* error_name)(joc_error) = joc_error_name;
|
const char*(JOC_CALL* error_name)(joc_error) = joc_error_name;
|
||||||
|
const char*(JOC_CALL* last_error_detail)() = joc_last_error_detail;
|
||||||
};
|
};
|
||||||
|
|
||||||
bool file_exists(const std::string& path) {
|
bool file_exists(const std::string& path) {
|
||||||
@@ -111,6 +140,22 @@ const char* error_text(const CoreApi& api, joc_error code) {
|
|||||||
return "unknown core error";
|
return "unknown core error";
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// The core keeps a structured detail for the last failing call ("eac3: chanmap
|
||||||
|
// declares [Lts,Rts] but joc_dmx_config_idx=2 expects [Vhl,Vhr]"). The plugin
|
||||||
|
// reports the variant rather than only its error code, so a stream the renderer
|
||||||
|
// deliberately refuses says why.
|
||||||
|
std::string error_with_detail(const CoreApi& api, joc_error code) {
|
||||||
|
std::string text = error_text(api, code);
|
||||||
|
if (api.last_error_detail != nullptr) {
|
||||||
|
const char* detail = api.last_error_detail();
|
||||||
|
if (detail != nullptr && *detail != '\0') {
|
||||||
|
text += ": ";
|
||||||
|
text += detail;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return text;
|
||||||
|
}
|
||||||
|
|
||||||
// ---------------------------------------------------------------------------
|
// ---------------------------------------------------------------------------
|
||||||
// ffmpeg child process producing the 5.1 core PCM on a pipe.
|
// ffmpeg child process producing the 5.1 core PCM on a pipe.
|
||||||
// ---------------------------------------------------------------------------
|
// ---------------------------------------------------------------------------
|
||||||
@@ -426,40 +471,47 @@ FileProbe probe_file(const std::string& path, std::size_t max_scan_bytes,
|
|||||||
return probe;
|
return probe;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// The renderer pairs one audio frame with exactly 1536 bed samples, so the
|
||||||
|
// stream length is counted in audio frames: a 7-channel program interleaves an
|
||||||
|
// independent and a dependent substream, and one audio frame is two syncframes.
|
||||||
|
const bool whole_file = (buffer.size() == stream_bytes);
|
||||||
|
std::size_t offset = 0;
|
||||||
|
std::size_t first_audio_frame = 0;
|
||||||
|
bool same_audio_frame_size = true;
|
||||||
|
std::uint64_t seen = 0;
|
||||||
|
while (true) {
|
||||||
|
const std::size_t bytes =
|
||||||
|
joc_eac3::audio_frame_bytes_at(buffer.data(), got, offset, whole_file);
|
||||||
|
if (bytes == 0 || offset + bytes > got) break;
|
||||||
|
if (seen == 0) {
|
||||||
|
first_audio_frame = bytes;
|
||||||
|
} else if (bytes != first_audio_frame) {
|
||||||
|
same_audio_frame_size = false;
|
||||||
|
}
|
||||||
|
offset += bytes;
|
||||||
|
++seen;
|
||||||
|
}
|
||||||
|
|
||||||
std::uint64_t frames = 0;
|
std::uint64_t frames = 0;
|
||||||
if (buffer.size() == stream_bytes) {
|
if (whole_file) {
|
||||||
std::size_t offset = 0;
|
frames = seen;
|
||||||
while (true) {
|
|
||||||
const std::size_t bytes = joc_eac3::frame_bytes_at(buffer.data(), got, offset);
|
|
||||||
if (bytes == 0 || offset + bytes > got) break;
|
|
||||||
offset += bytes;
|
|
||||||
++frames;
|
|
||||||
}
|
|
||||||
probe.detail = "frame count walked over the whole file";
|
probe.detail = "frame count walked over the whole file";
|
||||||
} else if (scan.all_frames_same_size) {
|
} else if (seen != 0 && same_audio_frame_size) {
|
||||||
frames = stream_bytes / scan.first_frame_bytes;
|
frames = stream_bytes / first_audio_frame;
|
||||||
probe.detail = "frame count extrapolated from a constant frame size";
|
probe.detail = "frame count extrapolated from a constant frame size";
|
||||||
} else {
|
} else if (offset != 0) {
|
||||||
// Variable frame size: count in the window and scale by the byte ratio.
|
// Variable frame size: count in the window and scale by the byte ratio.
|
||||||
std::size_t offset = 0;
|
frames = static_cast<std::uint64_t>(
|
||||||
std::uint64_t seen = 0;
|
(static_cast<double>(stream_bytes) / static_cast<double>(offset)) *
|
||||||
while (true) {
|
static_cast<double>(seen));
|
||||||
const std::size_t bytes = joc_eac3::frame_bytes_at(buffer.data(), got, offset);
|
|
||||||
if (bytes == 0 || offset + bytes > got) break;
|
|
||||||
offset += bytes;
|
|
||||||
++seen;
|
|
||||||
}
|
|
||||||
frames = (offset != 0) ? static_cast<std::uint64_t>(
|
|
||||||
(static_cast<double>(stream_bytes) /
|
|
||||||
static_cast<double>(offset)) *
|
|
||||||
static_cast<double>(seen))
|
|
||||||
: 0;
|
|
||||||
probe.detail = "frame count estimated from a variable frame size";
|
probe.detail = "frame count estimated from a variable frame size";
|
||||||
}
|
}
|
||||||
|
|
||||||
|
const int config = scan_config_idx(buffer.data(), got);
|
||||||
probe.frames = frames;
|
probe.frames = frames;
|
||||||
probe.sample_rate = 48000;
|
probe.sample_rate = 48000;
|
||||||
probe.channels = 6; // the core audio of an E-AC-3 JOC stream
|
// Core audio channel count: the 5.1 configurations give 6, the 7-channel ones 8.
|
||||||
|
probe.channels = static_cast<unsigned>(seven_channel_config(config) ? 8 : 6);
|
||||||
probe.duration_seconds =
|
probe.duration_seconds =
|
||||||
static_cast<double>(frames) * static_cast<double>(kFrameSamples) / 48000.0;
|
static_cast<double>(frames) * static_cast<double>(kFrameSamples) / 48000.0;
|
||||||
return probe;
|
return probe;
|
||||||
@@ -570,7 +622,10 @@ struct Engine::Impl {
|
|||||||
}
|
}
|
||||||
|
|
||||||
unsigned channels = 0;
|
unsigned channels = 0;
|
||||||
std::uint64_t frames_queued = 0; // E-AC-3 frames handed to the core
|
// Decoded bed channel count, resolved from joc_dmx_config_idx before the bed
|
||||||
|
// decoder starts: 6 for configurations 0/3, 8 for 1/2/4.
|
||||||
|
std::size_t bed_channels = kDefaultBedChannels;
|
||||||
|
std::uint64_t frames_queued = 0; // audio frames handed to the core
|
||||||
std::uint64_t bed_frames_pushed = 0;
|
std::uint64_t bed_frames_pushed = 0;
|
||||||
bool eac3_eof = false;
|
bool eac3_eof = false;
|
||||||
bool bed_eof = false;
|
bool bed_eof = false;
|
||||||
@@ -650,6 +705,10 @@ struct Engine::Impl {
|
|||||||
bool position_bare(std::uint64_t frame, std::string* error);
|
bool position_bare(std::uint64_t frame, std::string* error);
|
||||||
bool start_bed(std::uint64_t source_sample, std::string* error);
|
bool start_bed(std::uint64_t source_sample, std::string* error);
|
||||||
bool start_metadata(std::string* error);
|
bool start_metadata(std::string* error);
|
||||||
|
// Resolves bed_channels from the stream's own joc_dmx_config_idx. For a
|
||||||
|
// container this starts the metadata pipe once, reads a prefix and stops it
|
||||||
|
// again; for a bare stream it reads a prefix from the file and seeks back.
|
||||||
|
bool resolve_bed_channels(std::string* error);
|
||||||
};
|
};
|
||||||
|
|
||||||
bool Engine::Impl::grow_frame_index(std::uint64_t wanted, std::string* error) {
|
bool Engine::Impl::grow_frame_index(std::uint64_t wanted, std::string* error) {
|
||||||
@@ -681,9 +740,14 @@ bool Engine::Impl::grow_frame_index(std::uint64_t wanted, std::string* error) {
|
|||||||
index_complete = true;
|
index_complete = true;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
// The index holds audio frames, not syncframes: the renderer consumes one
|
||||||
|
// bed frame per audio frame, and a 7-channel program makes two syncframes
|
||||||
|
// into one audio frame.
|
||||||
|
const bool at_end = (index_file_offset + got >= size);
|
||||||
std::size_t consumed = 0;
|
std::size_t consumed = 0;
|
||||||
while (frame_offsets.size() < wanted) {
|
while (frame_offsets.size() < wanted) {
|
||||||
const std::size_t bytes = joc_eac3::frame_bytes_at(buffer.data(), got, consumed);
|
const std::size_t bytes =
|
||||||
|
joc_eac3::audio_frame_bytes_at(buffer.data(), got, consumed, at_end);
|
||||||
if (bytes == 0 || consumed + bytes > got) break;
|
if (bytes == 0 || consumed + bytes > got) break;
|
||||||
frame_offsets.push_back(index_stream_offset + consumed);
|
frame_offsets.push_back(index_stream_offset + consumed);
|
||||||
consumed += bytes;
|
consumed += bytes;
|
||||||
@@ -734,13 +798,49 @@ bool Engine::Impl::position_bare(std::uint64_t frame, std::string* error) {
|
|||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
bool Engine::Impl::resolve_bed_channels(std::string* error) {
|
||||||
|
bed_channels = kDefaultBedChannels;
|
||||||
|
std::vector<std::uint8_t> buffer(1u << 20);
|
||||||
|
int config = -1;
|
||||||
|
if (eac3_from_pipe) {
|
||||||
|
// The metadata stream has to run once to be sniffed; it is stopped again and
|
||||||
|
// restarted from the beginning, which costs one extra ffmpeg spawn per track.
|
||||||
|
if (!start_metadata(error)) return false;
|
||||||
|
const std::size_t got = eac3_pipe.read(buffer.data(), buffer.size());
|
||||||
|
eac3_pipe.stop();
|
||||||
|
config = scan_config_idx(buffer.data(), got);
|
||||||
|
} else {
|
||||||
|
if (!eac3.is_open() && !eac3.open(input_path)) {
|
||||||
|
if (error != nullptr) *error = "cannot open the input file";
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
const std::size_t got = eac3.read(buffer.data(), buffer.size());
|
||||||
|
config = scan_config_idx(buffer.data(), got);
|
||||||
|
// Put the file back where the feed loop expects it.
|
||||||
|
if (!eac3.seek(index_base)) {
|
||||||
|
if (error != nullptr) *error = "cannot position the input file";
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
bed_channels = seven_channel_config(config)
|
||||||
|
? static_cast<std::size_t>(7u + 1u)
|
||||||
|
: kDefaultBedChannels;
|
||||||
|
if (bed_channels > kMaxBedChannels) bed_channels = kMaxBedChannels;
|
||||||
|
joc_log::line("core: joc_dmx_config_idx=%d -> %llu bed channel(s)", config,
|
||||||
|
static_cast<unsigned long long>(bed_channels));
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
bool Engine::Impl::start_bed(std::uint64_t source_sample, std::string* error) {
|
bool Engine::Impl::start_bed(std::uint64_t source_sample, std::string* error) {
|
||||||
// The 5.1 core PCM, exactly as the reference renderer's own core decode does
|
// The core PCM the kernel expects: interleaved float32 at 48 kHz, laid out as
|
||||||
// it: 5.1 interleaved float32 at 48 kHz, the layout the renderer expects
|
// L R C LFE Ls Rs for 5.1 and L R C LFE BL BR SL SR for 7.1.
|
||||||
// (L R C LFE Ls Rs).
|
|
||||||
// -drc_scale 0 -target_level 0: the bed is taken as stored, without the
|
// -drc_scale 0 -target_level 0: the bed is taken as stored, without the
|
||||||
// stream's dynrng or target-level metadata being applied by the decoder.
|
// stream's dynrng or target-level metadata being applied by the decoder.
|
||||||
//
|
//
|
||||||
|
// -ac is only passed for the 5.1 configurations: `-ac 6` downmixes 5.1.2/7.1
|
||||||
|
// into 5.1 and drops the extra pair, and `-ac 8` would remap 5.1.2 into 7.1.
|
||||||
|
// The 7-channel configurations take the decoder's own layout instead.
|
||||||
|
//
|
||||||
// -ss is an input option: the demuxer is positioned on the frame boundary and
|
// -ss is an input option: the demuxer is positioned on the frame boundary and
|
||||||
// decoding starts there, so a seek costs the same wherever it lands. The price is
|
// decoding starts there, so a seek costs the same wherever it lands. The price is
|
||||||
// that the bed is carried by a decoder that started at the seek point rather than
|
// that the bed is carried by a decoder that started at the seek point rather than
|
||||||
@@ -752,7 +852,11 @@ bool Engine::Impl::start_bed(std::uint64_t source_sample, std::string* error) {
|
|||||||
if (!offset.empty()) input_arguments += L" -ss " + offset;
|
if (!offset.empty()) input_arguments += L" -ss " + offset;
|
||||||
std::wstring bed_arguments = L"-map 0:a:";
|
std::wstring bed_arguments = L"-map 0:a:";
|
||||||
bed_arguments += std::to_wstring(settings.audio_index);
|
bed_arguments += std::to_wstring(settings.audio_index);
|
||||||
bed_arguments += L" -vn -ac 6 -ar 48000 -c:a pcm_f32le -f f32le -";
|
bed_arguments += L" -vn";
|
||||||
|
if (bed_channels == kDefaultBedChannels) {
|
||||||
|
bed_arguments += L" -ac 6";
|
||||||
|
}
|
||||||
|
bed_arguments += L" -ar 48000 -c:a pcm_f32le -f f32le -";
|
||||||
return bed.start(settings.ffmpeg_path, input_path, input_arguments, bed_arguments, "bed",
|
return bed.start(settings.ffmpeg_path, input_path, input_arguments, bed_arguments, "bed",
|
||||||
stderr_path_for(L"joc_ffmpeg_bed.log"), error);
|
stderr_path_for(L"joc_ffmpeg_bed.log"), error);
|
||||||
}
|
}
|
||||||
@@ -804,7 +908,6 @@ bool Engine::start(const std::string& input_path, const Settings& settings, std:
|
|||||||
impl.reset_feed_state();
|
impl.reset_feed_state();
|
||||||
impl.end_sample = sample_of_seconds(settings.length_seconds);
|
impl.end_sample = sample_of_seconds(settings.length_seconds);
|
||||||
impl.eac3_buffer.resize(kEac3Chunk);
|
impl.eac3_buffer.resize(kEac3Chunk);
|
||||||
impl.bed_buffer.resize(kBedFramesChunk * kBedChannels);
|
|
||||||
|
|
||||||
if (!load_api(std::string(), &impl.api, error)) return false;
|
if (!load_api(std::string(), &impl.api, error)) return false;
|
||||||
const std::uint32_t abi = impl.api.abi_version();
|
const std::uint32_t abi = impl.api.abi_version();
|
||||||
@@ -834,6 +937,11 @@ bool Engine::start(const std::string& input_path, const Settings& settings, std:
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// The bed decoder has to know how many channels to produce before it starts,
|
||||||
|
// and that comes from the stream's own joc_dmx_config_idx.
|
||||||
|
if (!impl.resolve_bed_channels(error)) return false;
|
||||||
|
impl.bed_buffer.resize(kBedFramesChunk * impl.bed_channels);
|
||||||
|
|
||||||
joc_stream_config config{};
|
joc_stream_config config{};
|
||||||
config.struct_size = sizeof(config);
|
config.struct_size = sizeof(config);
|
||||||
config.struct_version = 1;
|
config.struct_version = 1;
|
||||||
@@ -888,7 +996,7 @@ bool Engine::start(const std::string& input_path, const Settings& settings, std:
|
|||||||
if (created != JOC_OK) {
|
if (created != JOC_OK) {
|
||||||
if (error != nullptr) {
|
if (error != nullptr) {
|
||||||
*error = std::string("cannot create the render stream: ") +
|
*error = std::string("cannot create the render stream: ") +
|
||||||
error_text(impl.api, created);
|
error_with_detail(impl.api, created);
|
||||||
}
|
}
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
@@ -972,7 +1080,7 @@ bool Engine::seek(double seconds, double total_seconds, std::string* error) {
|
|||||||
if (reset != JOC_OK) {
|
if (reset != JOC_OK) {
|
||||||
if (error != nullptr) {
|
if (error != nullptr) {
|
||||||
*error = std::string("cannot reset the render stream: ") +
|
*error = std::string("cannot reset the render stream: ") +
|
||||||
error_text(impl.api, reset);
|
error_with_detail(impl.api, reset);
|
||||||
}
|
}
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
@@ -1042,6 +1150,10 @@ std::size_t Engine::read(float* destination, std::size_t frames, std::string* er
|
|||||||
const std::size_t got = impl.read_eac3(impl.eac3_buffer.data() + impl.eac3_carry,
|
const std::size_t got = impl.read_eac3(impl.eac3_buffer.data() + impl.eac3_carry,
|
||||||
impl.eac3_buffer.size() - impl.eac3_carry);
|
impl.eac3_buffer.size() - impl.eac3_carry);
|
||||||
std::size_t total = impl.eac3_carry + got;
|
std::size_t total = impl.eac3_carry + got;
|
||||||
|
// A read that returns nothing means no more bytes will arrive, so the
|
||||||
|
// audio frame still open in the buffer is complete by definition. Without
|
||||||
|
// this the last audio frame of every file is left in the carry.
|
||||||
|
const bool at_eof = (got == 0) || impl.eac3_eof;
|
||||||
if (total == 0) {
|
if (total == 0) {
|
||||||
impl.eac3_eof = true;
|
impl.eac3_eof = true;
|
||||||
} else {
|
} else {
|
||||||
@@ -1051,8 +1163,8 @@ std::size_t Engine::read(float* destination, std::size_t frames, std::string* er
|
|||||||
if (impl.metadata_skip != 0) {
|
if (impl.metadata_skip != 0) {
|
||||||
std::size_t dropped = 0;
|
std::size_t dropped = 0;
|
||||||
while (impl.metadata_skip != 0) {
|
while (impl.metadata_skip != 0) {
|
||||||
const std::size_t bytes =
|
const std::size_t bytes = joc_eac3::audio_frame_bytes_at(
|
||||||
joc_eac3::frame_bytes_at(impl.eac3_buffer.data(), total, dropped);
|
impl.eac3_buffer.data(), total, dropped, at_eof);
|
||||||
if (bytes == 0 || dropped + bytes > total) break;
|
if (bytes == 0 || dropped + bytes > total) break;
|
||||||
dropped += bytes;
|
dropped += bytes;
|
||||||
--impl.metadata_skip;
|
--impl.metadata_skip;
|
||||||
@@ -1074,8 +1186,8 @@ std::size_t Engine::read(float* destination, std::size_t frames, std::string* er
|
|||||||
std::size_t offset = 0;
|
std::size_t offset = 0;
|
||||||
std::uint64_t complete = 0;
|
std::uint64_t complete = 0;
|
||||||
while (true) {
|
while (true) {
|
||||||
const std::size_t bytes =
|
const std::size_t bytes = joc_eac3::audio_frame_bytes_at(
|
||||||
joc_eac3::frame_bytes_at(impl.eac3_buffer.data(), total, offset);
|
impl.eac3_buffer.data(), total, offset, at_eof);
|
||||||
if (bytes == 0 || offset + bytes > total) break;
|
if (bytes == 0 || offset + bytes > total) break;
|
||||||
offset += bytes;
|
offset += bytes;
|
||||||
++complete;
|
++complete;
|
||||||
@@ -1096,8 +1208,8 @@ std::size_t Engine::read(float* destination, std::size_t frames, std::string* er
|
|||||||
pushed_frames = allowed;
|
pushed_frames = allowed;
|
||||||
std::size_t walk = 0;
|
std::size_t walk = 0;
|
||||||
for (std::uint64_t index = 0; index < pushed_frames; ++index) {
|
for (std::uint64_t index = 0; index < pushed_frames; ++index) {
|
||||||
const std::size_t bytes = joc_eac3::frame_bytes_at(
|
const std::size_t bytes = joc_eac3::audio_frame_bytes_at(
|
||||||
impl.eac3_buffer.data(), total, walk);
|
impl.eac3_buffer.data(), total, walk, at_eof);
|
||||||
if (bytes == 0 || walk + bytes > total) break;
|
if (bytes == 0 || walk + bytes > total) break;
|
||||||
walk += bytes;
|
walk += bytes;
|
||||||
}
|
}
|
||||||
@@ -1113,7 +1225,7 @@ std::size_t Engine::read(float* destination, std::size_t frames, std::string* er
|
|||||||
if (pushed != JOC_OK) {
|
if (pushed != JOC_OK) {
|
||||||
if (error != nullptr) {
|
if (error != nullptr) {
|
||||||
*error = std::string("E-AC-3 push failed: ") +
|
*error = std::string("E-AC-3 push failed: ") +
|
||||||
error_text(impl.api, pushed);
|
error_with_detail(impl.api, pushed);
|
||||||
}
|
}
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
@@ -1136,27 +1248,27 @@ std::size_t Engine::read(float* destination, std::size_t frames, std::string* er
|
|||||||
// return any number of bytes, and rounding a read down to whole samples
|
// return any number of bytes, and rounding a read down to whole samples
|
||||||
// quietly drops the rest of the stream's alignment.
|
// quietly drops the rest of the stream's alignment.
|
||||||
while (!impl.bed_eof && impl.bed_frames_pushed < impl.frames_queued) {
|
while (!impl.bed_eof && impl.bed_frames_pushed < impl.frames_queued) {
|
||||||
constexpr std::size_t kFrameBytes = kFrameSamples * kBedChannels * sizeof(float);
|
const std::size_t frame_bytes = kFrameSamples * impl.bed_channels * sizeof(float);
|
||||||
const std::size_t whole_frames = impl.bed_staged_bytes / kFrameBytes;
|
const std::size_t whole_frames = impl.bed_staged_bytes / frame_bytes;
|
||||||
if (whole_frames != 0) {
|
if (whole_frames != 0) {
|
||||||
joc_stream_buffer input{};
|
joc_stream_buffer input{};
|
||||||
input.struct_size = sizeof(input);
|
input.struct_size = sizeof(input);
|
||||||
input.struct_version = 1;
|
input.struct_version = 1;
|
||||||
input.kind = JOC_STREAM_IN_CORE_PCM;
|
input.kind = JOC_STREAM_IN_CORE_PCM;
|
||||||
input.pcm = impl.bed_buffer.data();
|
input.pcm = impl.bed_buffer.data();
|
||||||
input.channels = static_cast<std::uint32_t>(kBedChannels);
|
input.channels = static_cast<std::uint32_t>(impl.bed_channels);
|
||||||
input.sample_rate = 48000;
|
input.sample_rate = 48000;
|
||||||
input.sample_count = static_cast<std::uint32_t>(whole_frames * kFrameSamples);
|
input.sample_count = static_cast<std::uint32_t>(whole_frames * kFrameSamples);
|
||||||
const joc_error pushed = impl.api.push(impl.stream, &input, nullptr, nullptr);
|
const joc_error pushed = impl.api.push(impl.stream, &input, nullptr, nullptr);
|
||||||
if (pushed != JOC_OK) {
|
if (pushed != JOC_OK) {
|
||||||
if (error != nullptr) {
|
if (error != nullptr) {
|
||||||
*error = std::string("core PCM push failed: ") +
|
*error = std::string("core PCM push failed: ") +
|
||||||
error_text(impl.api, pushed);
|
error_with_detail(impl.api, pushed);
|
||||||
}
|
}
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
impl.bed_frames_pushed += whole_frames;
|
impl.bed_frames_pushed += whole_frames;
|
||||||
const std::size_t pushed_bytes = whole_frames * kFrameBytes;
|
const std::size_t pushed_bytes = whole_frames * frame_bytes;
|
||||||
impl.bed_staged_bytes -= pushed_bytes;
|
impl.bed_staged_bytes -= pushed_bytes;
|
||||||
if (impl.bed_staged_bytes != 0) {
|
if (impl.bed_staged_bytes != 0) {
|
||||||
std::memmove(impl.bed_buffer.data(),
|
std::memmove(impl.bed_buffer.data(),
|
||||||
@@ -1198,7 +1310,7 @@ std::size_t Engine::read(float* destination, std::size_t frames, std::string* er
|
|||||||
const joc_error pulled = impl.api.pull(impl.stream, &output, &produced);
|
const joc_error pulled = impl.api.pull(impl.stream, &output, &produced);
|
||||||
if (pulled != JOC_OK) {
|
if (pulled != JOC_OK) {
|
||||||
if (error != nullptr) {
|
if (error != nullptr) {
|
||||||
*error = std::string("pull failed: ") + error_text(impl.api, pulled);
|
*error = std::string("pull failed: ") + error_with_detail(impl.api, pulled);
|
||||||
}
|
}
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
@@ -1248,7 +1360,7 @@ std::size_t Engine::read(float* destination, std::size_t frames, std::string* er
|
|||||||
const joc_error flushed = impl.api.flush(impl.stream);
|
const joc_error flushed = impl.api.flush(impl.stream);
|
||||||
if (flushed != JOC_OK) {
|
if (flushed != JOC_OK) {
|
||||||
if (error != nullptr) {
|
if (error != nullptr) {
|
||||||
*error = std::string("flush failed: ") + error_text(impl.api, flushed);
|
*error = std::string("flush failed: ") + error_with_detail(impl.api, flushed);
|
||||||
}
|
}
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
@@ -1267,6 +1379,22 @@ std::size_t Engine::read(float* destination, std::size_t frames, std::string* er
|
|||||||
static_cast<unsigned long long>(status.frames_out),
|
static_cast<unsigned long long>(status.frames_out),
|
||||||
static_cast<unsigned long long>(status.samples_out),
|
static_cast<unsigned long long>(status.samples_out),
|
||||||
static_cast<unsigned long long>(status.buffered_samples));
|
static_cast<unsigned long long>(status.buffered_samples));
|
||||||
|
// Metadata the renderer had to work around; each one is per audio
|
||||||
|
// frame and a non-zero count is worth reporting with the rest.
|
||||||
|
if (status.missing_joc_frames != 0u || status.objects_clamped_frames != 0u ||
|
||||||
|
status.extra_container_frames != 0u ||
|
||||||
|
status.chanmap_pair_mismatch_frames != 0u ||
|
||||||
|
status.bed_mask_mismatch_frames != 0u) {
|
||||||
|
joc_log::line(
|
||||||
|
"core: metadata workarounds: missing_joc_frames=%llu "
|
||||||
|
"objects_clamped_frames=%llu extra_container_frames=%llu "
|
||||||
|
"chanmap_pair_mismatch_frames=%llu bed_mask_mismatch_frames=%llu",
|
||||||
|
static_cast<unsigned long long>(status.missing_joc_frames),
|
||||||
|
static_cast<unsigned long long>(status.objects_clamped_frames),
|
||||||
|
static_cast<unsigned long long>(status.extra_container_frames),
|
||||||
|
static_cast<unsigned long long>(status.chanmap_pair_mismatch_frames),
|
||||||
|
static_cast<unsigned long long>(status.bed_mask_mismatch_frames));
|
||||||
|
}
|
||||||
joc_log::line("core: bed bytes read=%llu, staged samples left=%llu",
|
joc_log::line("core: bed bytes read=%llu, staged samples left=%llu",
|
||||||
static_cast<unsigned long long>(impl.bed_bytes_read),
|
static_cast<unsigned long long>(impl.bed_bytes_read),
|
||||||
static_cast<unsigned long long>(impl.bed_staged_bytes));
|
static_cast<unsigned long long>(impl.bed_staged_bytes));
|
||||||
|
|||||||
+6
-9
@@ -4,17 +4,14 @@
|
|||||||
// drives when the output has to be compared byte for byte against joc_cli.
|
// drives when the output has to be compared byte for byte against joc_cli.
|
||||||
//
|
//
|
||||||
// Two inputs are needed to render, and they come from different places:
|
// Two inputs are needed to render, and they come from different places:
|
||||||
// * the bare E-AC-3 syncframes -- the metadata stream -- read straight from the
|
// * the E-AC-3 syncframes -- the metadata stream -- read straight from the file;
|
||||||
// file, since the plugin only claims bare .eac3/.ec3 today;
|
|
||||||
// * the 5.1 core PCM of those same frames -- the rendering core does not decode
|
// * the 5.1 core PCM of those same frames -- the rendering core does not decode
|
||||||
// the core (it has no AC-3 decoder at all), so ffmpeg produces it exactly the
|
// the core (it has no AC-3 decoder at all), so ffmpeg produces it.
|
||||||
// way the reference CLI does.
|
|
||||||
//
|
//
|
||||||
// The core is loaded from joc_core.dll through the public C ABI and called via
|
// The core is the C++ kernel under kernel/, compiled into this component and called
|
||||||
// function pointers. Static linking is not an option: the core's static library
|
// through its public C API via the CoreApi table. No DLL is shipped or loaded: the
|
||||||
// carries the internals but not the API layer in src/api, and the plugin is not
|
// table is filled with the linked entry points and start-up only checks the ABI
|
||||||
// allowed to compile core sources. Loading explicitly also lets the component
|
// version.
|
||||||
// ship its own copy of the DLL and check its ABI version at start-up.
|
|
||||||
#pragma once
|
#pragma once
|
||||||
|
|
||||||
#include <cstddef>
|
#include <cstddef>
|
||||||
|
|||||||
+1
-1
@@ -12,7 +12,7 @@
|
|||||||
|
|
||||||
// Kept in one place: the string reported to foobar2000 and written to the log
|
// Kept in one place: the string reported to foobar2000 and written to the log
|
||||||
// must not drift apart.
|
// must not drift apart.
|
||||||
#define JOC_VERSION "0.3.0"
|
#define JOC_VERSION "0.4.0"
|
||||||
|
|
||||||
DECLARE_COMPONENT_VERSION("JOC decoder (E-AC-3 JOC)", JOC_VERSION,
|
DECLARE_COMPONENT_VERSION("JOC decoder (E-AC-3 JOC)", JOC_VERSION,
|
||||||
"Plays E-AC-3 JOC (Dolby Atmos) files: the JOC objects are "
|
"Plays E-AC-3 JOC (Dolby Atmos) files: the JOC objects are "
|
||||||
|
|||||||
Reference in new issue
Block a user