// polyblep.c
// (C) 2026 Claude Heiland-Allen
// License: GNU AGPL, v3 only
// <https://mathr.co.uk/web/polyblep.html>

// gcc -o polyblep polyblep.c -lfftw3 -lsndfile -lm -O3 -Wall -Wextra -pedantic

#include <complex.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <fftw3.h>
#include <sndfile.h>

typedef struct
{
  int a;
  double *coefs; // [10 a]
} polyblep_spec_t;

double polyblep_window(double x)
{
#if 0
  return sin(M_PI * x) / (x); // Lanczos, performs worse
#else
  return 0.5 * (1 + cos(M_PI * x)); // raised cosine
#endif
}

polyblep_spec_t *polyblep_spec_new(int a)
{
  const double M[4][4] = {{1,0,0,0}, {0,1,0,0}, {-3,-2,3,-1}, {2,1,-2,1}};
  size_t bytes = sizeof(polyblep_spec_t) + 10 * a * sizeof(double);
  char *data = calloc(1, bytes);
  if (data)
  {
    polyblep_spec_t *spec = (polyblep_spec_t *)(data + 10 * a * sizeof(double));
    spec->a = a;
    spec->coefs = (double *) data;
    double Y = 0;
    for (int k = -a; k < a; ++k)
    {
      if (k == 0)
      {
        Y -= 1;
      }
      double f_k = k == 0 ? 1 : 0;
      double df_k = k == 0 ? 0 : polyblep_window((double) k / a) * (1 - 2 * (k & 1)) / k;
      double f_k1 = k + 1 == 0 ? 1 : 0;
      double df_k1 = k + 1 == 0 ? 0 : sin(M_PI * (k + 1) / a) / (M_PI * (k + 1) / a) * (1 - 2 * ((k + 1) & 1)) / (k + 1);
      double v[4] = {f_k, df_k, f_k1, df_k1};
      double
      Y1 = (spec->coefs[5 * (k + a) + 0] = Y);
      for (int j = 0; j < 4; ++j)
      {
        double s_k = 0;
        for (int i = 0; i < 4; ++i)
        {
          s_k += M[j][i] * v[i] / (1 + j);
        }
        Y1 += (spec->coefs[5 * (k + a) + 1 + j] = s_k);
      }
      Y = Y1;
    }
    return spec;
  }
  return 0;
}

void polyblep_spec_delete(polyblep_spec_t *spec)
{
  free(spec->coefs);
}

typedef struct
{
  polyblep_spec_t *spec;
  double *buffer; // [2 a]
} polyblep_t;

polyblep_t *polyblep_new(polyblep_spec_t *spec)
{
  size_t bytes = sizeof(polyblep_t) + 2 * spec->a * sizeof(double);
  char *data = calloc(1, bytes);
  if (data)
  {
    polyblep_t *state = (polyblep_t *)(data + 2 * spec->a * sizeof(double));
    state->spec = spec;
    state->buffer = (double *) data;
    return state;
  }
  return 0;
}

void polyblep_delete(polyblep_t *state)
{
  free(state->buffer);
}

void polyblep_write_plain(polyblep_t *state, double y)
{
  state->buffer[state->spec->a - 1] += y;
}

void polyblep_write_blep(polyblep_t *state, double t, double y)
{
  int a2 = 2 * state->spec->a;
  double *coefs = state->spec->coefs;
  double *buffer = state->buffer;
  double ts[5] = { 1, t, t * t, t * t * t, t * t * t * t };
  for (int k = 0; k < a2; ++k)
  {
    double dot = 0;
    for (int i = 0; i < 5; ++i)
    {
      dot += ts[i] * coefs[5 * k + i];
    }
    buffer[k] += y * dot;
  }
}

double polyblep_read(polyblep_t *state)
{
  return state->buffer[0];
}

void polyblep_advance(polyblep_t *state)
{
  int k = 2 * state->spec->a - 1;
  memmove(state->buffer, state->buffer + 1, sizeof(double) * k);
  state->buffer[k] = 0;
}

void polyblep_clear(polyblep_t *state)
{
  int k = 2 * state->spec->a;
  memset(state->buffer, 0, sizeof(double) * k);
}

int main(int argc, char ** argv)
{
  int ok = 0;
  if (! (argc == 2 || argc == 6))
  {
    fprintf(stderr, "usage:\n\t%s diagrams\n\t%s cycles samples polyblep-a out-audio.wav out-spectrum.dat\n", argv[0], argv[0]);
    return 1;
  }
  if (argc == 2)
  {
    const int a = 4;
    const int resolution = 1024;
    polyblep_spec_t *spec = polyblep_spec_new(a);
    if (spec)
    {
      ok = 1;
      if (ok)
      {
        polyblep_t *state = polyblep_new(spec);
        if (state)
        {
          ok = 0;
          const double inc = 5. / 32;
          const double discontinuities[5] = { -3.2, 3.2, 9.6, 16.0, 22.4 };
          FILE *out = fopen("waveform-points.dat", "wb");
          if (out)
          {

            for (int i = 0; i <= 18; ++i)
            {
              double x = i;
              double phase = (0.5 + x * inc) - floor(0.5 + x * inc);
              double naive = phase;
              fprintf(out, "%d %.18g\n", i, naive);
            }
            fprintf(out, "\n\n");

            for (int i = 0; i <= 18; ++i)
            {
              double x = i;
              double phase = (0.5 + x * inc) - floor(0.5 + x * inc);
              double bandlimited = 0;
              for (int h = 1; h < 0.5 / inc; ++h)
              {
                bandlimited += (1 - 2 * (h & 1)) * sin(2 * M_PI * h * (phase - 0.5)) / h;
              }
              bandlimited /= -M_PI;
              bandlimited += 0.5;
              fprintf(out, "%d %.18g\n", i, bandlimited);
            }
            fprintf(out, "\n\n");
            
            for (int i = -a; i <= 18; ++i)
            {
              double x = i + a - 1;
              double phase = (0.5 + x * inc) - floor(0.5 + x * inc);
              double naive = phase;
              polyblep_write_plain(state, naive);
              double p1 = phase + inc;
              if (p1 >= 1)
              {
                double t = (p1 - 1) / inc;
                polyblep_write_blep(state, t, -1);
              }
              double blep = polyblep_read(state);
              polyblep_advance(state);
              if (i >= 0)
              {
                fprintf(out, "%d %.18g\n", i, blep);
              }
            }
            fprintf(out, "\n\n");
            
            for (int j = 0; j < 5; ++j)
            {
              int i0 = floor(discontinuities[j]);
              double x = i0;
              double phase = (0.5 + x * inc) - floor(0.5 + x * inc);
              double p1 = phase + inc;
              double t = i0 == discontinuities[j] ? 0 : (p1 - 1) / inc;
              polyblep_clear(state);
              polyblep_write_blep(state, t, -1);
              for (int k = -a; k < a; ++k)
              {
                int i = i0 + k + (i0 < discontinuities[j]);
                if (0 <= i && i < 18)
                {
                  fprintf(out, "%d %.18g\n", i, state->buffer[k + a]);
                }
              }
              fprintf(out, "\n\n");
            }

            ok = 1;
            fclose(out);
          }

          if (ok)
          {
            ok = 0;
            FILE *out = fopen("waveform-smooth.dat", "wb");
            if (out)
            {
              double inc = 5. / 32;
              for (int i = 0; i <= 18 * 1024; ++i)
              {
                double x = (i + 0.5) / 1024;
                double phase = (0.5 + x * inc) - floor(0.5 + x * inc);
                double ideal = phase;
                fprintf(out, "%.18g %.18g\n", x, ideal);
              }
              fprintf(out, "\n\n");

              for (int i = 0; i <= 18 * 1024; ++i)
              {
                double x = (i + 0.5) / 1024;
                double phase = (0.5 + x * inc) - floor(0.5 + x * inc);
                double bandlimited = 0;
                for (int h = 1; h < 0.5 / inc; ++h)
                {
                  bandlimited += (1 - 2 * (h & 1)) * sin(2 * M_PI * h * (phase - 0.5)) / h;
                }
                bandlimited /= -M_PI;
                bandlimited += 0.5;
                fprintf(out, "%.18g %.18g\n", x, bandlimited);
              }
              fprintf(out, "\n\n");
             
              for (int i = 0; i <= 18 * 1024; ++i)
              {
                double x = (i + 0.5) / 1024;
                double phase = (0.5 + x * inc) - floor(0.5 + x * inc);
                double blep = phase;
                for (int j = 0; j < 5; ++j)
                {
                  double y = x - discontinuities[j];
                  int k = floor(y);
                  double t = y - k;
                  if (-a <= k && k < a)
                  {
                    blep -=
                      + spec->coefs[5 * (k + a) + 0]
                      + spec->coefs[5 * (k + a) + 1] * t
                      + spec->coefs[5 * (k + a) + 2] * t * t
                      + spec->coefs[5 * (k + a) + 3] * t * t * t
                      + spec->coefs[5 * (k + a) + 4] * t * t * t * t
                      ;
                  }
                }
                fprintf(out, "%.18g %.18g\n", x, blep);
              }
              fprintf(out, "\n\n");
              
              for (int j = 0; j < 5; ++j)
              {
                for (int i = 0; i <= 18 * 1024; ++i)
                {
                  double x = (i + 0.5) / 1024;
                  double y = x - discontinuities[j];
                  int k = floor(y);
                  double t = y - k;
                  if (-a <= k && k < a)
                  {
                    double blep
                      = spec->coefs[5 * (k + a) + 0]
                      + spec->coefs[5 * (k + a) + 1] * t
                      + spec->coefs[5 * (k + a) + 2] * t * t
                      + spec->coefs[5 * (k + a) + 3] * t * t * t
                      + spec->coefs[5 * (k + a) + 4] * t * t * t * t
                      ;
                    fprintf(out, "%.18g %.18g\n", x, -blep);
                  }
                }
                fprintf(out, "\n\n");
              }
              ok = 1;
              fclose(out);
            }
          }
          polyblep_delete(state);
        }
      }

      if (ok)
      {
        ok = 0;
        FILE *out = fopen("sinc-to-polyblep.dat", "wb");
        if (out)
        {
          for (int i = -a * resolution; i < a * resolution; ++i)
          {
            double x = (i + 0.5) / resolution;
            int k = floor(x);
            double t = x - floor(x);
            double sinc = sin(M_PI * x) / (M_PI * x);
            double window = polyblep_window(x  / a);
            double windowed_sinc = window * sinc;
            double spline_sinc
              = 1 * spec->coefs[5 * (k + a) + 1]
              + 2 * spec->coefs[5 * (k + a) + 2] * t
              + 3 * spec->coefs[5 * (k + a) + 3] * t * t
              + 4 * spec->coefs[5 * (k + a) + 4] * t * t * t
              ;
            double ideal_step = x >= 0 ? 1 : 0;
            double spline_step
              = ideal_step
              + spec->coefs[5 * (k + a) + 0]
              + spec->coefs[5 * (k + a) + 1] * t
              + spec->coefs[5 * (k + a) + 2] * t * t
              + spec->coefs[5 * (k + a) + 3] * t * t * t
              + spec->coefs[5 * (k + a) + 4] * t * t * t * t
              ;
            fprintf(out, "%.18g %.18g %.18g %.18g %.18g %.18g %.18g\n",
              x, sinc, window, windowed_sinc, spline_sinc, ideal_step, spline_step);
          }
          ok = 1;
          fclose(out);
        }
      }
      polyblep_spec_delete(spec);
    }
  }
  
  else
  {
    const int cycles = atoi(argv[1]);
    const int samples = atoi(argv[2]);
    const int a = atoi(argv[3]);
    char *wav_filename = argv[4];
    char *spectrum_filename = argv[5];
    double *wave = fftw_malloc(sizeof(*wave) * samples);
    if (wave)
    {
      double _Complex *fft = fftw_malloc(sizeof(*fft) * (samples / 2 + 1));
      if (fft)
      {
        fftw_import_wisdom_from_filename("polyblep.fftw");
        fftw_plan plan = fftw_plan_dft_r2c_1d(samples, wave, fft, FFTW_PATIENT | FFTW_DESTROY_INPUT);
        fftw_export_wisdom_to_filename("polyblep.fftw");
        if (plan)
        {
          double phase = 0.5;
          double inc = (double) cycles / samples;
          if (a > 0)
          {
            polyblep_spec_t *spec = polyblep_spec_new(a);
            if (spec)
            {
              polyblep_t *state = polyblep_new(spec);
              if (state)
              {
                for (int i = 0; i < samples + a; ++i)
                {
                  // precondition: inc < 0.5
                  // invariant: 0 <= phase && phase < 1
                  polyblep_write_plain(state, phase);
                  double p1 = phase + inc;
                  if (p1 >= 1)
                  {
                    double t = (p1 - 1) / inc;
                    polyblep_write_blep(state, t, -1);
                    p1 -= 1;
                  }
                  phase = p1;
                  if (i >= a)
                  {
                    wave[i - a] = polyblep_read(state) - 0.5;
                  }
                  polyblep_advance(state);
                }
                ok = 1;
                polyblep_delete(state);
              }
              polyblep_spec_delete(spec);
            }
          }
          else if (a == 0)
          {
            for (int i = 0; i < samples; ++i)
            {
              // precondition: inc < 0.5
              // invariant: 0 <= phase && phase < 1
              double p1 = phase + inc;
              if (p1 >= 1)
              {
                p1 -= 1;
              }
              phase = p1;
              wave[i] = phase - 0.5;
            }
            ok = 1;
          }
          else
          {
            phase = 0;
            for (int i = 0; i < samples; ++i)
            {
              // precondition: inc < 0.5
              // invariant: 0 <= phase && phase < 1
              double p1 = phase + inc;
              if (p1 >= 1)
              {
                p1 -= 1;
              }
              phase = p1;
              double y = 0;
              for (int h = 1; h < 0.5 / inc; ++h)
              {
                y += (1 - 2 * (h & 1)) * sin(2 * M_PI * h * phase) / h;
              }
              wave[i] = -y / M_PI;
            }
            ok = 1;
          }
          if (ok)
          {
            ok = 0;
            SF_INFO info = {0};
            info.samplerate = 48000;
            info.channels = 1;
            info.format = SF_FORMAT_WAV | SF_FORMAT_FLOAT;
            SNDFILE *wav = sf_open(wav_filename, SFM_WRITE, &info);
            if (wav)
            {
              ok = samples == sf_writef_double(wav, wave, samples);
              sf_close(wav);
            }
          }
          if (ok)
          {
            ok = 0;
            fftw_execute(plan);
            FILE *spectrum = fopen(spectrum_filename, "wb");
            if (spectrum)
            {
              for (int i = 0; i < samples / 2 + 1; ++i)
              {
                double freq = (double) i / samples;
                double db = 20 * log10(cabs(fft[i]) / cabs(fft[cycles]));
                fprintf(spectrum, "%g %g\n", freq, db);
              }
              ok = 1;
              fclose(spectrum);
            }
          }
          fftw_destroy_plan(plan);
        }
        fftw_free(fft);
      }
      fftw_free(wave);
    }
  }
  return ! ok;
}
