plugins/libvcf.c

   1 /* gAlan - Graphical Audio Language
   2  * Copyright (C) 1999 Tony Garnock-Jones
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <stdio.h>
  22 #include <stddef.h>
  23
  24 #include <gdk/gdk.h>
  25 #include <gtk/gtk.h>
  26
  27 #include "global.h"
  28 #include "generator.h"
  29 #include "comp.h"
  30 #include "control.h"
  31 #include "gencomp.h"
  32
  33 #define GENERATOR_CLASS_NAME    "303vcf"
  34 #define GENERATOR_CLASS_PATH    "Filter/2-pole Low-pass resonant"
  35
  36 #define SIG_INPUT               0
  37 #define SIG_OUTPUT              0
  38
  39 #define EVT_Q                   0
  40 #define EVT_CUTOFF              1
  41 #define NUM_EVENT_INPUTS        2
  42
  43 #define NUM_EVENT_OUTPUTS       0
  44
  45 #define VCF_CONTROL_Q           0
  46 #define VCF_CONTROL_CUTOFF      1
  47
  48 typedef struct Data {
  49   gdouble q;
  50   gdouble cutoff;
  51
  52   gdouble a, b, c;
  53   gdouble d1, d2;
  54   gdouble d3, d4;
  55 } Data;
  56
  57 PRIVATE void calc_coeffs(Generator *g) {
  58   Data *data = g->data;
  59   gdouble cutoff_ratio = data->cutoff / SAMPLE_RATE;
  60   gdouble tmp;
  61
  62   tmp = -M_PI * cutoff_ratio / data->q;
  63
  64   data->a = 2 * cos(2 * M_PI * cutoff_ratio) * exp(tmp);
  65   data->b = -exp(2 * tmp);
  66   data->c = 1 - data->a - data->b;
  67 }
  68
  69 PRIVATE int init_instance(Generator *g) {
  70   Data *data = safe_malloc(sizeof(Data));
  71   g->data = data;
  72
  73   data->q = 0.05;
  74   data->cutoff = 200;
  75
  76   data->a = data->b = data->c = 0;
  77   data->d1 = data->d2 = 0;
  78   data->d3 = data->d4 = 0;
  79
  80   calc_coeffs(g);
  81
  82   return 1;
  83 }
  84
  85 PRIVATE void destroy_instance(Generator *g) {
  86   free(g->data);
  87 }
  88
  89 PRIVATE void unpickle_instance(Generator *g, ObjectStoreItem *item, ObjectStore *db) {
  90   Data *data = safe_malloc(sizeof(Data));
  91   g->data = data;
  92
  93   data->q = objectstore_item_get_double(item, "vcf_q", 0.05);
  94   data->cutoff = objectstore_item_get_double(item, "vcf_cutoff", 200);
  95
  96   data->a = data->b = data->c = 0;
  97   data->d1 = data->d2 = 0;
  98   data->d3 = data->d4 = 0;
  99   calc_coeffs(g);
 100 }
 101
 102 PRIVATE void pickle_instance(Generator *g, ObjectStoreItem *item, ObjectStore *db) {
 103   Data *data = g->data;
 104   objectstore_item_set_double(item, "vcf_q", data->q);
 105   objectstore_item_set_double(item, "vcf_cutoff", data->cutoff);
 106 }
 107
 108 PRIVATE gboolean output_generator(Generator *g, SAMPLE *buf, int buflen) {
 109   Data *data = g->data;
 110   int i;
 111
 112   if (!gen_read_realtime_input(g, SIG_INPUT, -1, buf, buflen))
 113       memset(buf, 0, buflen * sizeof(SAMPLE));
 114
 115   for (i = 0; i < buflen; i++) {
 116     buf[i] = data->a * data->d1 + data->b * data->d2 + data->c * buf[i];
 117     data->d2 = data->d1;
 118     data->d1 = buf[i];
 119
 120     buf[i] = data->a * data->d3 + data->b * data->d4 + data->c * buf[i];
 121     data->d4 = data->d3;
 122     data->d3 = buf[i];
 123   }
 124   return TRUE;
 125 }
 126
 127 PRIVATE void evt_q_handler(Generator *g, AEvent *event) {
 128   Data *data = g->data;
 129   data->q = MAX(event->d.number, 0.00001);
 130   calc_coeffs(g);
 131   gen_update_controls(g, VCF_CONTROL_Q);
 132 }
 133
 134 PRIVATE void evt_cutoff_handler(Generator *g, AEvent *event) {
 135   Data *data = g->data;
 136   data->cutoff = MAX(event->d.number, 0.00001);
 137   calc_coeffs(g);
 138   gen_update_controls(g, VCF_CONTROL_CUTOFF);
 139 }
 140
 141 PRIVATE InputSignalDescriptor input_sigs[] = {
 142   { "Input", SIG_FLAG_REALTIME },
 143   { NULL, }
 144 };
 145
 146 PRIVATE OutputSignalDescriptor output_sigs[] = {
 147   { "Output", SIG_FLAG_REALTIME, { output_generator, } },
 148   { NULL, }
 149 };
 150
 151 PRIVATE ControlDescriptor controls[] = {
 152   /* { kind, name, min,max,step,page, size,editable, is_dst,queue_number,
 153        init,destroy,refresh,refresh_data }, */
 154   { CONTROL_KIND_KNOB, "reso", 0, 100, 0.5, 0.5, 0,TRUE, 1,EVT_Q,
 155     NULL,NULL, control_double_updater, (gpointer) offsetof(Data, q) },
 156   { CONTROL_KIND_KNOB, "cutoff", 1, 22050, 4, 1, 0,TRUE, 1,EVT_CUTOFF,
 157     NULL,NULL, control_double_updater, (gpointer) offsetof(Data, cutoff) },
 158   { CONTROL_KIND_NONE, },
 159 };
 160
 161 PRIVATE void setup_class(void) {
 162   GeneratorClass *k = gen_new_generatorclass(GENERATOR_CLASS_NAME, FALSE,
 163                                              NUM_EVENT_INPUTS, NUM_EVENT_OUTPUTS,
 164                                              input_sigs, output_sigs, controls,
 165                                              init_instance, destroy_instance,
 166                                              unpickle_instance, pickle_instance);
 167
 168   gen_configure_event_input(k, EVT_Q, "Resonance", evt_q_handler);
 169   gen_configure_event_input(k, EVT_CUTOFF, "Cutoff", evt_cutoff_handler);
 170
 171   gencomp_register_generatorclass(k, FALSE, GENERATOR_CLASS_PATH, NULL, NULL);
 172 }
 173
 174 PUBLIC void init_plugin(void) {
 175   setup_class();
 176 }