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<float> filter;
  56     dsp::biquad_d1<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, pitchbend, 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
  67     static void generate_waves();
  68     void set_sample_rate(uint32_t sr);
  69     void delayed_note_on();
  70     /// Handle MIDI Note On message (does not immediately trigger a note, as it must start on
  71     /// boundary of step_size samples).
  72     void note_on(int note, int vel);
  73     /// Handle MIDI Note Off message
  74     void note_off(int note, int vel);
  75     /// Handle pitch bend message.
  76     inline void pitch_bend(int value)
  77     {
  78         pitchbend = pow(2.0, value / 8192.0);
  79     }
  80     /// Update oscillator frequency based on base frequency, detune amount, pitch bend scaling factor and sample rate.
  81     inline void set_frequency()
  82     {
  83         osc1.set_freq(freq * (2 - detune) * pitchbend, srate);
  84         osc2.set_freq(freq * (detune)  * pitchbend * xpose, srate);
  85     }
  86     /// Handle control change messages.
  87     void control_change(int controller, int value);
  88     /// Update variables from control ports.
  89     void params_changed() {
  90         float sf = 0.001f;
  91         envelope.set(*params[par_attack] * sf, *params[par_decay] * sf, std::min(0.999f, *params[par_sustain]), *params[par_release] * sf, srate / step_size);
  92         filter_type = dsp::fastf2i_drm(*params[par_filtertype]);
  93         decay_factor = odcr * 1000.0 / *params[par_decay];
  94         separation = pow(2.0, *params[par_cutoffsep] / 1200.0);
  95         wave1 = dsp::clip(dsp::fastf2i_drm(*params[par_wave1]), 0, (int)wave_count - 1);
  96         wave2 = dsp::clip(dsp::fastf2i_drm(*params[par_wave2]), 0, (int)wave_count - 1);
  97         detune = pow(2.0, *params[par_detune] / 1200.0);
  98         xpose = pow(2.0, *params[par_osc2xpose] / 12.0);
  99         xfade = *params[par_oscmix];
 100         legato = dsp::fastf2i_drm(*params[par_legato]);
 101         master.set_inertia(*params[par_master]);
 102         set_frequency();
 103     }
 104     void activate();
 105     void deactivate();
 106     /// Run oscillators and two filters in series to produce mono output samples.
 107     void calculate_buffer_ser();
 108     /// Run oscillators and just one filter to produce mono output samples.
 109     void calculate_buffer_single();
 110     /// Run oscillators and two filters (one per channel) to produce stereo output samples.
 111     void calculate_buffer_stereo();
 112     /// Retrieve filter graph (which is 'live' so it cannot be generated by get_static_graph), or fall back to get_static_graph.
 113     bool get_graph(int index, int subindex, float *data, int points, cairo_iface *context);
 114     /// Retrieve waveform graph (which does not need information about synth state)
 115     bool get_static_graph(int index, int subindex, float value, float *data, int points, cairo_iface *context);
 116     /// @retval true if the filter 1 is to be used for the left channel and filter 2 for the right channel
 117     /// @retval false if filters are to be connected in series and sent (mono) to both channels
 118     inline bool is_stereo_filter() const
 119     {
 120         return filter_type == flt_2lp12 || filter_type == flt_2bp6;
 121     }
 122     /// No CV inputs for now
 123     bool is_cv(int param_no) { return false; }
 124     /// Practically all the stuff here is noisy
 125     bool is_noisy(int param_no) { return true; }
 126     /// Calculate control signals and produce step_size samples of output.
 127     void calculate_step();
 128     /// Main processing function
 129     uint32_t process(uint32_t offset, uint32_t nsamples, uint32_t inputs_mask, uint32_t outputs_mask) {
 130         if (!running && queue_note_on == -1)
 131             return 0;
 132         uint32_t op = offset;
 133         uint32_t op_end = offset + nsamples;
 134         while(op < op_end) {
 135             if (output_pos == 0) {
 136                 if (running || queue_note_on != -1)
 137                     calculate_step();
 138                 else
 139                     dsp::zero(buffer, step_size);
 140             }
 141             if(op < op_end) {
 142                 uint32_t ip = output_pos;
 143                 uint32_t len = std::min(step_size - output_pos, op_end - op);
 144                 if (is_stereo_filter())
 145                     for(uint32_t i = 0 ; i < len; i++) {
 146                         float vol = master.get();
 147                         outs[0][op + i] = buffer[ip + i] * vol,
 148                         outs[1][op + i] = buffer2[ip + i] * vol;
 149                     }
 150                 else
 151                     for(uint32_t i = 0 ; i < len; i++)
 152                         outs[0][op + i] = outs[1][op + i] = buffer[ip + i] * master.get();
 153                 op += len;
 154                 output_pos += len;
 155                 if (output_pos == step_size)
 156                     output_pos = 0;
 157             }
 158         }
 159
 160         return 3;
 161     }
 162 };
 163
 164 struct organ_audio_module: public audio_module<organ_metadata>, public dsp::drawbar_organ, public line_graph_iface
 165 {
 166 public:
 167     using drawbar_organ::note_on;
 168     using drawbar_organ::note_off;
 169     using drawbar_organ::control_change;
 170     enum { param_count = drawbar_organ::param_count};
 171     float *ins[in_count];
 172     float *outs[out_count];
 173     float *params[param_count];
 174     dsp::organ_parameters par_values;
 175     uint32_t srate;
 176     bool panic_flag;
 177     /// Value for configure variable map_curve
 178     std::string var_map_curve;
 179
 180     organ_audio_module()
 181     : drawbar_organ(&par_values)
 182     {
 183         var_map_curve = "2\n0 1\n1 1\n"; // XXXKF hacky bugfix
 184     }
 185
 186     void post_instantiate()
 187     {
 188         dsp::organ_voice_base::precalculate_waves(progress_report);
 189     }
 190
 191     void set_sample_rate(uint32_t sr) {
 192         srate = sr;
 193     }
 194     void params_changed() {
 195         for (int i = 0; i < param_count - var_count; i++)
 196             ((float *)&par_values)[i] = *params[i];
 197
 198         unsigned int old_poly = polyphony_limit;
 199         polyphony_limit = dsp::clip(dsp::fastf2i_drm(*params[par_polyphony]), 1, 32);
 200         if (polyphony_limit < old_poly)
 201             trim_voices();
 202
 203         update_params();
 204     }
 205     inline void pitch_bend(int amt)
 206     {
 207         drawbar_organ::pitch_bend(amt);
 208     }
 209     void activate() {
 210         setup(srate);
 211         panic_flag = false;
 212     }
 213     void deactivate();
 214     uint32_t process(uint32_t offset, uint32_t nsamples, uint32_t inputs_mask, uint32_t outputs_mask) {
 215         float *o[2] = { outs[0] + offset, outs[1] + offset };
 216         if (panic_flag)
 217         {
 218             control_change(120, 0); // stop all sounds
 219             control_change(121, 0); // reset all controllers
 220             panic_flag = false;
 221         }
 222         render_separate(o, nsamples);
 223         return 3;
 224     }
 225     /// No CV inputs for now
 226     bool is_cv(int param_no) { return false; }
 227     /// Practically all the stuff here is noisy
 228     bool is_noisy(int param_no) { return true; }
 229     void execute(int cmd_no);
 230     bool get_graph(int index, int subindex, float *data, int points, cairo_iface *context);
 231
 232     char *configure(const char *key, const char *value);
 233     void send_configures(send_configure_iface *);
 234     uint32_t message_run(const void *valid_inputs, void *output_ports) {
 235         // silence a default printf (which is kind of a warning about unhandled message_run)
 236         return 0;
 237     }
 238 };
 239
 240 };
 241
 242 #endif