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