sampler.h

   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 #ifndef CBOX_SAMPLER_H
  20 #define CBOX_SAMPLER_H
  21
  22 #include "biquad-float.h"
  23 #include "envelope.h"
  24 #include "module.h"
  25 #include "prefetch_pipe.h"
  26 #include "sampler_layer.h"
  27 #include "sampler_prg.h"
  28 #include "wavebank.h"
  29 #include <stdint.h>
  30
  31 #define MAX_SAMPLER_VOICES 128
  32
  33 #define CBOX_SAMPLER_ERROR cbox_sampler_error_quark()
  34
  35 enum CboxSamplerError
  36 {
  37     CBOX_SAMPLER_ERROR_FAILED,
  38     CBOX_SAMPLER_ERROR_INVALID_LAYER,
  39     CBOX_SAMPLER_ERROR_INVALID_WAVEFORM,
  40     CBOX_SAMPLER_ERROR_NO_PROGRAMS
  41 };
  42
  43 struct sampler_noteinitfunc;
  44 struct sampler_voice;
  45
  46 #define GET_RT_FROM_sampler_channel(channel) ((channel)->module->module.rt)
  47
  48 struct sampler_channel
  49 {
  50     struct sampler_module *module;
  51     int pitchwheel;
  52     uint32_t switchmask[4];
  53     uint32_t sustainmask[4];
  54     uint32_t sostenutomask[4];
  55     int previous_note;
  56     uint8_t cc[smsrc_perchan_count];
  57     struct sampler_program *program;
  58     struct sampler_voice *voices_running;
  59     int active_voices;
  60     uint8_t prev_note_velocity[128];
  61     uint32_t prev_note_start_time[128];
  62 };
  63
  64 struct sampler_lfo
  65 {
  66     uint32_t phase, delta;
  67     uint32_t age, delay, fade;
  68 };
  69
  70 struct sampler_gen
  71 {
  72     enum sampler_player_type mode;
  73     int16_t *sample_data;
  74     int16_t *scratch;
  75
  76     uint64_t bigpos, bigdelta;
  77     uint32_t loop_start, loop_end;
  78     uint32_t cur_sample_end;
  79     float lgain, rgain;
  80     float last_lgain, last_rgain;
  81
  82     // In-memory mode only
  83     uint32_t loop_overlap;
  84     float loop_overlap_step;
  85     uint32_t play_count, loop_count;
  86     int16_t scratch_bandlimited[2 * MAX_INTERPOLATION_ORDER * 2];
  87
  88     // Streaming mode only
  89     int16_t *streaming_buffer;
  90     uint32_t consumed, consumed_credit, streaming_buffer_frames;
  91     gboolean prefetch_only_loop, in_streaming_buffer;
  92 };
  93
  94 struct sampler_voice
  95 {
  96     struct sampler_voice *prev, *next;
  97     struct sampler_layer_data *layer;
  98     // Note: may be NULL when program is being deleted
  99     struct sampler_program *program;
 100     struct cbox_waveform *last_waveform;
 101     struct sampler_gen gen;
 102     struct cbox_prefetch_pipe *current_pipe;
 103     int note;
 104     int vel;
 105     int released, released_with_sustain, released_with_sostenuto, captured_sostenuto;
 106     int off_by;
 107     int delay;
 108     int age;
 109     float pitch_shift;
 110     float cutoff_shift;
 111     float gain_shift, gain_fromvel;
 112     struct cbox_biquadf_state filter_left, filter_right;
 113     struct cbox_biquadf_state filter_left2, filter_right2;
 114     struct cbox_biquadf_coeffs filter_coeffs;
 115     struct sampler_channel *channel;
 116     struct cbox_envelope amp_env, filter_env, pitch_env;
 117     struct sampler_lfo amp_lfo, filter_lfo, pitch_lfo;
 118     enum sampler_loop_mode loop_mode;
 119     int output_pair_no;
 120     int send1bus, send2bus;
 121     float send1gain, send2gain;
 122     int serial_no;
 123     struct cbox_envelope_shape dyn_envs[3]; // amp, filter, pitch
 124 };
 125
 126 struct sampler_module
 127 {
 128     struct cbox_module module;
 129
 130     struct sampler_voice *voices_free, voices_all[MAX_SAMPLER_VOICES];
 131     struct sampler_channel channels[16];
 132     struct sampler_program **programs;
 133     int program_count;
 134     int active_voices, max_voices;
 135     int serial_no;
 136     int output_pairs, aux_pairs;
 137     uint32_t current_time;
 138     gboolean deleting;
 139     struct cbox_prefetch_stack *pipe_stack;
 140     struct cbox_sincos sincos[12800];
 141 };
 142
 143 #define MAX_RELEASED_GROUPS 4
 144
 145 extern GQuark cbox_sampler_error_quark(void);
 146
 147 extern gboolean sampler_select_program(struct sampler_module *m, int channel, const gchar *preset, GError **error);
 148 extern void sampler_unselect_program(struct sampler_module *m, struct sampler_program *prg);
 149
 150 extern void sampler_channel_init(struct sampler_channel *c, struct sampler_module *m);
 151 // This function may only be called from RT thread!
 152 extern void sampler_channel_set_program_RT(struct sampler_channel *c, struct sampler_program *prg);
 153 // ... and this one is RT-safe
 154 extern void sampler_channel_set_program(struct sampler_channel *c, struct sampler_program *prg);
 155 extern void sampler_channel_start_note(struct sampler_channel *c, int note, int vel, gboolean is_release_trigger);
 156 extern void sampler_channel_stop_note(struct sampler_channel *c, int note, int vel, gboolean is_polyaft);
 157 extern void sampler_channel_program_change(struct sampler_channel *c, int program);
 158 extern void sampler_channel_stop_sustained(struct sampler_channel *c);
 159 extern void sampler_channel_stop_sostenuto(struct sampler_channel *c);
 160 extern void sampler_channel_capture_sostenuto(struct sampler_channel *c);
 161 extern void sampler_channel_release_groups(struct sampler_channel *c, int note, int exgroups[MAX_RELEASED_GROUPS], int exgroupcount);
 162 extern void sampler_channel_stop_all(struct sampler_channel *c);
 163
 164 extern void sampler_voice_start(struct sampler_voice *v, struct sampler_channel *c, struct sampler_layer_data *l, int note, int vel, int *exgroups, int *pexgroupcount);
 165 extern void sampler_voice_release(struct sampler_voice *v, gboolean is_polyaft);
 166 extern void sampler_voice_process(struct sampler_voice *v, struct sampler_module *m, cbox_sample_t **outputs);
 167 extern void sampler_voice_link(struct sampler_voice **pv, struct sampler_voice *v);
 168 extern void sampler_voice_unlink(struct sampler_voice **pv, struct sampler_voice *v);
 169 extern void sampler_voice_inactivate(struct sampler_voice *v, gboolean expect_active);
 170
 171 extern float sampler_sine_wave[2049];
 172
 173 static inline int sampler_channel_addcc(struct sampler_channel *c, int cc_no)
 174 {
 175     return (((int)c->cc[cc_no]) << 7) + c->cc[cc_no + 32];
 176 }
 177
 178 #define FOREACH_VOICE(var, p) \
 179     for (struct sampler_voice *p = (var), *p##_next = NULL; p && (p##_next = p->next, TRUE); p = p##_next)
 180
 181
 182 #endif