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