From d145fa6f792d6c44da2feec90507adb94e40323e Mon Sep 17 00:00:00 2001 From: Hans-Christoph Steiner Date: Sun, 31 Jul 2011 03:59:16 +0000 Subject: got everything building using the template Makefile svn path=/trunk/externals/unauthorized/; revision=15173 --- disto~.c | 490 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 490 insertions(+) create mode 100644 disto~.c (limited to 'disto~.c') diff --git a/disto~.c b/disto~.c new file mode 100644 index 0000000..66865db --- /dev/null +++ b/disto~.c @@ -0,0 +1,490 @@ +/* Copyleft (c) 2002 Yves Degoyon. */ +/* Copyright (c) 2001 Alexei Smoli */ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL */ +/* WARRANTIES, see the file, "COPYING" in this distribution. */ +/* */ +/* disto~ -- a kind of effect used in pop music */ +/* the algorithm was taken from Digital Effects (DISTORT3), */ +/* a guitar effects software for DOS which rocks, written by Alexey Smoli */ +/* ( http://st.karelia.ru/~smlalx/ ) */ +/* */ +/* This program is free software; you can redistribute it and/or */ +/* modify it under the terms of the GNU General Public License */ +/* as published by the Free Software Foundation; either version 2 */ +/* of the License, or (at your option) any later version. */ +/* */ +/* See file LICENSE for further informations on licensing terms. */ +/* */ +/* This program is distributed in the hope that it will be useful, */ +/* but WITHOUT ANY WARRANTY; without even the implied warranty of */ +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ +/* GNU General Public License for more details. */ +/* */ +/* You should have received a copy of the GNU General Public License */ +/* along with this program; if not, write to the Free Software */ +/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +/* */ +/* Based on PureData by Miller Puckette and others. */ +/* */ +/* Made while listening to : */ +/* */ +/* Bruce Gilbert -- Ab Ovo */ +/* Poison Girls -- Promenade Immortelle */ +/* */ +/* Special message for the french : */ +/* "Delay all your work...and go vote against national front" */ +/* ---------------------------------------------------------------------------- */ + +#include "m_pd.h" +#include +#include + +#ifdef NT +#define M_PI 3.14159265358979323846 +#endif + +#define BFSZ 4096 /* main delay buffer */ +#define BLOCK_DELAY 10 /* number of blocks to delay */ +#define NA 0.0 /* param not applicable */ +#define NBEXPS 129 + +static char *disto_version = "disto~: distortion, version 0.1 (ydegoyon@free.fr)"; + +struct hipass { + /* few intermediate variables */ + double omega; + double sn,cs; + double alpha; + /* filter coefficients */ + double a0,a1,a2,b0,b1,b2; + double k0,k1,k2,k3,k4; + /* amplitudes */ + double x0,x1,x2; + double y0,y1,y2; +} hipass; + +struct lowpass { + /* few intermediate variables */ + double omega; + double sn,cs; + double alpha; + /* filter coefficients */ + double a0,a1,a2,b0,b1,b2; + double k0,k1,k2,k3,k4; + /* amplitudes */ + double x0,x1,x2; + double y0,y1,y2; +} lowpass; + +typedef struct _disto +{ + t_object x_obj; + double *x_buf; + t_int x_samplerate; + double x_drive; /* distortion drive */ /* 0<= <=25 */ + double x_drymix; /* dry (unaffected) signal mix */ /* -5<= <=5 */ + double x_wetmix; /* wet (affected) signal mix */ /* -5<= <=5 */ + double x_feedback; /* feedback */ /* -10<= <=10 */ + double x_volume; /* distortion volume */ /* 0=< <=5 */ + double x_hipassfreq; /* cutoff frequency for hi pass filter */ /* 0< exps[i]=exp((double)i*x->x_drive)*x->x_wetmix; + } + + x->HPF.omega = 2.0*M_PI*x->x_hipassfreq/(double)x->x_samplerate; + x->HPF.sn = sin(x->HPF.omega); + x->HPF.cs = cos(x->HPF.omega); + x->HPF.alpha = x->HPF.sn/(2.0*x->x_hipassQ); + x->HPF.b0 = (1.0 + x->HPF.cs)/2.0; + x->HPF.b1 = -(1.0 + x->HPF.cs) ; + x->HPF.b2 = (1.0 + x->HPF.cs)/2.0; + x->HPF.a0 = 1.0 + x->HPF.alpha ; + x->HPF.a1 = -2.0*x->HPF.cs ; + x->HPF.a2 = 1.0 - x->HPF.alpha ; + x->HPF.k0 = (x->HPF.b0/x->HPF.a0); + x->HPF.k1 = (x->HPF.b1/x->HPF.a0); + x->HPF.k2 = (x->HPF.b2/x->HPF.a0); + x->HPF.k3 = (x->HPF.a1/x->HPF.a0); + x->HPF.k4 = (x->HPF.a2/x->HPF.a0); + + x->LPF.omega = 2.0*M_PI*x->x_lowpassfreq/(double)x->x_samplerate; + x->LPF.sn = sin(x->LPF.omega); + x->LPF.cs = cos(x->LPF.omega); + x->LPF.alpha = x->LPF.sn/(2.0*x->x_lowpassQ); + x->LPF.b0 = (1.0 - x->LPF.cs)/2.0; + x->LPF.b1 = 1.0 - x->LPF.cs ; + x->LPF.b2 = (1.0 - x->LPF.cs)/2.0; + x->LPF.a0 = 1.0 + x->LPF.alpha ; + x->LPF.a1 = -2.0*x->LPF.cs ; + x->LPF.a2 = 1.0 - x->LPF.alpha ; + x->LPF.k0 = (x->LPF.b0/x->LPF.a0); + x->LPF.k1 = (x->LPF.b1/x->LPF.a0); + x->LPF.k2 = (x->LPF.b2/x->LPF.a0); + x->LPF.k3 = (x->LPF.a1/x->LPF.a0); + x->LPF.k4 = (x->LPF.a2/x->LPF.a0); +} + +static void disto_drive(t_disto *x, t_floatarg fdrive ) +{ + if ( fdrive > 25.0 ) + { + fdrive = 25.0; + } + if ( fdrive < 0.0 ) + { + fdrive = 0.0; + } + x->x_drive = fdrive; + // post( "disto~ : drive: %f", x->x_drive ); + disto_init_filters( x ); +} + +static void disto_drymix(t_disto *x, t_floatarg fdrymix ) +{ + if ( fdrymix > 5.0 ) + { + fdrymix = 5.0; + } + if ( fdrymix < -5.0 ) + { + fdrymix = -5.0; + } + x->x_drymix = fdrymix; + // post( "disto~ : drymix: %f", x->x_drymix ); + disto_init_filters( x ); +} + +static void disto_wetmix(t_disto *x, t_floatarg fwetmix ) +{ + if ( fwetmix > 5.0 ) + { + fwetmix = 5.0; + } + if ( fwetmix < -5.0 ) + { + fwetmix = -5.0; + } + x->x_wetmix = fwetmix; + // post( "disto~ : wetmix: %f", x->x_wetmix ); + disto_init_filters( x ); +} + +static void disto_feedback(t_disto *x, t_floatarg ffeedback ) +{ + if ( ffeedback > 10.0 ) + { + ffeedback = 10.0; + } + if ( ffeedback < -10.0 ) + { + ffeedback = -10.0; + } + x->x_feedback = ffeedback; + // post( "disto~ : feedback: %f", x->x_feedback ); + disto_init_filters( x ); +} + +static void disto_volume(t_disto *x, t_floatarg fvolume ) +{ + if ( fvolume > 5.0 ) + { + fvolume = 5.0; + } + if ( fvolume < 0.0 ) + { + fvolume = 0.0; + } + x->x_volume = fvolume; + // post( "disto~ : volume: %f", x->x_volume ); + disto_init_filters( x ); +} + +static void disto_hipassfreq(t_disto *x, t_floatarg fhipassfreq ) +{ + if ( fhipassfreq > x->x_samplerate/2 ) + { + fhipassfreq = x->x_samplerate/2; + } + if ( fhipassfreq < 0.0 ) + { + fhipassfreq = 0.0; + } + x->x_hipassfreq = fhipassfreq; + // post( "disto~ : hipassfreq: %f", x->x_hipassfreq ); + disto_init_filters( x ); +} + +static void disto_hipassQ(t_disto *x, t_floatarg fhipassQ ) +{ + if ( fhipassQ > 1.0 ) + { + fhipassQ = 1.0; + } + if ( fhipassQ < 0.1 ) + { + fhipassQ = 0.1; + } + x->x_hipassQ = fhipassQ; + // post( "disto~ : hipassQ: %f", x->x_hipassQ ); + disto_init_filters( x ); +} + +static void disto_lowpassfreq(t_disto *x, t_floatarg flowpassfreq ) +{ + if ( flowpassfreq > x->x_samplerate/2 ) + { + flowpassfreq = x->x_samplerate/2; + } + if ( flowpassfreq < 0.0 ) + { + flowpassfreq = 0.0; + } + x->x_lowpassfreq = flowpassfreq; + // post( "disto~ : lowpassfreq: %f", x->x_lowpassfreq ); + disto_init_filters( x ); +} + +static void disto_lowpassQ(t_disto *x, t_floatarg flowpassQ ) +{ + if ( flowpassQ > 1.0 ) + { + flowpassQ = 1.0; + } + if ( flowpassQ < 0.1 ) + { + flowpassQ = 0.1; + } + x->x_lowpassQ = flowpassQ; + // post( "disto~ : lowpassQ: %f", x->x_lowpassQ ); + disto_init_filters( x ); +} + +static t_int *disto_perform(t_int *w) +{ + t_float *in = (t_float *)(w[1]); + t_float *out = (t_float *)(w[2]); + t_int n = (int)(w[3]); + t_disto *x = (t_disto*)(w[4]); + t_int i; + + for (i = 0; i < n; i++) + { + + x->HPF.x0 = *(in++); + x->HPF.y0 = (x->HPF.k0*x->HPF.x0+x->HPF.k1*x->HPF.x1+x->HPF.k2*x->HPF.x2-x->HPF.k3*x->HPF.y1-x->HPF.k4*x->HPF.y2); + x->HPF.y2 = x->HPF.y1; + x->HPF.y1 = x->HPF.y0; + x->HPF.x2 = x->HPF.x1; + x->HPF.x1 = x->HPF.x0; + x->data = (int)x->HPF.y0; + + if ((x->data-x->pred)>0) + x->outval += (x->data*x->x_drymix+ x->exps[abs(x->data)]); + else + if ((x->data-x->pred)<0) + x->outval += (x->data*x->x_drymix- x->exps[abs(x->data)]); + x->pred = x->data; + + x->LPF.x0 = *(out); + x->LPF.y0 = (x->LPF.k0*x->LPF.x0+x->LPF.k1*x->LPF.x1+x->LPF.k2*x->LPF.x2-x->LPF.k3*x->LPF.y1-x->LPF.k4*x->LPF.y2); + x->LPF.y2 = x->LPF.y1; + x->LPF.y1 = x->LPF.y0; + x->LPF.x2 = x->LPF.x1; + x->LPF.x1 = x->LPF.x0; + + x->outvol = x->LPF.y0*x->x_volume; + + if(x->outvol > 1.0) + x->data = 1.0; + else if(x->outvol < -1.0) + x->data = -1.0; + else + x->data = x->outvol; + + *(out++) = x->data; + + x->outval *= x->x_feedback; + + } + + return (w+5); +} + +static void disto_preset(t_disto *x, t_float pnumber) +{ + switch ( (int)pnumber ) + { + /* "Hard Distortion 100-10000Hz" */ + case 1: + x->x_drive = 1.5; + x->x_drymix = 1.0; + x->x_wetmix = 0.5; + x->x_feedback = 0.0; + x->x_volume = 1.0; + x->x_hipassfreq = 100.0; + x->x_hipassQ = 0.5; + x->x_lowpassfreq = 10000.0; + x->x_lowpassQ = 0.5; + break; + + /* "Hard Distortion 100-6000Hz" */ + case 2: + x->x_drive = 1.5; + x->x_drymix = 1.0; + x->x_wetmix = 0.5; + x->x_feedback = 0.0; + x->x_volume = 1.0; + x->x_hipassfreq = 100.0; + x->x_hipassQ = 0.5; + x->x_lowpassfreq = 2000.0; + x->x_lowpassQ = 0.5; + break; + + /* "Very Hard Distortion" */ + case 3: + x->x_drive = 2.0; + x->x_drymix = 0.0; + x->x_wetmix = 1.0; + x->x_feedback = 1.0; + x->x_volume = 5.0; + x->x_hipassfreq = 100.0; + x->x_hipassQ = 0.5; + x->x_lowpassfreq = 6000.0; + x->x_lowpassQ = 0.5; + break; + + /* "Medium Distortion 0.2" */ + case 4: + x->x_drive = 0.2; + x->x_drymix = 1.0; + x->x_wetmix = 1.0; + x->x_feedback = 0.1; + x->x_volume = 1.0; + x->x_hipassfreq = 100.0; + x->x_hipassQ = 0.5; + x->x_lowpassfreq = 6000.0; + x->x_lowpassQ = 0.5; + break; + + /* "Medium Distortion 0.8" */ + case 5: + x->x_drive = 0.8; + x->x_drymix = 1.0; + x->x_wetmix = 1.0; + x->x_feedback = 0.1; + x->x_volume = 1.0; + x->x_hipassfreq = 100.0; + x->x_hipassQ = 1.0; + x->x_lowpassfreq = 6000.0; + x->x_lowpassQ = 0.5; + break; + + /* "Soft Distortion 0.8" */ + case 6: + x->x_drive = 0.8; + x->x_drymix = 0.4; + x->x_wetmix = 0.8; + x->x_feedback = 0.0; + x->x_volume = 0.5; + x->x_hipassfreq = 100.0; + x->x_hipassQ = 1.0; + x->x_lowpassfreq = 10000.0; + x->x_lowpassQ = 0.5; + break; + + default: + post( "disto~ : unknown preset requested : %d", pnumber ); + return; + break; + } + disto_init_filters( x ); +} + +static void disto_dsp(t_disto *x, t_signal **sp) +{ + dsp_add(disto_perform, 4, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n, x ); +} + + /* clean up */ +static void disto_free(t_disto *x) +{ + if ( x->x_buf != NULL ) { + freebytes(x->x_buf, BFSZ*sizeof( double ) ); + post( "Freed %d bytes", BFSZ*sizeof( double ) ); + x->x_buf = NULL; + } +} + +static void *disto_new(void) +{ + t_disto *x = (t_disto *)pd_new(disto_class); + outlet_new(&x->x_obj, &s_signal); + inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("drive")); + inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("drymix")); + inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("wetmix")); + inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("feedback")); + inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("volume")); + inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("hipassfreq")); + inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("hipassQ")); + inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("lowpassfreq")); + inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("lowpassQ")); + + x->x_samplerate = (int)sys_getsr(); + x->pred = 0.0; + x->data = 0.0; + + if ( !( x->x_buf = ( double* ) getbytes( BFSZ*sizeof( double ) ) ) ) + { + post ("disto~ : could not allocate buffer" ); + return NULL; + } + + // set default parameters + disto_preset( x, 3 ); + disto_init_filters( x ); + + return (x); +} + +void disto_tilde_setup(void) +{ + post( disto_version ); + disto_class = class_new(gensym("disto~"), (t_newmethod)disto_new, (t_method)disto_free, + sizeof(t_disto), 0, 0); + + CLASS_MAINSIGNALIN( disto_class, t_disto, x_f ); + class_addmethod(disto_class, (t_method)disto_drive, gensym("drive"), A_FLOAT, 0); + class_addmethod(disto_class, (t_method)disto_drymix, gensym("drymix"), A_FLOAT, 0); + class_addmethod(disto_class, (t_method)disto_wetmix, gensym("wetmix"), A_FLOAT, 0); + class_addmethod(disto_class, (t_method)disto_feedback, gensym("feedback"), A_FLOAT, 0); + class_addmethod(disto_class, (t_method)disto_volume, gensym("volume"), A_FLOAT, 0); + class_addmethod(disto_class, (t_method)disto_hipassfreq, gensym("hipassfreq"), A_FLOAT, 0); + class_addmethod(disto_class, (t_method)disto_hipassQ, gensym("hipassQ"), A_FLOAT, 0); + class_addmethod(disto_class, (t_method)disto_lowpassfreq, gensym("lowpassfreq"), A_FLOAT, 0); + class_addmethod(disto_class, (t_method)disto_lowpassQ, gensym("lowpassQ"), A_FLOAT, 0); + class_addmethod(disto_class, (t_method)disto_dsp, gensym("dsp"), 0); + class_addmethod(disto_class, (t_method)disto_preset, gensym("preset"), A_FLOAT, 0); +} -- cgit v1.2.1