libs/plugins/reasonablesynth.lv2/lv2.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 #define _GNU_SOURCE
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <stdint.h>
  25
  26 /* LV2 */
  27 #include "lv2/lv2plug.in/ns/lv2core/lv2.h"
  28 #include "lv2/lv2plug.in/ns/ext/atom/atom.h"
  29 #include "lv2/lv2plug.in/ns/ext/urid/urid.h"
  30 #include "lv2/lv2plug.in/ns/ext/midi/midi.h"
  31
  32 #define RSY_URI "https://community.ardour.org/node/7596"
  33
  34 /* the synth interface */
  35 static void *   synth_alloc      (void);
  36 static void     synth_init       (void *, double rate);
  37 static void     synth_free       (void *);
  38 static void     synth_parse_midi (void *, const uint8_t *data, const size_t size);
  39 static uint32_t synth_sound      (void *, uint32_t written, uint32_t nframes, float **out);
  40
  41 #include "rsynth.c"
  42
  43 typedef enum {
  44   RSY_MIDIIN = 0,
  45   RSY_OUTL,
  46   RSY_OUTR
  47 } PortIndex;
  48
  49 typedef struct {
  50   const LV2_Atom_Sequence* midiin;
  51   float* outL;
  52   float* outR;
  53
  54   LV2_URID_Map* map;
  55   LV2_URID midi_MidiEvent;
  56
  57   double SampleRateD;
  58   void *synth;
  59 } RSynth;
  60
  61 /* main LV2 */
  62
  63 static LV2_Handle
  64 instantiate(const LV2_Descriptor*     descriptor,
  65             double                    rate,
  66             const char*               bundle_path,
  67             const LV2_Feature* const* features)
  68 {
  69   (void) descriptor; /* unused variable */
  70   (void) bundle_path; /* unused variable */
  71
  72   if (rate < 8000) {
  73     fprintf(stderr, "RSynth.lv2 error: unsupported sample-rate (must be > 8k)\n");
  74     return NULL;
  75   }
  76   RSynth* self = (RSynth*)calloc(1, sizeof(RSynth));
  77   if(!self) {
  78     return NULL;
  79   }
  80
  81   self->SampleRateD = rate;
  82
  83   int i;
  84   for (i=0; features[i]; ++i) {
  85     if (!strcmp(features[i]->URI, LV2_URID__map)) {
  86       self->map = (LV2_URID_Map*)features[i]->data;
  87     }
  88   }
  89
  90   if (!self->map) {
  91     fprintf(stderr, "RSynth.lv2 error: Host does not support urid:map\n");
  92     free(self);
  93     return NULL;
  94   }
  95
  96   self->midi_MidiEvent = self->map->map(self->map->handle, LV2_MIDI__MidiEvent);
  97
  98   self->synth = synth_alloc();
  99   synth_init(self->synth, rate);
 100
 101   return (LV2_Handle)self;
 102 }
 103
 104 static void
 105 connect_port(LV2_Handle handle,
 106              uint32_t   port,
 107              void*      data)
 108 {
 109   RSynth* self = (RSynth*)handle;
 110
 111   switch ((PortIndex)port) {
 112     case RSY_MIDIIN:
 113       self->midiin = (const LV2_Atom_Sequence*)data;
 114       break;
 115     case RSY_OUTL:
 116       self->outL = (float*)data;
 117       break;
 118     case RSY_OUTR:
 119       self->outR = (float*)data;
 120       break;
 121   }
 122 }
 123
 124 static void
 125 run(LV2_Handle handle, uint32_t n_samples)
 126 {
 127   RSynth* self = (RSynth*)handle;
 128   float* audio[2];
 129
 130   audio[0] = self->outL;
 131   audio[1] = self->outR;
 132
 133   uint32_t written = 0;
 134
 135   /* Process incoming MIDI events */
 136   if (self->midiin) {
 137     LV2_Atom_Event const* ev = (LV2_Atom_Event const*)((&(self->midiin)->body) + 1); // lv2_atom_sequence_begin
 138     while( // !lv2_atom_sequence_is_end
 139         (const uint8_t*)ev < ((const uint8_t*) &(self->midiin)->body + (self->midiin)->atom.size)
 140         )
 141     {
 142       if (ev->body.type == self->midi_MidiEvent) {
 143         if (written + BUFFER_SIZE_SAMPLES < ev->time.frames
 144             && ev->time.frames < n_samples) {
 145           /* first synthesize sound up until the message timestamp */
 146           written = synth_sound(self->synth, written, ev->time.frames, audio);
 147         }
 148         /* send midi message to synth */
 149         synth_parse_midi(self->synth, (const uint8_t*)(ev+1), ev->body.size);
 150       }
 151       ev = (LV2_Atom_Event const*) // lv2_atom_sequence_next()
 152         ((const uint8_t*)ev + sizeof(LV2_Atom_Event) + ((ev->body.size + 7) & ~7));
 153     }
 154   }
 155
 156   /* synthesize [remaining] sound */
 157   synth_sound(self->synth, written, n_samples, audio);
 158 }
 159
 160 static void
 161 cleanup(LV2_Handle handle)
 162 {
 163   RSynth* self = (RSynth*)handle;
 164   synth_free(self->synth);
 165   free(handle);
 166 }
 167
 168 static const void*
 169 extension_data(const char* uri)
 170 {
 171   (void) uri; /* unused variable */
 172   return NULL;
 173 }
 174
 175 static const LV2_Descriptor descriptor = {
 176   RSY_URI,
 177   instantiate,
 178   connect_port,
 179   NULL,
 180   run,
 181   NULL,
 182   cleanup,
 183   extension_data
 184 };
 185
 186 LV2_SYMBOL_EXPORT
 187 const LV2_Descriptor*
 188 lv2_descriptor(uint32_t index)
 189 {
 190   switch (index) {
 191   case 0:
 192     return &descriptor;
 193   default:
 194     return NULL;
 195   }
 196 }
 197
 198 /* vi:set ts=8 sts=2 sw=2 et: */