From 9340768f6c7dea7cb7fe348f6fdf52db75ce9d82 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?IOhannes=20m=20zm=C3=B6lnig?= Date: Tue, 23 Nov 2004 15:29:47 +0000 Subject: This commit was generated by cvs2svn to compensate for changes in r2300, which included commits to RCS files with non-trunk default branches. svn path=/trunk/externals/iem16/; revision=2301 --- src/iem16.c | 52 +++++ src/iem16.dsp | 99 ++++++++++ src/iem16.dsw | 29 +++ src/iem16.h | 42 ++++ src/iem16_array.c | 173 +++++++++++++++++ src/iem16_array_tilde.c | 502 ++++++++++++++++++++++++++++++++++++++++++++++++ src/iem16_delay.c | 285 +++++++++++++++++++++++++++ src/iem16_table.c | 141 ++++++++++++++ src/iem16_table.h | 27 +++ src/makefile | 79 ++++++++ 10 files changed, 1429 insertions(+) create mode 100644 src/iem16.c create mode 100755 src/iem16.dsp create mode 100755 src/iem16.dsw create mode 100644 src/iem16.h create mode 100644 src/iem16_array.c create mode 100644 src/iem16_array_tilde.c create mode 100755 src/iem16_delay.c create mode 100644 src/iem16_table.c create mode 100644 src/iem16_table.h create mode 100644 src/makefile (limited to 'src') diff --git a/src/iem16.c b/src/iem16.c new file mode 100644 index 0000000..d916ddc --- /dev/null +++ b/src/iem16.c @@ -0,0 +1,52 @@ +/* ...this is a very IEM16 external ... + it allows for 16bit-constructs where float would eat too much memory + + forum::für::umläute@IEM:2003 +*/ + +#include "iem16.h" + +/* do a little help thing */ + +typedef struct iem16 { + t_object t_ob; +} t_iem16; + +t_class *iem16_class; + +void *iem16_new(void){ + t_iem16 *x = (t_iem16 *)pd_new(iem16_class); + post("iem16: 16bit objects for low memory usage"); + return (void *)x; +} + +/* include some externals */ +void iem16_table_setup(); +void iem16_array_setup(); +void iem16_array_tilde_setup(); +void iem16_delay_setup(); + +void iem16_setup(void) { + iem16_table_setup(); + iem16_array_setup(); + iem16_array_tilde_setup(); + iem16_delay_setup(); + + /* ************************************** */ + post("iem16:\t16bit-objects for low memory usage"); + post("iem16:\t(l) forum::für::umläute\t\tIOhannes m zmölnig"); + post("iem16:\tInstitute of Electronic Music and Acoustics, Graz - iem"); + post("iem16:\tcompiled: "__DATE__); + + + iem16_class = class_new(gensym("iem16"), + iem16_new, + 0, + sizeof(t_iem16), CLASS_NOINLET, A_NULL); + class_addcreator((t_newmethod)iem16_new, + gensym("IEM16"), A_NULL); +} + +void IEM16_setup(void){ + iem16_setup(); +} diff --git a/src/iem16.dsp b/src/iem16.dsp new file mode 100755 index 0000000..1c2f7fc --- /dev/null +++ b/src/iem16.dsp @@ -0,0 +1,99 @@ +# Microsoft Developer Studio Project File - Name="iem16" - Package Owner=<4> +# Microsoft Developer Studio Generated Build File, Format Version 6.00 +# ** NICHT BEARBEITEN ** + +# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102 + +CFG=IEM16 - WIN32 RELEASE +!MESSAGE Dies ist kein gültiges Makefile. Zum Erstellen dieses Projekts mit NMAKE +!MESSAGE verwenden Sie den Befehl "Makefile exportieren" und führen Sie den Befehl +!MESSAGE +!MESSAGE NMAKE /f "iem16.mak". +!MESSAGE +!MESSAGE Sie können beim Ausführen von NMAKE eine Konfiguration angeben +!MESSAGE durch Definieren des Makros CFG in der Befehlszeile. Zum Beispiel: +!MESSAGE +!MESSAGE NMAKE /f "iem16.mak" CFG="IEM16 - WIN32 RELEASE" +!MESSAGE +!MESSAGE Für die Konfiguration stehen zur Auswahl: +!MESSAGE +!MESSAGE "iem16 - Win32 Release" (basierend auf "Win32 (x86) Dynamic-Link Library") +!MESSAGE + +# Begin Project +# PROP AllowPerConfigDependencies 1 +# PROP Scc_ProjName "" +# PROP Scc_LocalPath "" +CPP=cl.exe +MTL=midl.exe +RSC=rc.exe +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir "Release" +# PROP BASE Intermediate_Dir "Release" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir "" +# PROP Intermediate_Dir "obj\" +# PROP Ignore_Export_Lib 0 +# PROP Target_Dir "" +# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "IEM16_EXPORTS" /YX /FD /c +# ADD CPP /nologo /MT /W3 /GX /I "..\..\pd\src" /D "WIN32" /D "NT" /D "_WINDOWS" /D "IEM16" /FR /YX /FD /c +# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32 +# ADD MTL /nologo /win32 +# SUBTRACT MTL /mktyplib203 +# ADD BASE RSC /l 0xc07 /d "NDEBUG" +# ADD RSC /l 0xc07 +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 +# ADD LINK32 kernel32.lib wsock32.lib uuid.lib libc.lib oldnames.lib pd.lib /nologo /dll /machine:I386 /nodefaultlib /out:"..\iem16.dll" /libpath:"../../pd/bin" /export:iem16_setup +# SUBTRACT LINK32 /pdb:none +# Begin Target + +# Name "iem16 - Win32 Release" +# Begin Group "Quellcodedateien" + +# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" +# Begin Source File + +SOURCE=.\iem16.c +# End Source File +# Begin Source File + +SOURCE=.\iem16_array.c +# End Source File +# Begin Source File + +SOURCE=.\iem16_array_tilde.c +# End Source File +# Begin Source File + +SOURCE=.\iem16_delay.c +# End Source File +# Begin Source File + +SOURCE=.\iem16_table.c +# End Source File +# End Group +# Begin Group "Header-Dateien" + +# PROP Default_Filter "h;hpp;hxx;hm;inl" +# Begin Source File + +SOURCE=.\iem16.h +# End Source File +# Begin Source File + +SOURCE=.\iem16_table.h +# End Source File +# Begin Source File + +SOURCE=..\..\pd\src\m_pd.h +# End Source File +# End Group +# End Target +# End Project diff --git a/src/iem16.dsw b/src/iem16.dsw new file mode 100755 index 0000000..0e01cda --- /dev/null +++ b/src/iem16.dsw @@ -0,0 +1,29 @@ +Microsoft Developer Studio Workspace File, Format Version 6.00 +# WARNUNG: DIESE ARBEITSBEREICHSDATEI DARF NICHT BEARBEITET ODER GELÖSCHT WERDEN! + +############################################################################### + +Project: "iem16"=.\iem16.dsp - Package Owner=<4> + +Package=<5> +{{{ +}}} + +Package=<4> +{{{ +}}} + +############################################################################### + +Global: + +Package=<5> +{{{ +}}} + +Package=<3> +{{{ +}}} + +############################################################################### + diff --git a/src/iem16.h b/src/iem16.h new file mode 100644 index 0000000..f9649cd --- /dev/null +++ b/src/iem16.h @@ -0,0 +1,42 @@ +/* ********************************************** */ +/* the IEM16 external */ +/* ********************************************** */ +/* forum::für::umläute */ +/* ********************************************** */ + +/* the IEM16 external is a runtime-library for miller s. puckette's realtime-computermusic-software "pure data" + * therefore you NEED "pure data" to make any use of the IEM16 external + * (except if you want to use the code for other things) + * download "pure data" at + + http://pd.iem.at + ftp://iem.at/pd + + * + * if you are looking for the latest release of the IEM16-external you should have another look at + + ftp://iem.at/pd/Externals/IEM16 + + * + * IEM16 is published under the GNU GeneralPublicLicense, that must be shipped with IEM16. + * if you are using Debian GNU/linux, the GNU-GPL can be found under /usr/share/common-licenses/GPL + * if you still haven't found a copy of the GNU-GPL, have a look at http://www.gnu.org + * + * "pure data" has it's own license, that comes shipped with "pure data". + * + * there are ABSOLUTELY NO WARRANTIES for anything + */ + +#ifndef INCLUDE_IEM16_H__ +#define INCLUDE_IEM16_H__ + +#include "m_pd.h" + +typedef short t_iem16_16bit; + +#define IEM16_SCALE_UP (32767) +#define IEM16_SCALE_DOWN (1./32767) + +#define VERSION "0.1" + +#endif diff --git a/src/iem16_array.c b/src/iem16_array.c new file mode 100644 index 0000000..22ee35d --- /dev/null +++ b/src/iem16_array.c @@ -0,0 +1,173 @@ +/* copyleft (c) 2003 forum::für::umläute -- IOhannes m zmölnig @ IEM + * based on d_array.c from pd: + * Copyright (c) 1997-1999 Miller Puckette and others. + * For information on usage and redistribution, and for a DISCLAIMER OF ALL + * WARRANTIES, see the file, "LICENSE.txt," in this distribution. */ + +/* tab16read, tab16read4, tab16write */ + +#include "iem16_table.h" + +/* ---------- tab16read: control, non-interpolating ------------------------ */ + +static t_class *tab16read_class; + +typedef struct _tab16read{ + t_object x_obj; + t_symbol *x_arrayname; +} t_tab16read; + +static void tab16read_float(t_tab16read *x, t_float f){ + t_table16 *a; + int npoints; + t_iem16_16bit *vec; + + if (!(a = (t_table16 *)pd_findbyclass(x->x_arrayname, table16_class))) + error("%s: no such array", x->x_arrayname->s_name); + else if (!table16_getarray16(a, &npoints, &vec)) + error("%s: bad template for tab16read", x->x_arrayname->s_name); + else { + int n = f; + if (n < 0) n = 0; + else if (n >= npoints) n = npoints - 1; + outlet_float(x->x_obj.ob_outlet, (npoints ? vec[n] : 0)); + } +} + +static void tab16read_set(t_tab16read *x, t_symbol *s){ + x->x_arrayname = s; +} + +static void *tab16read_new(t_symbol *s){ + t_tab16read *x = (t_tab16read *)pd_new(tab16read_class); + x->x_arrayname = s; + outlet_new(&x->x_obj, &s_float); + return (x); +} + +static void tab16read_setup(void){ + tab16read_class = class_new(gensym("tab16read"), (t_newmethod)tab16read_new, + 0, sizeof(t_tab16read), 0, A_DEFSYM, 0); + class_addfloat(tab16read_class, (t_method)tab16read_float); + class_addmethod(tab16read_class, (t_method)tab16read_set, gensym("set"), + A_SYMBOL, 0); +} + +/* ---------- tab16read4: control, non-interpolating ------------------------ */ + +static t_class *tab16read4_class; + +typedef struct _tab16read4{ + t_object x_obj; + t_symbol *x_arrayname; +} t_tab16read4; + +static void tab16read4_float(t_tab16read4 *x, t_float f){ + t_table16 *a; + int npoints; + t_iem16_16bit *vec; + + if (!(a = (t_table16 *)pd_findbyclass(x->x_arrayname, table16_class))) + error("%s: no such array", x->x_arrayname->s_name); + else if (!table16_getarray16(a, &npoints, &vec)) + error("%s: bad template for tab16read4", x->x_arrayname->s_name); + else if (npoints < 4) + outlet_float(x->x_obj.ob_outlet, 0); + else if (f <= 1) + outlet_float(x->x_obj.ob_outlet, vec[1]); + else if (f >= npoints - 2) + outlet_float(x->x_obj.ob_outlet, vec[npoints - 2]); + else { + int n = f; + float a, b, c, d, cminusb, frac; + t_iem16_16bit *fp; + if (n >= npoints - 2) n = npoints - 3; + fp = vec + n; + frac = f - n; + a = fp[-1]; + b = fp[0]; + c = fp[1]; + d = fp[2]; + cminusb = c-b; + outlet_float(x->x_obj.ob_outlet, b + frac * ( + cminusb - 0.5f * (frac-1.) * ( + (a - d + 3.0f * cminusb) * frac + (b - a - cminusb)))); + } +} + +static void tab16read4_set(t_tab16read4 *x, t_symbol *s){ + x->x_arrayname = s; +} + +static void *tab16read4_new(t_symbol *s){ + t_tab16read4 *x = (t_tab16read4 *)pd_new(tab16read4_class); + x->x_arrayname = s; + outlet_new(&x->x_obj, &s_float); + return (x); +} + +static void tab16read4_setup(void){ + tab16read4_class = class_new(gensym("tab16read4"), (t_newmethod)tab16read4_new, + 0, sizeof(t_tab16read4), 0, A_DEFSYM, 0); + class_addfloat(tab16read4_class, (t_method)tab16read4_float); + class_addmethod(tab16read4_class, (t_method)tab16read4_set, gensym("set"), + A_SYMBOL, 0); +} + +/* ------------------ tab16write: control ------------------------ */ + +static t_class *tab16write_class; + +typedef struct _tab16write { + t_object x_obj; + t_symbol *x_arrayname; + float x_ft1; + int x_set; +} t_tab16write; + +static void tab16write_float(t_tab16write *x, t_float f) { + int vecsize; + t_table16 *a; + t_iem16_16bit *vec; + + if (!(a = (t_table16 *)pd_findbyclass(x->x_arrayname, table16_class))) + error("%s: no such array", x->x_arrayname->s_name); + else if (!table16_getarray16(a, &vecsize, &vec)) + error("%s: bad template for tab16write", x->x_arrayname->s_name); + else { + int n = x->x_ft1; + if (n < 0) n = 0; + else if (n >= vecsize) n = vecsize-1; + vec[n] = f; + } +} + +static void tab16write_set(t_tab16write *x, t_symbol *s){ + x->x_arrayname = s; +} + +static void tab16write_free(t_tab16write *x){} + +static void *tab16write_new(t_symbol *s){ + t_tab16write *x = (t_tab16write *)pd_new(tab16write_class); + x->x_ft1 = 0; + x->x_arrayname = s; + floatinlet_new(&x->x_obj, &x->x_ft1); + return (x); +} + +void tab16write_setup(void){ + tab16write_class = class_new(gensym("tab16write"), (t_newmethod)tab16write_new, + (t_method)tab16write_free, sizeof(t_tab16write), 0, A_DEFSYM, 0); + class_addfloat(tab16write_class, (t_method)tab16write_float); + class_addmethod(tab16write_class, (t_method)tab16write_set, gensym("set"), A_SYMBOL, 0); +} + +/* ------------------------ global setup routine ------------------------- */ + +void iem16_array_setup(void){ + tab16read_setup(); + tab16read4_setup(); + tab16write_setup(); +} + diff --git a/src/iem16_array_tilde.c b/src/iem16_array_tilde.c new file mode 100644 index 0000000..2cda11f --- /dev/null +++ b/src/iem16_array_tilde.c @@ -0,0 +1,502 @@ +/* copyleft (c) 2003 forum::für::umläute -- IOhannes m zmölnig @ IEM + * based on d_array.c from pd: + * Copyright (c) 1997-1999 Miller Puckette and others. + * For information on usage and redistribution, and for a DISCLAIMER OF ALL + * WARRANTIES, see the file, "LICENSE.txt," in this distribution. */ + +/* tab16write~, tab16play~, tab16read~, tab16read4~, tab16send~, tab16receive~ */ + +#include "iem16_table.h" + +/* ------------------------- tab16write~ -------------------------- */ + +static t_class *tab16write_tilde_class; + +typedef struct _tab16write_tilde { + t_object x_obj; + int x_phase; + int x_nsampsintab; + short *x_vec; + t_symbol *x_arrayname; + float x_f; +} t_tab16write_tilde; + +static void *tab16write_tilde_new(t_symbol *s) { + t_tab16write_tilde *x = (t_tab16write_tilde *)pd_new(tab16write_tilde_class); + x->x_phase = 0x7fffffff; + x->x_arrayname = s; + x->x_f = 0; + return (x); +} + +static t_int *tab16write_tilde_perform(t_int *w) { + t_tab16write_tilde *x = (t_tab16write_tilde *)(w[1]); + t_float *in = (t_float *)(w[2]); + int n = (int)(w[3]), phase = x->x_phase, endphase = x->x_nsampsintab; + if (!x->x_vec) goto bad; + + if (endphase > phase) { + int nxfer = endphase - phase; + t_iem16_16bit *fp = x->x_vec + phase; + if (nxfer > n) nxfer = n; + phase += nxfer; + while (nxfer--)*fp++ = *in++*IEM16_SCALE_UP; + x->x_phase = phase; + } + bad: + return (w+4); +} + +void tab16write_tilde_set(t_tab16write_tilde *x, t_symbol *s){ + t_table16 *a; + + x->x_arrayname = s; + if (!(a = (t_table16 *)pd_findbyclass(x->x_arrayname, table16_class))) { + if (*s->s_name) pd_error(x, "tab16write~: %s: no such array", + x->x_arrayname->s_name); + x->x_vec = 0; + } + else if (!table16_getarray16(a, &x->x_nsampsintab, &x->x_vec)) { + error("%s: bad template for tab16write~", x->x_arrayname->s_name); + x->x_vec = 0; + } + else table16_usedindsp(a); +} + +static void tab16write_tilde_dsp(t_tab16write_tilde *x, t_signal **sp){ + tab16write_tilde_set(x, x->x_arrayname); + dsp_add(tab16write_tilde_perform, 3, x, sp[0]->s_vec, sp[0]->s_n); +} + +static void tab16write_tilde_bang(t_tab16write_tilde *x){ + x->x_phase = 0; +} + +static void tab16write_tilde_stop(t_tab16write_tilde *x){} + +static void tab16write_tilde_free(t_tab16write_tilde *x){} + +static void tab16write_tilde_setup(void){ + tab16write_tilde_class = class_new(gensym("tab16write~"), + (t_newmethod)tab16write_tilde_new, (t_method)tab16write_tilde_free, + sizeof(t_tab16write_tilde), 0, A_DEFSYM, 0); + CLASS_MAINSIGNALIN(tab16write_tilde_class, t_tab16write_tilde, x_f); + class_addmethod(tab16write_tilde_class, (t_method)tab16write_tilde_dsp, + gensym("dsp"), 0); + class_addmethod(tab16write_tilde_class, (t_method)tab16write_tilde_set, + gensym("set"), A_SYMBOL, 0); + class_addmethod(tab16write_tilde_class, (t_method)tab16write_tilde_stop, + gensym("stop"), 0); + class_addbang(tab16write_tilde_class, tab16write_tilde_bang); +} + +/* ------------ tab16play~ - non-transposing sample playback --------------- */ + +static t_class *tab16play_tilde_class; + +typedef struct _tab16play_tilde{ + t_object x_obj; + t_outlet *x_bangout; + int x_phase; + int x_nsampsintab; + int x_limit; + t_iem16_16bit *x_vec; + t_symbol *x_arrayname; +} t_tab16play_tilde; + +static void *tab16play_tilde_new(t_symbol *s){ + t_tab16play_tilde *x = (t_tab16play_tilde *)pd_new(tab16play_tilde_class); + x->x_phase = 0x7fffffff; + x->x_limit = 0; + x->x_arrayname = s; + outlet_new(&x->x_obj, &s_signal); + x->x_bangout = outlet_new(&x->x_obj, &s_bang); + return (x); +} + +static t_int *tab16play_tilde_perform(t_int *w){ + t_tab16play_tilde *x = (t_tab16play_tilde *)(w[1]); + t_float *out = (t_float *)(w[2]); + t_iem16_16bit *fp; + int n = (int)(w[3]), phase = x->x_phase, + endphase = (x->x_nsampsintab < x->x_limit ? + x->x_nsampsintab : x->x_limit), nxfer, n3; + if (!x->x_vec || phase >= endphase) goto zero; + + nxfer = endphase - phase; + fp = x->x_vec + phase; + if (nxfer > n) + nxfer = n; + n3 = n - nxfer; + phase += nxfer; + while (nxfer--) *out++ = *fp++*IEM16_SCALE_DOWN; + if (phase >= endphase) { + x->x_phase = 0x7fffffff; + while (n3--) *out++ = 0; + } + else x->x_phase = phase; + + return (w+4); + zero: + while (n--) *out++ = 0; + return (w+4); +} + +void tab16play_tilde_set(t_tab16play_tilde *x, t_symbol *s){ + t_table16 *a; + + x->x_arrayname = s; + if (!(a = (t_table16 *)pd_findbyclass(x->x_arrayname, table16_class))) { + if (*s->s_name) pd_error(x, "tab16play~: %s: no such array", + x->x_arrayname->s_name); + x->x_vec = 0; + } + else if (!table16_getarray16(a, &x->x_nsampsintab, &x->x_vec)) { + error("%s: bad template for tab16play~", x->x_arrayname->s_name); + x->x_vec = 0; + } + else table16_usedindsp(a); +} + +static void tab16play_tilde_dsp(t_tab16play_tilde *x, t_signal **sp){ + tab16play_tilde_set(x, x->x_arrayname); + dsp_add(tab16play_tilde_perform, 3, x, sp[0]->s_vec, sp[0]->s_n); +} + +static void tab16play_tilde_list(t_tab16play_tilde *x, t_symbol *s, + int argc, t_atom *argv){ + long start = atom_getfloatarg(0, argc, argv); + long length = atom_getfloatarg(1, argc, argv); + if (start < 0) start = 0; + if (length <= 0)x->x_limit = 0x7fffffff; + else x->x_limit = start + length; + x->x_phase = start; +} + +static void tab16play_tilde_stop(t_tab16play_tilde *x){ + x->x_phase = 0x7fffffff; +} + +static void tab16play_tilde_free(t_tab16play_tilde *x){} + +static void tab16play_tilde_setup(void){ + tab16play_tilde_class = class_new(gensym("tab16play~"), + (t_newmethod)tab16play_tilde_new, (t_method)tab16play_tilde_free, + sizeof(t_tab16play_tilde), 0, A_DEFSYM, 0); + class_addmethod(tab16play_tilde_class, (t_method)tab16play_tilde_dsp, + gensym("dsp"), 0); + class_addmethod(tab16play_tilde_class, (t_method)tab16play_tilde_stop, + gensym("stop"), 0); + class_addmethod(tab16play_tilde_class, (t_method)tab16play_tilde_set, + gensym("set"), A_DEFSYM, 0); + class_addlist(tab16play_tilde_class, tab16play_tilde_list); +} + +/* ------------------------ tab16send~ ------------------------- */ + +static t_class *tab16send_class; + +typedef struct _tab16send{ + t_object x_obj; + t_iem16_16bit *x_vec; + int x_graphperiod; + int x_graphcount; + t_symbol *x_arrayname; + float x_f; +} t_tab16send; + +static void *tab16send_new(t_symbol *s){ + t_tab16send *x = (t_tab16send *)pd_new(tab16send_class); + x->x_graphcount = 0; + x->x_arrayname = s; + x->x_f = 0; + return (x); +} + +static t_int *tab16send_perform(t_int *w){ + t_tab16send *x = (t_tab16send *)(w[1]); + t_float *in = (t_float *)(w[2]); + int n = w[3]; + t_iem16_16bit *dest = x->x_vec; + int i = x->x_graphcount; + if (!x->x_vec) goto bad; + + while (n--) *dest = *in++*IEM16_SCALE_UP; + if (!i--)i = x->x_graphperiod; + x->x_graphcount = i; + bad: + return (w+4); +} + +static void tab16send_dsp(t_tab16send *x, t_signal **sp){ + int vecsize; + t_table16 *a; + + if (!(a = (t_table16 *)pd_findbyclass(x->x_arrayname, table16_class))) { + if (*x->x_arrayname->s_name) + error("tab16send~: %s: no such array", x->x_arrayname->s_name); + } + else if (!table16_getarray16(a, &vecsize, &x->x_vec)) + error("%s: bad template for tab16send~", x->x_arrayname->s_name); + else { + int n = sp[0]->s_n; + int ticksper = sp[0]->s_sr/n; + if (ticksper < 1) ticksper = 1; + x->x_graphperiod = ticksper; + if (x->x_graphcount > ticksper) x->x_graphcount = ticksper; + if (n < vecsize) vecsize = n; + table16_usedindsp(a); + dsp_add(tab16send_perform, 3, x, sp[0]->s_vec, vecsize); + } +} + +static void tab16send_free(t_tab16send *x){} + +static void tab16send_setup(void){ + tab16send_class = class_new(gensym("tab16send~"), (t_newmethod)tab16send_new, + (t_method)tab16send_free, sizeof(t_tab16send), 0, A_DEFSYM, 0); + CLASS_MAINSIGNALIN(tab16send_class, t_tab16send, x_f); + class_addmethod(tab16send_class, (t_method)tab16send_dsp, gensym("dsp"), 0); +} + +/* ------------------------ tab16receive~ ------------------------- */ + +static t_class *tab16receive_class; + +typedef struct _tab16receive{ + t_object x_obj; + t_iem16_16bit *x_vec; + t_symbol *x_arrayname; +} t_tab16receive; + +static t_int *tab16receive_perform(t_int *w){ + t_tab16receive *x = (t_tab16receive *)(w[1]); + t_float *out = (t_float *)(w[2]); + int n = w[3]; + t_iem16_16bit *from = x->x_vec; + if (from) while (n--) *out++ = *from++*IEM16_SCALE_DOWN; + else while (n--) *out++ = 0; + return (w+4); +} + +static void tab16receive_dsp(t_tab16receive *x, t_signal **sp){ + t_table16 *a; + int vecsize; + + if (!(a = (t_table16 *)pd_findbyclass(x->x_arrayname, table16_class))) { + if (*x->x_arrayname->s_name) + error("tab16send~: %s: no such array", x->x_arrayname->s_name); + } + else if (!table16_getarray16(a, &vecsize, &x->x_vec)) + error("%s: bad template for tab16receive~", x->x_arrayname->s_name); + else { + int n = sp[0]->s_n; + if (n < vecsize) vecsize = n; + table16_usedindsp(a); + dsp_add(tab16receive_perform, 3, x, sp[0]->s_vec, vecsize); + } +} + +static void *tab16receive_new(t_symbol *s){ + t_tab16receive *x = (t_tab16receive *)pd_new(tab16receive_class); + x->x_arrayname = s; + outlet_new(&x->x_obj, &s_signal); + return (x); +} + +static void tab16receive_setup(void){ + tab16receive_class = class_new(gensym("tab16receive~"), + (t_newmethod)tab16receive_new, 0, + sizeof(t_tab16receive), 0, A_DEFSYM, 0); + class_addmethod(tab16receive_class, (t_method)tab16receive_dsp, + gensym("dsp"), 0); +} + +/******************** tab16read~ ***********************/ + +static t_class *tab16read_tilde_class; + +typedef struct _tab16read_tilde{ + t_object x_obj; + int x_npoints; + t_iem16_16bit *x_vec; + t_symbol *x_arrayname; + float x_f; +} t_tab16read_tilde; + +static void *tab16read_tilde_new(t_symbol *s){ + t_tab16read_tilde *x = (t_tab16read_tilde *)pd_new(tab16read_tilde_class); + x->x_arrayname = s; + x->x_vec = 0; + outlet_new(&x->x_obj, gensym("signal")); + x->x_f = 0; + return (x); +} + +static t_int *tab16read_tilde_perform(t_int *w){ + t_tab16read_tilde *x = (t_tab16read_tilde *)(w[1]); + t_float *in = (t_float *)(w[2]); + t_float *out = (t_float *)(w[3]); + int n = (int)(w[4]); + int maxindex; + t_iem16_16bit *buf = x->x_vec; + int i; + + maxindex = x->x_npoints - 1; + if (!buf) goto zero; + + for (i = 0; i < n; i++) { + int index = *in++; + if (index < 0) index = 0; + else if (index > maxindex) index = maxindex; + *out++ = buf[index]*IEM16_SCALE_DOWN; + } + return (w+5); + zero: + while (n--) *out++ = 0; + + return (w+5); +} + +void tab16read_tilde_set(t_tab16read_tilde *x, t_symbol *s){ + t_table16 *a; + + x->x_arrayname = s; + if (!(a = (t_table16 *)pd_findbyclass(x->x_arrayname, table16_class))) { + if (*s->s_name) + error("tab16read~: %s: no such array", x->x_arrayname->s_name); + x->x_vec = 0; + } + else if (!table16_getarray16(a, &x->x_npoints, &x->x_vec)) { + error("%s: bad template for tab16read~", x->x_arrayname->s_name); + x->x_vec = 0; + } + else table16_usedindsp(a); +} + +static void tab16read_tilde_dsp(t_tab16read_tilde *x, t_signal **sp){ + tab16read_tilde_set(x, x->x_arrayname); + + dsp_add(tab16read_tilde_perform, 4, x, + sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n); + +} + +static void tab16read_tilde_free(t_tab16read_tilde *x){} + +static void tab16read_tilde_setup(void){ + tab16read_tilde_class = class_new(gensym("tab16read~"), + (t_newmethod)tab16read_tilde_new, (t_method)tab16read_tilde_free, + sizeof(t_tab16read_tilde), 0, A_DEFSYM, 0); + CLASS_MAINSIGNALIN(tab16read_tilde_class, t_tab16read_tilde, x_f); + class_addmethod(tab16read_tilde_class, (t_method)tab16read_tilde_dsp, + gensym("dsp"), 0); + class_addmethod(tab16read_tilde_class, (t_method)tab16read_tilde_set, + gensym("set"), A_SYMBOL, 0); +} + +/******************** tab16read4~ ***********************/ + +static t_class *tab16read4_tilde_class; + +typedef struct _tab16read4_tilde{ + t_object x_obj; + int x_npoints; + t_iem16_16bit *x_vec; + t_symbol *x_arrayname; + float x_f; +} t_tab16read4_tilde; + +static void *tab16read4_tilde_new(t_symbol *s){ + t_tab16read4_tilde *x = (t_tab16read4_tilde *)pd_new(tab16read4_tilde_class); + x->x_arrayname = s; + x->x_vec = 0; + outlet_new(&x->x_obj, gensym("signal")); + x->x_f = 0; + return (x); +} + +static t_int *tab16read4_tilde_perform(t_int *w){ + t_tab16read4_tilde *x = (t_tab16read4_tilde *)(w[1]); + t_float *in = (t_float *)(w[2]); + t_float *out = (t_float *)(w[3]); + int n = (int)(w[4]); + int maxindex; + t_iem16_16bit *buf = x->x_vec; + t_iem16_16bit *fp; + int i; + + maxindex = x->x_npoints - 3; + + if (!buf) goto zero; + + for (i = 0; i < n; i++) { + float findex = *in++; + int index = findex; + float frac, a, b, c, d, cminusb; + if (index < 1) index = 1, frac = 0; + else if (index > maxindex) index = maxindex, frac = 1; + else frac = findex - index; + fp = buf + index; + a = fp[-1]*IEM16_SCALE_DOWN; + b = fp[0]*IEM16_SCALE_DOWN; + c = fp[1]*IEM16_SCALE_DOWN; + d = fp[2]*IEM16_SCALE_DOWN; + cminusb = c-b; + *out++ = b + frac * ( + cminusb - 0.5f * (frac-1.) * ( + (a - d + 3.0f * cminusb) * frac + (b - a - cminusb) + ) + ); + } + return (w+5); + zero: + while (n--) *out++ = 0; + + return (w+5); +} + +void tab16read4_tilde_set(t_tab16read4_tilde *x, t_symbol *s){ + t_table16 *a; + + x->x_arrayname = s; + if (!(a = (t_table16 *)pd_findbyclass(x->x_arrayname, table16_class))) { + if (*s->s_name) + error("tab16read4~: %s: no such array", x->x_arrayname->s_name); + x->x_vec = 0; + } + else if (!table16_getarray16(a, &x->x_npoints, &x->x_vec)) { + error("%s: bad template for tab16read4~", x->x_arrayname->s_name); + x->x_vec = 0; + } + else table16_usedindsp(a); +} + +static void tab16read4_tilde_dsp(t_tab16read4_tilde *x, t_signal **sp){ + tab16read4_tilde_set(x, x->x_arrayname); + + dsp_add(tab16read4_tilde_perform, 4, x, + sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n); +} + +static void tab16read4_tilde_setup(void){ + tab16read4_tilde_class = class_new(gensym("tab16read4~"), + (t_newmethod)tab16read4_tilde_new, 0, + sizeof(t_tab16read4_tilde), 0, A_DEFSYM, 0); + CLASS_MAINSIGNALIN(tab16read4_tilde_class, t_tab16read4_tilde, x_f); + class_addmethod(tab16read4_tilde_class, (t_method)tab16read4_tilde_dsp, + gensym("dsp"), 0); + class_addmethod(tab16read4_tilde_class, (t_method)tab16read4_tilde_set, + gensym("set"), A_SYMBOL, 0); +} +/* ------------------------ global setup routine ------------------------- */ + +void iem16_array_tilde_setup(void){ + tab16write_tilde_setup(); + tab16play_tilde_setup(); + tab16read_tilde_setup(); + tab16read4_tilde_setup(); + tab16send_setup(); + tab16receive_setup(); +} + diff --git a/src/iem16_delay.c b/src/iem16_delay.c new file mode 100755 index 0000000..24a45d3 --- /dev/null +++ b/src/iem16_delay.c @@ -0,0 +1,285 @@ +/* copyleft (c) 2003 forum::für::umläute -- IOhannes m zmölnig @ IEM + * based on d_delay.c from pd: + * Copyright (c) 1997-1999 Miller Puckette. + * For information on usage and redistribution, and for a DISCLAIMER OF ALL + * WARRANTIES, see the file, "LICENSE.txt," in this distribution. */ + +/* del16read~, del16write~, vd16~ */ + +#include "iem16_table.h" +#ifdef NT +static int ugen_getsortno(void){return 0;} +#else +extern int ugen_getsortno(void); +#endif + +#define DEFDELVS 64 /* LATER get this from canvas at DSP time */ + +/* ----------------------------- del16write~ ----------------------------- */ +static t_class *sigdel16write_class; + +typedef struct del16writectl{ + int c_n; + t_iem16_16bit *c_vec; + int c_phase; +} t_del16writectl; + +typedef struct _sigdel16write{ + t_object x_obj; + t_symbol *x_sym; + t_del16writectl x_cspace; + int x_sortno; /* DSP sort number at which this was last put on chain */ + int x_rsortno; /* DSP sort # for first del16read or write in chain */ + int x_vecsize; /* vector size for del16read~ to use */ + float x_f; +} t_sigdel16write; + +#define XTRASAMPS 4 +#define SAMPBLK 4 + +/* routine to check that all del16writes/del16reads/vds have same vecsize */ +static void sigdel16write_checkvecsize(t_sigdel16write *x, int vecsize){ + if (x->x_rsortno != ugen_getsortno()) { + x->x_vecsize = vecsize; + x->x_rsortno = ugen_getsortno(); + } + else if (vecsize != x->x_vecsize) + pd_error(x, "del16read/del16write/vd vector size mismatch"); +} + +static void *sigdel16write_new(t_symbol *s, t_floatarg msec){ + int nsamps; + t_sigdel16write *x = (t_sigdel16write *)pd_new(sigdel16write_class); + if (!*s->s_name) s = gensym("del16write~"); + pd_bind(&x->x_obj.ob_pd, s); + x->x_sym = s; + nsamps = msec * sys_getsr() * (float)(0.001f); + if (nsamps < 1) nsamps = 1; + nsamps += ((- nsamps) & (SAMPBLK - 1)); + nsamps += DEFDELVS; + x->x_cspace.c_n = nsamps; + x->x_cspace.c_vec = + (t_iem16_16bit *)getbytes((nsamps + XTRASAMPS) * sizeof(t_iem16_16bit)); + x->x_cspace.c_phase = XTRASAMPS; + x->x_sortno = 0; + x->x_vecsize = 0; + x->x_f = 0; + return (x); +} + +static t_int *sigdel16write_perform(t_int *w){ + t_float *in = (t_float *)(w[1]); + t_del16writectl *c = (t_del16writectl *)(w[2]); + int n = (int)(w[3]); + int phase = c->c_phase, nsamps = c->c_n; + t_iem16_16bit *vp = c->c_vec, *bp = vp + phase, *ep = vp + (c->c_n + XTRASAMPS); + phase += n; + while (n--) { + *bp++ = (*in++*IEM16_SCALE_UP); + if (bp == ep) { + vp[0] = ep[-4]; + vp[1] = ep[-3]; + vp[2] = ep[-2]; + vp[3] = ep[-1]; + bp = vp + XTRASAMPS; + phase -= nsamps; + } + } + c->c_phase = phase; + return (w+4); +} + +static void sigdel16write_dsp(t_sigdel16write *x, t_signal **sp){ + dsp_add(sigdel16write_perform, 3, sp[0]->s_vec, &x->x_cspace, sp[0]->s_n); + x->x_sortno = ugen_getsortno(); + sigdel16write_checkvecsize(x, sp[0]->s_n); +} + +static void sigdel16write_free(t_sigdel16write *x){ + pd_unbind(&x->x_obj.ob_pd, x->x_sym); + freebytes(x->x_cspace.c_vec, + (x->x_cspace.c_n + XTRASAMPS) * sizeof(t_iem16_16bit)); +} + +static void sigdel16write_setup(void){ + sigdel16write_class = class_new(gensym("del16write~"), + (t_newmethod)sigdel16write_new, (t_method)sigdel16write_free, + sizeof(t_sigdel16write), 0, A_DEFSYM, A_DEFFLOAT, 0); + CLASS_MAINSIGNALIN(sigdel16write_class, t_sigdel16write, x_f); + class_addmethod(sigdel16write_class, (t_method)sigdel16write_dsp, + gensym("dsp"), 0); +} + +/* ----------------------------- del16read~ ----------------------------- */ +static t_class *sigdel16read_class; + +typedef struct _sigdel16read{ + t_object x_obj; + t_symbol *x_sym; + t_float x_deltime; /* delay in msec */ + int x_delsamps; /* delay in samples */ + t_float x_sr; /* samples per msec */ + t_float x_n; /* vector size */ + int x_zerodel; /* 0 or vecsize depending on read/write order */ +} t_sigdel16read; + +static void sigdel16read_16bit(t_sigdel16read *x, t_float f); + +static void *sigdel16read_new(t_symbol *s, t_floatarg f){ + t_sigdel16read *x = (t_sigdel16read *)pd_new(sigdel16read_class); + x->x_sym = s; + x->x_sr = 1; + x->x_n = 1; + x->x_zerodel = 0; + sigdel16read_16bit(x, f); + outlet_new(&x->x_obj, &s_signal); + return (x); +} + +static void sigdel16read_16bit(t_sigdel16read *x, t_float f){ + t_sigdel16write *delwriter = + (t_sigdel16write *)pd_findbyclass(x->x_sym, sigdel16write_class); + x->x_deltime = f; + if (delwriter) { + x->x_delsamps = (int)(0.5 + x->x_sr * x->x_deltime) + + x->x_n - x->x_zerodel; + if (x->x_delsamps < x->x_n) x->x_delsamps = x->x_n; + else if (x->x_delsamps > delwriter->x_cspace.c_n - DEFDELVS) + x->x_delsamps = delwriter->x_cspace.c_n - DEFDELVS; + } +} + +static t_int *sigdel16read_perform(t_int *w){ + t_float *out = (t_float *)(w[1]); + t_del16writectl *c = (t_del16writectl *)(w[2]); + int delsamps = *(int *)(w[3]); + int n = (int)(w[4]); + int phase = c->c_phase - delsamps, nsamps = c->c_n; + t_iem16_16bit *vp = c->c_vec, *bp, *ep = vp + (c->c_n + XTRASAMPS); + + if (phase < 0) phase += nsamps; + bp = vp + phase; + while (n--) { + *out++ = *bp++*IEM16_SCALE_DOWN; + if (bp == ep) bp -= nsamps; + } + return (w+5); +} + +static void sigdel16read_dsp(t_sigdel16read *x, t_signal **sp){ + t_sigdel16write *delwriter = + (t_sigdel16write *)pd_findbyclass(x->x_sym, sigdel16write_class); + x->x_sr = sp[0]->s_sr * 0.001; + x->x_n = sp[0]->s_n; + if (delwriter) { + sigdel16write_checkvecsize(delwriter, sp[0]->s_n); + x->x_zerodel = (delwriter->x_sortno == ugen_getsortno() ? + 0 : delwriter->x_vecsize); + sigdel16read_16bit(x, x->x_deltime); + dsp_add(sigdel16read_perform, 4, + sp[0]->s_vec, &delwriter->x_cspace, &x->x_delsamps, sp[0]->s_n); + } + else if (*x->x_sym->s_name) + error("delread~: %s: no such delwrite~",x->x_sym->s_name); +} + +static void sigdel16read_setup(void){ + sigdel16read_class = class_new(gensym("del16read~"), + (t_newmethod)sigdel16read_new, 0, + sizeof(t_sigdel16read), 0, A_DEFSYM, A_DEFFLOAT, 0); + class_addmethod(sigdel16read_class, (t_method)sigdel16read_dsp, + gensym("dsp"), 0); + class_addfloat(sigdel16read_class, (t_method)sigdel16read_16bit); +} + + +/* ----------------------------- vd~ ----------------------------- */ +static t_class *sig16vd_class; + +typedef struct _sig16vd{ + t_object x_obj; + t_symbol *x_sym; + t_float x_sr; /* samples per msec */ + int x_zerodel; /* 0 or vecsize depending on read/write order */ + float x_f; +} t_sig16vd; + +static void *sig16vd_new(t_symbol *s){ + t_sig16vd *x = (t_sig16vd *)pd_new(sig16vd_class); + if (!*s->s_name) s = gensym("vd~"); + x->x_sym = s; + x->x_sr = 1; + x->x_zerodel = 0; + outlet_new(&x->x_obj, &s_signal); + x->x_f = 0; + return (x); +} + +static t_int *sig16vd_perform(t_int *w){ + t_float *in = (t_float *)(w[1]); + t_float *out = (t_float *)(w[2]); + t_del16writectl *ctl = (t_del16writectl *)(w[3]); + t_sig16vd *x = (t_sig16vd *)(w[4]); + int n = (int)(w[5]); + + int nsamps = ctl->c_n; + float limit = nsamps - n - 1; + float fn = n-4; + t_iem16_16bit *vp = ctl->c_vec, *bp, *wp = vp + ctl->c_phase; + float zerodel = x->x_zerodel; + while (n--) { + float delsamps = x->x_sr * *in++ - zerodel, frac; + int idelsamps; + float a, b, c, d, cminusb; + if (delsamps < 1.00001f) delsamps = 1.00001f; + if (delsamps > limit) delsamps = limit; + delsamps += fn; + fn = fn - 1.0f; + idelsamps = delsamps; + frac = delsamps - (float)idelsamps; + bp = wp - (idelsamps + 3); + if (bp < vp + 4) bp += nsamps; + d = bp[-3]*IEM16_SCALE_DOWN; + c = bp[-2]*IEM16_SCALE_DOWN; + b = bp[-1]*IEM16_SCALE_DOWN; + a = bp[00]*IEM16_SCALE_DOWN; + cminusb = c-b; + *out++ = b + frac * ( + cminusb - 0.5f * (frac-1.) * ( + (a - d + 3.0f * cminusb) * frac + (b - a - cminusb) + ) + ); + } + return (w+6); +} + +static void sig16vd_dsp(t_sig16vd *x, t_signal **sp){ + t_sigdel16write *delwriter = + (t_sigdel16write *)pd_findbyclass(x->x_sym, sigdel16write_class); + x->x_sr = sp[0]->s_sr * 0.001; + if (delwriter) { + sigdel16write_checkvecsize(delwriter, sp[0]->s_n); + x->x_zerodel = (delwriter->x_sortno == ugen_getsortno() ? + 0 : delwriter->x_vecsize); + dsp_add(sig16vd_perform, 5, + sp[0]->s_vec, sp[1]->s_vec, + &delwriter->x_cspace, x, sp[0]->s_n); + } + else error("vd~: %s: no such delwrite~",x->x_sym->s_name); +} + +static void sig16vd_setup(void){ + sig16vd_class = class_new(gensym("vd16~"), (t_newmethod)sig16vd_new, 0, + sizeof(t_sig16vd), 0, A_DEFSYM, 0); + class_addmethod(sig16vd_class, (t_method)sig16vd_dsp, gensym("dsp"), 0); + CLASS_MAINSIGNALIN(sig16vd_class, t_sig16vd, x_f); +} + +/* ----------------------- global setup routine ---------------- */ + +void iem16_delay_setup(void){ + sigdel16write_setup(); + sigdel16read_setup(); + sig16vd_setup(); +} + diff --git a/src/iem16_table.c b/src/iem16_table.c new file mode 100644 index 0000000..f43e2bb --- /dev/null +++ b/src/iem16_table.c @@ -0,0 +1,141 @@ +/* copyleft (c) 2003 forum::für::umläute -- IOhannes m zmölnig @ IEM + * based on d_array.c from pd: + * Copyright (c) 1997-1999 Miller Puckette and others. + * For information on usage and redistribution, and for a DISCLAIMER OF ALL + * WARRANTIES, see the file, "LICENSE.txt," in this distribution. */ + +/* sampling */ + +#include "iem16_table.h" +static void table16_const(t_table16*x, t_float f); + +static void *table16_new(t_symbol *s, t_float f){ + t_table16 *x = (t_table16*)pd_new(table16_class); + int i=f; + if(i<1)i=100; + x->x_tablename=s; + x->x_size=i; + x->x_table=getbytes(x->x_size*sizeof(t_iem16_16bit)); + x->x_usedindsp=0; + pd_bind(&x->x_obj.ob_pd, x->x_tablename); + + table16_const(x, 0); + return(x); +} + +static void table16_free(t_table16 *x){ + if(x->x_table)freebytes(x->x_table, x->x_size*sizeof(t_iem16_16bit)); + pd_unbind(&x->x_obj.ob_pd, x->x_tablename); +} + +int table16_getarray16(t_table16*x, int*size,t_iem16_16bit**vec){ + *size=x->x_size; + *vec =x->x_table; + return 1; +} +void table16_usedindsp(t_table16*x){ + x->x_usedindsp=1; +} +static void table16_resize(t_table16*x, t_float f){ + int i=f; + int was=x->x_size; + if (i<1){ + error("can only resize to sizes >0"); + return; + } + x->x_table=resizebytes(x->x_table, was*sizeof(t_iem16_16bit), i*sizeof(t_iem16_16bit)); + if(i>was)memset(x->x_table+was, 0, (i-was)*sizeof(t_iem16_16bit)); + x->x_size =i; + if (x->x_usedindsp) canvas_update_dsp(); +} + +static void table16_const(t_table16*x, t_float f){ + t_iem16_16bit s = (t_iem16_16bit)f; + int i = x->x_size; + t_iem16_16bit*buf=x->x_table; + while(i--)*buf++=s; +} + + +static void table16_from(t_table16*x, t_symbol*s, int argc, t_atom*argv){ + float scale=IEM16_SCALE_UP; + int resize=0; + int startfrom=0, startto=0, endfrom=0, endto=x->x_size; + t_garray *a=0; + int npoints; + t_float *vec, *src; + t_iem16_16bit *dest; + + int i,length=0; + + if(argc<1 || argv->a_type!=A_SYMBOL){ + error("you have to specify the from-table !"); + return; + } + s=atom_getsymbol(argv); argc--;argv++; + if (!(a = (t_garray *)pd_findbyclass(s, garray_class))){ + error("%s: no such array", s->s_name); + return; + } else if (!garray_getfloatarray(a, &npoints, &vec)){ + error("%s: bad template for tabread4", s->s_name); + return; + } + + if(argc>0 && atom_getsymbol(argv+argc-1)==gensym("resize")){ + resize=1; + argc--; + } + endfrom=npoints; + + switch(argc){ + case 0:break; + case 4: + endto =atom_getfloat(argv+3); + case 3: + startto =atom_getfloat(argv+2); + case 2: + endfrom =atom_getfloat(argv+1); + case 1: + startfrom=atom_getfloat(argv); + break; + default: + error("table16: from [ [ [ []]]] [resize]"); + return; + } + if(startfrom<0)startfrom=0; + if (startto<0)startto=0; + if(endfrom<=startfrom)return; + if(endto <=startto) return; + + length=endfrom-startfrom; + if(resize){ + if(x->x_size < (startto+length))table16_resize(x, startto+length); + } else{ + if(x->x_size < (startto+length))length=x->x_size-startto; + } + endfrom=startfrom+length; + endto =startto+length; + + dest=x->x_table+startto; + src =vec+startfrom; + i=length; + while(i--)*dest++=(*src++)*scale; + post("from %s (%d, %d) --> (%d, %d)\tresize=%s", s->s_name, startfrom, endfrom, startto, endto, (resize)?"yes":"no"); +} + + +static void table16_setup(void){ + table16_class = class_new(gensym("table16"), + (t_newmethod)table16_new, (t_method)table16_free, + sizeof(t_table16), 0, A_DEFSYM, A_DEFFLOAT, 0); + class_addmethod(table16_class, (t_method)table16_resize, gensym("resize"), A_DEFFLOAT); + class_addmethod(table16_class, (t_method)table16_const, gensym("const"), A_DEFFLOAT); + class_addmethod(table16_class, (t_method)table16_from, gensym("from"), A_GIMME); +} + + +void iem16_table_setup(void) +{ + table16_setup(); +} + diff --git a/src/iem16_table.h b/src/iem16_table.h new file mode 100644 index 0000000..4810312 --- /dev/null +++ b/src/iem16_table.h @@ -0,0 +1,27 @@ +/* copyleft (c) 2003 forum::für::umläute -- IOhannes m zmölnig @ IEM + * based on d_array.c from pd: + * Copyright (c) 1997-1999 Miller Puckette and others. + * For information on usage and redistribution, and for a DISCLAIMER OF ALL + * WARRANTIES, see the file, "LICENSE.txt," in this distribution. */ + +/* sampling */ + +#include "iem16.h" +#include +/* ------------------------- table16 -------------------------- */ +/* a 16bit table */ + +t_class *table16_class; +typedef struct _table16 { + t_object x_obj; + + t_symbol *x_tablename; + long x_size; + t_iem16_16bit *x_table; // hold the data + + int x_usedindsp; +} t_table16; + + +EXTERN int table16_getarray16(t_table16*x, int*size,t_iem16_16bit**vec); +EXTERN void table16_usedindsp(t_table16*x); diff --git a/src/makefile b/src/makefile new file mode 100644 index 0000000..d8e6685 --- /dev/null +++ b/src/makefile @@ -0,0 +1,79 @@ +current: all + +# the IEM16-EXTERNAL-makefile +# everything is GnuGPL that should come with the iem16.tgz +# NO WARRANTIES FOR ANYTHING +# et cetera +# forum::für::umläute@IEM:2003 + +# make sure that the "m_pd.h" is somehow available either by putting it into this +# directory, by adding it's path to the INCLUDE-path or by putting it into an +# already included path, e.g. "/usr/local/include/" + +#these are the user adjustables : adjust them to fit into your system +# PD will install to $(DESTDIR)$(INSTALLL_PREFIX)$(PDLIBDIR), which is /usr/local/lib/pd +# by default +DESTDIR = +INSTALL_PREFIX = /usr +PDLIBDIR = /lib/pd +#these were the user adjustables + + +TARGETS = iem16 \ + iem16_table \ + iem16_array iem16_array_tilde \ + iem16_delay + +# ----------------------- LINUX ---------------------------- +.SUFFIXES: .pd_linux + + +LINUXOBJECTS = $(TARGETS:%=%.o) +ARCH = $(shell uname --machine) + +PD_DIR = $(DESTDIR)$(INSTALL_PREFIX)$(PDLIBDIR) + +ifeq (${ARCH},alpha) +AFLAGS = -mieee -mcpu=ev56 +endif + +LINCLUDE = + +$(LINUXOBJECTS): *.h + +#CFLAGS = -O2 -g -Wall $(LINCLUDE) $(UCFLAGS) $(AFLAGS) +CFLAGS = -O3 -g -Wall $(LINCLUDE) $(UCFLAGS) $(AFLAGS) + + +everything: clean all install distclean + +distclean: + touch dummy.o + touch dummy.pd_linux + touch dummy~ + touch _dummy + rm *.o *.pd_linux *~ _* + +clean: + touch dummy.o + touch dummy.pd_linux + rm *.o *.pd_linux + +all: $(LINUXOBJECTS) + + @echo :: $(LINUXOBJECTS) + + ld -export_dynamic -shared -o iem16.pd_linux *.o -lc -lm + strip --strip-unneeded iem16.pd_linux + +.c.pd_linux: + cc $(CFLAGS) -O2 -DPD -fPIC $(INCLUDE) -c -o $*.o $*.c + + +install: installdocs + install -d $(PD_DIR)/extra + install -m 644 iem16.pd_linux $(PD_DIR)/extra + +installdocs: + install -d $(PD_DIR)/doc/5.reference/iem16 + install -m644 ../examples/*.pd $(PD_DIR)/doc/5.reference/iem16 -- cgit v1.2.1