src/calf/modules_synths.h

   1 /* Calf DSP Library
   2  * Audio modules - synthesizers
   3  *
   4  * Copyright (C) 2001-2007 Krzysztof Foltman
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General
  17  * Public License along with this program; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21 #ifndef __CALF_MODULES_SYNTHS_H
  22 #define __CALF_MODULES_SYNTHS_H
  23
  24 #include <assert.h>
  25 #include "biquad.h"
  26 #include "onepole.h"
  27 #include "audio_fx.h"
  28 #include "inertia.h"
  29 #include "osc.h"
  30 #include "synth.h"
  31 #include "envelope.h"
  32 #include "organ.h"
  33
  34 namespace calf_plugins {
  35
  36 #define MONOSYNTH_WAVE_BITS 12
  37
  38 /// Monosynth-in-making. Parameters may change at any point, so don't make songs with it!
  39 /// It lacks inertia for parameters, even for those that really need it.
  40 class monosynth_audio_module: public audio_module<monosynth_metadata>, public line_graph_iface
  41 {
  42 public:
  43     float *ins[in_count];
  44     float *outs[out_count];
  45     float *params[param_count];
  46     uint32_t srate, crate;
  47     static dsp::waveform_family<MONOSYNTH_WAVE_BITS> *waves;
  48     dsp::waveform_oscillator<MONOSYNTH_WAVE_BITS> osc1, osc2;
  49     bool running, stopping, gate, force_fadeout;
  50     int last_key;
  51
  52     float buffer[step_size], buffer2[step_size];
  53     uint32_t output_pos;
  54     dsp::onepole<float> phaseshifter;
  55     dsp::biquad_d1_lerp<float> filter;
  56     dsp::biquad_d1_lerp<float> filter2;
  57     int wave1, wave2, filter_type, last_filter_type;
  58     float freq, start_freq, target_freq, cutoff, decay_factor, fgain, fgain_delta, separation;
  59     float detune, xpose, xfade, ampctl, fltctl, queue_vel;
  60     float odcr, porta_time;
  61     int queue_note_on, stop_count;
  62     int legato;
  63     dsp::adsr envelope;
  64     dsp::keystack stack;
  65     dsp::gain_smoothing master;
  66     dsp::inertia<dsp::exponential_ramp> inertia_cutoff;
  67     dsp::inertia<dsp::exponential_ramp> inertia_pitchbend;
  68
  69     monosynth_audio_module();
  70     static void precalculate_waves(progress_report_iface *reporter);
  71     void set_sample_rate(uint32_t sr);
  72     void delayed_note_on();
  73     /// Handle MIDI Note On message (does not immediately trigger a note, as it must start on
  74     /// boundary of step_size samples).
  75     void note_on(int note, int vel);
  76     /// Handle MIDI Note Off message
  77     void note_off(int note, int vel);
  78     /// Handle pitch bend message.
  79     inline void pitch_bend(int value)
  80     {
  81         inertia_pitchbend.set_inertia(pow(2.0, (value * *params[par_pwhlrange]) / (1200.0 * 8192.0)));
  82     }
  83     /// Update oscillator frequency based on base frequency, detune amount, pitch bend scaling factor and sample rate.
  84     inline void set_frequency()
  85     {
  86         osc1.set_freq(freq * (2 - detune) * inertia_pitchbend.get_last(), srate);
  87         osc2.set_freq(freq * (detune)  * inertia_pitchbend.get_last() * xpose, srate);
  88     }
  89     /// Handle control change messages.
  90     void control_change(int controller, int value);
  91     /// Update variables from control ports.
  92     void params_changed() {
  93         float sf = 0.001f;
  94         envelope.set(*params[par_attack] * sf, *params[par_decay] * sf, std::min(0.999f, *params[par_sustain]), *params[par_release] * sf, srate / step_size);
  95         filter_type = dsp::fastf2i_drm(*params[par_filtertype]);
  96         decay_factor = odcr * 1000.0 / *params[par_decay];
  97         separation = pow(2.0, *params[par_cutoffsep] / 1200.0);
  98         wave1 = dsp::clip(dsp::fastf2i_drm(*params[par_wave1]), 0, (int)wave_count - 1);
  99         wave2 = dsp::clip(dsp::fastf2i_drm(*params[par_wave2]), 0, (int)wave_count - 1);
 100         detune = pow(2.0, *params[par_detune] / 1200.0);
 101         xpose = pow(2.0, *params[par_osc2xpose] / 12.0);
 102         xfade = *params[par_oscmix];
 103         legato = dsp::fastf2i_drm(*params[par_legato]);
 104         master.set_inertia(*params[par_master]);
 105         set_frequency();
 106     }
 107     void activate();
 108     void deactivate();
 109     void post_instantiate()
 110     {
 111         precalculate_waves(progress_report);
 112     }
 113     /// Run oscillators and two filters in series to produce mono output samples.
 114     void calculate_buffer_ser();
 115     /// Run oscillators and just one filter to produce mono output samples.
 116     void calculate_buffer_single();
 117     /// Run oscillators and two filters (one per channel) to produce stereo output samples.
 118     void calculate_buffer_stereo();
 119     /// Retrieve filter graph (which is 'live' so it cannot be generated by get_static_graph), or fall back to get_static_graph.
 120     bool get_graph(int index, int subindex, float *data, int points, cairo_iface *context);
 121     /// Retrieve waveform graph (which does not need information about synth state)
 122     bool get_static_graph(int index, int subindex, float value, float *data, int points, cairo_iface *context);
 123     /// @retval true if the filter 1 is to be used for the left channel and filter 2 for the right channel
 124     /// @retval false if filters are to be connected in series and sent (mono) to both channels
 125     inline bool is_stereo_filter() const
 126     {
 127         return filter_type == flt_2lp12 || filter_type == flt_2bp6;
 128     }
 129     /// No CV inputs for now
 130     bool is_cv(int param_no) { return false; }
 131     /// Practically all the stuff here is noisy
 132     bool is_noisy(int param_no) { return true; }
 133     /// Calculate control signals and produce step_size samples of output.
 134     void calculate_step();
 135     /// Main processing function
 136     uint32_t process(uint32_t offset, uint32_t nsamples, uint32_t inputs_mask, uint32_t outputs_mask) {
 137         if (!running && queue_note_on == -1)
 138             return 0;
 139         uint32_t op = offset;
 140         uint32_t op_end = offset + nsamples;
 141         while(op < op_end) {
 142             if (output_pos == 0) {
 143                 if (running || queue_note_on != -1)
 144                     calculate_step();
 145                 else
 146                     dsp::zero(buffer, step_size);
 147             }
 148             if(op < op_end) {
 149                 uint32_t ip = output_pos;
 150                 uint32_t len = std::min(step_size - output_pos, op_end - op);
 151                 if (is_stereo_filter())
 152                     for(uint32_t i = 0 ; i < len; i++) {
 153                         float vol = master.get();
 154                         outs[0][op + i] = buffer[ip + i] * vol,
 155                         outs[1][op + i] = buffer2[ip + i] * vol;
 156                     }
 157                 else
 158                     for(uint32_t i = 0 ; i < len; i++)
 159                         outs[0][op + i] = outs[1][op + i] = buffer[ip + i] * master.get();
 160                 op += len;
 161                 output_pos += len;
 162                 if (output_pos == step_size)
 163                     output_pos = 0;
 164             }
 165         }
 166
 167         return 3;
 168     }
 169 };
 170
 171 struct organ_audio_module: public audio_module<organ_metadata>, public dsp::drawbar_organ, public line_graph_iface
 172 {
 173 public:
 174     using drawbar_organ::note_on;
 175     using drawbar_organ::note_off;
 176     using drawbar_organ::control_change;
 177     enum { param_count = drawbar_organ::param_count};
 178     float *ins[in_count];
 179     float *outs[out_count];
 180     float *params[param_count];
 181     dsp::organ_parameters par_values;
 182     uint32_t srate;
 183     bool panic_flag;
 184     /// Value for configure variable map_curve
 185     std::string var_map_curve;
 186
 187     organ_audio_module()
 188     : drawbar_organ(&par_values)
 189     {
 190         var_map_curve = "2\n0 1\n1 1\n"; // XXXKF hacky bugfix
 191     }
 192
 193     void post_instantiate()
 194     {
 195         dsp::organ_voice_base::precalculate_waves(progress_report);
 196     }
 197
 198     void set_sample_rate(uint32_t sr) {
 199         srate = sr;
 200     }
 201     void params_changed() {
 202         for (int i = 0; i < param_count - var_count; i++)
 203             ((float *)&par_values)[i] = *params[i];
 204
 205         unsigned int old_poly = polyphony_limit;
 206         polyphony_limit = dsp::clip(dsp::fastf2i_drm(*params[par_polyphony]), 1, 32);
 207         if (polyphony_limit < old_poly)
 208             trim_voices();
 209
 210         update_params();
 211     }
 212     inline void pitch_bend(int amt)
 213     {
 214         drawbar_organ::pitch_bend(amt);
 215     }
 216     void activate() {
 217         setup(srate);
 218         panic_flag = false;
 219     }
 220     void deactivate();
 221     uint32_t process(uint32_t offset, uint32_t nsamples, uint32_t inputs_mask, uint32_t outputs_mask) {
 222         float *o[2] = { outs[0] + offset, outs[1] + offset };
 223         if (panic_flag)
 224         {
 225             control_change(120, 0); // stop all sounds
 226             control_change(121, 0); // reset all controllers
 227             panic_flag = false;
 228         }
 229         render_separate(o, nsamples);
 230         return 3;
 231     }
 232     /// No CV inputs for now
 233     bool is_cv(int param_no) { return false; }
 234     /// Practically all the stuff here is noisy
 235     bool is_noisy(int param_no) { return true; }
 236     void execute(int cmd_no);
 237     bool get_graph(int index, int subindex, float *data, int points, cairo_iface *context);
 238
 239     char *configure(const char *key, const char *value);
 240     void send_configures(send_configure_iface *);
 241     uint32_t message_run(const void *valid_inputs, void *output_ports) {
 242         // silence a default printf (which is kind of a warning about unhandled message_run)
 243         return 0;
 244     }
 245 };
 246
 247 };
 248
 249 #endif