/*
* Copyright (C) 2026 Linux Studio Plugins Project
* (C) 2026 Vladimir Sadovnikov
*
* This file is part of lsp-runtime-lib
* Created on: 6 сент. 2019 г.
*
* lsp-runtime-lib is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* lsp-runtime-lib is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with lsp-runtime-lib. If not, see .
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
namespace lsp
{
namespace room_ew
{
const char *charsets[] =
{
"UTF-8",
"UTF-16LE",
"UTF-16BE",
NULL
};
config_t *build_config(const LSPString *eq, const LSPString *notes,
int32_t major, int32_t minor, size_t filters)
{
const char *peq = eq->get_utf8();
if (peq == NULL)
return NULL;
const char *pnotes = notes->get_utf8();
if (pnotes == NULL)
return NULL;
size_t n_hdr = ::strlen(peq) + 1;
size_t n_notes = ::strlen(pnotes) + 1;
size_t n_strings = align_size(n_hdr + n_notes, DEFAULT_ALIGN);
size_t n_cfg = align_size(sizeof(config_t), DEFAULT_ALIGN);
size_t n_filters = align_size(sizeof(filter_t) * filters, DEFAULT_ALIGN);
size_t to_alloc = n_strings + n_cfg + n_filters;
uint8_t *ptr = reinterpret_cast(::malloc(to_alloc));
if (ptr == NULL)
return NULL;
::bzero(ptr, to_alloc);
config_t *cfg = reinterpret_cast(ptr);
ptr += n_cfg;
char *xeq = reinterpret_cast(ptr);
char *xnotes = &xeq[n_hdr];
ptr += n_strings;
::memcpy(xeq, peq, n_hdr);
::memcpy(xnotes, pnotes, n_notes);
cfg->vFilters = reinterpret_cast(ptr);
ptr += n_filters;
// Fill the basic configuration
cfg->nVerMaj = major;
cfg->nVerMin = minor;
cfg->sEqType = xeq;
cfg->sNotes = xnotes;
cfg->fPreamp = 0.0;
cfg->nFilters = filters;
return cfg;
}
filter_type_t decode_filter_type(const char *type)
{
#define DECODE(text, ftype) \
if (!::strcasecmp(type, text)) return ftype;
DECODE("PK", PK);
DECODE("MODAL", MODAL);
DECODE("LP", LP);
DECODE("HP", HP);
DECODE("LPQ", LPQ);
DECODE("HPQ", HPQ);
DECODE("LS", LS);
DECODE("LSC", LSC);
DECODE("HS", HS);
DECODE("HSC", HSC);
DECODE("LS6", LS6);
DECODE("HS6", HS6);
DECODE("LS12", LS12);
DECODE("HS12", HS12);
DECODE("NO", NO);
DECODE("AP", AP);
DECODE("BP", BP);
#undef DECODE
return NONE;
}
status_t load_object_stream(java::ObjectStream *os, config_t **dst)
{
status_t res;
LSPString eq, notes, xeq;
java::RawArray *filters;
java::int_t major=0, minor=0, stub=0;
// Read the REW data in Java serialization format
if ((res = os->read_string(&eq)) != STATUS_OK)
return res;
if (!xeq.set_ascii("Equaliser:"))
return STATUS_NO_MEM;
ssize_t idx = eq.index_of(&xeq);
if (idx >= 0)
eq.remove(0, idx + xeq.length());
lsp_trace("equalizer: %s", eq.get_utf8());
if ((res = os->read_int(&major)) != STATUS_OK)
return res;
if ((res = os->read_int(&minor)) != STATUS_OK)
return res;
lsp_trace("version: %d.%d", int(major), int(minor));
if ((res = os->read_string(¬es)) != STATUS_OK)
return res;
if (notes.starts_with_ascii("Notes:"))
notes.remove(0, 6);
lsp_trace("notes: %s", notes.get_utf8());
if ((res = os->read_int(&stub)) != STATUS_OK) // Don't know what this number actually means currently
return res;
lsp_trace("stub: %d", int(stub));
if ((res = os->read_array(&filters)) != STATUS_OK)
return res;
// Now we are ready to allocate the data
config_t *cfg = build_config(&eq, ¬es, major, minor, filters->length());
if (cfg == NULL)
return STATUS_NO_MEM;
// Read the entire data
const java::Object **vsf = filters->get_objects();
filter_t *vdf = cfg->vFilters;
for (size_t i=0, n=filters->length(); iget_double("Q", &Q)) != STATUS_OK)
break;
if ((res = sf->get_double("fc", &fc)) != STATUS_OK)
break;
if ((res = sf->get_double("gain", &gain)) != STATUS_OK)
break;
if ((res = sf->get_bool("enabled", &enabled)) != STATUS_OK)
break;
if ((res = sf->get_enum("filterType", &ftype)) != STATUS_OK)
break;
lsp_trace(
"Filter %d: %s %s Fc %.0f Hz Gain %.1f dB Q %.7f",
int(i+1), (enabled) ? "ON" : "OFF", ftype,
double(fc), double(gain), double(Q)
);
// lsp_trace(
// "check_filter(&vf[idx++], %s, room_ew::%s, %.2f, %.2f, %.7f);",
// (enabled) ? "true" : "false", ftype,
// double(fc), double(gain), double(Q)
// );
// Fill the state of filter
df->Q = Q;
df->fc = fc;
df->gain = gain;
df->enabled = enabled;
df->filterType = decode_filter_type(ftype);
}
if ((res != STATUS_OK) || (dst == NULL))
::free(cfg);
else if (res == STATUS_OK)
*dst = cfg;
return STATUS_OK;
}
status_t load_java(io::IInStream *is, config_t **dst)
{
// Open file
java::Handles handles;
java::ObjectStream os(&handles);
status_t res = os.wrap(is, WRAP_NONE);
if (res == STATUS_OK)
res = load_object_stream(&os, dst);
if (res == STATUS_OK)
return os.close();
os.close();
return res;
}
status_t skip_whitespace(const LSPString *s, size_t *offset)
{
size_t len = s->length();
while (*offset < len)
{
switch (s->char_at(*offset))
{
case ' ':
case '\n':
case '\t':
case '\r':
++(*offset);
break;
default:
return STATUS_OK;
}
}
return STATUS_OK;
}
status_t skip_data(const LSPString *s, size_t *offset)
{
size_t len = s->length();
while (*offset < len)
{
switch (s->char_at(*offset))
{
case ' ':
case '\n':
case '\t':
case '\r':
return STATUS_OK;
default:
++(*offset);
break;
}
}
return STATUS_OK;
}
status_t parse_decimal(ssize_t *dst, const LSPString *s, size_t *offset)
{
status_t res = skip_whitespace(s, offset);
if (res != STATUS_OK)
return res;
ssize_t num = 0, n=0;
size_t len = s->length();
for ( ; *offset < len; ++(*offset), ++n)
{
lsp_wchar_t wc = s->char_at(*offset);
if ((wc >= '0') && (wc <= '9'))
num = num * 10 + (wc - '0');
else
break;
}
if (n <= 0)
return STATUS_BAD_FORMAT;
*dst = num;
return STATUS_OK;
}
status_t parse_double(double *dst, const LSPString *s, size_t *offset)
{
status_t res = skip_whitespace(s, offset);
lsp_wchar_t wc;
if (res != STATUS_OK)
return res;
lsp_trace("s = %s", s->get_utf8(*offset));
size_t len = s->length();
// Check sign
bool negative = false;
ssize_t is = 0;
if (*offset < len)
{
wc = s->char_at(*offset);
if (wc == '+')
{
++is;
++(*offset);
}
else if (wc == '-')
{
++is;
++(*offset);
negative = true;
}
}
// Parse integer part
double num = 0;
ssize_t in = 0;
for ( ; *offset < len; ++(*offset), ++in)
{
wc = s->char_at(*offset);
if ((wc >= '0') && (wc <= '9'))
num = num * 10 + (wc - '0');
else
break;
}
// No fraction part?
if ((*offset) >= len)
{
if (in <= 0)
return STATUS_BAD_FORMAT;
*dst = num;
return STATUS_OK;
}
else
{
wc = s->char_at(*offset);
if ((wc != '.') && (wc != ','))
{
if (in <= 0)
return STATUS_BAD_FORMAT;
*dst = num;
return STATUS_OK;
}
++(*offset);
}
// Parse fraction part
double fnum = 0.1;
ssize_t fn=0;
for ( ; *offset < len; ++(*offset), ++fn)
{
wc = s->char_at(*offset);
if ((wc >= '0') && (wc <= '9'))
{
num += (wc - '0') * fnum;
fnum *= 0.1;
}
else
break;
}
// No integer and no fraction parts?
if ((in <= 0) && (fn <= 0))
{
--(*offset);
if (is > 0)
--(*offset);
return STATUS_BAD_FORMAT;
}
// Return the result
*dst = (negative) ? -num : num;
return STATUS_OK;
}
status_t parse_filter_settings(filter_t *f, const LSPString *s, size_t *offset)
{
status_t res;
if ((res = skip_whitespace(s, offset)) != STATUS_OK)
return res;
LSPString tmp;
/**
* Filter 6: ON None
* Filter 7: ON PK Fc 100 Hz Gain 0.0 dB Q 10.000
* Filter 8: ON Modal Fc 100 Hz Gain 0.0 dB Q 13.643 T60 target 300 ms
*/
// On/Off
if (s->starts_with_ascii_nocase("on ", *offset))
{
*offset += 3;
f->enabled = true;
}
else if (s->starts_with_ascii_nocase("off ", *offset))
{
*offset += 4;
f->enabled = false;
}
else
return STATUS_BAD_FORMAT;
if ((res = skip_whitespace(s, offset)) != STATUS_OK)
return res;
// Filter type
if (s->starts_with_ascii_nocase("none ", *offset))
{
f->filterType = NONE;
*offset += 5;
}
else if (s->starts_with_ascii_nocase("modal ", *offset))
{
f->filterType = MODAL;
*offset += 6;
}
else if (s->starts_with_ascii_nocase("pk ", *offset))
{
f->filterType = PK;
*offset += 3;
}
else if (s->starts_with_ascii_nocase("lp ", *offset))
{
f->filterType = LP;
*offset += 3;
}
else if (s->starts_with_ascii_nocase("hp ", *offset))
{
f->filterType = HP;
*offset += 3;
}
else if (s->starts_with_ascii_nocase("lpq ", *offset))
{
f->filterType = LPQ;
*offset += 4;
}
else if (s->starts_with_ascii_nocase("hpq ", *offset))
{
f->filterType = HPQ;
*offset += 4;
}
else if (s->starts_with_ascii_nocase("ls 6dB ", *offset))
{
f->filterType = LS6;
*offset += 7;
}
else if (s->starts_with_ascii_nocase("ls 12dB ", *offset))
{
f->filterType = LS12;
*offset += 8;
}
else if (s->starts_with_ascii_nocase("ls ", *offset))
{
f->filterType = LS;
*offset += 3;
}
else if (s->starts_with_ascii_nocase("lsc ", *offset))
{
f->filterType = LSC;
*offset += 4;
}
else if (s->starts_with_ascii_nocase("hs 6dB ", *offset))
{
f->filterType = HS6;
*offset += 7;
}
else if (s->starts_with_ascii_nocase("hs 12dB ", *offset))
{
f->filterType = HS12;
*offset += 8;
}
else if (s->starts_with_ascii_nocase("hs ", *offset))
{
f->filterType = HS;
*offset += 3;
}
else if (s->starts_with_ascii_nocase("hsc ", *offset))
{
f->filterType = HSC;
*offset += 4;
}
else if (s->starts_with_ascii_nocase("no ", *offset))
{
f->filterType = NO;
*offset += 3;
}
else if (s->starts_with_ascii_nocase("ap ", *offset))
{
f->filterType = AP;
*offset += 3;
}
else if (s->starts_with_ascii_nocase("bp ", *offset))
{
f->filterType = BP;
*offset += 3;
}
else
return STATUS_BAD_FORMAT;
// Other parameters
f->Q = 1.0;
f->fc = 100.0;
f->gain = 0.0;
if ((f->filterType == LP) || (f->filterType == HP) || (f->filterType == BP))
f->Q = M_SQRT1_2;
if ((res = skip_whitespace(s, offset)) != STATUS_OK)
return res;
// Scan the rest of line for optional parameters
size_t len = s->length();
lsp_trace("offset = %d, len = %d", int(*offset), int(len));
while (*offset < len)
{
lsp_trace("analyzing: %s", s->get_utf8(*offset));
if (s->starts_with_ascii_nocase("fc ", *offset))
{
*offset += 3;
if ((res = parse_double(&f->fc, s, offset)) != STATUS_OK)
return res;
if (f->fc < 0)
return STATUS_BAD_FORMAT;
if ((res = skip_whitespace(s, offset)) != STATUS_OK)
return res;
if (s->starts_with_ascii_nocase("hz ", *offset))
*offset += 3;
else if (s->starts_with_ascii_nocase("h z ", *offset))
*offset += 4;
else
return STATUS_BAD_FORMAT;
}
else if (s->starts_with_ascii_nocase("gain ", *offset))
{
*offset += 5;
if ((res = parse_double(&f->gain, s, offset)) != STATUS_OK)
return res;
if ((res = skip_whitespace(s, offset)) != STATUS_OK)
return res;
if (!s->starts_with_ascii_nocase("db ", *offset))
return STATUS_BAD_FORMAT;
*offset += 3;
}
else if (s->starts_with_ascii_nocase("q ", *offset))
{
*offset += 2;
if ((res = parse_double(&f->Q, s, offset)) != STATUS_OK)
return res;
}
else
{
if ((res = skip_data(s, offset)) != STATUS_OK)
return res;
}
if ((res = skip_whitespace(s, offset)) != STATUS_OK)
return res;
}
return STATUS_OK;
}
status_t parse_text_config(io::IInSequence *is, config_t **dst)
{
LSPString s;
status_t res;
// Read lines
LSPString notes, eq;
ssize_t major=0, minor=0;
size_t offset = 0;
lltl::darray vfilters;
double preamp = 0.0;
while ((res = is->read_line(&s, true)) == STATUS_OK)
{
lsp_trace("Parsing line: %s", s.get_utf8());
if (s.starts_with_ascii("Room EQ V"))
{
offset = 9;
if ((res = parse_decimal(&major, &s, &offset)) != STATUS_OK)
return res;
if (offset < s.length())
{
lsp_wchar_t wc = s.char_at(offset);
if ((wc != '.') && (wc != ','))
return STATUS_BAD_FORMAT;
++offset;
}
else
return STATUS_BAD_FORMAT;
if ((res = parse_decimal(&minor, &s, &offset)) != STATUS_OK)
return res;
}
else if (s.starts_with_ascii("Notes:"))
{
if (!notes.set(&s, 6))
return STATUS_NO_MEM;
}
else if ((s.starts_with_ascii("Equaliser:")) || (s.starts_with_ascii("Equalizer:")))
{
offset = 10;
if ((res = skip_whitespace(&s, &offset)) != STATUS_OK)
return res;
if (!eq.set(&s, offset))
return STATUS_NO_MEM;
}
else if (s.starts_with_ascii("Preamp:"))
{
offset = 7;
if ((res = skip_whitespace(&s, &offset)) != STATUS_OK)
return res;
if ((res = parse_double(&preamp, &s, &offset)) != STATUS_OK)
return res;
if ((res = skip_whitespace(&s, &offset)) != STATUS_OK)
return res;
if (s.starts_with_ascii("dB", offset))
offset += 2;
else
preamp = exp((M_LN10 * 0.05) * preamp);
if ((res = skip_whitespace(&s, &offset)) != STATUS_OK)
return res;
}
else if (s.starts_with_ascii("Filter Settings file"))
{
// Nothing
}
else if (s.starts_with_ascii("Filter"))
{
offset = 6;
if (!s.append(' ')) // For easier parsing, we add a whitespace at the end
return STATUS_NO_MEM;
// Check syntax
lsp_wchar_t ch = s.char_at(offset++);
if (ch == ' ')
{
// Find filter definition
size_t len = s.length();
while (offset < len)
if (s.char_at(offset++) == ':')
break;
}
else if (ch != ':')
continue;
// Allocate filter
filter_t *f = vfilters.add();
if (f == NULL)
return STATUS_NO_MEM;
// Parse filter settings
if ((res = parse_filter_settings(f, &s, &offset)) != STATUS_OK)
return res;
lsp_trace(
"Filter %d: %s [%d] Fc %.0f Hz Gain %.1f dB Q %.7f",
int(vfilters.size()), (f->enabled) ? "ON" : "OFF", f->filterType,
double(f->fc), double(f->gain), double(f->Q)
);
}
}
// Analyze current status
if (res == STATUS_EOF)
res = STATUS_OK;
else if (res != STATUS_OK)
return res;
// Now we are ready to allocate the data
config_t *cfg = build_config(&eq, ¬es, int32_t(major), int32_t(minor), vfilters.size());
if (cfg == NULL)
return STATUS_NO_MEM;
// Copy filter data
cfg->fPreamp = preamp;
::memcpy(cfg->vFilters, vfilters.array(), sizeof(filter_t) * vfilters.size());
// Store the result
if (dst != NULL)
*dst = cfg;
else
::free(cfg);
return STATUS_OK;
}
status_t load_text_file(io::IInStream *is, config_t **dst, const char *charset)
{
io::InSequence cs;
status_t res = cs.wrap(is, WRAP_NONE, charset);
if (res != STATUS_OK)
{
cs.close();
return res;
}
res = parse_text_config(&cs, dst);
if (res == STATUS_OK)
return cs.close();
cs.close();
return res;
}
status_t load_text(io::IInStream *is, config_t **dst)
{
// Read UTF-16 signature (if present)
uint16_t signature;
status_t res = is->read_block(&signature, sizeof(signature));
if (res != STATUS_OK)
return (res == STATUS_EOF) ? STATUS_BAD_FORMAT : res;
signature = BE_TO_CPU(signature);
if (signature == 0xfeff) // UTF-16BE
{
if ((res = load_text_file(is, dst, "UTF-16BE")) == STATUS_OK)
return res;
}
else if (signature == 0xfffe) // UTF-16LE
{
if ((res = load_text_file(is, dst, "UTF-16LE")) == STATUS_OK)
return res;
}
// Try to load unicode character sets
for (const char **cset=charsets; *cset != NULL; ++cset)
{
const wssize_t position = is->seek(0);
if (position < 0)
return status_t(-res);
else if (position != 0)
return STATUS_IO_ERROR;
if ((res = load_text_file(is, dst, *cset)) == STATUS_OK)
return res;
}
// Try default system charset
const wssize_t position = is->seek(0);
if (position < 0)
return status_t(-res);
else if (position != 0)
return STATUS_IO_ERROR;
return load_text_file(is, dst, NULL);
}
status_t load(const char *path, config_t **dst)
{
if (path == NULL)
return STATUS_BAD_ARGUMENTS;
LSPString tmp;
if (!tmp.set_utf8(path))
return STATUS_NO_MEM;
return load(&tmp, dst);
}
status_t load(const LSPString *path, config_t **dst)
{
if (path == NULL)
return STATUS_BAD_ARGUMENTS;
io::InFileStream ifs;
status_t res = ifs.open(path);
if (res != STATUS_OK)
{
ifs.close();
return res;
}
res = load(&ifs, dst);
if (res != STATUS_OK)
{
ifs.close();
return res;
}
return ifs.close();
}
status_t load(const io::Path *path, config_t **dst)
{
if (path == NULL)
return STATUS_BAD_ARGUMENTS;
return load(path->as_string(), dst);
}
status_t load(FILE *fd, config_t **dst)
{
if (fd == NULL)
return STATUS_BAD_ARGUMENTS;
io::InFileStream ifs;
status_t res = ifs.wrap(fd, false);
if (res != STATUS_OK)
{
ifs.close();
return res;
}
res = load(&ifs, dst);
if (res != STATUS_OK)
{
ifs.close();
return res;
}
return ifs.close();
}
status_t load(io::File *fd, config_t **dst)
{
if (fd == NULL)
return STATUS_BAD_ARGUMENTS;
io::InFileStream ifs;
status_t res = ifs.wrap(fd, false);
if (res != STATUS_OK)
{
ifs.close();
return res;
}
res = load(&ifs, dst);
if (res != STATUS_OK)
{
ifs.close();
return res;
}
return ifs.close();
}
status_t load(io::IInStream *is, config_t **dst)
{
if (is == NULL)
return STATUS_BAD_ARGUMENTS;
// We need to sink file to memory to detect the file format (java or text)
io::OutMemoryStream os;
wssize_t bytes = is->sink(&os);
if (bytes < 0)
{
os.close();
return status_t(-bytes);
}
// Load the file
status_t res = load(os.data(), os.size(), dst);
if (res != STATUS_OK)
{
os.close();
return res;
}
return os.close();
}
status_t load(const void *data, size_t size, config_t **dst)
{
if ((data == NULL) || (dst == NULL))
return STATUS_BAD_ARGUMENTS;
io::InMemoryStream is;
is.wrap(data, size);
// Try to load java format
status_t res = load_java(&is, dst);
if (res == STATUS_OK)
return is.close();
else if (res != STATUS_BAD_FORMAT)
{
is.close();
return res;
}
// Try to load plain text format
is.seek(0);
res = load_text(&is, dst);
if (res == STATUS_OK)
return is.close();
is.close();
return res;
}
} /* namespace room_ew */
} /* namespace lsp */