sampler_channel.c

   1 /*
   2 Calf Box, an open source musical instrument.
   3 Copyright (C) 2010-2013 Krzysztof Foltman
   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 3 of the License, or
   8 (at your option) 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, see <http://www.gnu.org/licenses/>.
  17 */
  18
  19 #include "config-api.h"
  20 #include "dspmath.h"
  21 #include "errors.h"
  22 #include "midi.h"
  23 #include "module.h"
  24 #include "rt.h"
  25 #include "sampler.h"
  26 #include "sampler_impl.h"
  27 #include "sfzloader.h"
  28 #include "stm.h"
  29 #include <assert.h>
  30 #include <errno.h>
  31 #include <glib.h>
  32 #include <math.h>
  33 #include <memory.h>
  34 #include <sndfile.h>
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37
  38 void sampler_channel_init(struct sampler_channel *c, struct sampler_module *m)
  39 {
  40     c->module = m;
  41     c->voices_running = NULL;
  42     c->active_voices = 0;
  43     c->pitchwheel = 0;
  44     memset(c->cc, 0, sizeof(c->cc));
  45
  46     // default to maximum and pan=centre if MIDI mixing disabled
  47     if (m->disable_mixer_controls)
  48     {
  49         c->channel_volume_cc = 16383;
  50         c->channel_pan_cc = 8192;
  51     }
  52     else
  53     {
  54         sampler_channel_process_cc(c, 7, 100);
  55         sampler_channel_process_cc(c, 7 + 32, 0);
  56         sampler_channel_process_cc(c, 10, 64);
  57         sampler_channel_process_cc(c, 10 + 32, 0);
  58     }
  59     c->cc[11] = 127;
  60     c->cc[71] = 64;
  61     c->cc[74] = 64;
  62     c->previous_note = -1;
  63     c->program = NULL;
  64     sampler_channel_set_program_RT(c, m->program_count ? m->programs[0] : NULL);
  65     memset(c->switchmask, 0, sizeof(c->switchmask));
  66     memset(c->sustainmask, 0, sizeof(c->sustainmask));
  67     memset(c->sostenutomask, 0, sizeof(c->sostenutomask));
  68 }
  69
  70 void sampler_channel_process_cc(struct sampler_channel *c, int cc, int val)
  71 {
  72     struct sampler_module *m = c->module;
  73     // Handle CC triggering.
  74     if (c->program && c->program->rll && c->program->rll->layers_oncc && m->voices_free)
  75     {
  76         struct sampler_rll *rll = c->program->rll;
  77         if (!(rll->cc_trigger_bitmask[cc >> 5] & (1 << (cc & 31))))
  78             return;
  79         int old_value = c->cc[cc];
  80         for (GSList *p = rll->layers_oncc; p; p = p->next)
  81         {
  82             struct sampler_layer *layer = p->data;
  83             assert(layer->runtime);
  84             // Only trigger on transition between 'out of range' and 'in range' values.
  85             // XXXKF I'm not sure if it's what is expected here, but don't have
  86             // the reference implementation handy.
  87             if (layer->runtime->on_cc_number == cc &&
  88                 (val >= layer->runtime->on_locc && val <= layer->runtime->on_hicc) &&
  89                 !(old_value >= layer->runtime->on_locc && old_value <= layer->runtime->on_hicc))
  90             {
  91                 struct sampler_voice *v = m->voices_free;
  92                 int exgroups[MAX_RELEASED_GROUPS], exgroupcount = 0;
  93                 sampler_voice_start(v, c, layer->runtime, layer->runtime->pitch_keycenter, 127, exgroups, &exgroupcount);
  94                 sampler_channel_release_groups(c, -1, exgroups, exgroupcount);
  95             }
  96         }
  97     }
  98     int was_enabled = c->cc[cc] >= 64;
  99     int enabled = val >= 64;
 100     switch(cc)
 101     {
 102         case 10:
 103         case 10 + 32:
 104             c->cc[cc] = val;
 105             if (!c->module->disable_mixer_controls)
 106                 c->channel_pan_cc = sampler_channel_addcc(c, 10);
 107             break;
 108         case 7:
 109         case 7 + 32:
 110             c->cc[cc] = val;
 111             if (!c->module->disable_mixer_controls)
 112                 c->channel_volume_cc = sampler_channel_addcc(c, 7);
 113             break;
 114         case 64:
 115             if (was_enabled && !enabled)
 116             {
 117                 sampler_channel_stop_sustained(c);
 118             }
 119             break;
 120         case 66:
 121             if (was_enabled && !enabled)
 122                 sampler_channel_stop_sostenuto(c);
 123             else if (!was_enabled && enabled)
 124                 sampler_channel_capture_sostenuto(c);
 125             break;
 126
 127         case 120:
 128         case 123:
 129             sampler_channel_stop_all(c);
 130             break;
 131         case 121:
 132             // Recommended Practice (RP-015) Response to Reset All Controllers
 133             // http://www.midi.org/techspecs/rp15.php
 134             sampler_channel_process_cc(c, 64, 0);
 135             sampler_channel_process_cc(c, 66, 0);
 136             c->cc[11] = 127;
 137             c->cc[1] = 0;
 138             c->pitchwheel = 0;
 139             c->cc[smsrc_chanaft] = 0;
 140             // XXXKF reset polyphonic pressure values when supported
 141             return;
 142     }
 143     if (cc < 120)
 144         c->cc[cc] = val;
 145 }
 146
 147 void sampler_channel_release_groups(struct sampler_channel *c, int note, int exgroups[MAX_RELEASED_GROUPS], int exgroupcount)
 148 {
 149     if (exgroupcount)
 150     {
 151         FOREACH_VOICE(c->voices_running, v)
 152         {
 153             for (int j = 0; j < exgroupcount; j++)
 154             {
 155                 if (v->off_by == exgroups[j] && v->note != note)
 156                 {
 157                     if (v->layer->off_mode == som_fast)
 158                     {
 159                         v->released = 1;
 160                         cbox_envelope_go_to(&v->amp_env, 15);
 161                     }
 162                     else
 163                     {
 164                         v->released = 1;
 165                     }
 166                     break;
 167                 }
 168             }
 169         }
 170     }
 171 }
 172
 173 void sampler_channel_start_note(struct sampler_channel *c, int note, int vel, gboolean is_release_trigger)
 174 {
 175     struct sampler_module *m = c->module;
 176     float random = rand() * 1.0 / (RAND_MAX + 1.0);
 177     gboolean is_first = FALSE;
 178     if (!is_release_trigger)
 179     {
 180         c->switchmask[note >> 5] |= 1 << (note & 31);
 181         c->prev_note_velocity[note] = vel;
 182         c->prev_note_start_time[note] = m->current_time;
 183         is_first = TRUE;
 184         FOREACH_VOICE(c->voices_running, v)
 185         {
 186             if (!v->released && v->layer->trigger != stm_release)
 187             {
 188                 is_first = FALSE;
 189                 break;
 190             }
 191         }
 192     }
 193     struct sampler_program *prg = c->program;
 194     if (!prg || !prg->rll || prg->deleting)
 195         return;
 196     GSList *next_layer = sampler_program_get_next_layer(prg, c, !is_release_trigger ? prg->rll->layers : prg->rll->layers_release, note, vel, random, is_first);
 197     if (!next_layer)
 198     {
 199         if (!is_release_trigger)
 200             c->previous_note = note;
 201         return;
 202     }
 203
 204     // this might perhaps be optimized by mapping the group identifiers to flat-array indexes
 205     // but I'm not going to do that until someone gives me an SFZ worth doing that work ;)
 206     int exgroups[MAX_RELEASED_GROUPS], exgroupcount = 0;
 207
 208     FOREACH_VOICE(m->voices_free, v)
 209     {
 210         struct sampler_layer *l = next_layer->data;
 211         // Maybe someone forgot to call sampler_update_layer?
 212         assert(l->runtime);
 213         sampler_voice_start(v, c, l->runtime, note, vel, exgroups, &exgroupcount);
 214         next_layer = sampler_program_get_next_layer(prg, c, g_slist_next(next_layer), note, vel, random, is_first);
 215         if (!next_layer)
 216             break;
 217     }
 218     if (!is_release_trigger)
 219         c->previous_note = note;
 220     sampler_channel_release_groups(c, note, exgroups, exgroupcount);
 221 }
 222
 223 void sampler_channel_start_release_triggered_voices(struct sampler_channel *c, int note)
 224 {
 225     if (c->program && c->program->rll && c->program->rll->layers_release)
 226     {
 227         if (c->prev_note_velocity[note])
 228         {
 229             sampler_channel_start_note(c, note, c->prev_note_velocity[note], TRUE);
 230             c->prev_note_velocity[note] = 0;
 231         }
 232     }
 233 }
 234
 235 void sampler_channel_stop_note(struct sampler_channel *c, int note, int vel, gboolean is_polyaft)
 236 {
 237     c->switchmask[note >> 5] &= ~(1 << (note & 31));
 238     FOREACH_VOICE(c->voices_running, v)
 239     {
 240         if (v->note == note && v->layer->trigger != stm_release)
 241         {
 242             if (v->captured_sostenuto)
 243                 v->released_with_sostenuto = 1;
 244             else if (c->cc[64] >= 64)
 245                 v->released_with_sustain = 1;
 246             else
 247                 sampler_voice_release(v, is_polyaft);
 248
 249         }
 250     }
 251     if (c->cc[64] < 64)
 252         sampler_channel_start_release_triggered_voices(c, note);
 253     else
 254         c->sustainmask[note >> 5] |= (1 << (note & 31));
 255 }
 256
 257 void sampler_channel_stop_sustained(struct sampler_channel *c)
 258 {
 259     FOREACH_VOICE(c->voices_running, v)
 260     {
 261         if (v->channel == c && v->released_with_sustain && v->layer->trigger != stm_release)
 262         {
 263             sampler_voice_release(v, FALSE);
 264             v->released_with_sustain = 0;
 265         }
 266     }
 267     // Start release layers for the newly released keys
 268     if (c->program && c->program->rll && c->program->rll->layers_release)
 269     {
 270         for (int i = 0; i < 128; i++)
 271         {
 272             if (c->sustainmask[i >> 5] & (1 << (i & 31)))
 273                 sampler_channel_start_release_triggered_voices(c, i);
 274         }
 275     }
 276     memset(c->sustainmask, 0, sizeof(c->sustainmask));
 277 }
 278
 279 void sampler_channel_stop_sostenuto(struct sampler_channel *c)
 280 {
 281     FOREACH_VOICE(c->voices_running, v)
 282     {
 283         if (v->released_with_sostenuto && v->layer->trigger != stm_release)
 284         {
 285             sampler_channel_start_release_triggered_voices(c, v->note);
 286             sampler_voice_release(v, FALSE);
 287             v->released_with_sostenuto = 0;
 288             // XXXKF unsure what to do with sustain
 289         }
 290     }
 291     // Start release layers for the newly released keys
 292     if (c->program && c->program->rll && c->program->rll->layers_release)
 293     {
 294         for (int i = 0; i < 128; i++)
 295         {
 296             if (c->sostenutomask[i >> 5] & (1 << (i & 31)))
 297                 sampler_channel_start_release_triggered_voices(c, i);
 298         }
 299     }
 300     memset(c->sostenutomask, 0, sizeof(c->sostenutomask));
 301 }
 302
 303 void sampler_channel_capture_sostenuto(struct sampler_channel *c)
 304 {
 305     FOREACH_VOICE(c->voices_running, v)
 306     {
 307         if (!v->released && v->loop_mode != slm_one_shot && v->loop_mode != slm_one_shot_chokeable && !v->layer->count)
 308         {
 309             // XXXKF unsure what to do with sustain
 310             v->captured_sostenuto = 1;
 311             c->sostenutomask[v->note >> 5] |= (1 << (v->note & 31));
 312         }
 313     }
 314 }
 315
 316 void sampler_channel_stop_all(struct sampler_channel *c)
 317 {
 318     FOREACH_VOICE(c->voices_running, v)
 319     {
 320         sampler_voice_release(v, v->loop_mode == slm_one_shot_chokeable);
 321         v->released_with_sustain = 0;
 322         v->released_with_sostenuto = 0;
 323         v->captured_sostenuto = 0;
 324     }
 325 }
 326
 327 void sampler_channel_set_program_RT(struct sampler_channel *c, struct sampler_program *prg)
 328 {
 329     if (c->program)
 330         c->program->in_use--;
 331     c->program = prg;
 332     if (prg)
 333     {
 334         for(GSList *p = prg->ctrl_init_list; p; p = p->next)
 335         {
 336             union sampler_ctrlinit_union u;
 337             u.ptr = p->data;
 338             // printf("Setting controller %d -> %d\n", u.cinit.controller, u.cinit.value);
 339             c->cc[u.cinit.controller] = u.cinit.value;
 340         }
 341         c->program->in_use++;
 342     }
 343 }
 344
 345 #define sampler_channel_set_program_args(ARG) ARG(struct sampler_program *, prg)
 346
 347 DEFINE_RT_VOID_FUNC(sampler_channel, c, sampler_channel_set_program)
 348 {
 349     sampler_channel_set_program_RT(c, prg);
 350 }
 351
 352 void sampler_channel_program_change(struct sampler_channel *c, int program)
 353 {
 354     struct sampler_module *m = c->module;
 355     // XXXKF replace with something more efficient
 356     for (int i = 0; i < m->program_count; i++)
 357     {
 358         // XXXKF support banks
 359         if (m->programs[i]->prog_no == program)
 360         {
 361             sampler_channel_set_program_RT(c, m->programs[i]);
 362             return;
 363         }
 364     }
 365     g_warning("Unknown program %d", program);
 366     sampler_channel_set_program_RT(c, m->programs[0]);
 367 }
 368