Add forced 24-bit output (int24) for the delivered samples
build / windows (push) Has been cancelled
build / release (push) Has been cancelled

This commit is contained in:
TheM14 committed 2026-10-14 17:34:29 +08:00
1 parent ce3de51f8f
commit 5c3083b11c
12 files changed
+299 -57

No files matched your search

+14
View File
@@ -65,6 +65,15 @@ Preferences → Tools → **JOC decoder**:
`binaural.personalized_headphone`; `binaural.personalized_headphone`;
* **Gain** — a switch and a value in dB. Binaural rendering can exceed full scale on material * **Gain** — a switch and a value in dB. Binaural rendering can exceed full scale on material
that does not clip in the core mix, so attenuation belongs here; that does not clip in the core mix, so attenuation belongs here;
* **Force 24-bit output (int24)** — off by default, which delivers float32. When on, every sample
is quantised with the core's own int24 rule (clip to ±1, ×8388607, truncate) before it is handed
over, the samples that had to be clipped are counted in the log, and the component reports the
file as 24-bit fixed point. The renderer itself stays float32: this is the precision the decoder
delivers, not the output device's bit depth, which is set in Preferences → Output. **Reload a
file's information after flipping this switch** (Properties → *Reload info*, or remove the file
from the Media Library and add it again): foobar2000 caches technical information per file, and
until it is reloaded Properties and the Converter still go by the old 32-bit floating-point
answer, warning that the encoder does not take floating-point input.
* the **ffmpeg** executable to use. * the **ffmpeg** executable to use.
No control on the page is disabled, and the status line states what is in effect. No control on the page is disabled, and the status line states what is in effect.
@@ -111,6 +120,11 @@ every container in the library, which is where the volume comes from.
behind it) can be **read but not written**: no component claims raw E-AC-3 for writing, and behind it) can be **read but not written**: no component claims raw E-AC-3 for writing, and
rewriting the whole file to insert a tag is not this component's job. rewriting the whole file to insert a tag is not this component's job.
* Transport streams (`.ts`, `.m2ts`) are not claimed. * Transport streams (`.ts`, `.m2ts`) are not claimed.
* **Force 24-bit output** only changes the precision the decoder delivers: foobar2000 converts the
int24 it receives into its own floating-point samples, and which bit depth the output device runs
at is still decided in Preferences → Output, not by this component. Samples outside ±1 follow the
core's `continue` clip policy (binaural rendering can exceed full scale, so use **Gain** when
attenuation is wanted).
* Playback length is exactly the file's duration. The binaural renderer still computes its room * Playback length is exactly the file's duration. The binaural renderer still computes its room
tail, but it is not delivered as playback time the file does not have. tail, but it is not delivered as playback time the file does not have.
* A seek re-enters the bitstream at the frame holding the target instead of decoding everything * A seek re-enters the bitstream at the frame holding the target instead of decoding everything
+9
View File
@@ -57,6 +57,12 @@ Preferences → Tools → **JOC decoder**:
* **HRTF source** —— **SOFA** 文件或 **Rosella** `.personalized_headphone` 模型。路径留空表示 * **HRTF source** —— **SOFA** 文件或 **Rosella** `.personalized_headphone` 模型。路径留空表示
用默认位置 `<组件目录>\HRTF\` 下的 `binaural.sofa` 或 `binaural.personalized_headphone`; 用默认位置 `<组件目录>\HRTF\` 下的 `binaural.sofa` 或 `binaural.personalized_headphone`;
* **Gain** —— 开关加 dB 值。双耳渲染在核心混音不削顶的素材上也可能超过满刻度,衰减放在这里; * **Gain** —— 开关加 dB 值。双耳渲染在核心混音不削顶的素材上也可能超过满刻度,衰减放在这里;
* **强制 24bit 输出(int24)** —— 默认关闭,交付 float32。打开后,交付前按内核写 WAV 的 int24
规则量化(截到 ±1 → ×8388607 → 截断),超范围的样本被截断到边缘、次数记进日志;组件同时把该
文件的技术信息报成 24bit 定点。渲染本身仍是 float32,这一项说的是交付给 foobar2000 的采样精度,
不是输出设备的位深(那个在 Preferences → Output 里设置)。**切换这个开关后要刷新文件信息**
(Properties → Reload info,或把文件从媒体库移除后重新加入):foobar2000 按文件缓存技术信息,
缓存没刷新时 Properties 与转换器仍按旧的 32bit 浮点判断,会提示"编码器不支持浮点输入"。
* **ffmpeg** 可执行文件路径。 * **ffmpeg** 可执行文件路径。
页面上的控件都不禁用,状态行会说明当前生效的是什么。 页面上的控件都不禁用,状态行会说明当前生效的是什么。
@@ -94,6 +100,9 @@ pwsh -File tools/package.ps1 # 两个架构,打包到 dist\*.fb2k-c
* 裸流 `.eac3` / `.ec3` 的标签(流前面的 ID3v2,或后面的 APEv2/ID3v1)**能读不能写**:没有 * 裸流 `.eac3` / `.ec3` 的标签(流前面的 ID3v2,或后面的 APEv2/ID3v1)**能读不能写**:没有
组件声明可以写裸 E-AC-3,为插入标签重写整个文件也不是本组件该做的事。 组件声明可以写裸 E-AC-3,为插入标签重写整个文件也不是本组件该做的事。
* 传输流(`.ts`、`.m2ts`)不接管。 * 传输流(`.ts`、`.m2ts`)不接管。
* **强制 24bit 输出**只改变解码器交付的采样精度:交付的 int24 会被 foobar2000 转成它内部的
浮点,输出设备用什么位深仍由 Preferences → Output 决定,组件不能替它选。超出 ±1 的样本按内核
的 `continue` 策略截断(双耳渲染可能超过满刻度,需要衰减时用 **Gain**)。
* 播放长度严格等于文件时长。双耳渲染器仍会算出房间尾音,但它不作为文件本身没有的播放时间交付。 * 播放长度严格等于文件时长。双耳渲染器仍会算出房间尾音,但它不作为文件本身没有的播放时间交付。
* 跳转会从包含目标位置的那个帧重新进入码流,而不是把前面的内容全部解码一遍——这是跳转代价与 * 跳转会从包含目标位置的那个帧重新进入码流,而不是把前面的内容全部解码一遍——这是跳转代价与
目标位置无关的原因。位置精确、不漂移;样本是同一段波形交给了从该处开始的解码器,与从头播放 目标位置无关的原因。位置精确、不漂移;样本是同一段波形交给了从该处开始的解码器,与从头播放
+64 -13
View File
@@ -354,14 +354,22 @@ public:
channels = layout_channels != 0 ? layout_channels : 6; channels = layout_channels != 0 ? layout_channels : 6;
render = "speaker " + settings.speaker_layout; render = "speaker " + settings.speaker_layout;
} }
// The custom field and the log line state the delivery format, because it
// is the one thing about the output that a listener cannot hear.
if (settings.force_int24) render += ", 24-bit delivery";
info.info_set("codec", "E-AC-3 JOC"); info.info_set("codec", "E-AC-3 JOC");
info.info_set("codec_long", "E-AC-3 JOC (Dolby Atmos)"); info.info_set("codec_long", "E-AC-3 JOC (Dolby Atmos)");
info.info_set("encoding", "lossy"); info.info_set("encoding", "lossy");
info.info_set_int("samplerate", kSampleRate); info.info_set_int("samplerate", kSampleRate);
info.info_set_int("channels", channels); info.info_set_int("channels", channels);
info.info_set_int("bitspersample", 32); // What the component hands over, which is what the host keeps if it writes a
info.info_set("bitspersample_extra", "floating-point"); // file from this stream: float32 by default, int24 when forced. This is also
// what foobar2000's own lossless-conversion warning reads
// (SDK file_info.cpp:is_encoding_float), so it has to use the SDK's convention:
// 32 bits with "floating-point", or a bit depth that is fixed-point by
// definition (anything but 32/64, with no extra field at all).
info.info_set_bitspersample(settings.force_int24 ? 24u : 32u, !settings.force_int24);
info.set_length(duration); info.set_length(duration);
m_length = duration; m_length = duration;
// The renderer keeps its room tail, but the stream this component hands over // The renderer keeps its room tail, but the stream this component hands over
@@ -455,8 +463,15 @@ public:
m_frames_delivered = 0; m_frames_delivered = 0;
m_reported = false; m_reported = false;
m_delivery_mismatches = 0; m_delivery_mismatches = 0;
joc_log::line("decoder: engine ready, %u output channel(s), %u frames per read", // The clip total belongs to the file rather than to one run of it, so a seek
m_channels, static_cast<unsigned>(kRunFrames)); // does not clear it: the log line at the end of the stream is a statement
// about everything this component handed over.
m_clipped_samples = 0;
m_clip_reported = false;
joc_log::line("decoder: engine ready, %u output channel(s), %u frames per read, "
"delivery=%s",
m_channels, static_cast<unsigned>(kRunFrames),
m_settings.force_int24 ? "int24" : "float32");
} }
bool decode_run(audio_chunk& chunk, abort_callback& abort) { bool decode_run(audio_chunk& chunk, abort_callback& abort) {
@@ -472,6 +487,10 @@ public:
static_cast<unsigned long long>(m_frames_delivered), static_cast<unsigned long long>(m_frames_delivered),
m_delivery_mismatches == 0 ? "" m_delivery_mismatches == 0 ? ""
: " (the delivery changed samples)"); : " (the delivery changed samples)");
if (m_clipped_samples != 0) {
joc_log::line("decoder: forced int24 truncated %llu sample(s) in total",
static_cast<unsigned long long>(m_clipped_samples));
}
return false; return false;
} }
@@ -479,30 +498,58 @@ public:
// 32-bit builds and double on 64-bit ones (SDK audio_math.h): the samples are // 32-bit builds and double on 64-bit ones (SDK audio_math.h): the samples are
// converted, not copied. set_data_32() is the SDK's conversion for a float32 // converted, not copied. set_data_32() is the SDK's conversion for a float32
// source, and it sets the channel count, the sample rate and the sample count. // source, and it sets the channel count, the sample rate and the sample count.
chunk.set_data_32(m_buffer.data(), frames, m_channels, kSampleRate); //
// A forced int24 delivery goes the other way: the samples are packed to the
// core's int24 bytes and the host converts them back, so the audio the rest of
// the pipeline sees is the 24-bit grid rather than the renderer's float -- which
// is the whole point of the option. The quantisation happens here and nowhere
// else, so a sample is rounded once.
double expected_delivered_peak = 0.0;
if (m_settings.force_int24) {
m_int24.resize(frames * m_channels * 3);
const joc_decode::Int24Block block = joc_decode::pack_int24(
m_buffer.data(), frames * m_channels, m_int24.data());
m_clipped_samples += block.clipped;
if (block.clipped != 0 && !m_clip_reported) {
m_clip_reported = true;
joc_log::line("decoder: forced int24: %llu sample(s) outside [-1,1] in this "
"block are truncated to the edge (the core's clip policy; "
"attenuate with the gain setting to avoid it)",
static_cast<unsigned long long>(block.clipped));
}
chunk.set_data_fixedpoint_signed(m_int24.data(), m_int24.size(), kSampleRate,
m_channels, 24,
audio_chunk::g_guess_channel_config(m_channels));
expected_delivered_peak =
static_cast<double>(block.peak) / joc_decode::kInt24ImportScale;
} else {
chunk.set_data_32(m_buffer.data(), frames, m_channels, kSampleRate);
expected_delivered_peak = peak_of(m_buffer.data(), frames * m_channels);
}
m_frames_delivered += frames; m_frames_delivered += frames;
// A delivery that mangled the samples would be heard as noise rather than reported // A delivery that mangled the samples would be heard as noise rather than reported
// as a failure, so every chunk is checked: the conversion is exact, and the peak of // as a failure, so every chunk is checked: the conversion is exact, and the peak of
// what the chunk holds has to equal the peak of what the renderer produced. // what the chunk holds has to equal the peak of what the renderer produced -- or,
const double produced = peak_of(m_buffer.data(), frames * m_channels); // for int24, the peak the packing step actually wrote.
const double delivered = const double delivered =
peak_of(chunk.get_data(), chunk.get_sample_count() * chunk.get_channels()); peak_of(chunk.get_data(), chunk.get_sample_count() * chunk.get_channels());
if (delivered > produced + 1e-6 + produced * 1e-6 || if (delivered > expected_delivered_peak + 1e-6 + expected_delivered_peak * 1e-6 ||
delivered < produced - 1e-6 - produced * 1e-6) { delivered < expected_delivered_peak - 1e-6 - expected_delivered_peak * 1e-6) {
++m_delivery_mismatches; ++m_delivery_mismatches;
if (m_delivery_mismatches == 1) { if (m_delivery_mismatches == 1) {
joc_log::line("decoder: delivery changed the samples: peak %.9f produced, " joc_log::line("decoder: delivery changed the samples: peak %.9f produced, "
"%.9f delivered", "%.9f delivered",
produced, delivered); expected_delivered_peak, delivered);
} }
} }
if (!m_reported) { if (!m_reported) {
m_reported = true; m_reported = true;
joc_log::line("decoder: first %llu frames delivered (%u ch), peak %.6f, " joc_log::line("decoder: first %llu frames delivered (%u ch, %s), peak %.6f, "
"delivered peak %.6f", "delivered peak %.6f",
static_cast<unsigned long long>(frames), m_channels, produced, static_cast<unsigned long long>(frames), m_channels,
delivered); m_settings.force_int24 ? "int24" : "float32",
peak_of(m_buffer.data(), frames * m_channels), delivered);
} }
return true; return true;
} }
@@ -605,6 +652,10 @@ private:
unsigned m_audio_index = 0; unsigned m_audio_index = 0;
joc_container::Result m_container; joc_container::Result m_container;
std::vector<float> m_buffer; std::vector<float> m_buffer;
// int24 delivery: the packed bytes handed to the host, and what the clip caught.
std::vector<std::uint8_t> m_int24;
std::uint64_t m_clipped_samples = 0;
bool m_clip_reported = false;
unsigned m_channels = 2; unsigned m_channels = 2;
std::uint64_t m_frames_delivered = 0; std::uint64_t m_frames_delivered = 0;
bool m_reported = false; bool m_reported = false;
+40
View File
@@ -6,6 +6,7 @@
#include <cstdio> #include <cstdio>
#include <cstring> #include <cstring>
#include <cwchar> #include <cwchar>
#include <limits>
#include <vector> #include <vector>
// The kernel copy that is compiled into this component; see kernel/. // The kernel copy that is compiled into this component; see kernel/.
@@ -309,6 +310,45 @@ unsigned speaker_channels(const std::string& layout) {
return 0; return 0;
} }
namespace {
// The core's conversion, reproduced: kernel/src/io/wav_writer.cpp:to_int32.
// (min)() is written that way because the test tools compile this file without
// NOMINMAX, and windows.h's min macro would otherwise swallow the call.
std::int32_t to_int32(const float value) {
if (!std::isfinite(value)) {
return (std::numeric_limits<std::int32_t>::min)();
}
return static_cast<std::int32_t>(value);
}
} // namespace
Int24Block pack_int24(const float* interleaved, std::size_t count, std::uint8_t* out) {
Int24Block block;
for (std::size_t i = 0; i < count; ++i) {
float value = interleaved[i];
if (value > 1.0f) {
value = 1.0f;
++block.clipped;
} else if (value < -1.0f) {
value = -1.0f;
++block.clipped;
}
const std::int32_t scaled = to_int32(value * 8388607.0f);
const std::uint32_t bits = static_cast<std::uint32_t>(scaled);
out[i * 3 + 0] = static_cast<std::uint8_t>(bits & 0xFFu);
out[i * 3 + 1] = static_cast<std::uint8_t>((bits >> 8) & 0xFFu);
out[i * 3 + 2] = static_cast<std::uint8_t>((bits >> 16) & 0xFFu);
// What the host will read back is the sign-extended low 24 bits.
std::int32_t written = static_cast<std::int32_t>(bits & 0xFFFFFFu);
if ((written & 0x800000) != 0) written -= 0x1000000;
const std::int32_t magnitude = (written < 0) ? -written : written;
if (magnitude > block.peak) block.peak = magnitude;
}
return block;
}
std::string component_directory() { std::string component_directory() {
HMODULE self = nullptr; HMODULE self = nullptr;
if (GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | if (GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
+31
View File
@@ -96,6 +96,15 @@ struct Settings {
// is what the reference CLI's --duration does. Zero means "the whole file". // is what the reference CLI's --duration does. Zero means "the whole file".
// Only the comparison harness sets it; playback leaves it at zero. // Only the comparison harness sets it; playback leaves it at zero.
std::uint64_t input_frame_limit = 0; std::uint64_t input_frame_limit = 0;
// Deliver 24-bit fixed-point PCM instead of float32. The renderer itself is
// always float32 and this does not change it: the flag says how the *caller*
// hands the samples on, and the quantisation happens once, where the format is
// decided (see pack_int24 below). It exists because the streaming interface
// has no int24 output -- the core's int24 rule lives in its file-writing path
// (kernel/src/io/wav_writer.cpp), which the component cannot reach, so the
// rule is reproduced here instead. Out-of-range samples follow the core's
// JOC_CLIP_CONTINUE policy: truncated to the edge, and reported.
bool force_int24 = false;
}; };
// Channel count of a named layout, or 0 when the layout is not one of the // Channel count of a named layout, or 0 when the layout is not one of the
@@ -139,6 +148,28 @@ FileProbe probe_file(const std::string& path, std::size_t max_scan_bytes = 0,
bool probe_container_joc(const std::string& ffmpeg_path, const std::string& path, bool probe_container_joc(const std::string& ffmpeg_path, const std::string& path,
unsigned audio_index, bool* joc, std::string* detail); unsigned audio_index, bool* joc, std::string* detail);
// ---- forced int24 delivery ------------------------------------------------
//
// The core's own int24 rule, reproduced byte for byte from
// kernel/src/io/wav_writer.cpp: clip to [-1, 1], multiply by 8388607, truncate
// toward zero (the core's comment: the int32 conversion is "identical to NumPy's
// float32 -> int32 cast after clipping"), write the low three bytes, little
// endian; a non-finite sample becomes 0, exactly as the core writes it.
//
// Sample values that have been through this are what foobar2000's int24 import
// gives back, i.e. n / 2^23 (SDK/pfc audio_math.cpp:_import24). That is the scale
// a caller should use when it wants to check what the host received.
constexpr double kInt24ImportScale = 8388608.0;
struct Int24Block {
std::size_t clipped = 0; // samples that were outside [-1, 1]
std::int32_t peak = 0; // largest magnitude actually written
};
// Packs `count` interleaved float32 samples into `out`, which must hold
// count * 3 bytes, and reports what the clip caught.
Int24Block pack_int24(const float* interleaved, std::size_t count, std::uint8_t* out);
class Engine { class Engine {
public: public:
Engine(); Engine();
+18 -1
View File
@@ -214,7 +214,7 @@ private:
notify(); notify();
return TRUE; return TRUE;
} }
if (id == IDC_CHECK_GAIN) { if (id == IDC_CHECK_GAIN || id == IDC_CHECK_INT24) {
update_enabled_state(); update_enabled_state();
notify(); notify();
return TRUE; return TRUE;
@@ -301,6 +301,8 @@ private:
SendMessageW(GetDlgItem(m_hwnd, IDC_CHECK_GAIN), BM_SETCHECK, SendMessageW(GetDlgItem(m_hwnd, IDC_CHECK_GAIN), BM_SETCHECK,
values.gain_enabled ? BST_CHECKED : BST_UNCHECKED, 0); values.gain_enabled ? BST_CHECKED : BST_UNCHECKED, 0);
SendMessageW(GetDlgItem(m_hwnd, IDC_CHECK_INT24), BM_SETCHECK,
values.force_int24 ? BST_CHECKED : BST_UNCHECKED, 0);
update_enabled_state(); update_enabled_state();
} }
@@ -328,6 +330,8 @@ private:
values.gain_db = std::atof(get_text(GetDlgItem(m_hwnd, IDC_EDIT_GAIN)).c_str()); values.gain_db = std::atof(get_text(GetDlgItem(m_hwnd, IDC_EDIT_GAIN)).c_str());
values.gain_enabled = values.gain_enabled =
IsDlgButtonChecked(m_hwnd, IDC_CHECK_GAIN) == BST_CHECKED; IsDlgButtonChecked(m_hwnd, IDC_CHECK_GAIN) == BST_CHECKED;
values.force_int24 =
IsDlgButtonChecked(m_hwnd, IDC_CHECK_INT24) == BST_CHECKED;
// Advanced values are not on this page; keep whatever is stored. // Advanced values are not on this page; keep whatever is stored.
const joc_settings::Values stored = joc_settings::read(); const joc_settings::Values stored = joc_settings::read();
values.object_delay_samples = stored.object_delay_samples; values.object_delay_samples = stored.object_delay_samples;
@@ -354,6 +358,18 @@ private:
} }
set_text(GetDlgItem(m_hwnd, IDC_LABEL_OUTPUT_STATUS), output_status); set_text(GetDlgItem(m_hwnd, IDC_LABEL_OUTPUT_STATUS), output_status);
// The hint says what the switch does and what the other state means: the
// renderer is float32 either way, so "24bit" is about the delivery, and
// that is not something a checkbox label can carry on its own. The second
// half matters because this switch changes what the component *reports*
// about a file, and foobar2000 caches that per file: an item whose
// information was read before the switch was flipped keeps the old format
// until it is reloaded.
set_text(GetDlgItem(m_hwnd, IDC_LABEL_INT24_HINT),
values.force_int24
? "开启:量化到 int24,超出 ±1 截断;切换后需刷新文件信息"
: "关闭:按 32 位浮点交付(默认)");
joc_decode::Settings effective = joc_settings::current(); joc_decode::Settings effective = joc_settings::current();
effective.hrtf_source = effective.hrtf_source =
static_cast<joc_decode::HrtfSource>(values.hrtf_source); static_cast<joc_decode::HrtfSource>(values.hrtf_source);
@@ -383,6 +399,7 @@ private:
if (now.hrtf_file != m_initial.hrtf_file) return true; if (now.hrtf_file != m_initial.hrtf_file) return true;
if (now.binaural_mode != m_initial.binaural_mode) return true; if (now.binaural_mode != m_initial.binaural_mode) return true;
if (now.gain_enabled != m_initial.gain_enabled) return true; if (now.gain_enabled != m_initial.gain_enabled) return true;
if (now.force_int24 != m_initial.force_int24) return true;
if (now.gain_db != m_initial.gain_db) return true; if (now.gain_db != m_initial.gain_db) return true;
if (now.tail_seconds != m_initial.tail_seconds) return true; if (now.tail_seconds != m_initial.tail_seconds) return true;
if (now.ffmpeg_path != m_initial.ffmpeg_path) return true; if (now.ffmpeg_path != m_initial.ffmpeg_path) return true;
+23 -20
View File
@@ -7,11 +7,11 @@
// sample page uses (SDK\foobar2000\foo_sample\foo_sample.rc). A CAPTION statement // sample page uses (SDK\foobar2000\foo_sample\foo_sample.rc). A CAPTION statement
// implies WS_CAPTION, which would draw a second frame inside the host's and shift // implies WS_CAPTION, which would draw a second frame inside the host's and shift
// every control down by the caption height -- visible but not clickable. // every control down by the caption height -- visible but not clickable.
IDD_JOC_PREFS DIALOGEX 0, 0, 330, 273 IDD_JOC_PREFS DIALOGEX 0, 0, 330, 299
STYLE DS_SETFONT | WS_CHILD STYLE DS_SETFONT | WS_CHILD
FONT 8, "Microsoft Sans Serif", 400, 0, 0x0 FONT 8, "Microsoft Sans Serif", 400, 0, 0x0
BEGIN BEGIN
GROUPBOX "输出", IDC_GROUP_OUTPUT, 7, 5, 316, 61 GROUPBOX "输出", IDC_GROUP_OUTPUT, 7, 5, 316, 86
CONTROL "双耳(HRTF)", IDC_RADIO_BINAURAL, "Button", CONTROL "双耳(HRTF)", IDC_RADIO_BINAURAL, "Button",
BS_AUTORADIOBUTTON | WS_GROUP | WS_TABSTOP, 16, 20, 72, 10 BS_AUTORADIOBUTTON | WS_GROUP | WS_TABSTOP, 16, 20, 72, 10
CONTROL "扬声器布局", IDC_RADIO_SPEAKER, "Button", CONTROL "扬声器布局", IDC_RADIO_SPEAKER, "Button",
@@ -25,30 +25,33 @@ BEGIN
LTEXT "房间尾音(秒)", IDC_LABEL_TAIL, 172, 41, 62, 10 LTEXT "房间尾音(秒)", IDC_LABEL_TAIL, 172, 41, 62, 10
EDITTEXT IDC_EDIT_TAIL, 238, 38, 40, 13, ES_AUTOHSCROLL EDITTEXT IDC_EDIT_TAIL, 238, 38, 40, 13, ES_AUTOHSCROLL
LTEXT "", IDC_LABEL_OUTPUT_STATUS, 16, 52, 300, 10 LTEXT "", IDC_LABEL_OUTPUT_STATUS, 16, 52, 300, 10
CONTROL "强制 24bit 输出(int24)", IDC_CHECK_INT24, "Button",
BS_AUTOCHECKBOX | WS_TABSTOP, 16, 64, 116, 10
LTEXT "", IDC_LABEL_INT24_HINT, 16, 76, 300, 10
GROUPBOX "HRTF", IDC_GROUP_HRTF, 7, 71, 316, 100 GROUPBOX "HRTF", IDC_GROUP_HRTF, 7, 97, 316, 100
CONTROL "SOFA 文件", IDC_RADIO_HRTF_SOFA, "Button", CONTROL "SOFA 文件", IDC_RADIO_HRTF_SOFA, "Button",
BS_AUTORADIOBUTTON | WS_GROUP | WS_TABSTOP, 16, 86, 56, 10 BS_AUTORADIOBUTTON | WS_GROUP | WS_TABSTOP, 16, 112, 56, 10
CONTROL "Rosella 个性化模型", IDC_RADIO_HRTF_ROSELLA, "Button", CONTROL "Rosella 个性化模型", IDC_RADIO_HRTF_ROSELLA, "Button",
BS_AUTORADIOBUTTON | WS_TABSTOP, 78, 86, 78, 10 BS_AUTORADIOBUTTON | WS_TABSTOP, 78, 112, 78, 10
LTEXT "HRTF 文件(留空=默认位置)", IDC_LABEL_HRTF, 16, 105, 106, 10 LTEXT "HRTF 文件(留空=默认位置)", IDC_LABEL_HRTF, 16, 131, 106, 10
EDITTEXT IDC_EDIT_HRTF, 126, 102, 148, 13, ES_AUTOHSCROLL EDITTEXT IDC_EDIT_HRTF, 126, 128, 148, 13, ES_AUTOHSCROLL
PUSHBUTTON "浏览…", IDC_BROWSE_HRTF, 279, 102, 38, 13 PUSHBUTTON "浏览…", IDC_BROWSE_HRTF, 279, 128, 38, 13
LTEXT "留空时读组件目录下 HRTF\\binaural.sofa 或 binaural.personalized_headphone;SOFA 由渲染器内部编译,滤波组表已编入库中。", LTEXT "留空时读组件目录下 HRTF\\binaural.sofa 或 binaural.personalized_headphone;SOFA 由渲染器内部编译,滤波组表已编入库中。",
IDC_LABEL_HRTF_HINT, 16, 121, 300, 20 IDC_LABEL_HRTF_HINT, 16, 147, 300, 20
LTEXT "", IDC_LABEL_STATUS, 16, 145, 300, 20 LTEXT "", IDC_LABEL_STATUS, 16, 171, 300, 20
GROUPBOX "增益", IDC_GROUP_GAIN, 7, 176, 316, 48 GROUPBOX "增益", IDC_GROUP_GAIN, 7, 202, 316, 48
CONTROL "应用增益", IDC_CHECK_GAIN, "Button", CONTROL "应用增益", IDC_CHECK_GAIN, "Button",
BS_AUTOCHECKBOX | WS_TABSTOP, 16, 192, 58, 10 BS_AUTOCHECKBOX | WS_TABSTOP, 16, 218, 58, 10
LTEXT "dB", IDC_LABEL_GAIN, 80, 192, 12, 10 LTEXT "dB", IDC_LABEL_GAIN, 80, 218, 12, 10
EDITTEXT IDC_EDIT_GAIN, 96, 189, 40, 13, ES_AUTOHSCROLL EDITTEXT IDC_EDIT_GAIN, 96, 215, 40, 13, ES_AUTOHSCROLL
LTEXT "", IDC_LABEL_GAIN_STATUS, 145, 192, 171, 10 LTEXT "", IDC_LABEL_GAIN_STATUS, 145, 218, 171, 10
LTEXT "双耳渲染后可能超过 0 dBFS,可用负值衰减。", LTEXT "双耳渲染后可能超过 0 dBFS,可用负值衰减。",
IDC_LABEL_GAIN_HINT, 16, 208, 300, 10 IDC_LABEL_GAIN_HINT, 16, 234, 300, 10
GROUPBOX "其它", IDC_GROUP_MISC, 7, 229, 316, 38 GROUPBOX "其它", IDC_GROUP_MISC, 7, 255, 316, 38
LTEXT "ffmpeg.exe", IDC_LABEL_FFMPEG, 16, 245, 44, 10 LTEXT "ffmpeg.exe", IDC_LABEL_FFMPEG, 16, 271, 44, 10
EDITTEXT IDC_EDIT_FFMPEG, 64, 242, 210, 13, ES_AUTOHSCROLL EDITTEXT IDC_EDIT_FFMPEG, 64, 268, 210, 13, ES_AUTOHSCROLL
PUSHBUTTON "浏览…", IDC_BROWSE_FFMPEG, 279, 242, 38, 13 PUSHBUTTON "浏览…", IDC_BROWSE_FFMPEG, 279, 268, 38, 13
END END
+3
View File
@@ -13,6 +13,9 @@
#define IDC_LABEL_TAIL 2017 #define IDC_LABEL_TAIL 2017
#define IDC_EDIT_TAIL 2018 #define IDC_EDIT_TAIL 2018
#define IDC_LABEL_OUTPUT_STATUS 2019 #define IDC_LABEL_OUTPUT_STATUS 2019
// Delivery format, in the same group: what the decoder hands to foobar2000.
#define IDC_CHECK_INT24 2050
#define IDC_LABEL_INT24_HINT 2051
#define IDC_GROUP_HRTF 2020 #define IDC_GROUP_HRTF 2020
#define IDC_RADIO_HRTF_SOFA 2021 #define IDC_RADIO_HRTF_SOFA 2021
+23
View File
@@ -6,6 +6,7 @@
#include <windows.h> #include <windows.h>
#include <cstddef>
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
#include <cstring> #include <cstring>
@@ -27,6 +28,7 @@ constexpr GUID kGuidBinauralMode = {0x1a57c9e4, 0x83b6, 0x42f1, {0x9c, 0x50, 0x2
constexpr GUID kGuidGainEnabled = {0x74b1e5c8, 0x2a39, 0x4d16, {0x8f, 0x62, 0x0d, 0x51, 0xb7, 0x3c, 0x9a, 0x28}}; constexpr GUID kGuidGainEnabled = {0x74b1e5c8, 0x2a39, 0x4d16, {0x8f, 0x62, 0x0d, 0x51, 0xb7, 0x3c, 0x9a, 0x28}};
constexpr GUID kGuidGain = {0x6c04d8b2, 0xe75f, 0x4a39, {0x8d, 0x26, 0x51, 0xb3, 0xc8, 0x40, 0x9e, 0x27}}; constexpr GUID kGuidGain = {0x6c04d8b2, 0xe75f, 0x4a39, {0x8d, 0x26, 0x51, 0xb3, 0xc8, 0x40, 0x9e, 0x27}};
constexpr GUID kGuidTail = {0x38f1b6a7, 0x0d24, 0x4e88, {0xb7, 0x95, 0x2c, 0x61, 0x4f, 0xd2, 0x08, 0xa3}}; constexpr GUID kGuidTail = {0x38f1b6a7, 0x0d24, 0x4e88, {0xb7, 0x95, 0x2c, 0x61, 0x4f, 0xd2, 0x08, 0xa3}};
constexpr GUID kGuidForceInt24 = {0xd2c67f41, 0x8b53, 0x4a2e, {0x97, 0x61, 0x0f, 0xc8, 0x35, 0xba, 0x64, 0x12}};
constexpr GUID kGuidObjectDelay = {0x5b2e9c18, 0xa640, 0x4d7b, {0x92, 0x0e, 0x37, 0xc5, 0x81, 0x6b, 0x2a, 0x54}}; constexpr GUID kGuidObjectDelay = {0x5b2e9c18, 0xa640, 0x4d7b, {0x92, 0x0e, 0x37, 0xc5, 0x81, 0x6b, 0x2a, 0x54}};
constexpr GUID kGuidThreads = {0xcb7a4015, 0x3f98, 0x4c62, {0xa0, 0x8d, 0x1b, 0x74, 0x29, 0xe6, 0x53, 0x0f}}; constexpr GUID kGuidThreads = {0xcb7a4015, 0x3f98, 0x4c62, {0xa0, 0x8d, 0x1b, 0x74, 0x29, 0xe6, 0x53, 0x0f}};
constexpr GUID kGuidFfmpeg = {0x0e9d37c2, 0x5a18, 0x4b40, {0xb6, 0x3f, 0x88, 0x2d, 0x9a, 0x70, 0x1c, 0x65}}; constexpr GUID kGuidFfmpeg = {0x0e9d37c2, 0x5a18, 0x4b40, {0xb6, 0x3f, 0x88, 0x2d, 0x9a, 0x70, 0x1c, 0x65}};
@@ -42,10 +44,23 @@ cfg_bool g_gain_enabled(kGuidGainEnabled, true);
cfg_int g_gain_mdb(kGuidGain, 0); cfg_int g_gain_mdb(kGuidGain, 0);
// milli-seconds // milli-seconds
cfg_uint g_tail_ms(kGuidTail, 5000); cfg_uint g_tail_ms(kGuidTail, 5000);
// Deliver int24 instead of float32.
cfg_bool g_force_int24(kGuidForceInt24, false);
cfg_uint g_object_delay(kGuidObjectDelay, 1473); cfg_uint g_object_delay(kGuidObjectDelay, 1473);
cfg_uint g_threads(kGuidThreads, 0); cfg_uint g_threads(kGuidThreads, 0);
cfg_string g_ffmpeg(kGuidFfmpeg, "ffmpeg"); cfg_string g_ffmpeg(kGuidFfmpeg, "ffmpeg");
// Appends an optional trailing field to one of the fixed describe() buffers, so a
// setting that is off leaves the line exactly as it was.
template <std::size_t N>
void append_to(char (&buffer)[N], const char* text) {
if (text == nullptr || *text == '\0') return;
const std::size_t used = std::strlen(buffer);
const std::size_t extra = std::strlen(text);
if (used + extra + 1u > N) return;
std::memcpy(buffer + used, text, extra + 1u);
}
std::string environment(const char* name) { std::string environment(const char* name) {
char buffer[4096] = {}; char buffer[4096] = {};
const DWORD length = GetEnvironmentVariableA(name, buffer, sizeof(buffer)); const DWORD length = GetEnvironmentVariableA(name, buffer, sizeof(buffer));
@@ -108,6 +123,7 @@ Values read() {
values.gain_enabled = static_cast<bool>(g_gain_enabled); values.gain_enabled = static_cast<bool>(g_gain_enabled);
values.gain_db = static_cast<double>(static_cast<long long>(g_gain_mdb)) / 1000.0; values.gain_db = static_cast<double>(static_cast<long long>(g_gain_mdb)) / 1000.0;
values.tail_seconds = static_cast<double>(static_cast<unsigned>(g_tail_ms)) / 1000.0; values.tail_seconds = static_cast<double>(static_cast<unsigned>(g_tail_ms)) / 1000.0;
values.force_int24 = static_cast<bool>(g_force_int24);
values.object_delay_samples = static_cast<unsigned>(g_object_delay); values.object_delay_samples = static_cast<unsigned>(g_object_delay);
values.native_threads = static_cast<unsigned>(g_threads); values.native_threads = static_cast<unsigned>(g_threads);
values.ffmpeg_path = g_ffmpeg.get_ptr(); values.ffmpeg_path = g_ffmpeg.get_ptr();
@@ -124,6 +140,7 @@ void write(const Values& values) {
g_gain_enabled = values.gain_enabled; g_gain_enabled = values.gain_enabled;
g_gain_mdb = static_cast<long long>(values.gain_db * 1000.0 + (values.gain_db >= 0 ? 0.5 : -0.5)); g_gain_mdb = static_cast<long long>(values.gain_db * 1000.0 + (values.gain_db >= 0 ? 0.5 : -0.5));
g_tail_ms = static_cast<unsigned>(values.tail_seconds * 1000.0 + 0.5); g_tail_ms = static_cast<unsigned>(values.tail_seconds * 1000.0 + 0.5);
g_force_int24 = values.force_int24;
g_object_delay = values.object_delay_samples; g_object_delay = values.object_delay_samples;
g_threads = values.native_threads; g_threads = values.native_threads;
g_ffmpeg = values.ffmpeg_path.c_str(); g_ffmpeg = values.ffmpeg_path.c_str();
@@ -146,6 +163,7 @@ joc_decode::Settings current() {
(void)env_double("JOC_GAIN_DB", &values.gain_db); (void)env_double("JOC_GAIN_DB", &values.gain_db);
if (env_string("JOC_GAIN_ENABLED", &text)) values.gain_enabled = (text != "0"); if (env_string("JOC_GAIN_ENABLED", &text)) values.gain_enabled = (text != "0");
(void)env_double("JOC_TAIL_SECONDS", &values.tail_seconds); (void)env_double("JOC_TAIL_SECONDS", &values.tail_seconds);
if (env_string("JOC_FORCE_INT24", &text)) values.force_int24 = (text != "0");
(void)env_uint("JOC_OBJECT_DELAY", &values.object_delay_samples); (void)env_uint("JOC_OBJECT_DELAY", &values.object_delay_samples);
(void)env_uint("JOC_THREADS", &values.native_threads); (void)env_uint("JOC_THREADS", &values.native_threads);
@@ -161,6 +179,7 @@ joc_decode::Settings current() {
// attenuation has to be visible and switchable. // attenuation has to be visible and switchable.
settings.gain_db = values.gain_enabled ? values.gain_db : 0.0; settings.gain_db = values.gain_enabled ? values.gain_db : 0.0;
settings.tail_seconds = values.tail_seconds; settings.tail_seconds = values.tail_seconds;
settings.force_int24 = values.force_int24;
settings.object_delay_samples = values.object_delay_samples; settings.object_delay_samples = values.object_delay_samples;
settings.native_threads = values.native_threads; settings.native_threads = values.native_threads;
settings.ffmpeg_path = values.ffmpeg_path.empty() ? "ffmpeg" : values.ffmpeg_path; settings.ffmpeg_path = values.ffmpeg_path.empty() ? "ffmpeg" : values.ffmpeg_path;
@@ -187,6 +206,9 @@ std::string describe(const joc_decode::Settings& settings) {
settings.object_delay_samples, settings.native_threads, settings.object_delay_samples, settings.native_threads,
settings.ffmpeg_path.c_str()); settings.ffmpeg_path.c_str());
} }
// Stated only when it is not the default, so a default log line reads as it
// always did.
append_to(text, settings.force_int24 ? ", int24=forced" : "");
return text; return text;
} }
@@ -200,6 +222,7 @@ std::string describe(const Values& values) {
values.binaural_mode, values.gain_enabled ? "" : "(off) ", values.gain_db, values.binaural_mode, values.gain_enabled ? "" : "(off) ", values.gain_db,
values.tail_seconds, values.object_delay_samples, values.native_threads, values.tail_seconds, values.object_delay_samples, values.native_threads,
values.ffmpeg_path.c_str()); values.ffmpeg_path.c_str());
append_to(text, values.force_int24 ? " int24=forced" : "");
return text; return text;
} }
+2
View File
@@ -40,6 +40,8 @@ struct Values {
bool gain_enabled = true; bool gain_enabled = true;
double gain_db = 0.0; double gain_db = 0.0;
double tail_seconds = 5.0; double tail_seconds = 5.0;
// Deliver int24 instead of float32; see joc_decode::Settings::force_int24.
bool force_int24 = false;
unsigned object_delay_samples = 1473; unsigned object_delay_samples = 1473;
unsigned native_threads = 0; unsigned native_threads = 0;
std::string ffmpeg_path = "ffmpeg"; std::string ffmpeg_path = "ffmpeg";
+16 -7
View File
@@ -94,12 +94,23 @@ bool is_descendant(HWND candidate, HWND ancestor) {
// A control the user can operate: static text and group boxes answer WM_NCHITTEST // A control the user can operate: static text and group boxes answer WM_NCHITTEST
// with HTTRANSPARENT, so a real click passes straight through them. // with HTTRANSPARENT, so a real click passes straight through them.
//
// BS_GROUPBOX is 0x0007, whose bits are a subset of what BS_AUTOCHECKBOX (0x0003)
// and BS_AUTORADIOBUTTON (0x0009) set, so testing the style against BS_GROUPBOX
// alone classifies every checkbox and radio button as a group box -- and then
// exempts exactly the controls this tool exists to check. BS_TYPEMASK is what
// tells the button styles apart.
bool is_group_box_window(HWND window) {
if (class_of(window) != "Button") return false;
const LONG_PTR style = GetWindowLongPtrW(window, GWL_STYLE);
return (style & BS_TYPEMASK) == BS_GROUPBOX;
}
bool is_interactive(HWND window) { bool is_interactive(HWND window) {
const std::string window_class = class_of(window); const std::string window_class = class_of(window);
if (window_class == "Edit" || window_class == "ComboBox") return true; if (window_class == "Edit" || window_class == "ComboBox") return true;
if (window_class != "Button") return false; if (window_class != "Button") return false;
const LONG_PTR style = GetWindowLongPtrW(window, GWL_STYLE); return !is_group_box_window(window);
return (style & BS_GROUPBOX) == 0;
} }
// True when another interactive sibling sits above the control at that point -- // True when another interactive sibling sits above the control at that point --
@@ -209,11 +220,9 @@ int main(int argc, char** argv) {
// Only controls the user is meant to operate count as problems: static // Only controls the user is meant to operate count as problems: static
// text and group boxes are transparent to the mouse by design. // text and group boxes are transparent to the mouse by design.
const LONG_PTR control_style = GetWindowLongPtrW(control.window, GWL_STYLE); const bool group_box = is_group_box_window(control.window);
const bool is_group_box = const bool is_label = control.window_class == "Static";
control.window_class == "Button" && (control_style & BS_GROUPBOX) != 0; const bool interactive = !group_box && !is_label;
const bool is_label = control.window_class == "Static" && !is_group_box;
const bool interactive = !is_group_box && !is_label;
const bool bad = interactive && (!enabled || !inside || !hits_self); const bool bad = interactive && (!enabled || !inside || !hits_self);
if (bad) ++problems; if (bad) ++problems;
+56 -16
View File
@@ -4,6 +4,7 @@
// //
// render_harness --input <file.eac3> --output <out.wav> [options] // render_harness --input <file.eac3> --output <out.wav> [options]
// --mode binaural|speaker default binaural // --mode binaural|speaker default binaural
// --format float32|int24 delivered sample format (default float32)
// --layout NAME speaker layout (default 7.1) // --layout NAME speaker layout (default 7.1)
// --hrtf-source sofa|rosella kind of model --hrtf points at (default sofa) // --hrtf-source sofa|rosella kind of model --hrtf points at (default sofa)
// --hrtf PATH HRTF to render with; supplied by the caller and // --hrtf PATH HRTF to render with; supplied by the caller and
@@ -36,8 +37,14 @@
// It exists because the plugin's engine (src/joc_decode.*) has no foobar2000 // It exists because the plugin's engine (src/joc_decode.*) has no foobar2000
// dependency: the very code that plays in foobar2000 can be run here, against the // dependency: the very code that plays in foobar2000 can be run here, against the
// reference renderer or against the same engine's continuous render. The WAV header // reference renderer or against the same engine's continuous render. The WAV header
// mirrors the renderer's own writer: a simple IEEE-float header up to two channels, // mirrors the renderer's own writer: a simple header up to two channels,
// WAVE_FORMAT_EXTENSIBLE above that with a channel mask of zero. // WAVE_FORMAT_EXTENSIBLE above that with a channel mask of zero -- for float32
// (IEEE_FLOAT) and for int24 (PCM) alike.
//
// --format int24 is the byte-for-byte counterpart of the CLI's
// --speaker-format/--binaural-format int24: the component renders float32 and the
// int24 packing is the core's own rule (src/joc_decode.h:pack_int24), so the file
// this writes is directly comparable with the one the reference writes.
#include <cstdio> #include <cstdio>
#include <thread> #include <thread>
@@ -54,6 +61,7 @@ struct Options {
std::string input; std::string input;
std::string output; std::string output;
std::string mode = "binaural"; std::string mode = "binaural";
std::string format = "float32"; // float32 | int24
std::string layout = "7.1"; std::string layout = "7.1";
std::string hrtf; // SOFA file, or Rosella model file std::string hrtf; // SOFA file, or Rosella model file
std::string hrtf_source = "sofa"; // sofa | rosella std::string hrtf_source = "sofa"; // sofa | rosella
@@ -83,33 +91,37 @@ void put_u32(std::string* out, unsigned long long value) {
for (int i = 0; i < 4; ++i) out->push_back(static_cast<char>((value >> (8 * i)) & 0xFFu)); for (int i = 0; i < 4; ++i) out->push_back(static_cast<char>((value >> (8 * i)) & 0xFFu));
} }
// Same bytes the core's wav_writer produces. // Same bytes the core's wav_writer produces, for either format it can write.
std::string wav_header(unsigned channels, unsigned rate, std::uint64_t frames) { std::string wav_header(unsigned channels, unsigned rate, std::uint64_t frames, bool int24) {
const unsigned bytes_per_sample = 4; const unsigned bytes_per_sample = int24 ? 3u : 4u;
const unsigned bits_per_sample = 8u * bytes_per_sample;
const unsigned block_align = channels * bytes_per_sample; const unsigned block_align = channels * bytes_per_sample;
const std::uint64_t data_bytes = frames * block_align; const std::uint64_t data_bytes = frames * block_align;
std::string fmt; std::string fmt;
if (channels <= 2) { if (channels <= 2) {
put_u16(&fmt, 3); // WAVE_FORMAT_IEEE_FLOAT put_u16(&fmt, int24 ? 0x0001u : 0x0003u); // WAVE_FORMAT_PCM / IEEE_FLOAT
put_u16(&fmt, channels); put_u16(&fmt, channels);
put_u32(&fmt, rate); put_u32(&fmt, rate);
put_u32(&fmt, rate * block_align); put_u32(&fmt, rate * block_align);
put_u16(&fmt, block_align); put_u16(&fmt, block_align);
put_u16(&fmt, 8 * bytes_per_sample); put_u16(&fmt, bits_per_sample);
} else { } else {
put_u16(&fmt, 0xFFFE); // WAVE_FORMAT_EXTENSIBLE put_u16(&fmt, 0xFFFE); // WAVE_FORMAT_EXTENSIBLE
put_u16(&fmt, channels); put_u16(&fmt, channels);
put_u32(&fmt, rate); put_u32(&fmt, rate);
put_u32(&fmt, rate * block_align); put_u32(&fmt, rate * block_align);
put_u16(&fmt, block_align); put_u16(&fmt, block_align);
put_u16(&fmt, 8 * bytes_per_sample); put_u16(&fmt, bits_per_sample);
put_u16(&fmt, 22); // cbSize put_u16(&fmt, 22); // cbSize
put_u16(&fmt, 8 * bytes_per_sample); put_u16(&fmt, bits_per_sample);
put_u32(&fmt, 0); // channel mask, as the core writes it put_u32(&fmt, 0); // channel mask, as the core writes it
static const unsigned char kFloatGuid[16] = {0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, static const unsigned char kFloatGuid[16] = {0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71}; 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71};
fmt.append(reinterpret_cast<const char*>(kFloatGuid), 16); static const unsigned char kPcmGuid[16] = {0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71};
const unsigned char* guid = int24 ? kPcmGuid : kFloatGuid;
fmt.append(reinterpret_cast<const char*>(guid), 16);
} }
std::string header; std::string header;
@@ -131,6 +143,7 @@ bool parse(int argc, char** argv, Options* options) {
if (arg == "--input") options->input = next(); if (arg == "--input") options->input = next();
else if (arg == "--output") options->output = next(); else if (arg == "--output") options->output = next();
else if (arg == "--mode") options->mode = next(); else if (arg == "--mode") options->mode = next();
else if (arg == "--format") options->format = next();
else if (arg == "--layout") options->layout = next(); else if (arg == "--layout") options->layout = next();
else if (arg == "--hrtf") options->hrtf = next(); else if (arg == "--hrtf") options->hrtf = next();
else if (arg == "--hrtf-source") options->hrtf_source = next(); else if (arg == "--hrtf-source") options->hrtf_source = next();
@@ -165,6 +178,10 @@ bool parse(int argc, char** argv, Options* options) {
return false; return false;
} }
} }
if (options->format != "float32" && options->format != "int24") {
std::fprintf(stderr, "render_harness: --format wants float32 or int24\n");
return false;
}
return !options->input.empty() && !options->output.empty(); return !options->input.empty() && !options->output.empty();
} }
@@ -190,13 +207,18 @@ bool render_once(const joc_decode::Settings& settings, const Options& options,
return false; return false;
} }
// The header carries the length, so write a placeholder and come back to it. // The header carries the length, so write a placeholder and come back to it.
const std::string header = wav_header(channels, 48000, 0); const bool int24 = settings.force_int24;
const std::string header = wav_header(channels, 48000, 0, int24);
std::fwrite(header.data(), 1, header.size(), file); std::fwrite(header.data(), 1, header.size(), file);
constexpr std::size_t kChunk = 4096; constexpr std::size_t kChunk = 4096;
std::vector<float> buffer(kChunk * channels); std::vector<float> buffer(kChunk * channels);
std::vector<std::uint8_t> packed;
std::uint64_t frames_written = 0; std::uint64_t frames_written = 0;
double peak = 0.0; double peak = 0.0;
// What the int24 packing wrote, so the run reports the grid it delivered.
std::uint64_t clipped_samples = 0;
std::int32_t grid_peak = 0;
std::vector<char> applied(options.seeks_at.size(), 0); std::vector<char> applied(options.seeks_at.size(), 0);
for (;;) { for (;;) {
for (std::size_t i = 0; i < options.seeks_at.size(); ++i) { for (std::size_t i = 0; i < options.seeks_at.size(); ++i) {
@@ -226,19 +248,34 @@ bool render_once(const joc_decode::Settings& settings, const Options& options,
: static_cast<double>(buffer[i]); : static_cast<double>(buffer[i]);
if (value > peak) peak = value; if (value > peak) peak = value;
} }
std::fwrite(buffer.data(), sizeof(float), frames * channels, file); if (int24) {
packed.resize(frames * channels * 3u);
const joc_decode::Int24Block block =
joc_decode::pack_int24(buffer.data(), frames * channels, packed.data());
clipped_samples += block.clipped;
if (block.peak > grid_peak) grid_peak = block.peak;
std::fwrite(packed.data(), 1, packed.size(), file);
} else {
std::fwrite(buffer.data(), sizeof(float), frames * channels, file);
}
frames_written += frames; frames_written += frames;
} }
engine.stop(); engine.stop();
const std::string final_header = wav_header(channels, 48000, frames_written); const std::string final_header = wav_header(channels, 48000, frames_written, int24);
std::fseek(file, 0, SEEK_SET); std::fseek(file, 0, SEEK_SET);
std::fwrite(final_header.data(), 1, final_header.size(), file); std::fwrite(final_header.data(), 1, final_header.size(), file);
std::fclose(file); std::fclose(file);
std::printf("render_harness: %s -> %s\n", options.input.c_str(), output.c_str()); std::printf("render_harness: %s -> %s\n", options.input.c_str(), output.c_str());
std::printf(" channels=%u frames=%llu peak=%.9f\n", channels, std::printf(" channels=%u frames=%llu format=%s peak=%.9f\n", channels,
static_cast<unsigned long long>(frames_written), peak); static_cast<unsigned long long>(frames_written),
int24 ? "int24" : "float32", peak);
if (int24) {
std::printf(" int24 grid_peak=%.9f clipped=%llu\n",
static_cast<double>(grid_peak) / joc_decode::kInt24ImportScale,
static_cast<unsigned long long>(clipped_samples));
}
return true; return true;
} }
@@ -253,7 +290,8 @@ int main(int argc, char** argv) {
if (!parse(argc, argv, &options)) { if (!parse(argc, argv, &options)) {
std::fprintf(stderr, std::fprintf(stderr,
"usage: render_harness --input <eac3> --output <wav> [--mode binaural|speaker]\n" "usage: render_harness --input <eac3> --output <wav> [--mode binaural|speaker]\n"
" [--layout NAME] [--hrtf-source sofa|rosella] [--hrtf PATH]\n" " [--format float32|int24] [--layout NAME]\n"
" [--hrtf-source sofa|rosella] [--hrtf PATH]\n"
" [--gain-db X] [--tail S] [--ffmpeg path] [--max-frames N]\n" " [--gain-db X] [--tail S] [--ffmpeg path] [--max-frames N]\n"
" [--max-input-frames N] [--seek-to S] [--seek-at N:S]\n" " [--max-input-frames N] [--seek-to S] [--seek-at N:S]\n"
" [--total-seconds S] [--pipeline-delay N] [--preroll-frames N]\n" " [--total-seconds S] [--pipeline-delay N] [--preroll-frames N]\n"
@@ -279,6 +317,8 @@ int main(int argc, char** argv) {
settings.input_kind = options.container ? joc_decode::InputKind::kContainer settings.input_kind = options.container ? joc_decode::InputKind::kContainer
: joc_decode::InputKind::kBare; : joc_decode::InputKind::kBare;
settings.audio_index = options.audio_index; settings.audio_index = options.audio_index;
// The engine always renders float32; the flag is what the writer above packs.
settings.force_int24 = (options.format == "int24");
std::string error; std::string error;
if (options.parallel != 0) { if (options.parallel != 0) {