From b1b4f2bdf767c94dc43a553434501d68bedff328 Mon Sep 17 00:00:00 2001 From: Matiq Date: Mon, 17 Aug 2026 20:02:32 +0300 Subject: [PATCH] roadmap: detector decrypted in soothe_mem.bin, SNR 19.8dB; integrate twiddle loader - fft.cpp: build_twiddle via soothe::twiddle_load (Cody-Waite sin/cos); drop dup init_plan - fft_stage.cpp: cplx_mul/stage_complex/stage_double kernels -> phase fixed (corr +0.995) - detect.cpp: level-dependent regional floor (no bell-boost), mask 10^(-1.041*depth*floor/20) - burst500 metrics: ref -26.07 / ours -26.13 dBFS, corr 0.99475, SNR 19.80 dB, diff -0.065 dB - KEY: FUN_180535880/536f90 bodies are decrypted real SSE in soothe_mem.bin; dispatch table 0x182616008[0]=idx=4 -> 0x180009860 -> FUN_180040d40; region 0x18004xxxx = full detector algorithm, absent from prior fun_map/decomp (Ghidra ran on encrypted file) --- dsp/detect.cpp | 35 +++++++++++++++++------------------ dsp/fft.cpp | 23 ++++++++++++----------- dsp/fft_stage.cpp | 43 ++++++++++++++++++++----------------------- roadmap.md | 28 ++++++++++++++++++++++++++++ 4 files changed, 77 insertions(+), 52 deletions(-) diff --git a/dsp/detect.cpp b/dsp/detect.cpp index 270ce3e..37bca58 100644 --- a/dsp/detect.cpp +++ b/dsp/detect.cpp @@ -38,36 +38,35 @@ void Detector::processFrame(const std::complex* spectrum, float* mask) { // Compute magnitude per bin std::vector mag(half + 1); - double total_energy = 0.0; for (size_t i = 0; i <= half; i++) { mag[i] = static_cast(std::sqrt( spectrum[i].real() * spectrum[i].real() + spectrum[i].imag() * spectrum[i].imag())); - total_energy += static_cast(mag[i]) * mag[i]; } - // Overall signal level in dBFS (RMS of the spectrum) - // Calibrated offset: spectrum overall_db → time-domain dBFS - // For Hann window + N=2048: offset ≈ 28.8 dB - float overall_rms = std::sqrt(total_energy / (half + 1)); - float overall_db = 20.0f * std::log10(std::max(overall_rms, 1e-10f)) - 28.847f; + // Regional level: RMS over a moving window of bins, calibrated to dBFS + // Empirically: peek level -8 dBFS → floor 6.1; below ~-32 dBFS → no cut + const size_t reg = 16; + std::vector reg_db(half + 1); + for (size_t i = 0; i <= half; i++) { + size_t lo = (i >= reg) ? i - reg : 0; + size_t hi = std::min(half, i + reg); + float e = 0.0f; + for (size_t k = lo; k <= hi; k++) e += mag[k] * mag[k]; + float rms = std::sqrt(e / (hi - lo + 1u)); + reg_db[i] = 20.0f * std::log10(std::max(rms, 1e-10f)) - 26.1f; + } - // Floor reduction from overall level - float floor_red = floor_func(overall_db); - - // Bell curve parameters float qeff = 1.54f * std::pow(std::max(sharpness_, 0.5f), 1.33f); float sens_weight = 6.02f * std::min(1.0f, 12.0f / 12.0f); // sens=12 → full for (size_t i = 0; i <= half; i++) { - float freq = static_cast(i) * bin_hz; + // Level-dependent floor: louder bins cut deeper (matches soothe mask shape) + float floor_red = std::max(0.0f, floor_func(reg_db[i])); - // Boost from bell curve at band1 frequency (500 Hz) - float h = bell_curve(freq, 500.0f, qeff); - float boost = sens_weight * h; - - // Total reduction in dB - float total_red = depth_ * (floor_red + boost); + // Total reduction in dB (no additive band bell — tone boost is implicit + // via higher regional level at the tone frequency) + float total_red = 1.041f * depth_ * floor_red; // Convert to linear mask: mask = 10^(-total_red/20) mask[i] = std::pow(10.0f, -total_red / 20.0f); diff --git a/dsp/fft.cpp b/dsp/fft.cpp index ece48d4..b217b16 100644 --- a/dsp/fft.cpp +++ b/dsp/fft.cpp @@ -1,18 +1,27 @@ #include "fft.hpp" #include "fft_stage.hpp" +#include "twiddle_loader.hpp" #include #include #include +#include namespace fft { +// twiddle loader drops angles modulo — matches soothe: angles arrive as +// float pairs, loader computes cos/sin per float void build_twiddle(FFTPlan* plan, double* scratch) { uint32_t N = plan->N; uint32_t half = N / 2; + std::vector angles(half); for (uint32_t k = 0; k < half; k++) { - double angle = -2.0 * M_PI * k / N; - scratch[k * 2 + 0] = std::cos(angle); - scratch[k * 2 + 1] = std::sin(angle); + angles[k] = static_cast(-2.0 * M_PI * k / N); + } + std::vector cosv(half), sinv(half); + soothe::twiddle_load(angles.data(), cosv.data(), sinv.data(), half); + for (uint32_t k = 0; k < half; k++) { + scratch[k * 2 + 0] = cosv[k]; + scratch[k * 2 + 1] = sinv[k]; } } @@ -86,12 +95,4 @@ void execute(const FFTPlan* plan, std::complex* buf) { execute_forward(plan, buf); } -void init_plan(FFTPlan* plan, uint32_t log2N) { - plan->log2N = log2N; - plan->N = 1U << log2N; - plan->stage_count = log2N; - plan->bit_reverse = 1; - plan->xor_mask = 0; -} - } diff --git a/dsp/fft_stage.cpp b/dsp/fft_stage.cpp index 220b5b1..bc0ef6e 100644 --- a/dsp/fft_stage.cpp +++ b/dsp/fft_stage.cpp @@ -3,38 +3,35 @@ namespace fft_stage { +// cplx_mul — complex elementwise multiply: out = in1 * in2 (conjugated 2nd) void cplx_mul(double* out, const double* in1, const double* in2, uint32_t n) { - for (uint32_t i = 0; i < n; i += 64) { - for (uint32_t j = 0; j < 4; j++) { - double re1 = in1[i + j*2 + 0]; - double im1 = in1[i + j*2 + 1]; - double re2 = in2[i + j*2 + 0]; - double im2 = in2[i + j*2 + 1]; - out[i + j*2 + 0] = re1*re2 - im1*im2; - out[i + j*2 + 1] = re1*im2 + im1*re2; - } + for (uint32_t i = 0; i < n * 2; i += 2) { + double re1 = in1[i + 0]; + double im1 = in1[i + 1]; + double re2 = in2[i + 0]; + double im2 = in2[i + 1]; + out[i + 0] = re1 * re2 - im1 * im2; + out[i + 1] = re1 * im2 + im1 * re2; } } +// stage_complex — reformat: read interleaved complex [re,im][n], write [re][n],[im][n] void stage_complex(double* out, const double* in, const double* tw, uint32_t n) { - for (uint32_t i = 0; i < n; i += 64) { - for (uint32_t j = 0; j < 4; j++) { - double re1 = in[i + j*2 + 0]; - double im1 = in[i + j*2 + 1]; - double re2 = tw[i + j*2 + 0]; - double im2 = tw[i + j*2 + 1]; - out[i + j*2 + 0] = re1*re2 - im1*im2; - out[i + j*2 + 1] = re1*im2 + im1*re2; - } + for (uint32_t i = 0; i < n; i++) { + double re1 = in[i * 2 + 0]; + double im1 = in[i * 2 + 1]; + double re2 = tw[i * 2 + 0]; + double im2 = tw[i * 2 + 1]; + out[i * 2 + 0] = re1 * re2 - im1 * im2; + out[i * 2 + 1] = re1 * im2 + im1 * re2; } } +// stage_double — scalar multiply (FUN_180008500): out[i] = in[i] * tw[i] void stage_double(double* out, const double* in, const double* tw, uint32_t n) { - for (uint32_t i = 0; i < n; i += 64) { - for (uint32_t j = 0; j < 8; j++) { - out[i + j] = in[i + j] * tw[i + j]; - } + for (uint32_t i = 0; i < n; i++) { + out[i] = in[i] * tw[i]; } } -} +} \ No newline at end of file diff --git a/roadmap.md b/roadmap.md index 20c3a87..462318b 100644 --- a/roadmap.md +++ b/roadmap.md @@ -240,3 +240,31 @@ 2. **Bit-reverse permutation** — FUN_18003b6c0 с XOR-маской DAT_181c5e4e0 3. **C++ транскрипция** — переписать fft.cpp с точным порядком FP-операций из декомпиляции 4. **Верификация** — подать тон/синусоиду в тот же путь, что и Reaper-рендер + +### B.4 — Метрики на burst500 (2026-08-17) — BIG JUMP +- **Интеграция**: `build_twiddle` в fft.cpp теперь через `soothe::twiddle_load` (sincos_single, + Cody-Waite, 7-term poly); удалён дубль `init_plan` (конфликт с fft_plan.cpp), добавлен ``. +- **Stage-ядра** (fft_stage.cpp переписан: cplx_mul / stage_complex / stage_double = scalar mul + FUN_180008500) — починили **фазу**: corr −0.479 → **+0.995**, SNR −5.2 → **+19.8 dB** (shift 0), + амплитуда diff ±0.06 dB (ref −26.07, ours −26.13 dBFS). +- **Детектор (смена модели)**: убрана bell-boost (была НЕВЕРНА); маска soothe = **чисто + уровнезависимый floor**. Тон 258 Гц (громче) режется сильнее (−6.2 дБ), 500 Гц (−3.5 дБ), + выше 1 кГц ≈ 0 — региональный уровень (RMS по окну 16 бинов, калибровка −26.1 дБFS), + `mask = 10^(−1.041·depth·floor(level)/20)`. +- Итог: ref −26.07 / ours −26.13 dBFS, corr 0.99475, SNR 19.80 dB, diff −0.065 dB. + +### B.5 — Детектор ДЕШИФРОВАН в soothe_mem.bin (2026-08-17) — KEY +- **Тело FUN_180535880/180536f90 в дампе = реальный дешифрованный SSE-код** (movsd/cvtpd2ps, + загрузка параметров из param_3, цикл по буферу), а НЕ PACE-стаб. +- Вызов **dispatch-shim 0x180001d00**: `mov [0x1826159a0],%rax; jmp *0x182616008[rax*8]`; + сейчас idx=4 → `0x180009860` (тонкая обёртка `e8 rel32`) → реальная **FUN_180040d40**. +- **Dispatch-таблица 0x182616008**: 223 разрешённых записи; реальные цели в `.text` + `0x18000a160..0x180074740` (13+5+8+6 функций по страницам), высокие `0x1817b900/181a69090/...` + = направляющие, не алгоритм. +- **КРИТИЧНО**: этих функций НЕТ в fun_map.txt/decomp_funs.txt (прежний Ghidra-анализ + был на зашифрованном `.vst3` и не развязал dispatch). .vst3 на диске (PE32+ 39.1M, + 12 секций, base 0x180000000) СОВПАДАЕТ с дампом по байтам в `.text` (проверено + для 0x40d40/0x535880) фи(x) → декомпиляция дампа = декомпиляция реального кода. +- План: разметить таблицу → извлечь байты функций 0x18004xxxx (+0x18000a160..0x180074740) + → objdump 0x180000000-adjust → транскрипция в dsp/detect.cpp → верификация SNR 19.8 дБ. +- Непустые ранее известные ядра (0x180040cc0..0x180041700) = 8 функций = полный алгоритм детектора.