libs/plugins/a-delay.lv2/a-delay.c

   1 /* a-delay
   2  * Copyright (C) 2016 Damien Zammit <damien@zamaudio.com>
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  */
  14
  15 #include <math.h>
  16 #include <stdlib.h>
  17 #include <stdio.h>
  18
  19 #include "lv2/lv2plug.in/ns/lv2core/lv2.h"
  20 #include "lv2/lv2plug.in/ns/ext/atom/atom.h"
  21 #include "lv2/lv2plug.in/ns/ext/time/time.h"
  22 #include "lv2/lv2plug.in/ns/ext/atom/forge.h"
  23 #include "lv2/lv2plug.in/ns/ext/urid/urid.h"
  24
  25 #define ADELAY_URI "urn:ardour:a-delay"
  26
  27 // 8 seconds of delay at 96kHz
  28 #define MAX_DELAY 768000
  29
  30 #ifndef M_PI
  31 # define M_PI 3.1415926
  32 #endif
  33
  34 typedef enum {
  35         ADELAY_INPUT = 0,
  36         ADELAY_OUTPUT,
  37
  38         ADELAY_BPM,
  39
  40         ADELAY_INV,
  41         ADELAY_SYNC,
  42         ADELAY_TIME,
  43         ADELAY_DIVISOR,
  44         ADELAY_WETDRY,
  45         ADELAY_FEEDBACK,
  46         ADELAY_LPF,
  47         ADELAY_GAIN,
  48
  49         ADELAY_DELAYTIME,
  50 } PortIndex;
  51
  52
  53 typedef struct {
  54         LV2_URID atom_Blank;
  55         LV2_URID atom_Object;
  56         LV2_URID atom_Sequence;
  57         LV2_URID atom_Long;
  58         LV2_URID atom_Int;
  59         LV2_URID atom_Float;
  60         LV2_URID atom_Double;
  61         LV2_URID time_beatUnit;
  62         LV2_URID time_beatsPerMinute;
  63         LV2_URID time_Position;
  64 } DelayURIs;
  65
  66 typedef struct {
  67         float* input;
  68         float* output;
  69
  70         const LV2_Atom_Sequence* atombpm;
  71
  72         float* inv;
  73         float* sync;
  74         float* time;
  75         float* divisor;
  76         float* wetdry;
  77         float* feedback;
  78         float* lpf;
  79         float* gain;
  80
  81         float* delaytime;
  82
  83         float srate;
  84         float bpm;
  85         float beatunit;
  86         int bpmvalid;
  87
  88         uint32_t posz;
  89         float tap[2];
  90         float z[MAX_DELAY];
  91         int active;
  92         int next;
  93         float fbstate;
  94         float lpfold;
  95         float feedbackold;
  96         float divisorold;
  97         float gainold;
  98         float invertold;
  99         float timeold;
 100         float delaytimeold;
 101         float syncold;
 102         float wetdryold;
 103         float delaysamplesold;
 104         float tau;
 105
 106         float A0, A1, A2, A3, A4, A5;
 107         float B0, B1, B2, B3, B4, B5;
 108         float state[4];
 109
 110         DelayURIs uris;
 111         LV2_Atom_Forge forge;
 112         LV2_URID_Map* map;
 113 } ADelay;
 114
 115 static inline void
 116 map_uris(LV2_URID_Map* map, DelayURIs* uris)
 117 {
 118         uris->atom_Blank          = map->map(map->handle, LV2_ATOM__Blank);
 119         uris->atom_Object         = map->map(map->handle, LV2_ATOM__Object);
 120         uris->atom_Sequence       = map->map(map->handle, LV2_ATOM__Sequence);
 121         uris->atom_Long           = map->map(map->handle, LV2_ATOM__Long);
 122         uris->atom_Int            = map->map(map->handle, LV2_ATOM__Int);
 123         uris->atom_Float          = map->map(map->handle, LV2_ATOM__Float);
 124         uris->atom_Double         = map->map(map->handle, LV2_ATOM__Double);
 125         uris->time_beatUnit       = map->map(map->handle, LV2_TIME__beatUnit);
 126         uris->time_beatsPerMinute = map->map(map->handle, LV2_TIME__beatsPerMinute);
 127         uris->time_Position       = map->map(map->handle, LV2_TIME__Position);
 128 }
 129
 130 static LV2_Handle
 131 instantiate(const LV2_Descriptor* descriptor,
 132             double rate,
 133             const char* bundle_path,
 134             const LV2_Feature* const* features)
 135 {
 136         int i;
 137         ADelay* adelay = (ADelay*)calloc(1, sizeof(ADelay));
 138         if (!adelay) return NULL;
 139
 140         for (i = 0; features[i]; ++i) {
 141                 if (!strcmp(features[i]->URI, LV2_URID__map)) {
 142                         adelay->map = (LV2_URID_Map*)features[i]->data;
 143                 }
 144         }
 145
 146         if (!adelay->map) {
 147                 fprintf(stderr, "a-delay.lv2 error: Host does not support urid:map\n");
 148                 free(adelay);
 149                 return NULL;
 150         }
 151
 152         map_uris(adelay->map, &adelay->uris);
 153         lv2_atom_forge_init(&adelay->forge, adelay->map);
 154
 155         adelay->srate = rate;
 156         adelay->bpmvalid = 0;
 157         // 25Hz time constant @ 64fpp
 158         adelay->tau = (1.0 - exp(-2.0 * M_PI * 64. * 25. / adelay->srate));
 159
 160         return (LV2_Handle)adelay;
 161 }
 162
 163 static void
 164 connect_port(LV2_Handle instance,
 165              uint32_t port,
 166              void* data)
 167 {
 168         ADelay* adelay = (ADelay*)instance;
 169
 170         switch ((PortIndex)port) {
 171         case ADELAY_INPUT:
 172                 adelay->input = (float*)data;
 173                 break;
 174         case ADELAY_OUTPUT:
 175                 adelay->output = (float*)data;
 176                 break;
 177         case ADELAY_BPM:
 178                 adelay->atombpm = (const LV2_Atom_Sequence*)data;
 179                 break;
 180         case ADELAY_INV:
 181                 adelay->inv = (float*)data;
 182                 break;
 183         case ADELAY_SYNC:
 184                 adelay->sync = (float*)data;
 185                 break;
 186         case ADELAY_TIME:
 187                 adelay->time = (float*)data;
 188                 break;
 189         case ADELAY_DIVISOR:
 190                 adelay->divisor = (float*)data;
 191                 break;
 192         case ADELAY_WETDRY:
 193                 adelay->wetdry = (float*)data;
 194                 break;
 195         case ADELAY_FEEDBACK:
 196                 adelay->feedback = (float*)data;
 197                 break;
 198         case ADELAY_LPF:
 199                 adelay->lpf = (float*)data;
 200                 break;
 201         case ADELAY_GAIN:
 202                 adelay->gain = (float*)data;
 203                 break;
 204         case ADELAY_DELAYTIME:
 205                 adelay->delaytime = (float*)data;
 206                 break;
 207         }
 208 }
 209
 210 static inline float
 211 sanitize_denormal(float value) {
 212         if (!isnormal(value)) {
 213                 value = 0.f;
 214         }
 215         return value;
 216 }
 217
 218 static inline float
 219 from_dB(float gdb) {
 220         return (exp(gdb/20.f*log(10.f)));
 221 }
 222
 223 static inline float
 224 to_dB(float g) {
 225         return (20.f*log10(g));
 226 }
 227
 228 static inline bool
 229 is_eq(float a, float b, float small) {
 230         return (fabsf(a - b) < small);
 231 }
 232
 233 static void clearfilter(LV2_Handle instance)
 234 {
 235         ADelay* adelay = (ADelay*)instance;
 236
 237         adelay->state[0] = adelay->state[1] =
 238                 adelay->state[2] = adelay->state[3] = 0.f;
 239 }
 240
 241 static void
 242 activate(LV2_Handle instance)
 243 {
 244         ADelay* adelay = (ADelay*)instance;
 245
 246         int i;
 247         for (i = 0; i < MAX_DELAY; i++) {
 248                 adelay->z[i] = 0.f;
 249         }
 250         adelay->posz = 0;
 251         adelay->tap[0] = 0;
 252         adelay->tap[1] = 0;
 253         adelay->active = 0;
 254         adelay->next = 1;
 255         adelay->fbstate = 0.f;
 256
 257         clearfilter(adelay);
 258
 259         adelay->lpfold = 0.f;
 260         adelay->divisorold = 0.f;
 261         adelay->gainold = 0.f;
 262         adelay->invertold = 0.f;
 263         adelay->timeold = 0.f;
 264         adelay->delaytimeold = 0.f;
 265         adelay->syncold = 0.f;
 266         adelay->wetdryold = 0.f;
 267         adelay->delaysamplesold = 1.f;
 268 }
 269
 270 static void lpfRbj(LV2_Handle instance, float fc, float srate)
 271 {
 272         ADelay* adelay = (ADelay*)instance;
 273
 274         float w0, alpha, cw, sw, q;
 275         q = 0.707;
 276         w0 = (2. * M_PI * fc / srate);
 277         sw = sin(w0);
 278         cw = cos(w0);
 279         alpha = sw / (2. * q);
 280
 281         adelay->A0 = 1. + alpha;
 282         adelay->A1 = -2. * cw;
 283         adelay->A2 = 1. - alpha;
 284         adelay->B0 = (1. - cw) / 2.;
 285         adelay->B1 = (1. - cw);
 286         adelay->B2 = adelay->B0;
 287
 288         adelay->A3 = 1. + alpha;
 289         adelay->A4 = -2. * cw;
 290         adelay->A5 = 1. - alpha;
 291         adelay->B3 = (1. - cw) / 2.;
 292         adelay->B4 = (1. - cw);
 293         adelay->B5 = adelay->B3;
 294 }
 295
 296 static float runfilter(LV2_Handle instance, float in)
 297 {
 298         ADelay* a = (ADelay*)instance;
 299
 300         float out;
 301         in = sanitize_denormal(in);
 302
 303         out = a->B0/a->A0*in + a->B1/a->A0*a->state[0] + a->B2/a->A0*a->state[1]
 304                         -a->A1/a->A0*a->state[2] - a->A2/a->A0*a->state[3] + 1e-20;
 305
 306         a->state[1] = a->state[0];
 307         a->state[0] = in;
 308         a->state[3] = a->state[2];
 309         a->state[2] = out;
 310         return out;
 311 }
 312
 313 static void
 314 update_bpm(ADelay* self, const LV2_Atom_Object* obj)
 315 {
 316         const DelayURIs* uris = &self->uris;
 317
 318         // Received new transport bpm/beatunit
 319         LV2_Atom *beatunit = NULL, *bpm = NULL;
 320         lv2_atom_object_get(obj,
 321                             uris->time_beatUnit, &beatunit,
 322                             uris->time_beatsPerMinute, &bpm,
 323                             NULL);
 324         // Tempo changed, update BPM
 325         if (bpm && bpm->type == uris->atom_Float) {
 326                 self->bpm = ((LV2_Atom_Float*)bpm)->body;
 327         }
 328         // Time signature changed, update beatunit
 329         if (beatunit && beatunit->type == uris->atom_Int) {
 330                 int b = ((LV2_Atom_Int*)beatunit)->body;
 331                 self->beatunit = (float)b;
 332         }
 333         if (beatunit && beatunit->type == uris->atom_Double) {
 334                 double b = ((LV2_Atom_Double*)beatunit)->body;
 335                 self->beatunit = (float)b;
 336         }
 337         if (beatunit && beatunit->type == uris->atom_Float) {
 338                 self->beatunit = ((LV2_Atom_Float*)beatunit)->body;
 339         }
 340         if (beatunit && beatunit->type == uris->atom_Long) {
 341                 long int b = ((LV2_Atom_Long*)beatunit)->body;
 342                 self->beatunit = (float)b;
 343         }
 344         self->bpmvalid = 1;
 345 }
 346
 347 static void
 348 run(LV2_Handle instance, uint32_t n_samples)
 349 {
 350         ADelay* adelay = (ADelay*)instance;
 351
 352         const float* const input = adelay->input;
 353         float* const output = adelay->output;
 354
 355         float srate = adelay->srate;
 356         float tau = adelay->tau;
 357
 358         uint32_t i;
 359         float in;
 360         int delaysamples = 0;
 361         unsigned int tmp;
 362         float inv;
 363         float xfade;
 364         int recalc;
 365         if (*(adelay->inv) < 0.5) {
 366                 inv = -1.f;
 367         } else {
 368                 inv = 1.f;
 369         }
 370
 371         recalc = 0;
 372         if (*(adelay->inv) != adelay->invertold) {
 373                 recalc = 1;
 374         }
 375         if (*(adelay->sync) != adelay->syncold) {
 376                 recalc = 1;
 377         }
 378         if (*(adelay->time) != adelay->timeold) {
 379                 recalc = 1;
 380         }
 381         if (*(adelay->feedback) != adelay->feedbackold) {
 382                 recalc = 1;
 383         }
 384         if (*(adelay->divisor) != adelay->divisorold) {
 385                 recalc = 1;
 386         }
 387         if (!is_eq(adelay->lpfold, *adelay->lpf, 0.1)) {
 388                 adelay->lpfold += tau * (*adelay->lpf - adelay->lpfold);
 389                 recalc = 1;
 390         }
 391         if (*(adelay->gain) != adelay->gainold) {
 392                 recalc = 1;
 393         }
 394
 395         if (recalc) {
 396                 lpfRbj(adelay, adelay->lpfold, srate);
 397                 if (*(adelay->sync) > 0.5f && adelay->bpmvalid) {
 398                         *(adelay->delaytime) = adelay->beatunit * 1000.f * 60.f / (adelay->bpm * *(adelay->divisor));
 399                 } else {
 400                         *(adelay->delaytime) = *(adelay->time);
 401                 }
 402                 delaysamples = (int)(*(adelay->delaytime) * srate) / 1000;
 403                 adelay->tap[adelay->next] = delaysamples;
 404         }
 405
 406         xfade = 0.f;
 407         for (i = 0; i < n_samples; i++) {
 408                 in = input[i];
 409                 adelay->z[adelay->posz] = in + *adelay->feedback / 100. * adelay->fbstate;
 410                 adelay->fbstate = 0.f;
 411                 int p = adelay->posz - adelay->tap[adelay->active]; // active line
 412                 if (p<0) p += MAX_DELAY;
 413                 adelay->fbstate += adelay->z[p];
 414
 415                 if (recalc) {
 416                         xfade += 1.0f / (float)n_samples;
 417                         adelay->fbstate *= (1.-xfade);
 418                         p = adelay->posz - adelay->tap[adelay->next]; // next line
 419                         if (p<0) p += MAX_DELAY;
 420                         adelay->fbstate += adelay->z[p] * xfade;
 421                 }
 422                 output[i] = from_dB(*(adelay->gain)) * ((100.-*(adelay->wetdry)) / 100. * in + *(adelay->wetdry) / 100. * -inv * runfilter(adelay, adelay->fbstate));
 423                 if (++(adelay->posz) >= MAX_DELAY) {
 424                         adelay->posz = 0;
 425                 }
 426         }
 427         adelay->feedbackold = *(adelay->feedback);
 428         adelay->divisorold = *(adelay->divisor);
 429         adelay->gainold = *(adelay->gain);
 430         adelay->invertold = *(adelay->inv);
 431         adelay->timeold = *(adelay->time);
 432         adelay->syncold = *(adelay->sync);
 433         adelay->wetdryold = *(adelay->wetdry);
 434         adelay->delaytimeold = *(adelay->delaytime);
 435         adelay->delaysamplesold = delaysamples;
 436         if (recalc) {
 437                 tmp = adelay->active;
 438                 adelay->active = adelay->next;
 439                 adelay->next = tmp;
 440         }
 441
 442         if (adelay->atombpm) {
 443                 LV2_Atom_Event* ev = lv2_atom_sequence_begin(&(adelay->atombpm)->body);
 444                 while(!lv2_atom_sequence_is_end(&(adelay->atombpm)->body, (adelay->atombpm)->atom.size, ev)) {
 445                         if (ev->body.type == adelay->uris.atom_Blank || ev->body.type == adelay->uris.atom_Object) {
 446                                 const LV2_Atom_Object* obj = (LV2_Atom_Object*)&ev->body;
 447                                 if (obj->body.otype == adelay->uris.time_Position) {
 448                                         update_bpm(adelay, obj);
 449                                 }
 450                         }
 451                         ev = lv2_atom_sequence_next(ev);
 452                 }
 453         }
 454 }
 455
 456 static void
 457 cleanup(LV2_Handle instance)
 458 {
 459         free(instance);
 460 }
 461
 462 static const void*
 463 extension_data(const char* uri)
 464 {
 465         return NULL;
 466 }
 467
 468 static const LV2_Descriptor descriptor = {
 469         ADELAY_URI,
 470         instantiate,
 471         connect_port,
 472         activate,
 473         run,
 474         NULL,
 475         cleanup,
 476         extension_data
 477 };
 478
 479 LV2_SYMBOL_EXPORT
 480 const LV2_Descriptor*
 481 lv2_descriptor(uint32_t index)
 482 {
 483         switch (index) {
 484         case 0:
 485                 return &descriptor;
 486         default:
 487                 return NULL;
 488         }
 489 }