JailDesigner
d3698a1504
Afig una capa d'efectes oberta a la unitat d'àudio. Els sons puntuals
es poden reproduir processats per un eco o un reverb (Freeverb 8C/4AP)
sense afectar la música ni canviar el camí ràpid existent (playSound
sense efecte segueix sent una sola crida sense cost extra).
- data/sounds.yaml: catàleg de presets nominats (echo: cave/short,
reverb: stone_hall/small_room).
- core/audio/audio_effects: processadors purs que prenen un Ja::Sound
(U8/S16, mono o estèreo) i tornen PCM S16 amb la cua de l'efecte
(cap a 800 ms eco, 1500 ms reverb).
- core/audio/sound_effects_config: Meyers singleton que parseja
sounds.yaml a EchoParams/ReverbParams indexats per nom; l'API
pública d'Audio fa el lookup per nom.
- jail_audio::Engine: nou camí playSoundWith{Echo,Reverb} que empenta
el buffer ja processat a un canal lliure marcat com a has_effect.
El cap MAX_EFFECT_CHANNELS limita a 4 sons amb efecte simultanis;
si està al límit, l'engine retorna -1 i Audio cau a la versió seca.
- Audio::playSoundWith{Echo,Reverb}(name, preset, group) com a única
via pública. Si el preset no existeix, fallback dry amb avís.
- director: load("data/sounds.yaml") abans d'Audio::init.
251 lines
10 KiB
C++
251 lines
10 KiB
C++
#include "core/audio/audio_effects.hpp"
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <cmath>
|
|
#include <cstdint>
|
|
#include <cstring>
|
|
#include <iostream>
|
|
#include <vector>
|
|
|
|
#include "core/audio/jail_audio.hpp"
|
|
|
|
namespace AudioEffects {
|
|
|
|
namespace {
|
|
|
|
// --- Caps de cua ---
|
|
constexpr float ECHO_TAIL_MS = 800.0F;
|
|
constexpr float REVERB_TAIL_MS = 1500.0F;
|
|
|
|
// --- Constants Freeverb ---
|
|
// Delays de comb i allpass tunats per a 44.1 kHz; els reescalem per
|
|
// freqüència real de la font.
|
|
constexpr int COMB_REFERENCE_RATE = 44100;
|
|
constexpr std::array<int, 8> COMB_DELAYS_L = {1116, 1188, 1277, 1356, 1422, 1491, 1557, 1617};
|
|
constexpr std::array<int, 4> ALLPASS_DELAYS_L = {556, 441, 341, 225};
|
|
constexpr int STEREO_SPREAD = 23;
|
|
|
|
// Mapeig de Schroeder/Dattorro/Freeverb estàndard.
|
|
constexpr float FIXED_GAIN = 0.015F;
|
|
constexpr float SCALE_ROOM = 0.28F;
|
|
constexpr float OFFSET_ROOM = 0.7F;
|
|
constexpr float SCALE_DAMP = 0.4F;
|
|
|
|
// --- Decodificació a float -1..1 ---
|
|
// Suporta U8/S16, mono/estèreo. Mono es duplica a L i R (la cadena
|
|
// d'efectes treballa sempre amb dos canals per simplicitat).
|
|
auto decodeToStereoFloat(const Ja::Sound& src, std::vector<float>& left, std::vector<float>& right) -> bool {
|
|
const auto& spec = src.spec;
|
|
const Uint8* buf = src.buffer.get();
|
|
if (buf == nullptr || src.length == 0) { return false; }
|
|
|
|
int bytes_per_sample = 0;
|
|
if (spec.format == SDL_AUDIO_S16) {
|
|
bytes_per_sample = 2;
|
|
} else if (spec.format == SDL_AUDIO_U8) {
|
|
bytes_per_sample = 1;
|
|
} else {
|
|
std::cerr << "AudioEffects: format de so no suportat (només U8 o S16)\n";
|
|
return false;
|
|
}
|
|
if (spec.channels < 1 || spec.channels > 2) {
|
|
std::cerr << "AudioEffects: el so ha de ser mono o estèreo\n";
|
|
return false;
|
|
}
|
|
|
|
const std::size_t TOTAL_FRAMES = src.length / static_cast<std::size_t>(bytes_per_sample * spec.channels);
|
|
left.resize(TOTAL_FRAMES);
|
|
right.resize(TOTAL_FRAMES);
|
|
|
|
for (std::size_t i = 0; i < TOTAL_FRAMES; ++i) {
|
|
float sample_l = 0.0F;
|
|
float sample_r = 0.0F;
|
|
if (spec.format == SDL_AUDIO_S16) {
|
|
const auto* p = reinterpret_cast<const std::int16_t*>(buf + (i * spec.channels * 2));
|
|
sample_l = static_cast<float>(p[0]) / 32768.0F;
|
|
sample_r = (spec.channels == 2) ? static_cast<float>(p[1]) / 32768.0F : sample_l;
|
|
} else { // U8
|
|
const Uint8* p = buf + (i * spec.channels);
|
|
sample_l = (static_cast<float>(p[0]) - 128.0F) / 128.0F;
|
|
sample_r = (spec.channels == 2) ? (static_cast<float>(p[1]) - 128.0F) / 128.0F : sample_l;
|
|
}
|
|
left[i] = sample_l;
|
|
right[i] = sample_r;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Empaqueta dos canals float (-1..1) a S16 entrellaçat.
|
|
void encodeStereoS16(const std::vector<float>& left, const std::vector<float>& right, std::vector<std::uint8_t>& out) {
|
|
const std::size_t LEN = left.size();
|
|
out.resize(LEN * 2 * sizeof(std::int16_t));
|
|
auto* dst = reinterpret_cast<std::int16_t*>(out.data());
|
|
for (std::size_t i = 0; i < LEN; ++i) {
|
|
const float L = std::clamp(left[i], -1.0F, 1.0F);
|
|
const float R = std::clamp(right[i], -1.0F, 1.0F);
|
|
dst[(i * 2) + 0] = static_cast<std::int16_t>(std::lround(L * 32767.0F));
|
|
dst[(i * 2) + 1] = static_cast<std::int16_t>(std::lround(R * 32767.0F));
|
|
}
|
|
}
|
|
|
|
// Reescala un delay de la taula de Freeverb per a la freqüència real.
|
|
auto scaledDelay(int reference_delay, int rate) -> int {
|
|
const long SCALED = std::lround(static_cast<double>(reference_delay) * static_cast<double>(rate) / static_cast<double>(COMB_REFERENCE_RATE));
|
|
return std::max(1, static_cast<int>(SCALED));
|
|
}
|
|
|
|
// --- Filtres bàsics ---
|
|
struct Comb {
|
|
std::vector<float> buf;
|
|
std::size_t idx{0};
|
|
float feedback{0.0F};
|
|
float damp1{0.0F};
|
|
float damp2{1.0F};
|
|
float store{0.0F};
|
|
|
|
void init(int delay, float fb, float damping) {
|
|
buf.assign(static_cast<std::size_t>(delay), 0.0F);
|
|
idx = 0;
|
|
feedback = fb;
|
|
damp1 = damping;
|
|
damp2 = 1.0F - damping;
|
|
store = 0.0F;
|
|
}
|
|
auto tick(float in) -> float {
|
|
const float OUT = buf[idx];
|
|
store = (OUT * damp2) + (store * damp1);
|
|
buf[idx] = in + (store * feedback);
|
|
idx = (idx + 1) % buf.size();
|
|
return OUT;
|
|
}
|
|
};
|
|
|
|
struct Allpass {
|
|
std::vector<float> buf;
|
|
std::size_t idx{0};
|
|
|
|
void init(int delay) {
|
|
buf.assign(static_cast<std::size_t>(delay), 0.0F);
|
|
idx = 0;
|
|
}
|
|
auto tick(float in) -> float {
|
|
const float BUFOUT = buf[idx];
|
|
const float OUT = -in + BUFOUT;
|
|
buf[idx] = in + (BUFOUT * 0.5F);
|
|
idx = (idx + 1) % buf.size();
|
|
return OUT;
|
|
}
|
|
};
|
|
|
|
} // namespace
|
|
|
|
auto applyEcho(const Ja::Sound& src, const Ja::EchoParams& params) -> std::optional<ProcessedSound> {
|
|
std::vector<float> left;
|
|
std::vector<float> right;
|
|
if (!decodeToStereoFloat(src, left, right)) { return std::nullopt; }
|
|
|
|
const int RATE = src.spec.freq;
|
|
const int DELAY_SAMPLES = std::max(1, static_cast<int>(std::lround(params.delay_ms * 0.001F * static_cast<float>(RATE))));
|
|
const auto TAIL_SAMPLES = static_cast<std::size_t>(std::lround(ECHO_TAIL_MS * 0.001F * static_cast<float>(RATE)));
|
|
|
|
const float FEEDBACK = std::clamp(params.feedback, 0.0F, 0.95F);
|
|
const float WET = std::clamp(params.wet, 0.0F, 1.0F);
|
|
const float DRY = 1.0F - WET;
|
|
|
|
const std::size_t INPUT_LEN = left.size();
|
|
const std::size_t TOTAL_LEN = INPUT_LEN + TAIL_SAMPLES;
|
|
|
|
std::vector<float> ring_l(static_cast<std::size_t>(DELAY_SAMPLES), 0.0F);
|
|
std::vector<float> ring_r(static_cast<std::size_t>(DELAY_SAMPLES), 0.0F);
|
|
std::size_t cursor = 0;
|
|
|
|
std::vector<float> out_l(TOTAL_LEN);
|
|
std::vector<float> out_r(TOTAL_LEN);
|
|
|
|
for (std::size_t i = 0; i < TOTAL_LEN; ++i) {
|
|
const float IN_L = (i < INPUT_LEN) ? left[i] : 0.0F;
|
|
const float IN_R = (i < INPUT_LEN) ? right[i] : 0.0F;
|
|
|
|
const float DELAYED_L = ring_l[cursor];
|
|
const float DELAYED_R = ring_r[cursor];
|
|
|
|
out_l[i] = (DRY * IN_L) + (WET * DELAYED_L);
|
|
out_r[i] = (DRY * IN_R) + (WET * DELAYED_R);
|
|
|
|
ring_l[cursor] = IN_L + (DELAYED_L * FEEDBACK);
|
|
ring_r[cursor] = IN_R + (DELAYED_R * FEEDBACK);
|
|
cursor = (cursor + 1) % static_cast<std::size_t>(DELAY_SAMPLES);
|
|
}
|
|
|
|
ProcessedSound result;
|
|
result.spec = SDL_AudioSpec{.format = SDL_AUDIO_S16, .channels = 2, .freq = RATE};
|
|
encodeStereoS16(out_l, out_r, result.bytes);
|
|
return result;
|
|
}
|
|
|
|
auto applyReverb(const Ja::Sound& src, const Ja::ReverbParams& params) -> std::optional<ProcessedSound> {
|
|
std::vector<float> left;
|
|
std::vector<float> right;
|
|
if (!decodeToStereoFloat(src, left, right)) { return std::nullopt; }
|
|
|
|
const int RATE = src.spec.freq;
|
|
const auto TAIL_SAMPLES = static_cast<std::size_t>(std::lround(REVERB_TAIL_MS * 0.001F * static_cast<float>(RATE)));
|
|
|
|
const float ROOM_SIZE = std::clamp(params.room_size, 0.0F, 1.0F);
|
|
const float DAMPING = std::clamp(params.damping, 0.0F, 1.0F);
|
|
const float WET = std::clamp(params.wet, 0.0F, 1.0F);
|
|
const float DRY = 1.0F - WET;
|
|
|
|
const float FEEDBACK = (ROOM_SIZE * SCALE_ROOM) + OFFSET_ROOM; // 0.7..0.98
|
|
const float DAMP1 = DAMPING * SCALE_DAMP; // 0..0.4
|
|
|
|
// Inicialitza els 8 comb filters per cada canal i els 4 allpass.
|
|
std::array<Comb, 8> comb_l;
|
|
std::array<Comb, 8> comb_r;
|
|
for (std::size_t i = 0; i < COMB_DELAYS_L.size(); ++i) {
|
|
comb_l[i].init(scaledDelay(COMB_DELAYS_L[i], RATE), FEEDBACK, DAMP1);
|
|
comb_r[i].init(scaledDelay(COMB_DELAYS_L[i] + STEREO_SPREAD, RATE), FEEDBACK, DAMP1);
|
|
}
|
|
std::array<Allpass, 4> allpass_l;
|
|
std::array<Allpass, 4> allpass_r;
|
|
for (std::size_t i = 0; i < ALLPASS_DELAYS_L.size(); ++i) {
|
|
allpass_l[i].init(scaledDelay(ALLPASS_DELAYS_L[i], RATE));
|
|
allpass_r[i].init(scaledDelay(ALLPASS_DELAYS_L[i] + STEREO_SPREAD, RATE));
|
|
}
|
|
|
|
const std::size_t INPUT_LEN = left.size();
|
|
const std::size_t TOTAL_LEN = INPUT_LEN + TAIL_SAMPLES;
|
|
std::vector<float> out_l(TOTAL_LEN);
|
|
std::vector<float> out_r(TOTAL_LEN);
|
|
|
|
for (std::size_t i = 0; i < TOTAL_LEN; ++i) {
|
|
const float IN_L = (i < INPUT_LEN) ? left[i] : 0.0F;
|
|
const float IN_R = (i < INPUT_LEN) ? right[i] : 0.0F;
|
|
const float MONO_INPUT = (IN_L + IN_R) * FIXED_GAIN;
|
|
|
|
// 8 comb filters en paral·lel, sumats.
|
|
float wet_l = 0.0F;
|
|
float wet_r = 0.0F;
|
|
for (std::size_t k = 0; k < comb_l.size(); ++k) {
|
|
wet_l += comb_l[k].tick(MONO_INPUT);
|
|
wet_r += comb_r[k].tick(MONO_INPUT);
|
|
}
|
|
// 4 allpass en sèrie.
|
|
for (std::size_t k = 0; k < allpass_l.size(); ++k) {
|
|
wet_l = allpass_l[k].tick(wet_l);
|
|
wet_r = allpass_r[k].tick(wet_r);
|
|
}
|
|
|
|
out_l[i] = (DRY * IN_L) + (WET * wet_l);
|
|
out_r[i] = (DRY * IN_R) + (WET * wet_r);
|
|
}
|
|
|
|
ProcessedSound result;
|
|
result.spec = SDL_AudioSpec{.format = SDL_AUDIO_S16, .channels = 2, .freq = RATE};
|
|
encodeStereoS16(out_l, out_r, result.bytes);
|
|
return result;
|
|
}
|
|
|
|
} // namespace AudioEffects
|