189 lines
7.4 KiB
C++
189 lines
7.4 KiB
C++
#include <iostream>
|
|
#include <fstream>
|
|
#include <vector>
|
|
#include <string>
|
|
#include <cstring>
|
|
#include <cmath>
|
|
#include <algorithm>
|
|
#include <sstream>
|
|
#include "spectral.hpp"
|
|
#include "filter.hpp"
|
|
#include "detect.hpp"
|
|
#include "ms.hpp"
|
|
#include "params.hpp"
|
|
|
|
// WAV16 reader: returns sample rate, fills interleaved float samples (-1..1).
|
|
static float read_wav16(const char* path, std::vector<float>& out) {
|
|
std::ifstream f(path, std::ios::binary);
|
|
if (!f) return -1;
|
|
char riff[12];
|
|
f.read(riff, 12);
|
|
if (memcmp(riff, "RIFF", 4) || memcmp(riff + 8, "WAVE", 4)) return -1;
|
|
while (true) {
|
|
char chunk_id[4];
|
|
uint32_t chunk_size;
|
|
if (!f.read(chunk_id, 4) || !f.read(reinterpret_cast<char*>(&chunk_size), 4)) return -1;
|
|
if (memcmp(chunk_id, "fmt ", 4) == 0) {
|
|
if (chunk_size < 16) return -1;
|
|
uint16_t audio_fmt, channels, block_align, bits;
|
|
uint32_t sample_rate, bytes_per_sec;
|
|
f.read(reinterpret_cast<char*>(&audio_fmt), 2);
|
|
f.read(reinterpret_cast<char*>(&channels), 2);
|
|
f.read(reinterpret_cast<char*>(&sample_rate), 4);
|
|
f.read(reinterpret_cast<char*>(&bytes_per_sec), 4);
|
|
f.read(reinterpret_cast<char*>(&block_align), 2);
|
|
f.read(reinterpret_cast<char*>(&bits), 2);
|
|
if (chunk_size > 16) f.seekg(chunk_size - 16, std::ios::cur);
|
|
while (true) {
|
|
char id[4];
|
|
uint32_t dsize;
|
|
if (!f.read(id, 4) || !f.read(reinterpret_cast<char*>(&dsize), 4)) return -1;
|
|
if (memcmp(id, "data", 4) == 0) {
|
|
size_t n = dsize / (bits / 8);
|
|
out.resize(n);
|
|
std::vector<int16_t> raw(n);
|
|
f.read(reinterpret_cast<char*>(raw.data()), dsize);
|
|
for (size_t i = 0; i < n; i++) out[i] = static_cast<float>(raw[i]) / 32768.0f;
|
|
return static_cast<float>(sample_rate);
|
|
} else {
|
|
f.seekg(dsize, std::ios::cur);
|
|
}
|
|
}
|
|
} else {
|
|
f.seekg(chunk_size, std::ios::cur);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void write_wav24(const char* path, const float* data, size_t samples, int channels, int sample_rate) {
|
|
std::ofstream f(path, std::ios::binary);
|
|
int block_align = channels * 3;
|
|
int data_size = static_cast<int>(samples) * channels * 3;
|
|
int file_size = 36 + data_size;
|
|
f.write("RIFF", 4);
|
|
f.write(reinterpret_cast<const char*>(&file_size), 4);
|
|
f.write("WAVE", 4);
|
|
f.write("fmt ", 4);
|
|
int fmt_size = 16;
|
|
f.write(reinterpret_cast<const char*>(&fmt_size), 4);
|
|
int16_t audio_fmt = 1;
|
|
f.write(reinterpret_cast<const char*>(&audio_fmt), 2);
|
|
f.write(reinterpret_cast<const char*>(&channels), 2);
|
|
f.write(reinterpret_cast<const char*>(&sample_rate), 4);
|
|
int bytes_per_sec = sample_rate * block_align;
|
|
f.write(reinterpret_cast<const char*>(&bytes_per_sec), 4);
|
|
f.write(reinterpret_cast<const char*>(&block_align), 2);
|
|
int16_t bits = 24;
|
|
f.write(reinterpret_cast<const char*>(&bits), 2);
|
|
f.write("data", 4);
|
|
f.write(reinterpret_cast<const char*>(&data_size), 4);
|
|
for (size_t i = 0; i < samples * static_cast<size_t>(channels); i++) {
|
|
float val = std::max(-1.0f, std::min(1.0f, data[i]));
|
|
int32_t ival = static_cast<int32_t>(val * 8388607.0f);
|
|
unsigned char bytes[3] = { static_cast<unsigned char>(ival & 0xff),
|
|
static_cast<unsigned char>((ival >> 8) & 0xff),
|
|
static_cast<unsigned char>((ival >> 16) & 0xff) };
|
|
f.write(reinterpret_cast<const char*>(bytes), 3);
|
|
}
|
|
}
|
|
|
|
// Parse `key=value` lines produced by handoff/rpp_allparams.py --flat.
|
|
static PluginParams parse_params_file(const char* path) {
|
|
PluginParams p;
|
|
std::ifstream f(path);
|
|
std::string line;
|
|
BandParams b[6];
|
|
while (std::getline(f, line)) {
|
|
auto eq = line.find('=');
|
|
if (eq == std::string::npos) continue;
|
|
std::string k = line.substr(0, eq);
|
|
double v = std::atof(line.c_str() + eq + 1);
|
|
if (k == "depth") p.depth = v;
|
|
else if (k == "mix") p.mix = v;
|
|
else if (k == "mode") p.mode = v;
|
|
else if (k == "attack") p.attack = v;
|
|
else if (k == "release") p.release = v;
|
|
else if (k == "selectivity") p.selectivity = v;
|
|
else if (k == "sharpness") p.sharpness = v;
|
|
else if (k == "resolution") p.resolution = v;
|
|
else if (k == "offline resolution") p.offline_resolution = v;
|
|
else if (k == "oversample") p.oversample = v;
|
|
else if (k == "offline oversample") p.offline_oversample = v;
|
|
else if (k == "stereo balance") p.stereo_balance = v;
|
|
else if (k == "stereo link") p.stereo_link = v;
|
|
else if (k == "stereo mode") p.stereo_mode = v;
|
|
else if (k == "bypass") p.bypass = v;
|
|
for (int i = 0; i < 6; i++) {
|
|
std::string pre = "band" + std::to_string(i) + " ";
|
|
if (k == pre + "freq") b[i].freq = v;
|
|
else if (k == pre + "q") b[i].q = v;
|
|
else if (k == pre + "sens") b[i].sens = v;
|
|
else if (k == pre + "mode") b[i].mode = v;
|
|
else if (k == pre + "on") b[i].on = v;
|
|
else if (k == pre + "balance") b[i].balance = v;
|
|
}
|
|
}
|
|
for (auto& bd : b) p.bands.push_back(bd);
|
|
return p;
|
|
}
|
|
|
|
int main(int argc, char* argv[]) {
|
|
if (argc < 3) {
|
|
std::cerr << "Usage: " << argv[0] << " input.wav output.wav [params.conf]\n";
|
|
return 1;
|
|
}
|
|
PluginParams params;
|
|
if (argc > 3) params = parse_params_file(argv[3]);
|
|
else {
|
|
params.bands.push_back(BandParams{});
|
|
}
|
|
|
|
std::vector<float> input;
|
|
float sr = read_wav16(argv[1], input);
|
|
if (sr <= 0 || input.empty()) {
|
|
std::cerr << "Failed to read input file\n";
|
|
return 1;
|
|
}
|
|
int channels = 2; // all etalon renders are 2ch
|
|
size_t frames = input.size() / static_cast<size_t>(channels);
|
|
// Trim guard: output length == input length (honest metric, B.14).
|
|
if (input.size() % channels != 0) frames = input.size() / channels;
|
|
|
|
std::vector<float> left_in(frames), right_in(frames);
|
|
for (size_t i = 0; i < frames; i++) {
|
|
left_in[i] = input[i * 2];
|
|
right_in[i] = input[i * 2 + 1];
|
|
}
|
|
|
|
SpectralProcessor sp(2048, 512);
|
|
std::vector<DetectorBand> bands;
|
|
for (const auto& b : params.bands) {
|
|
if (b.on > 0.5f && b.freq > 1.0f) {
|
|
DetectorBand db;
|
|
db.fc = static_cast<float>(b.freq);
|
|
db.q = static_cast<float>(b.q > 0.0f ? b.q : 1.0f);
|
|
db.sens = static_cast<float>(b.sens);
|
|
bands.push_back(db);
|
|
}
|
|
}
|
|
if (bands.empty()) {
|
|
DetectorBand db{500.0f, 1.0f, 12.0f};
|
|
bands.push_back(db);
|
|
}
|
|
sp.setDetectorParams(bands);
|
|
|
|
std::vector<float> left(frames, 0.0f), right(frames, 0.0f);
|
|
encode_ms(left_in.data(), right_in.data(), frames);
|
|
sp.processBlock(left_in.data(), left.data(), frames, 1);
|
|
sp.processBlock(right_in.data(), right.data(), frames, 1);
|
|
decode_ms(left.data(), right.data(), frames);
|
|
|
|
std::vector<float> output(frames * 2);
|
|
for (size_t i = 0; i < frames; i++) {
|
|
output[i * 2] = left[i];
|
|
output[i * 2 + 1] = right[i];
|
|
}
|
|
write_wav24(argv[2], output.data(), frames, channels, static_cast<int>(sr));
|
|
std::cout << "Done! frames=" << frames << " sr=" << sr << "\n";
|
|
return 0;
|
|
} |