Download cpp/src/synth.cpp from RL10x/tiny-voca-hindi: direct link, hf CLI and curl.
- Browser
- Download file 9.4 kB
-
https://huggingface.co/RL10x/tiny-voca-hindi/resolve/main/cpp/src/synth.cpp
- Command line
-
hf download hf://RL10x/tiny-voca-hindi/cpp/src/synth.cpp
-
curl -L -o synth.cpp https://huggingface.co/RL10x/tiny-voca-hindi/resolve/main/cpp/src/synth.cpp
9.4 kB
| namespace { | |
| using cd = std::complex<double>; | |
| 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<cd>& 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<double> hann(int n) { // torch.hann_window(n) (periodic) | |
| std::vector<double> 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<cd>& 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 <typename ResponseFn> // response(frame, cd* bins): fills fft/2+1 bins for one frame, on demand | |
| std::vector<double> shape(const std::vector<double>& 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<double> 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<double> w = hann(n_fft); | |
| std::vector<double> ola(size_t(n_fft) + size_t(hop) * (n_frames - 1), 0.0), env(ola.size(), 0.0); | |
| std::vector<cd> 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<double> 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<float> vocos_istft(const float* head, int frames, int n_fft, int hop) { | |
| const int bins = n_fft / 2 + 1; | |
| const std::vector<double> w = hann(n_fft); | |
| std::vector<double> ola(size_t(n_fft) + size_t(hop) * (frames - 1), 0.0), env(ola.size(), 0.0); | |
| std::vector<cd> 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<float> 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<float> pulse_train(const float* f0, int T, int sample_rate, int hop, double limit) { | |
| std::vector<double> knots(T + 1); | |
| for (int t = 0; t < T; ++t) knots[t] = std::log(std::max<double>(f0[t], 1.0)); | |
| knots[T] = knots[T - 1]; | |
| const size_t S = size_t(T) * hop; | |
| std::vector<float> 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<float> 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<cd> work; | |
| // harmonic branch: envelope interpolated between frames, one gain per sub-frame | |
| const int hframes = hsteps * T + 3; | |
| std::vector<float> 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<float> 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<float> pulses = pulse_train(f0, T, c.sample_rate, c.hop, c.harmonic_limit); | |
| std::vector<double> ps(pulses.begin(), pulses.end()), ns(noise, noise + S); | |
| const std::vector<double> yh = shape(ps, hresp, hframes, c.synth_fft, c.synth_hop); | |
| const std::vector<double> yn = shape(ns, nresp, nframes, c.noise_fft, c.noise_hop); | |
| std::vector<float> wave(S); | |
| for (size_t i = 0; i < S; ++i) wave[i] = float(yh[i] + yn[i]); | |
| return wave; | |
| } | |