libs/plugins/reasonablesynth.lv2/rsynth.c

   1 /* reasonable simple synth
   2  *
   3  * Copyright (C) 2013 Robin Gareus <robin@gareus.org>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2, or (at your option)
   8  * any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software Foundation,
  17  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 #ifndef _GNU_SOURCE
  21 #define _GNU_SOURCE // needed for M_PI
  22 #endif
  23
  24 #include <math.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <stdint.h>
  28 #include <assert.h>
  29
  30 #ifndef BUFFER_SIZE_SAMPLES
  31 #define BUFFER_SIZE_SAMPLES 64
  32 #endif
  33
  34 #ifndef MIN
  35 #define MIN(A, B) ( (A) < (B) ? (A) : (B) )
  36 #endif
  37
  38 /* internal MIDI event abstraction */
  39 enum RMIDI_EV_TYPE {
  40   INVALID=0,
  41   NOTE_ON,
  42   NOTE_OFF,
  43   PROGRAM_CHANGE,
  44   CONTROL_CHANGE,
  45 };
  46
  47 struct rmidi_event_t {
  48   enum RMIDI_EV_TYPE type;
  49   uint8_t channel; /**< the MIDI channel number 0-15 */
  50   union {
  51     struct {
  52       uint8_t note;
  53       uint8_t velocity;
  54     } tone;
  55     struct {
  56       uint8_t param;
  57       uint8_t value;
  58     } control;
  59   } d;
  60 };
  61
  62 typedef struct {
  63   uint32_t tme[3]; // attack, decay, release times [settings:ms || internal:samples]
  64   float    vol[2]; // attack, sustain volume [0..1]
  65   uint32_t off[3]; // internal use (added attack,decay,release times)
  66 } ADSRcfg;
  67
  68 typedef struct _RSSynthChannel {
  69   uint32_t  keycomp;
  70   uint32_t  adsr_cnt[128];
  71   float     adsr_amp[128];
  72   float     phase[128];      // various use, zero'ed on note-on
  73   int8_t    miditable[128];  // internal, note-on/off velocity
  74   ADSRcfg   adsr;
  75   void      (*synthesize) (struct _RSSynthChannel* sc,
  76       const uint8_t note, const float vol, const float pc,
  77       const size_t n_samples, float* left, float* right);
  78 } RSSynthChannel;
  79
  80 typedef void (*SynthFunction) (RSSynthChannel* sc,
  81     const uint8_t note, const float vol, const float pc,
  82     const size_t n_samples, float* left, float* right);
  83
  84 typedef struct {
  85   uint32_t       boffset;
  86   float          buf [2][BUFFER_SIZE_SAMPLES];
  87   RSSynthChannel sc[16];
  88   float          freqs[128];
  89   float          kcgain;
  90   float          kcfilt;
  91   double         rate;
  92   uint32_t       xmas_on;
  93   uint32_t       xmas_off;
  94 } RSSynthesizer;
  95
  96
  97 /* initialize ADSR values
  98  *
  99  * @param rate sample-rate
 100  * @param a attack time in seconds
 101  * @param d decay time in seconds
 102  * @param r release time in seconds
 103  * @param avol attack gain [0..1]
 104  * @param svol sustain volume level [0..1]
 105  */
 106 static void init_adsr(ADSRcfg *adsr, const double rate,
 107     const uint32_t a, const uint32_t d, const uint32_t r,
 108     const float avol, const float svol) {
 109
 110   adsr->vol[0] = avol;
 111   adsr->vol[1] = svol;
 112   adsr->tme[0] = a * rate / 1000.0;
 113   adsr->tme[1] = d * rate / 1000.0;
 114   adsr->tme[2] = r * rate / 1000.0;
 115
 116   assert(adsr->tme[0] > 32);
 117   assert(adsr->tme[1] > 32);
 118   assert(adsr->tme[2] > 32);
 119   assert(adsr->vol[0] >=0 && adsr->vol[1] <= 1.0);
 120   assert(adsr->vol[1] >=0 && adsr->vol[1] <= 1.0);
 121
 122   adsr->off[0] = adsr->tme[0];
 123   adsr->off[1] = adsr->tme[1] + adsr->off[0];
 124   adsr->off[2] = adsr->tme[2] + adsr->off[1];
 125 }
 126
 127 /* calculate per-sample, per-key envelope */
 128 static inline float adsr_env(RSSynthChannel *sc, const uint8_t note) {
 129
 130   if (sc->adsr_cnt[note] < sc->adsr.off[0]) {
 131     // attack
 132     const uint32_t p = ++sc->adsr_cnt[note];
 133     if (p == sc->adsr.tme[0]) {
 134       sc->adsr_amp[note] = sc->adsr.vol[0];
 135       return sc->adsr.vol[0];
 136     } else {
 137       const float d = sc->adsr.vol[0] - sc->adsr_amp[note];
 138       return sc->adsr_amp[note] + (p / (float) sc->adsr.tme[0]) * d;
 139     }
 140   }
 141   else if (sc->adsr_cnt[note] < sc->adsr.off[1]) {
 142     // decay
 143     const uint32_t p = ++sc->adsr_cnt[note] - sc->adsr.off[0];
 144     if (p == sc->adsr.tme[1]) {
 145       sc->adsr_amp[note] = sc->adsr.vol[1];
 146       return sc->adsr.vol[1];
 147     } else {
 148       const float d = sc->adsr.vol[1] - sc->adsr_amp[note];
 149       return sc->adsr_amp[note] + (p / (float) sc->adsr.tme[1]) * d;
 150     }
 151   }
 152   else if (sc->adsr_cnt[note] == sc->adsr.off[1]) {
 153     // sustain
 154     return sc->adsr.vol[1];
 155   }
 156   else if (sc->adsr_cnt[note] < sc->adsr.off[2]) {
 157     // release
 158     const uint32_t p = ++sc->adsr_cnt[note] - sc->adsr.off[1];
 159     if (p == sc->adsr.tme[2]) {
 160       sc->adsr_amp[note] = 0;
 161       return 0;
 162     } else {
 163       const float d = 0 - sc->adsr_amp[note];
 164       return sc->adsr_amp[note] + (p / (float) sc->adsr.tme[2]) * d;
 165     }
 166   }
 167   else {
 168     sc->adsr_cnt[note] = 0;
 169     return 0;
 170   }
 171 }
 172
 173
 174 /*****************************************************************************/
 175 /* piano like sound w/slight stereo phase */
 176 static void synthesize_sineP (RSSynthChannel* sc,
 177     const uint8_t note, const float vol, const float fq,
 178     const size_t n_samples, float* left, float* right) {
 179
 180   size_t i;
 181   float phase = sc->phase[note];
 182
 183   for (i=0; i < n_samples; ++i) {
 184     float env = adsr_env(sc, note);
 185     if (sc->adsr_cnt[note] == 0) break;
 186     const float amp = vol * env;
 187
 188     left[i]  += amp * sinf(2.0 * M_PI * phase);
 189     left[i]  += .300 * amp * sinf(2.0 * M_PI * phase * 2.0);
 190     left[i]  += .150 * amp * sinf(2.0 * M_PI * phase * 3.0);
 191     left[i]  += .080 * amp * sinf(2.0 * M_PI * phase * 4.0);
 192   //left[i]  -= .007 * amp * sinf(2.0 * M_PI * phase * 5.0);
 193   //left[i]  += .010 * amp * sinf(2.0 * M_PI * phase * 6.0);
 194     left[i]  += .020 * amp * sinf(2.0 * M_PI * phase * 7.0);
 195     phase += fq;
 196     right[i] += amp * sinf(2.0 * M_PI * phase);
 197     right[i] += .300 * amp * sinf(2.0 * M_PI * phase * 2.0);
 198     right[i] += .150 * amp * sinf(2.0 * M_PI * phase * 3.0);
 199     right[i] -= .080 * amp * sinf(2.0 * M_PI * phase * 4.0);
 200   //right[i] += .007 * amp * sinf(2.0 * M_PI * phase * 5.0);
 201   //right[i] += .010 * amp * sinf(2.0 * M_PI * phase * 6.0);
 202     right[i] -= .020 * amp * sinf(2.0 * M_PI * phase * 7.0);
 203     if (phase > 1.0) phase -= 2.0;
 204   }
 205   sc->phase[note] = phase;
 206 }
 207
 208 static const ADSRcfg piano_adsr = {{   5, 800,  100}, { 1.0,  0.0}, {0,0,0}};
 209
 210 /*****************************************************************************/
 211
 212
 213 /* process note - move through ADSR states, count active keys,.. */
 214 static void process_key (void *synth,
 215     const uint8_t chn, const uint8_t note,
 216     const size_t n_samples, float *left, float *right)
 217 {
 218   RSSynthesizer*  rs = (RSSynthesizer*)synth;
 219   RSSynthChannel* sc = &rs->sc[chn];
 220   const int8_t vel = sc->miditable[note];
 221   const float vol = /* master_volume */ 0.25 * fabsf(vel) / 127.0;
 222   const float phase = sc->phase[note];
 223
 224   if (phase == -10 && vel > 0) {
 225     // new note on
 226     assert(sc->adsr_cnt[note] == 0);
 227     sc->adsr_amp[note] = 0;
 228     sc->adsr_cnt[note] = 0;
 229     sc->phase[note] = 0;
 230     sc->keycomp++;
 231     //printf("[On] Now %d keys active on chn %d\n", sc->keycomp, chn);
 232   }
 233   else if (phase >= -1.0 && phase <= 1.0 && vel > 0) {
 234     // sustain note or re-start note while adsr in progress:
 235     if (sc->adsr_cnt[note] > sc->adsr.off[1]) {
 236       // x-fade to attack
 237       sc->adsr_amp[note] = adsr_env(sc, note);
 238       sc->adsr_cnt[note] = 0;
 239     }
 240   }
 241   else if (phase >= -1.0 && phase <= 1.0 && vel < 0) {
 242     // note off
 243     if (sc->adsr_cnt[note] <= sc->adsr.off[1]) {
 244       if (sc->adsr_cnt[note] != sc->adsr.off[1]) {
 245         // x-fade to release
 246         sc->adsr_amp[note] = adsr_env(sc, note);
 247       }
 248       sc->adsr_cnt[note] = sc->adsr.off[1] + 1;
 249     }
 250   }
 251   else {
 252     /* note-on + off in same cycle */
 253     sc->miditable[note] = 0;
 254     sc->adsr_cnt[note] = 0;
 255     sc->phase[note] = -10;
 256     return;
 257   }
 258
 259   // synthesize actual sound
 260   sc->synthesize(sc, note, vol, rs->freqs[note], n_samples, left, right);
 261
 262   if (sc->adsr_cnt[note] == 0) {
 263     //printf("Note %d,%d released\n", chn, note);
 264     sc->miditable[note] = 0;
 265     sc->adsr_amp[note] = 0;
 266     sc->phase[note] = -10;
 267     sc->keycomp--;
 268     //printf("[off] Now %d keys active on chn %d\n", sc->keycomp, chn);
 269   }
 270 }
 271
 272 /* synthesize a BUFFER_SIZE_SAMPLES's of audio-data */
 273 static void synth_fragment (void *synth, const size_t n_samples, float *left, float *right) {
 274   RSSynthesizer* rs = (RSSynthesizer*)synth;
 275   memset (left, 0, n_samples * sizeof(float));
 276   memset (right, 0, n_samples * sizeof(float));
 277   uint8_t keycomp = 0;
 278   int c,k;
 279   size_t i;
 280
 281   for (c=0; c < 16; ++c) {
 282     for (k=0; k < 128; ++k) {
 283       if (rs->sc[c].miditable[k] == 0) continue;
 284       process_key(synth, c, k, n_samples, left, right);
 285     }
 286     keycomp += rs->sc[c].keycomp;
 287   }
 288
 289 #if 1 // key-compression
 290   float kctgt = 8.0 / (float)(keycomp + 7.0);
 291   if (kctgt < .5) kctgt = .5;
 292   if (kctgt > 1.0) kctgt = 1.0;
 293   const float _w = rs->kcfilt;
 294   for (i=0; i < n_samples; ++i) {
 295     rs->kcgain += _w * (kctgt - rs->kcgain);
 296     left[i]  *= rs->kcgain;
 297     right[i] *= rs->kcgain;
 298   }
 299   rs->kcgain += 1e-12;
 300 #endif
 301 }
 302
 303 static void synth_reset_channel(RSSynthChannel* sc) {
 304   int k;
 305   for (k=0; k < 128; ++k) {
 306     sc->adsr_cnt[k]  = 0;
 307     sc->adsr_amp[k]  = 0;
 308     sc->phase[k]     = -10;
 309     sc->miditable[k] = 0;
 310   }
 311   sc->keycomp = 0;
 312 }
 313
 314 static void synth_reset(void *synth) {
 315   RSSynthesizer* rs = (RSSynthesizer*)synth;
 316   int c;
 317   for (c=0; c < 16; ++c) {
 318     synth_reset_channel(&(rs->sc[c]));
 319   }
 320   rs->kcgain = 0;
 321 }
 322
 323 static void synth_load(RSSynthChannel *sc, const double rate,
 324     SynthFunction synthesize,
 325     ADSRcfg const * const adsr) {
 326   synth_reset_channel(sc);
 327   init_adsr(&sc->adsr, rate,
 328       adsr->tme[0], adsr->tme[1], adsr->tme[2],
 329       adsr->vol[0], adsr->vol[1]);
 330   sc->synthesize = synthesize;
 331 }
 332
 333
 334 /**
 335  * internal abstraction of MIDI data handling
 336  */
 337 static void synth_process_midi_event(void *synth, struct rmidi_event_t *ev) {
 338   RSSynthesizer* rs = (RSSynthesizer*)synth;
 339   switch(ev->type) {
 340     case NOTE_ON:
 341       if (rs->sc[ev->channel].miditable[ev->d.tone.note] <= 0)
 342         rs->sc[ev->channel].miditable[ev->d.tone.note] = ev->d.tone.velocity;
 343       break;
 344     case NOTE_OFF:
 345       if (rs->sc[ev->channel].miditable[ev->d.tone.note] > 0)
 346         rs->sc[ev->channel].miditable[ev->d.tone.note] *= -1.0;
 347       break;
 348     case PROGRAM_CHANGE:
 349       break;
 350     case CONTROL_CHANGE:
 351       if (ev->d.control.param == 0x00 || ev->d.control.param == 0x20) {
 352         /*  0x00 and 0x20 are used for BANK select */
 353         break;
 354       } else
 355       if (ev->d.control.param == 121) {
 356         /* reset all controllers */
 357         break;
 358       } else
 359       if (ev->d.control.param == 120 || ev->d.control.param == 123) {
 360         /* Midi panic: 120: all sound off, 123: all notes off*/
 361         synth_reset_channel(&(rs->sc[ev->channel]));
 362         break;
 363       } else
 364       if (ev->d.control.param >= 120) {
 365         /* params 122-127 are reserved - skip them. */
 366         break;
 367       }
 368       break;
 369     default:
 370       break;
 371   }
 372 }
 373
 374 /******************************************************************************
 375  * PUBLIC API (used by lv2.c)
 376  */
 377
 378 /**
 379  * align LV2 and internal synth buffers
 380  * call synth_fragment as often as needed for the given LV2 buffer size
 381  *
 382  * @param synth synth-handle
 383  * @param written samples written so far (offset in \ref out)
 384  * @param nframes total samples to synthesize and write to the \out buffer
 385  * @param out pointer to stereo output buffers
 386  * @return end of buffer (written + nframes)
 387  */
 388 static uint32_t synth_sound (void *synth, uint32_t written, const uint32_t nframes, float **out) {
 389   RSSynthesizer* rs = (RSSynthesizer*)synth;
 390
 391   while (written < nframes) {
 392     uint32_t nremain = nframes - written;
 393
 394     if (rs->boffset >= BUFFER_SIZE_SAMPLES)  {
 395       rs->boffset = 0;
 396       synth_fragment(rs, BUFFER_SIZE_SAMPLES, rs->buf[0], rs->buf[1]);
 397     }
 398
 399     uint32_t nread = MIN(nremain, (BUFFER_SIZE_SAMPLES - rs->boffset));
 400
 401     memcpy(&out[0][written], &rs->buf[0][rs->boffset], nread*sizeof(float));
 402     memcpy(&out[1][written], &rs->buf[1][rs->boffset], nread*sizeof(float));
 403
 404     written += nread;
 405     rs->boffset += nread;
 406   }
 407   return written;
 408 }
 409
 410 /**
 411  * parse raw midi-data.
 412  *
 413  * @param synth synth-handle
 414  * @param data 8bit midi message
 415  * @param size number of bytes in the midi-message
 416  */
 417 static void synth_parse_midi(void *synth, const uint8_t *data, const size_t size) {
 418   if (size < 2 || size > 3) return;
 419   // All messages need to be 3 bytes; except program-changes: 2bytes.
 420   if (size == 2 && (data[0] & 0xf0)  != 0xC0) return;
 421
 422   struct rmidi_event_t ev;
 423
 424   ev.channel = data[0]&0x0f;
 425   switch (data[0] & 0xf0) {
 426     case 0x80:
 427       ev.type=NOTE_OFF;
 428       ev.d.tone.note=data[1]&0x7f;
 429       ev.d.tone.velocity=data[2]&0x7f;
 430       break;
 431     case 0x90:
 432       ev.type=NOTE_ON;
 433       ev.d.tone.note=data[1]&0x7f;
 434       ev.d.tone.velocity=data[2]&0x7f;
 435       break;
 436     case 0xB0:
 437       ev.type=CONTROL_CHANGE;
 438       ev.d.control.param=data[1]&0x7f;
 439       ev.d.control.value=data[2]&0x7f;
 440       break;
 441     case 0xC0:
 442       ev.type=PROGRAM_CHANGE;
 443       ev.d.control.value=data[1]&0x7f;
 444       break;
 445     default:
 446       return;
 447   }
 448   synth_process_midi_event(synth, &ev);
 449 }
 450
 451 static const uint8_t jingle[] = { 71 ,71 ,71 ,71 ,71 ,71 ,71 ,74 ,67 ,69 ,71 ,72 ,72 ,72 ,72 ,72 ,71 ,71 ,71 ,71 ,71 ,69 ,69 ,71 ,69 ,74 ,71 ,71 ,71 ,71 ,71 ,71 ,71 ,74 ,67 ,69 ,71 ,72 ,72 ,72 ,72 ,72 ,71 ,71 ,71 ,71 ,74 ,74 ,72 ,69 ,67 ,62 ,62 ,71 ,69 ,67 ,62 ,62 ,62 ,62 ,71 ,69 ,67 ,64 ,64 ,64 ,72 ,71 ,69 ,66 ,74 ,76 ,74 ,72 ,69 ,71 ,62 ,62 ,71 ,69 ,67 ,62 ,62 ,62 ,62 ,71 ,69 ,67 ,64 ,64 ,64 ,72 ,71 ,69 ,74 ,74 ,74 ,74 ,76 ,74 ,72 ,69 ,67 ,74 ,71 ,71 ,71 ,71 ,71 ,71 ,71 ,74 ,67 ,69 ,71 ,72 ,72 ,72 ,72 ,72 ,71 ,71 ,71 ,71 ,71 ,69 ,69 ,71 ,69 ,74 ,71 ,71 ,71 ,71 ,71 ,71 ,71 ,74 ,67 ,69 ,71 ,72 ,72 ,72 ,72 ,72 ,71 ,71 ,71 ,71 ,74 ,74 ,72 ,69 ,67 };
 452
 453 static void synth_parse_xmas(void *synth, const uint8_t *data, const size_t size) {
 454   RSSynthesizer* rs = (RSSynthesizer*)synth;
 455   if (size < 2 || size > 3) return;
 456   // All messages need to be 3 bytes; except program-changes: 2bytes.
 457   if (size == 2 && (data[0] & 0xf0)  != 0xC0) return;
 458
 459   struct rmidi_event_t ev;
 460
 461   ev.channel = data[0]&0x0f;
 462   switch (data[0] & 0xf0) {
 463     case 0x80:
 464       ev.type=NOTE_OFF;
 465       ev.d.tone.note=jingle[rs->xmas_off++];
 466       ev.d.tone.velocity=data[2]&0x7f;
 467       if (rs->xmas_off >= sizeof(jingle)) rs->xmas_off = 0;
 468       break;
 469     case 0x90:
 470       ev.type=NOTE_ON;
 471       ev.d.tone.note=jingle[rs->xmas_on++];
 472       ev.d.tone.velocity=data[2]&0x7f;
 473       if (rs->xmas_on >= sizeof(jingle)) rs->xmas_on = 0;
 474       break;
 475     case 0xB0:
 476       ev.type=CONTROL_CHANGE;
 477       ev.d.control.param=data[1]&0x7f;
 478       ev.d.control.value=data[2]&0x7f;
 479       break;
 480     case 0xC0:
 481       ev.type=PROGRAM_CHANGE;
 482       ev.d.control.value=data[1]&0x7f;
 483       break;
 484     default:
 485       return;
 486   }
 487   synth_process_midi_event(synth, &ev);
 488 }
 489 /**
 490  * initialize the synth
 491  * This should be called after synth_alloc()
 492  * as soon as the sample-rate is known
 493  *
 494  * @param synth synth-handle
 495  * @param rate sample-rate
 496  */
 497 static void synth_init(void *synth, double rate) {
 498   RSSynthesizer* rs = (RSSynthesizer*)synth;
 499   rs->rate = rate;
 500   rs->boffset = BUFFER_SIZE_SAMPLES;
 501   const float tuning = 440;
 502   int c,k;
 503   for (k=0; k < 128; k++) {
 504     rs->freqs[k] = (2.0 * tuning / 32.0f) * powf(2, (k - 9.0) / 12.0) / rate;
 505     assert(rs->freqs[k] < M_PI/2); // otherwise spatialization may phase out..
 506   }
 507   rs->kcfilt = 12.0 / rate;
 508   synth_reset(synth);
 509
 510   for (c=0; c < 16; c++) {
 511     synth_load(&rs->sc[c], rate, &synthesize_sineP, &piano_adsr);
 512   }
 513   rs->xmas_on = 0;
 514   rs->xmas_off = 0;
 515 }
 516
 517 /**
 518  * Allocate data-structure, create a handle for all other synth_* functions.
 519  *
 520  * This data should be freeded with \ref synth_free when the synth is no
 521  * longer needed.
 522  *
 523  * The synth can only be used after calling \rev synth_init as well.
 524  *
 525  * @return synth-handle
 526  */
 527 static void * synth_alloc(void) {
 528   return calloc(1, sizeof(RSSynthesizer));
 529 }
 530
 531 /**
 532  * release synth data structure
 533  * @param synth synth-handle
 534  */
 535 static void synth_free(void *synth) {
 536   free(synth);
 537 }
 538 /* vi:set ts=8 sts=2 sw=2 et: */