152 lines
5.9 KiB
C++
152 lines
5.9 KiB
C++
// render48k.cpp — 48000/N=4096 internal-grid renderer (BITEXACT_PLAN step 6, path b).
|
|
//
|
|
// Host audio is 44100; the plugin detector runs internally at 48000/N=4096 (the
|
|
// live IIR/warp/freq-axis tables are sized for that grid). This tool mirrors that:
|
|
// 1. read input WAV (44100 host samples)
|
|
// 2. resample 44100 -> 48000 (libsamplerate, SINC best)
|
|
// 3. SpectralProcessor(4096, 1024, 48000) with the given bands
|
|
// 4. resample 48000 -> 44100
|
|
// 5. write 24-bit output WAV (matches reference format)
|
|
// Usage: render48k <in.wav> <out.wav> [fc,q,sens[,scale] ...] (comma bands, like framed_test)
|
|
#include "spectral.hpp"
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <vector>
|
|
#include <cmath>
|
|
#include <cstring>
|
|
#include <samplerate.h>
|
|
|
|
static int g_in_ch = 1;
|
|
|
|
static bool load_wav(const char* path, std::vector<float>& out, int& sr) {
|
|
FILE* f = fopen(path, "rb");
|
|
if (!f) return false;
|
|
char hdr[44];
|
|
if (fread(hdr, 1, 44, f) != 44) return false;
|
|
sr = *(int*)(hdr + 24);
|
|
int ch = *(short*)(hdr + 22);
|
|
int bits = *(short*)(hdr + 34);
|
|
// scan chunks to find data chunk size (hdr[40] may be bext/junk size)
|
|
int data = 0;
|
|
int64_t pos = 12;
|
|
fseek(f, 12, SEEK_SET);
|
|
while (pos < 32 * 1024 * 1024) {
|
|
char cid[4]; int csize;
|
|
if (fread(cid, 1, 4, f) < 4 || fread(&csize, 4, 1, f) < 1) break;
|
|
pos += 8;
|
|
if (memcmp(cid, "data", 4) == 0) { data = csize; break; }
|
|
pos += csize;
|
|
int skip = csize;
|
|
if (csize % 2) skip++; // odd chunk size padded
|
|
fseek(f, skip, SEEK_CUR);
|
|
}
|
|
if (!data) { fclose(f); return false; }
|
|
int n = data / (ch * (bits / 8));
|
|
g_in_ch = ch;
|
|
out.resize(n);
|
|
if (bits == 16) {
|
|
std::vector<short> raw(n * ch);
|
|
fread(raw.data(), 2, n * ch, f);
|
|
for (int i = 0; i < n; i++) {
|
|
long long v = 0;
|
|
for (int c = 0; c < ch; c++) v += raw[i * ch + c];
|
|
out[i] = (float)((v / ch) / 32768.0);
|
|
}
|
|
} else if (bits == 24) {
|
|
std::vector<unsigned char> raw(n * ch * 3);
|
|
fread(raw.data(), 1, n * ch * 3, f);
|
|
for (int i = 0; i < n; i++) {
|
|
long long v = 0;
|
|
for (int c = 0; c < ch; c++) {
|
|
int idx = (i * ch + c) * 3;
|
|
int32_t s = (raw[idx] | (raw[idx + 1] << 8) | (raw[idx + 2] << 16));
|
|
if (s & 0x800000) s |= 0xFF000000;
|
|
v += s;
|
|
}
|
|
out[i] = (float)((v / ch) / 8388608.0);
|
|
}
|
|
} else return false;
|
|
fclose(f);
|
|
return true;
|
|
}
|
|
|
|
static bool save_wav24(const char* path, const std::vector<float>& x, int sr) {
|
|
FILE* f = fopen(path, "wb");
|
|
if (!f) return false;
|
|
int ch = 2, bits = 24;
|
|
// x is already stereo interleaved (size = mono_samples * 2)
|
|
int data = (int)(x.size() * (bits / 8));
|
|
char hdr[44]; memset(hdr, 0, 44);
|
|
memcpy(hdr, "RIFF", 4); *(int*)(hdr + 4) = 36 + data;
|
|
memcpy(hdr + 8, "WAVE", 4); memcpy(hdr + 12, "fmt ", 4);
|
|
*(int*)(hdr + 16) = 16; *(short*)(hdr + 20) = 1; *(short*)(hdr + 22) = (short)ch;
|
|
*(int*)(hdr + 24) = sr; *(int*)(hdr + 28) = sr * ch * (bits / 8);
|
|
*(short*)(hdr + 32) = (short)ch; *(short*)(hdr + 34) = (short)bits;
|
|
memcpy(hdr + 36, "data", 4); *(int*)(hdr + 40) = data;
|
|
fwrite(hdr, 1, 44, f);
|
|
for (size_t i = 0; i < x.size(); i++) {
|
|
int32_t v = (int32_t)(std::max(-1.0f, std::min(1.0f, x[i])) * 8388607.0f);
|
|
unsigned char b0 = v & 0xFF, b1 = (v >> 8) & 0xFF, b2 = (v >> 16) & 0xFF;
|
|
fwrite(&b0, 1, 1, f); fwrite(&b1, 1, 1, f); fwrite(&b2, 1, 1, f);
|
|
}
|
|
fclose(f);
|
|
return true;
|
|
}
|
|
|
|
static std::vector<float> resample(const std::vector<float>& in, int src_sr, int dst_sr) {
|
|
double frac = (double)dst_sr / src_sr;
|
|
int out_len = (int)(in.size() * frac) + 16;
|
|
std::vector<float> buf(out_len);
|
|
SRC_DATA sd;
|
|
sd.data_in = in.data(); sd.input_frames = (long)in.size();
|
|
sd.data_out = buf.data(); sd.output_frames = out_len;
|
|
sd.src_ratio = frac; sd.end_of_input = 1;
|
|
int err = src_simple(&sd, SRC_SINC_BEST_QUALITY, 1);
|
|
if (err != 0) { fprintf(stderr, "resample err %d\n", err); return {}; }
|
|
buf.resize(sd.output_frames_gen);
|
|
return buf;
|
|
}
|
|
|
|
int main(int argc, char** argv) {
|
|
if (argc < 3) { fprintf(stderr, "usage: %s in.wav out.wav [fc,q,sens[,scale] ...]\n", argv[0]); return 1; }
|
|
std::vector<float> x; int sr;
|
|
if (!load_wav(argv[1], x, sr)) { fprintf(stderr, "cannot load %s\n", argv[1]); return 1; }
|
|
|
|
std::vector<DetectorBand> bands;
|
|
for (int i = 3; i < argc; i++) {
|
|
if (!strchr(argv[i], ',')) continue;
|
|
float fc, q, sens, scl = 1.0f;
|
|
if (sscanf(argv[i], "%f,%f,%f,%f", &fc, &q, &sens, &scl) < 3) continue;
|
|
DetectorBand b; b.fc = fc; b.q = q; b.sens = sens; b.level_scale = scl;
|
|
bands.push_back(b);
|
|
}
|
|
if (bands.empty()) bands.push_back({1000.0f, 1.0f, 12.0f});
|
|
|
|
auto x48 = resample(x, sr, 48000);
|
|
if (x48.empty()) return 1;
|
|
|
|
SpectralProcessor sp(4096, 1024, 48000.0f);
|
|
sp.setDetectorParams(bands);
|
|
std::vector<float> y48(x48.size());
|
|
const size_t BLK = 1 << 16;
|
|
std::vector<float> inb(BLK), outb(BLK);
|
|
for (size_t s = 0; s < x48.size(); s += BLK) {
|
|
size_t n = std::min(BLK, x48.size() - s);
|
|
memcpy(inb.data(), x48.data() + s, n * sizeof(float));
|
|
for (size_t i = n; i < BLK; i++) inb[i] = 0.0f;
|
|
sp.processBlock(inb.data(), outb.data(), BLK, 1);
|
|
memcpy(y48.data() + s, outb.data(), n * sizeof(float));
|
|
}
|
|
auto y = resample(y48, 48000, 44100);
|
|
if ((int)y.size() > (int)x.size()) y.resize(x.size());
|
|
|
|
// write stereo 24-bit
|
|
std::vector<float> yst(y.size() * 2);
|
|
for (size_t i = 0; i < y.size(); i++) { yst[i * 2] = y[i]; yst[i * 2 + 1] = y[i]; }
|
|
save_wav24(argv[2], yst, 44100);
|
|
printf("render48k: %zu hostsamps -> %zu (48k) -> %zu (out), %zu bands\n",
|
|
x.size(), x48.size(), y.size(), bands.size());
|
|
(void)g_in_ch;
|
|
return 0;
|
|
}
|