#include "synth.h" #include #include #include #include namespace { using cd = std::complex; const double PI = 3.14159265358979323846; // In-place iterative radix-2 FFT (n a power of two). inverse: no 1/n scaling. void fft(std::vector& a, bool inverse) { const size_t n = a.size(); for (size_t i = 1, j = 0; i < n; ++i) { size_t bit = n >> 1; for (; j & bit; bit >>= 1) j ^= bit; j ^= bit; if (i < j) std::swap(a[i], a[j]); } for (size_t len = 2; len <= n; len <<= 1) { const double ang = 2 * PI / double(len) * (inverse ? 1 : -1); const cd wl(std::cos(ang), std::sin(ang)); for (size_t i = 0; i < n; i += len) { cd w(1); for (size_t k = 0; k < len / 2; ++k) { const cd u = a[i + k], v = a[i + k + len / 2] * w; a[i + k] = u + v; a[i + k + len / 2] = u - v; w *= wl; } } } } std::vector hann(int n) { // torch.hann_window(n) (periodic) std::vector w(n); for (int i = 0; i < n; ++i) w[i] = 0.5 - 0.5 * std::cos(2 * PI * i / n); return w; } // cepstrum_response: exp(rfft(buffer)) with the real part clamped to [-14, 6]; buffer = causal at the start, the // anticausal coefficients (flipped) at the end. Returns fft/2+1 bins. void cepstrum_response(const float* causal, int n_causal, const float* anti, int n_anti, int n_fft, std::vector& work, cd* out) { work.assign(n_fft, cd(0)); for (int i = 0; i < n_causal; ++i) work[i] = causal[i]; for (int j = 0; j < n_anti; ++j) work[n_fft - n_anti + j] = anti[n_anti - 1 - j]; fft(work, false); for (int k = 0; k <= n_fft / 2; ++k) { const double re = std::clamp(work[k].real(), -14.0, 6.0); out[k] = std::polar(std::exp(re), work[k].imag()); } } // SourceFilter._shape: STFT (centered, zero padded, Hann), multiply by response[frame][bin], inverse STFT (overlap-add, // divided by the summed squared window), trimmed to the source length. The source is padded with fft/2 trailing zeros // first, as in the model. template // response(frame, cd* bins): fills fft/2+1 bins for one frame, on demand std::vector shape(const std::vector& source_in, ResponseFn&& response, int frames, int n_fft, int hop) { const int S = int(source_in.size()); const int L = S + n_fft / 2; // F.pad(source, (0, fft // 2)) const int bins = n_fft / 2 + 1; const int n_frames = 1 + L / hop; if (n_frames != frames) throw std::runtime_error("filter frames do not match the source"); std::vector padded(L + n_fft, 0.0); // center=True: n_fft/2 zeros on both sides std::copy(source_in.begin(), source_in.end(), padded.begin() + n_fft / 2); const std::vector w = hann(n_fft); std::vector ola(size_t(n_fft) + size_t(hop) * (n_frames - 1), 0.0), env(ola.size(), 0.0); std::vector buf(n_fft), r(bins); for (int f = 0; f < n_frames; ++f) { const double* x = padded.data() + size_t(f) * hop; for (int n = 0; n < n_fft; ++n) buf[n] = cd(x[n] * w[n], 0.0); fft(buf, false); response(f, r.data()); for (int k = 0; k < bins; ++k) buf[k] *= r[k]; // one-sided -> full Hermitian spectrum (irfft ignores the imaginary part of DC and Nyquist) buf[0] = cd(buf[0].real(), 0.0); buf[n_fft / 2] = cd(buf[n_fft / 2].real(), 0.0); for (int k = 1; k < n_fft / 2; ++k) buf[n_fft - k] = std::conj(buf[k]); fft(buf, true); double* o = ola.data() + size_t(f) * hop; double* e = env.data() + size_t(f) * hop; for (int n = 0; n < n_fft; ++n) { o[n] += buf[n].real() / n_fft * w[n]; e[n] += w[n] * w[n]; } } std::vector y(S); for (int i = 0; i < S; ++i) { // drop the centering pad, keep the first S samples const size_t j = size_t(i) + n_fft / 2; y[i] = env[j] > 1e-11 ? ola[j] / env[j] : 0.0; } return y; } } // namespace std::vector vocos_istft(const float* head, int frames, int n_fft, int hop) { const int bins = n_fft / 2 + 1; const std::vector w = hann(n_fft); std::vector ola(size_t(n_fft) + size_t(hop) * (frames - 1), 0.0), env(ola.size(), 0.0); std::vector buf(n_fft); for (int f = 0; f < frames; ++f) { const float* row = head + size_t(f) * 2 * bins; // [log magnitude x bins, phase x bins] for (int k = 0; k < bins; ++k) buf[k] = std::polar(std::min(std::exp(double(row[k])), 100.0), double(row[bins + k])); buf[0] = cd(buf[0].real(), 0.0); // irfft ignores the imaginary part of DC and Nyquist buf[n_fft / 2] = cd(buf[n_fft / 2].real(), 0.0); for (int k = 1; k < n_fft / 2; ++k) buf[n_fft - k] = std::conj(buf[k]); fft(buf, true); double* o = ola.data() + size_t(f) * hop; double* e = env.data() + size_t(f) * hop; for (int n = 0; n < n_fft; ++n) { o[n] += buf[n].real() / n_fft * w[n]; e[n] += w[n] * w[n]; } } const size_t S = size_t(hop) * (frames - 1); // center=True: n_fft/2 trimmed at both ends std::vector y(S); for (size_t i = 0; i < S; ++i) { const size_t j = i + n_fft / 2; y[i] = float(env[j] > 1e-11 ? ola[j] / env[j] : 0.0); } return y; } std::vector pulse_train(const float* f0, int T, int sample_rate, int hop, double limit) { std::vector knots(T + 1); for (int t = 0; t < T; ++t) knots[t] = std::log(std::max(f0[t], 1.0)); knots[T] = knots[T - 1]; const size_t S = size_t(T) * hop; std::vector out(S); double cum = 0.0; for (size_t i = 0; i < S; ++i) { const double position = double(i) / hop; const size_t low = size_t(std::floor(position)); const double weight = position - double(low); const double frequency = std::exp(knots[low] * (1 - weight) + knots[low + 1] * weight); cum += frequency / sample_rate; double theta = std::fmod(2 * PI * cum, 2 * PI); if (theta < 0) theta += 2 * PI; const double harmonics = std::max(limit * sample_rate / frequency, 1.0); const double whole = std::floor(harmonics); const double den = 2 * std::sin(theta / 2); const double core = std::fabs(den) < 1e-7 ? whole : std::sin((whole + 0.5) * theta) / den - 0.5; const double wave = core + (harmonics - whole) * std::cos((whole + 1) * theta); out[i] = float(wave * std::sqrt(2.0 / harmonics)); } return out; } std::vector synthesize_wave(const SynthConfig& c, const float* harmonic, const float* noise_head, const float* f0, int T, const float* noise) { const int hsteps = c.hop / c.synth_hop, nsteps = c.hop / c.noise_hop; const int hw = c.cep_causal + c.cep_anti + hsteps, nw = c.noise_cep + nsteps; const int last = T - 1; const size_t S = size_t(T) * c.hop; std::vector work; // harmonic branch: envelope interpolated between frames, one gain per sub-frame const int hframes = hsteps * T + 3; std::vector causal(c.cep_causal), anti(c.cep_anti); auto hresp = [&](int j, cd* out) { const int sub = std::min(j, hsteps * T - 1); const int here = sub / hsteps, following = std::min((sub + 1) / hsteps, last); const float* a = harmonic + size_t(here) * hw; const float* b = harmonic + size_t(following) * hw; for (int k = 0; k < c.cep_causal; ++k) causal[k] = 0.5f * (a[k] + b[k]) * c.causal_lifter[k]; for (int k = 0; k < c.cep_anti; ++k) anti[k] = 0.5f * (a[c.cep_causal + k] + b[c.cep_causal + k]) * c.anti_lifter[k]; const int gi = sub; // gains flattened [T * hsteps] causal[0] += harmonic[size_t(gi / hsteps) * hw + c.cep_causal + c.cep_anti + gi % hsteps]; cepstrum_response(causal.data(), c.cep_causal, anti.data(), c.cep_anti, c.synth_fft, work, out); }; // noise branch: one envelope per frame, nsteps gains per frame const int nframes = nsteps * T + 3; std::vector shp(c.noise_cep); auto nresp = [&](int j, cd* out) { const int sub = std::min(j, nsteps * T - 1); const float* a = noise_head + size_t(sub / nsteps) * nw; for (int k = 0; k < c.noise_cep; ++k) shp[k] = a[k] * c.noise_lifter[k]; shp[0] += noise_head[size_t(sub / nsteps) * nw + c.noise_cep + sub % nsteps]; cepstrum_response(shp.data(), c.noise_cep, nullptr, 0, c.noise_fft, work, out); }; const std::vector pulses = pulse_train(f0, T, c.sample_rate, c.hop, c.harmonic_limit); std::vector ps(pulses.begin(), pulses.end()), ns(noise, noise + S); const std::vector yh = shape(ps, hresp, hframes, c.synth_fft, c.synth_hop); const std::vector yn = shape(ns, nresp, nframes, c.noise_fft, c.noise_hop); std::vector wave(S); for (size_t i = 0; i < S; ++i) wave[i] = float(yh[i] + yn[i]); return wave; }