summaryrefslogtreecommitdiff
path: root/apps/plugins/pdbox/PDa/src/d_math.c
diff options
context:
space:
mode:
Diffstat (limited to 'apps/plugins/pdbox/PDa/src/d_math.c')
-rw-r--r--apps/plugins/pdbox/PDa/src/d_math.c573
1 files changed, 0 insertions, 573 deletions
diff --git a/apps/plugins/pdbox/PDa/src/d_math.c b/apps/plugins/pdbox/PDa/src/d_math.c
deleted file mode 100644
index d64e2e3483..0000000000
--- a/apps/plugins/pdbox/PDa/src/d_math.c
+++ /dev/null
@@ -1,573 +0,0 @@
1/* Copyright (c) 1997-2001 Miller Puckette and others.
2* For information on usage and redistribution, and for a DISCLAIMER OF ALL
3* WARRANTIES, see the file, "LICENSE.txt," in this distribution. */
4
5/* mathematical functions and other transfer functions, including tilde
6 versions of stuff from x_acoustics.c.
7*/
8
9#include "m_pd.h"
10#include <math.h>
11#define LOGTEN 2.302585092994
12
13/* ------------------------- clip~ -------------------------- */
14static t_class *clip_class;
15
16typedef struct _clip
17{
18 t_object x_obj;
19 float x_f;
20 t_sample x_lo;
21 t_sample x_hi;
22} t_clip;
23
24static void *clip_new(t_floatarg lo, t_floatarg hi)
25{
26 t_clip *x = (t_clip *)pd_new(clip_class);
27 x->x_lo = lo;
28 x->x_hi = hi;
29 outlet_new(&x->x_obj, gensym("signal"));
30 floatinlet_new(&x->x_obj, &x->x_lo);
31 floatinlet_new(&x->x_obj, &x->x_hi);
32 x->x_f = 0;
33 return (x);
34}
35
36static t_int *clip_perform(t_int *w)
37{
38 t_clip *x = (t_clip *)(w[1]);
39 t_float *in = (t_float *)(w[2]);
40 t_float *out = (t_float *)(w[3]);
41 int n = (int)(w[4]);
42 while (n--)
43 {
44 float f = *in++;
45 if (f < x->x_lo) f = x->x_lo;
46 if (f > x->x_hi) f = x->x_hi;
47 *out++ = f;
48 }
49 return (w+5);
50}
51
52static void clip_dsp(t_clip *x, t_signal **sp)
53{
54 dsp_add(clip_perform, 4, x, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
55}
56
57static void clip_setup(void)
58{
59 clip_class = class_new(gensym("clip~"), (t_newmethod)clip_new, 0,
60 sizeof(t_clip), 0, A_DEFFLOAT, A_DEFFLOAT, 0);
61 CLASS_MAINSIGNALIN(clip_class, t_clip, x_f);
62 class_addmethod(clip_class, (t_method)clip_dsp, gensym("dsp"), 0);
63}
64
65/* sigrsqrt - reciprocal square root good to 8 mantissa bits */
66
67#define DUMTAB1SIZE 256
68#define DUMTAB2SIZE 1024
69
70static float rsqrt_exptab[DUMTAB1SIZE], rsqrt_mantissatab[DUMTAB2SIZE];
71
72static void init_rsqrt(void)
73{
74 int i;
75 for (i = 0; i < DUMTAB1SIZE; i++)
76 {
77 float f;
78 long l = (i ? (i == DUMTAB1SIZE-1 ? DUMTAB1SIZE-2 : i) : 1)<< 23;
79 *(long *)(&f) = l;
80 rsqrt_exptab[i] = 1./sqrt(f);
81 }
82 for (i = 0; i < DUMTAB2SIZE; i++)
83 {
84 float f = 1 + (1./DUMTAB2SIZE) * i;
85 rsqrt_mantissatab[i] = 1./sqrt(f);
86 }
87}
88
89 /* these are used in externs like "bonk" */
90
91float q8_rsqrt(float f)
92{
93 long l = *(long *)(&f);
94 if (f < 0) return (0);
95 else return (rsqrt_exptab[(l >> 23) & 0xff] *
96 rsqrt_mantissatab[(l >> 13) & 0x3ff]);
97}
98
99float q8_sqrt(float f)
100{
101 long l = *(long *)(&f);
102 if (f < 0) return (0);
103 else return (f * rsqrt_exptab[(l >> 23) & 0xff] *
104 rsqrt_mantissatab[(l >> 13) & 0x3ff]);
105}
106
107 /* the old names are OK unless we're in IRIX N32 */
108
109#ifndef N32
110float qsqrt(float f) {return (q8_sqrt(f)); }
111float qrsqrt(float f) {return (q8_rsqrt(f)); }
112#endif
113
114
115
116typedef struct sigrsqrt
117{
118 t_object x_obj;
119 float x_f;
120} t_sigrsqrt;
121
122static t_class *sigrsqrt_class;
123
124static void *sigrsqrt_new(void)
125{
126 t_sigrsqrt *x = (t_sigrsqrt *)pd_new(sigrsqrt_class);
127 outlet_new(&x->x_obj, gensym("signal"));
128 x->x_f = 0;
129 return (x);
130}
131
132static t_int *sigrsqrt_perform(t_int *w)
133{
134 float *in = *(t_float **)(w+1), *out = *(t_float **)(w+2);
135 t_int n = *(t_int *)(w+3);
136 while (n--)
137 {
138 float f = *in;
139 long l = *(long *)(in++);
140 if (f < 0) *out++ = 0;
141 else
142 {
143 float g = rsqrt_exptab[(l >> 23) & 0xff] *
144 rsqrt_mantissatab[(l >> 13) & 0x3ff];
145 *out++ = 1.5 * g - 0.5 * g * g * g * f;
146 }
147 }
148 return (w + 4);
149}
150
151static void sigrsqrt_dsp(t_sigrsqrt *x, t_signal **sp)
152{
153 dsp_add(sigrsqrt_perform, 3, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
154}
155
156void sigrsqrt_setup(void)
157{
158 init_rsqrt();
159 sigrsqrt_class = class_new(gensym("rsqrt~"), (t_newmethod)sigrsqrt_new, 0,
160 sizeof(t_sigrsqrt), 0, 0);
161 /* an old name for it: */
162 class_addcreator(sigrsqrt_new, gensym("q8_rsqrt~"), 0);
163 CLASS_MAINSIGNALIN(sigrsqrt_class, t_sigrsqrt, x_f);
164 class_addmethod(sigrsqrt_class, (t_method)sigrsqrt_dsp, gensym("dsp"), 0);
165}
166
167
168/* sigsqrt - square root good to 8 mantissa bits */
169
170typedef struct sigsqrt
171{
172 t_object x_obj;
173 float x_f;
174} t_sigsqrt;
175
176static t_class *sigsqrt_class;
177
178static void *sigsqrt_new(void)
179{
180 t_sigsqrt *x = (t_sigsqrt *)pd_new(sigsqrt_class);
181 outlet_new(&x->x_obj, gensym("signal"));
182 x->x_f = 0;
183 return (x);
184}
185
186t_int *sigsqrt_perform(t_int *w) /* not static; also used in d_fft.c */
187{
188 float *in = *(t_float **)(w+1), *out = *(t_float **)(w+2);
189 t_int n = *(t_int *)(w+3);
190 while (n--)
191 {
192 float f = *in;
193 long l = *(long *)(in++);
194 if (f < 0) *out++ = 0;
195 else
196 {
197 float g = rsqrt_exptab[(l >> 23) & 0xff] *
198 rsqrt_mantissatab[(l >> 13) & 0x3ff];
199 *out++ = f * (1.5 * g - 0.5 * g * g * g * f);
200 }
201 }
202 return (w + 4);
203}
204
205static void sigsqrt_dsp(t_sigsqrt *x, t_signal **sp)
206{
207 dsp_add(sigsqrt_perform, 3, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
208}
209
210void sigsqrt_setup(void)
211{
212 sigsqrt_class = class_new(gensym("sqrt~"), (t_newmethod)sigsqrt_new, 0,
213 sizeof(t_sigsqrt), 0, 0);
214 class_addcreator(sigsqrt_new, gensym("q8_sqrt~"), 0); /* old name */
215 CLASS_MAINSIGNALIN(sigsqrt_class, t_sigsqrt, x_f);
216 class_addmethod(sigsqrt_class, (t_method)sigsqrt_dsp, gensym("dsp"), 0);
217}
218
219/* ------------------------------ wrap~ -------------------------- */
220
221typedef struct wrap
222{
223 t_object x_obj;
224 float x_f;
225} t_sigwrap;
226
227t_class *sigwrap_class;
228
229static void *sigwrap_new(void)
230{
231 t_sigwrap *x = (t_sigwrap *)pd_new(sigwrap_class);
232 outlet_new(&x->x_obj, gensym("signal"));
233 x->x_f = 0;
234 return (x);
235}
236
237static t_int *sigwrap_perform(t_int *w)
238{
239 float *in = *(t_float **)(w+1), *out = *(t_float **)(w+2);
240 t_int n = *(t_int *)(w+3);
241 while (n--)
242 {
243 float f = *in++;
244 int k = f;
245 if (f > 0) *out++ = f-k;
246 else *out++ = f - (k-1);
247 }
248 return (w + 4);
249}
250
251static void sigwrap_dsp(t_sigwrap *x, t_signal **sp)
252{
253 dsp_add(sigwrap_perform, 3, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
254}
255
256void sigwrap_setup(void)
257{
258 sigwrap_class = class_new(gensym("wrap~"), (t_newmethod)sigwrap_new, 0,
259 sizeof(t_sigwrap), 0, 0);
260 CLASS_MAINSIGNALIN(sigwrap_class, t_sigwrap, x_f);
261 class_addmethod(sigwrap_class, (t_method)sigwrap_dsp, gensym("dsp"), 0);
262}
263
264/* ------------------------------ mtof_tilde~ -------------------------- */
265
266typedef struct mtof_tilde
267{
268 t_object x_obj;
269 float x_f;
270} t_mtof_tilde;
271
272t_class *mtof_tilde_class;
273
274static void *mtof_tilde_new(void)
275{
276 t_mtof_tilde *x = (t_mtof_tilde *)pd_new(mtof_tilde_class);
277 outlet_new(&x->x_obj, gensym("signal"));
278 x->x_f = 0;
279 return (x);
280}
281
282static t_int *mtof_tilde_perform(t_int *w)
283{
284 float *in = *(t_float **)(w+1), *out = *(t_float **)(w+2);
285 t_int n = *(t_int *)(w+3);
286 for (; n--; in++, out++)
287 {
288 float f = *in;
289 if (f <= -1500) *out = 0;
290 else
291 {
292 if (f > 1499) f = 1499;
293 *out = 8.17579891564 * exp(.0577622650 * f);
294 }
295 }
296 return (w + 4);
297}
298
299static void mtof_tilde_dsp(t_mtof_tilde *x, t_signal **sp)
300{
301 dsp_add(mtof_tilde_perform, 3, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
302}
303
304void mtof_tilde_setup(void)
305{
306 mtof_tilde_class = class_new(gensym("mtof~"), (t_newmethod)mtof_tilde_new, 0,
307 sizeof(t_mtof_tilde), 0, 0);
308 CLASS_MAINSIGNALIN(mtof_tilde_class, t_mtof_tilde, x_f);
309 class_addmethod(mtof_tilde_class, (t_method)mtof_tilde_dsp, gensym("dsp"), 0);
310}
311
312/* ------------------------------ ftom_tilde~ -------------------------- */
313
314typedef struct ftom_tilde
315{
316 t_object x_obj;
317 float x_f;
318} t_ftom_tilde;
319
320t_class *ftom_tilde_class;
321
322static void *ftom_tilde_new(void)
323{
324 t_ftom_tilde *x = (t_ftom_tilde *)pd_new(ftom_tilde_class);
325 outlet_new(&x->x_obj, gensym("signal"));
326 x->x_f = 0;
327 return (x);
328}
329
330static t_int *ftom_tilde_perform(t_int *w)
331{
332 float *in = *(t_float **)(w+1), *out = *(t_float **)(w+2);
333 t_int n = *(t_int *)(w+3);
334 for (; n--; *in++, out++)
335 {
336 float f = *in;
337 *out = (f > 0 ? 17.3123405046 * log(.12231220585 * f) : -1500);
338 }
339 return (w + 4);
340}
341
342static void ftom_tilde_dsp(t_ftom_tilde *x, t_signal **sp)
343{
344 dsp_add(ftom_tilde_perform, 3, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
345}
346
347void ftom_tilde_setup(void)
348{
349 ftom_tilde_class = class_new(gensym("ftom~"), (t_newmethod)ftom_tilde_new, 0,
350 sizeof(t_ftom_tilde), 0, 0);
351 CLASS_MAINSIGNALIN(ftom_tilde_class, t_ftom_tilde, x_f);
352 class_addmethod(ftom_tilde_class, (t_method)ftom_tilde_dsp, gensym("dsp"), 0);
353}
354
355/* ------------------------------ dbtorms~ -------------------------- */
356
357typedef struct dbtorms_tilde
358{
359 t_object x_obj;
360 float x_f;
361} t_dbtorms_tilde;
362
363t_class *dbtorms_tilde_class;
364
365static void *dbtorms_tilde_new(void)
366{
367 t_dbtorms_tilde *x = (t_dbtorms_tilde *)pd_new(dbtorms_tilde_class);
368 outlet_new(&x->x_obj, gensym("signal"));
369 x->x_f = 0;
370 return (x);
371}
372
373static t_int *dbtorms_tilde_perform(t_int *w)
374{
375 float *in = *(t_float **)(w+1), *out = *(t_float **)(w+2);
376 t_int n = *(t_int *)(w+3);
377 for (; n--; in++, out++)
378 {
379 float f = *in;
380 if (f <= 0) *out = 0;
381 else
382 {
383 if (f > 485)
384 f = 485;
385 *out = exp((LOGTEN * 0.05) * (f-100.));
386 }
387 }
388 return (w + 4);
389}
390
391static void dbtorms_tilde_dsp(t_dbtorms_tilde *x, t_signal **sp)
392{
393 dsp_add(dbtorms_tilde_perform, 3, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
394}
395
396void dbtorms_tilde_setup(void)
397{
398 dbtorms_tilde_class = class_new(gensym("dbtorms~"), (t_newmethod)dbtorms_tilde_new, 0,
399 sizeof(t_dbtorms_tilde), 0, 0);
400 CLASS_MAINSIGNALIN(dbtorms_tilde_class, t_dbtorms_tilde, x_f);
401 class_addmethod(dbtorms_tilde_class, (t_method)dbtorms_tilde_dsp, gensym("dsp"), 0);
402}
403
404/* ------------------------------ rmstodb~ -------------------------- */
405
406typedef struct rmstodb_tilde
407{
408 t_object x_obj;
409 float x_f;
410} t_rmstodb_tilde;
411
412t_class *rmstodb_tilde_class;
413
414static void *rmstodb_tilde_new(void)
415{
416 t_rmstodb_tilde *x = (t_rmstodb_tilde *)pd_new(rmstodb_tilde_class);
417 outlet_new(&x->x_obj, gensym("signal"));
418 x->x_f = 0;
419 return (x);
420}
421
422static t_int *rmstodb_tilde_perform(t_int *w)
423{
424 float *in = *(t_float **)(w+1), *out = *(t_float **)(w+2);
425 t_int n = *(t_int *)(w+3);
426 for (; n--; in++, out++)
427 {
428 float f = *in;
429 if (f <= 0) *out = 0;
430 else
431 {
432 float g = 100 + 20./LOGTEN * log(f);
433 *out = (g < 0 ? 0 : g);
434 }
435 }
436 return (w + 4);
437}
438
439static void rmstodb_tilde_dsp(t_rmstodb_tilde *x, t_signal **sp)
440{
441 dsp_add(rmstodb_tilde_perform, 3, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
442}
443
444void rmstodb_tilde_setup(void)
445{
446 rmstodb_tilde_class = class_new(gensym("rmstodb~"), (t_newmethod)rmstodb_tilde_new, 0,
447 sizeof(t_rmstodb_tilde), 0, 0);
448 CLASS_MAINSIGNALIN(rmstodb_tilde_class, t_rmstodb_tilde, x_f);
449 class_addmethod(rmstodb_tilde_class, (t_method)rmstodb_tilde_dsp, gensym("dsp"), 0);
450}
451
452/* ------------------------------ dbtopow~ -------------------------- */
453
454typedef struct dbtopow_tilde
455{
456 t_object x_obj;
457 float x_f;
458} t_dbtopow_tilde;
459
460t_class *dbtopow_tilde_class;
461
462static void *dbtopow_tilde_new(void)
463{
464 t_dbtopow_tilde *x = (t_dbtopow_tilde *)pd_new(dbtopow_tilde_class);
465 outlet_new(&x->x_obj, gensym("signal"));
466 x->x_f = 0;
467 return (x);
468}
469
470static t_int *dbtopow_tilde_perform(t_int *w)
471{
472 float *in = *(t_float **)(w+1), *out = *(t_float **)(w+2);
473 t_int n = *(t_int *)(w+3);
474 for (; n--; in++, out++)
475 {
476 float f = *in;
477 if (f <= 0) *out = 0;
478 else
479 {
480 if (f > 870)
481 f = 870;
482 *out = exp((LOGTEN * 0.1) * (f-100.));
483 }
484 }
485 return (w + 4);
486}
487
488static void dbtopow_tilde_dsp(t_dbtopow_tilde *x, t_signal **sp)
489{
490 dsp_add(dbtopow_tilde_perform, 3, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
491}
492
493void dbtopow_tilde_setup(void)
494{
495 dbtopow_tilde_class = class_new(gensym("dbtopow~"), (t_newmethod)dbtopow_tilde_new, 0,
496 sizeof(t_dbtopow_tilde), 0, 0);
497 CLASS_MAINSIGNALIN(dbtopow_tilde_class, t_dbtopow_tilde, x_f);
498 class_addmethod(dbtopow_tilde_class, (t_method)dbtopow_tilde_dsp, gensym("dsp"), 0);
499}
500
501/* ------------------------------ powtodb~ -------------------------- */
502
503typedef struct powtodb_tilde
504{
505 t_object x_obj;
506 float x_f;
507} t_powtodb_tilde;
508
509t_class *powtodb_tilde_class;
510
511static void *powtodb_tilde_new(void)
512{
513 t_powtodb_tilde *x = (t_powtodb_tilde *)pd_new(powtodb_tilde_class);
514 outlet_new(&x->x_obj, gensym("signal"));
515 x->x_f = 0;
516 return (x);
517}
518
519static t_int *powtodb_tilde_perform(t_int *w)
520{
521 float *in = *(t_float **)(w+1), *out = *(t_float **)(w+2);
522 t_int n = *(t_int *)(w+3);
523 for (; n--; in++, out++)
524 {
525 float f = *in;
526 if (f <= 0) *out = 0;
527 else
528 {
529 float g = 100 + 10./LOGTEN * log(f);
530 *out = (g < 0 ? 0 : g);
531 }
532 }
533 return (w + 4);
534}
535
536static void powtodb_tilde_dsp(t_powtodb_tilde *x, t_signal **sp)
537{
538 dsp_add(powtodb_tilde_perform, 3, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
539}
540
541void powtodb_tilde_setup(void)
542{
543 powtodb_tilde_class = class_new(gensym("powtodb~"), (t_newmethod)powtodb_tilde_new, 0,
544 sizeof(t_powtodb_tilde), 0, 0);
545 CLASS_MAINSIGNALIN(powtodb_tilde_class, t_powtodb_tilde, x_f);
546 class_addmethod(powtodb_tilde_class, (t_method)powtodb_tilde_dsp, gensym("dsp"), 0);
547}
548
549
550/* ------------------------ global setup routine ------------------------- */
551
552void d_math_setup(void)
553{
554 t_symbol *s = gensym("acoustics~.pd");
555 clip_setup();
556 sigrsqrt_setup();
557 sigsqrt_setup();
558 sigwrap_setup();
559 mtof_tilde_setup();
560 ftom_tilde_setup();
561 dbtorms_tilde_setup();
562 rmstodb_tilde_setup();
563 dbtopow_tilde_setup();
564 powtodb_tilde_setup();
565
566 class_sethelpsymbol(mtof_tilde_class, s);
567 class_sethelpsymbol(ftom_tilde_class, s);
568 class_sethelpsymbol(dbtorms_tilde_class, s);
569 class_sethelpsymbol(rmstodb_tilde_class, s);
570 class_sethelpsymbol(dbtopow_tilde_class, s);
571 class_sethelpsymbol(powtodb_tilde_class, s);
572}
573
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-22 23:33:12 +0000