Commitac48bc1bRecorded2 Apr 2026Repositorysigil-dsp

Add sigil-dsp package with vendored SoundPipe and native bindings

Message

Vendor 43 Phase 1 SoundPipe modules (oscillators, filters, envelopes, effects, noise, utility) and create native Sigil bindings with GC-managed foreign objects. Includes Sigil wrapper modules with define-native declarations and convenience constructors (make-oscillator, make-filter).

Modules: (sigil dsp core), (sigil dsp osc), (sigil dsp filter), (sigil dsp env), (sigil dsp fx), (sigil dsp noise), (sigil dsp util)

Changed
 .gitignore                            |    3 +
 README.md                             |   58 ++-
 package.sgl                           |  160 +++++++
 sigil.lock                            |    8 +
 src/c/dsp.c                           | 1998 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 src/sigil/dsp/core.sgl                |   23 ++
 src/sigil/dsp/env.sgl                 |   33 ++
 src/sigil/dsp/filter.sgl              |   42 ++
 src/sigil/dsp/fx.sgl                  |   34 ++
 src/sigil/dsp/noise.sgl               |   24 ++
 src/sigil/dsp/osc.sgl                 |   69 ++++
 src/sigil/dsp/test-main.sgl           |   74 ++++
 src/sigil/dsp/util.sgl                |   51 +++
 test/basic-test.sgl                   |    5 +
 vendor/soundpipe/h/adsr.h             |   19 +
 vendor/soundpipe/h/atone.h            |   10 +
 vendor/soundpipe/h/base.h             |   97 +++++
 vendor/soundpipe/h/blsaw.h            |   12 +
 vendor/soundpipe/h/blsquare.h         |   13 +
 vendor/soundpipe/h/bltriangle.h       |   12 +
 vendor/soundpipe/h/brown.h            |    8 +
 vendor/soundpipe/h/buthp.h            |   11 +
 vendor/soundpipe/h/butlp.h            |   11 +
 vendor/soundpipe/h/clamp.h            |    9 +
 vendor/soundpipe/h/clip.h             |    8 +
 vendor/soundpipe/h/clock.h            |   10 +
 vendor/soundpipe/h/crossfade.h        |    8 +
 vendor/soundpipe/h/dcblock.h          |   11 +
 vendor/soundpipe/h/delay.h            |   13 +
 vendor/soundpipe/h/expon.h            |   11 +
 vendor/soundpipe/h/fosc.h             |   10 +
 vendor/soundpipe/h/ftbl.h             |   29 ++
 vendor/soundpipe/h/line.h             |   11 +
 vendor/soundpipe/h/lpf18.h            |    9 +
 vendor/soundpipe/h/metro.h            |   11 +
 vendor/soundpipe/h/moogladder.h       |   17 +
 vendor/soundpipe/h/noise.h            |    8 +
 vendor/soundpipe/h/osc.h              |   11 +
 vendor/soundpipe/h/pan2.h             |    9 +
 vendor/soundpipe/h/peaklim.h          |   10 +
 vendor/soundpipe/h/phasor.h           |    9 +
 vendor/soundpipe/h/pinknoise.h        |   15 +
 vendor/soundpipe/h/port.h             |   11 +
 vendor/soundpipe/h/posc3.h            |   13 +
 vendor/soundpipe/h/randh.h            |   11 +
 vendor/soundpipe/h/randi.h            |   13 +
 vendor/soundpipe/h/randmt.h           |   10 +
 vendor/soundpipe/h/revsc.h            |   28 ++
 vendor/soundpipe/h/saturator.h        |   15 +
 vendor/soundpipe/h/scale.h            |    8 +
 vendor/soundpipe/h/soundpipe.h        |  617 +++++++++++++++++++++++++++
 vendor/soundpipe/h/tadsr.h            |   20 +
 vendor/soundpipe/h/tenv.h             |   14 +
 vendor/soundpipe/h/tgate.h            |    9 +
 vendor/soundpipe/h/tone.h             |   10 +
 vendor/soundpipe/h/vdelay.h           |   14 +
 vendor/soundpipe/h/wavout.h           |    5 +
 vendor/soundpipe/h/zitarev.h          |   21 +
 vendor/soundpipe/lib/dr_wav/Makefile  |    5 +
 vendor/soundpipe/lib/dr_wav/dr_wav.c  |    2 +
 vendor/soundpipe/lib/dr_wav/dr_wav.h  | 3490 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 vendor/soundpipe/lib/faust/CUI.h      |   16 +
 vendor/soundpipe/modules/adsr.c       |   95 +++++
 vendor/soundpipe/modules/atone.c      |   63 +++
 vendor/soundpipe/modules/base.c       |  198 +++++++++
 vendor/soundpipe/modules/blsaw.c      |  171 ++++++++
 vendor/soundpipe/modules/blsquare.c   |  185 +++++++++
 vendor/soundpipe/modules/bltriangle.c |  202 +++++++++
 vendor/soundpipe/modules/brown.c      |   47 +++
 vendor/soundpipe/modules/buthp.c      |   83 ++++
 vendor/soundpipe/modules/butlp.c      |   81 ++++
 vendor/soundpipe/modules/clamp.c      |   29 ++
 vendor/soundpipe/modules/clip.c       |   61 +++
 vendor/soundpipe/modules/clock.c      |   41 ++
 vendor/soundpipe/modules/crossfade.c  |   26 ++
 vendor/soundpipe/modules/dcblock.c    |   51 +++
 vendor/soundpipe/modules/delay.c      |   40 ++
 vendor/soundpipe/modules/expon.c      |   78 ++++
 vendor/soundpipe/modules/fosc.c       |  101 +++++
 vendor/soundpipe/modules/ftbl.c       |  406 ++++++++++++++++++
 vendor/soundpipe/modules/line.c       |   57 +++
 vendor/soundpipe/modules/lpf18.c      |   98 +++++
 vendor/soundpipe/modules/metro.c      |   60 +++
 vendor/soundpipe/modules/moogladder.c |  122 ++++++
 vendor/soundpipe/modules/noise.c      |   29 ++
 vendor/soundpipe/modules/osc.c        |   71 ++++
 vendor/soundpipe/modules/pan2.c       |   83 ++++
 vendor/soundpipe/modules/peaklim.c    |   80 ++++
 vendor/soundpipe/modules/phasor.c     |   52 +++
 vendor/soundpipe/modules/pinknoise.c  |   69 ++++
 vendor/soundpipe/modules/port.c       |   66 +++
 vendor/soundpipe/modules/posc3.c      |   93 +++++
 vendor/soundpipe/modules/randh.c      |   44 ++
 vendor/soundpipe/modules/randi.c      |   98 +++++
 vendor/soundpipe/modules/randmt.c     |  135 ++++++
 vendor/soundpipe/modules/revsc.c      |  279 +++++++++++++
 vendor/soundpipe/modules/saturator.c  |  109 +++++
 vendor/soundpipe/modules/scale.c      |   27 ++
 vendor/soundpipe/modules/tadsr.c      |  152 +++++++
 vendor/soundpipe/modules/tenv.c       |   90 ++++
 vendor/soundpipe/modules/tgate.c      |   34 ++
 vendor/soundpipe/modules/tone.c       |   68 +++
 vendor/soundpipe/modules/vdelay.c     |  116 ++++++
 vendor/soundpipe/modules/wavout.c     |   53 +++
 vendor/soundpipe/modules/zitarev.c    | 1062 +++++++++++++++++++++++++++++++++++++++++++++++
 105 files changed, 12430 insertions(+), 1 deletion(-)
Diff
.gitignoreadded
@@ -0,0 +1,3 @@
+1
build/
+2
.sigil/
+3
sigil.lock
README.mdmodified
@@ -1,3 +1,59 @@
1
# sigil-dsp
2
−3
Digital signal processing library for Sigil — oscillators, filters, effects, envelopes via vendored SoundPipe
3
No newline at end of file
+4
DSP primitives for Sigil via vendored [SoundPipe](https://github.com/PaulBatchelor/Soundpipe).
+5
+6
## Modules
+7
+8
- `(sigil dsp core)` -- DSP engine lifecycle, function tables
+9
- `(sigil dsp osc)` -- Oscillators: sine, saw, square, triangle, FM, phasor
+10
- `(sigil dsp filter)` -- Filters: Moog ladder, Butterworth, resonant LP, DC block
+11
- `(sigil dsp env)` -- Envelopes: ADSR, triggered, line, exponential, portamento
+12
- `(sigil dsp fx)` -- Effects: stereo reverb (revsc, zitarev), delay, variable delay
+13
- `(sigil dsp noise)` -- Noise: white, pink, brown
+14
- `(sigil dsp util)` -- Panning, dynamics, timing, random modulation, scaling, WAV output
+15
+16
## Usage
+17
+18
```scheme
+19
(import (sigil dsp core)
+20
(sigil dsp osc)
+21
(sigil dsp filter))
+22
+23
(dsp-init 44100)
+24
+25
;; Create a 440Hz sine oscillator
+26
(define osc (make-osc 440.0 1.0))
+27
+28
;; Or use the convenience constructor
+29
(define saw (make-oscillator 'saw 220.0 0.8))
+30
+31
;; Create a lowpass filter
+32
(define filt (make-moogladder 1000.0 0.4))
+33
+34
;; Per-sample processing
+35
(let ((sample (osc-compute osc)))
+36
(filter-compute filt sample))
+37
+38
(dsp-shutdown)
+39
```
+40
+41
## Building
+42
+43
```bash
+44
sigil deps install
+45
sigil build
+46
```
+47
+48
## Testing
+49
+50
The test entry point exercises all module categories:
+51
+52
```bash
+53
# Add entry: '(sigil dsp test-main) to package.sgl, then:
+54
sigil build --force
+55
sigil run
+56
```
+57
+58
## License
+59
+60
MIT (SoundPipe) / BSD-3-Clause (sigil-dsp bindings)
package.sgladded
@@ -0,0 +1,160 @@
+1
;;; sigil-dsp - DSP primitives for Sigil
+2
;;;
+3
;;; Provides oscillators, filters, envelopes, effects, noise generators,
+4
;;; and utility modules via vendored SoundPipe.
+5
+6
(package
+7
name: "sigil-dsp"
+8
version: "0.1.0"
+9
description: "DSP primitives for Sigil (SoundPipe bindings)"
+10
url: "https://codeberg.org/sigil/sigil-dsp"
+11
license: "MIT"
+12
authors: (list "David Wilson <[email protected]>")
+13
+14
configs: (list
+15
(config
+16
name: 'dev
+17
output-dir: "build/dev"
+18
debug?: #t
+19
optimize: 0)
+20
(config
+21
name: 'release
+22
output-dir: "build/release"
+23
debug?: #f
+24
optimize: 2))
+25
+26
dependencies: (list
+27
(from-git url: "codeberg:sigil/sigil" package: "sigil-stdlib" version: "^0.9.0"))
+28
+29
libraries: (list
+30
(library
+31
name: 'sigil-dsp
+32
c-sources: '(;; SoundPipe core
+33
"vendor/soundpipe/modules/base.c"
+34
"vendor/soundpipe/modules/ftbl.c"
+35
"vendor/soundpipe/modules/randmt.c"
+36
;; Oscillators
+37
"vendor/soundpipe/modules/osc.c"
+38
"vendor/soundpipe/modules/posc3.c"
+39
"vendor/soundpipe/modules/blsaw.c"
+40
"vendor/soundpipe/modules/blsquare.c"
+41
"vendor/soundpipe/modules/bltriangle.c"
+42
"vendor/soundpipe/modules/fosc.c"
+43
"vendor/soundpipe/modules/phasor.c"
+44
;; Filters
+45
"vendor/soundpipe/modules/moogladder.c"
+46
"vendor/soundpipe/modules/butlp.c"
+47
"vendor/soundpipe/modules/buthp.c"
+48
"vendor/soundpipe/modules/lpf18.c"
+49
"vendor/soundpipe/modules/tone.c"
+50
"vendor/soundpipe/modules/atone.c"
+51
"vendor/soundpipe/modules/dcblock.c"
+52
;; Envelopes
+53
"vendor/soundpipe/modules/adsr.c"
+54
"vendor/soundpipe/modules/tadsr.c"
+55
"vendor/soundpipe/modules/tenv.c"
+56
"vendor/soundpipe/modules/line.c"
+57
"vendor/soundpipe/modules/expon.c"
+58
"vendor/soundpipe/modules/port.c"
+59
;; Reverb
+60
"vendor/soundpipe/modules/revsc.c"
+61
"vendor/soundpipe/modules/zitarev.c"
+62
;; Delay
+63
"vendor/soundpipe/modules/delay.c"
+64
"vendor/soundpipe/modules/vdelay.c"
+65
;; Noise
+66
"vendor/soundpipe/modules/noise.c"
+67
"vendor/soundpipe/modules/pinknoise.c"
+68
"vendor/soundpipe/modules/brown.c"
+69
;; Dynamics / Waveshaping
+70
"vendor/soundpipe/modules/saturator.c"
+71
"vendor/soundpipe/modules/clip.c"
+72
"vendor/soundpipe/modules/peaklim.c"
+73
;; Spatial
+74
"vendor/soundpipe/modules/pan2.c"
+75
;; Timing
+76
"vendor/soundpipe/modules/metro.c"
+77
"vendor/soundpipe/modules/clock.c"
+78
"vendor/soundpipe/modules/tgate.c"
+79
;; Modulation
+80
"vendor/soundpipe/modules/randh.c"
+81
"vendor/soundpipe/modules/randi.c"
+82
;; Utility
+83
"vendor/soundpipe/modules/scale.c"
+84
"vendor/soundpipe/modules/clamp.c"
+85
"vendor/soundpipe/modules/crossfade.c"
+86
;; Output
+87
"vendor/soundpipe/modules/wavout.c"
+88
;; dr_wav implementation
+89
"vendor/soundpipe/lib/dr_wav/dr_wav.c"
+90
;; Native bindings
+91
"src/c/dsp.c")
+92
c-include-dirs: '("vendor/soundpipe/h"
+93
"vendor/soundpipe/lib/faust"
+94
"vendor/soundpipe/lib/dr_wav")
+95
c-flags: '("-DNO_LIBSNDFILE" "-DSPFLOAT=float"
+96
"-Wno-unused-parameter" "-Wno-sign-compare")
+97
native-init: "sigil__init_sigil_dsp_module"
+98
link-flags: '("-lm")))
+99
+100
tasks: (list
+101
(task
+102
name: 'build
+103
description: "Build sigil-dsp"
+104
steps: (list
+105
(compile-c-sources
+106
sources: '("vendor/soundpipe/modules/base.c"
+107
"vendor/soundpipe/modules/ftbl.c"
+108
"vendor/soundpipe/modules/randmt.c"
+109
"vendor/soundpipe/modules/osc.c"
+110
"vendor/soundpipe/modules/posc3.c"
+111
"vendor/soundpipe/modules/blsaw.c"
+112
"vendor/soundpipe/modules/blsquare.c"
+113
"vendor/soundpipe/modules/bltriangle.c"
+114
"vendor/soundpipe/modules/fosc.c"
+115
"vendor/soundpipe/modules/phasor.c"
+116
"vendor/soundpipe/modules/moogladder.c"
+117
"vendor/soundpipe/modules/butlp.c"
+118
"vendor/soundpipe/modules/buthp.c"
+119
"vendor/soundpipe/modules/lpf18.c"
+120
"vendor/soundpipe/modules/tone.c"
+121
"vendor/soundpipe/modules/atone.c"
+122
"vendor/soundpipe/modules/dcblock.c"
+123
"vendor/soundpipe/modules/adsr.c"
+124
"vendor/soundpipe/modules/tadsr.c"
+125
"vendor/soundpipe/modules/tenv.c"
+126
"vendor/soundpipe/modules/line.c"
+127
"vendor/soundpipe/modules/expon.c"
+128
"vendor/soundpipe/modules/port.c"
+129
"vendor/soundpipe/modules/revsc.c"
+130
"vendor/soundpipe/modules/zitarev.c"
+131
"vendor/soundpipe/modules/delay.c"
+132
"vendor/soundpipe/modules/vdelay.c"
+133
"vendor/soundpipe/modules/noise.c"
+134
"vendor/soundpipe/modules/pinknoise.c"
+135
"vendor/soundpipe/modules/brown.c"
+136
"vendor/soundpipe/modules/saturator.c"
+137
"vendor/soundpipe/modules/clip.c"
+138
"vendor/soundpipe/modules/peaklim.c"
+139
"vendor/soundpipe/modules/pan2.c"
+140
"vendor/soundpipe/modules/metro.c"
+141
"vendor/soundpipe/modules/clock.c"
+142
"vendor/soundpipe/modules/tgate.c"
+143
"vendor/soundpipe/modules/randh.c"
+144
"vendor/soundpipe/modules/randi.c"
+145
"vendor/soundpipe/modules/scale.c"
+146
"vendor/soundpipe/modules/clamp.c"
+147
"vendor/soundpipe/modules/crossfade.c"
+148
"vendor/soundpipe/modules/wavout.c"
+149
"vendor/soundpipe/lib/dr_wav/dr_wav.c"
+150
"src/c/dsp.c")
+151
include-dirs: '("../sigil/packages/sigil-lib/include"
+152
"../sigil/packages/sigil-lib/src"
+153
"vendor/soundpipe/h"
+154
"vendor/soundpipe/lib/faust"
+155
"vendor/soundpipe/lib/dr_wav")
+156
flags: '("-std=c99" "-D_GNU_SOURCE" "-DNO_LIBSNDFILE" "-DSPFLOAT=float"
+157
"-Wno-unused-parameter" "-Wno-unused-function" "-Wno-sign-compare"))
+158
(create-static-library name: "sigil-dsp")
+159
(compile-sigil-modules sources: "src/**/*.sgl"
+160
output-dir: (config-output-subdir "lib"))))))
sigil.lockadded
@@ -0,0 +1,8 @@
+1
;; Auto-generated by sigil deps install. Do not edit.
+2
(lock
+3
(package name: "sigil-stdlib"
+4
url: "codeberg:sigil/sigil"
+5
ref: "^0.9.0"
+6
sha: "0123d3fc7d2dd37e5c27e9fade7d11b817deb21a"
+7
package-selector: "sigil-stdlib")
+8
)
src/c/dsp.cadded
@@ -0,0 +1,1998 @@
+1
/*
+2
* dsp.c - Sigil DSP Module
+3
*
+4
* Native bindings for SoundPipe DSP primitives.
+5
* Provides oscillators, filters, envelopes, effects, noise generators,
+6
* and utility modules for audio synthesis.
+7
*/
+8
+9
#include <sigil/sigil.h>
+10
+11
#include <stdlib.h>
+12
#include <string.h>
+13
#include <math.h>
+14
+15
#include "soundpipe.h"
+16
+17
/* ============================================================
+18
* GLOBAL STATE
+19
* ============================================================ */
+20
+21
static sp_data *g_sp = NULL;
+22
+23
/* Type tags for foreign objects */
+24
static Value tt_osc = SIGIL_UNDEFINED;
+25
static Value tt_posc3 = SIGIL_UNDEFINED;
+26
static Value tt_blsaw = SIGIL_UNDEFINED;
+27
static Value tt_blsquare = SIGIL_UNDEFINED;
+28
static Value tt_bltriangle = SIGIL_UNDEFINED;
+29
static Value tt_fosc = SIGIL_UNDEFINED;
+30
static Value tt_phasor = SIGIL_UNDEFINED;
+31
static Value tt_moogladder = SIGIL_UNDEFINED;
+32
static Value tt_butlp = SIGIL_UNDEFINED;
+33
static Value tt_buthp = SIGIL_UNDEFINED;
+34
static Value tt_lpf18 = SIGIL_UNDEFINED;
+35
static Value tt_tone = SIGIL_UNDEFINED;
+36
static Value tt_atone = SIGIL_UNDEFINED;
+37
static Value tt_dcblock = SIGIL_UNDEFINED;
+38
static Value tt_adsr = SIGIL_UNDEFINED;
+39
static Value tt_tadsr = SIGIL_UNDEFINED;
+40
static Value tt_tenv = SIGIL_UNDEFINED;
+41
static Value tt_line = SIGIL_UNDEFINED;
+42
static Value tt_expon = SIGIL_UNDEFINED;
+43
static Value tt_port = SIGIL_UNDEFINED;
+44
static Value tt_revsc = SIGIL_UNDEFINED;
+45
static Value tt_zitarev = SIGIL_UNDEFINED;
+46
static Value tt_delay = SIGIL_UNDEFINED;
+47
static Value tt_vdelay = SIGIL_UNDEFINED;
+48
static Value tt_noise = SIGIL_UNDEFINED;
+49
static Value tt_pinknoise = SIGIL_UNDEFINED;
+50
static Value tt_brown = SIGIL_UNDEFINED;
+51
static Value tt_saturator = SIGIL_UNDEFINED;
+52
static Value tt_clip = SIGIL_UNDEFINED;
+53
static Value tt_peaklim = SIGIL_UNDEFINED;
+54
static Value tt_pan2 = SIGIL_UNDEFINED;
+55
static Value tt_metro = SIGIL_UNDEFINED;
+56
static Value tt_clock = SIGIL_UNDEFINED;
+57
static Value tt_tgate = SIGIL_UNDEFINED;
+58
static Value tt_randh = SIGIL_UNDEFINED;
+59
static Value tt_randi = SIGIL_UNDEFINED;
+60
static Value tt_scale = SIGIL_UNDEFINED;
+61
static Value tt_clamp = SIGIL_UNDEFINED;
+62
static Value tt_crossfade = SIGIL_UNDEFINED;
+63
static Value tt_wavout = SIGIL_UNDEFINED;
+64
static Value tt_ftbl = SIGIL_UNDEFINED;
+65
+66
/* ============================================================
+67
* HELPERS
+68
* ============================================================ */
+69
+70
#define ENSURE_TAG(vm, tag, name) \
+71
if (sigil_is_undefined(tag)) { \
+72
tag = sigil_intern_symbol(vm, name, strlen(name)); \
+73
}
+74
+75
#define CHECK_SP(vm, funcname) \
+76
if (!g_sp) { \
+77
sigil__vm_set_error(vm, SIGIL_ERR_RUNTIME, funcname ": DSP not initialized, call dsp-init first"); \
+78
return SIGIL_FALSE; \
+79
}
+80
+81
/* Wrapper struct for wavetable oscillator (owns ftbl) */
+82
typedef struct {
+83
sp_osc *osc;
+84
sp_ftbl *ft;
+85
} dsp_osc;
+86
+87
/* Wrapper struct for posc3 (owns ftbl) */
+88
typedef struct {
+89
sp_posc3 *osc;
+90
sp_ftbl *ft;
+91
} dsp_posc3;
+92
+93
/* Wrapper struct for fosc (owns ftbl) */
+94
typedef struct {
+95
sp_fosc *osc;
+96
sp_ftbl *ft;
+97
} dsp_fosc;
+98
+99
/* ============================================================
+100
* DESTRUCTORS
+101
* ============================================================ */
+102
+103
static void destroy_osc(void *data) {
+104
dsp_osc *d = (dsp_osc *)data;
+105
if (d->osc) sp_osc_destroy(&d->osc);
+106
if (d->ft) sp_ftbl_destroy(&d->ft);
+107
free(d);
+108
}
+109
+110
static void destroy_posc3(void *data) {
+111
dsp_posc3 *d = (dsp_posc3 *)data;
+112
if (d->osc) sp_posc3_destroy(&d->osc);
+113
if (d->ft) sp_ftbl_destroy(&d->ft);
+114
free(d);
+115
}
+116
+117
static void destroy_blsaw(void *data) { sp_blsaw *p = (sp_blsaw *)data; sp_blsaw_destroy(&p); }
+118
static void destroy_blsquare(void *data) { sp_blsquare *p = (sp_blsquare *)data; sp_blsquare_destroy(&p); }
+119
static void destroy_bltriangle(void *data) { sp_bltriangle *p = (sp_bltriangle *)data; sp_bltriangle_destroy(&p); }
+120
+121
static void destroy_fosc(void *data) {
+122
dsp_fosc *d = (dsp_fosc *)data;
+123
if (d->osc) sp_fosc_destroy(&d->osc);
+124
if (d->ft) sp_ftbl_destroy(&d->ft);
+125
free(d);
+126
}
+127
+128
static void destroy_phasor(void *data) { sp_phasor *p = (sp_phasor *)data; sp_phasor_destroy(&p); }
+129
static void destroy_moogladder(void *data) { sp_moogladder *p = (sp_moogladder *)data; sp_moogladder_destroy(&p); }
+130
static void destroy_butlp(void *data) { sp_butlp *p = (sp_butlp *)data; sp_butlp_destroy(&p); }
+131
static void destroy_buthp(void *data) { sp_buthp *p = (sp_buthp *)data; sp_buthp_destroy(&p); }
+132
static void destroy_lpf18(void *data) { sp_lpf18 *p = (sp_lpf18 *)data; sp_lpf18_destroy(&p); }
+133
static void destroy_tone(void *data) { sp_tone *p = (sp_tone *)data; sp_tone_destroy(&p); }
+134
static void destroy_atone(void *data) { sp_atone *p = (sp_atone *)data; sp_atone_destroy(&p); }
+135
static void destroy_dcblock(void *data) { sp_dcblock *p = (sp_dcblock *)data; sp_dcblock_destroy(&p); }
+136
static void destroy_adsr(void *data) { sp_adsr *p = (sp_adsr *)data; sp_adsr_destroy(&p); }
+137
static void destroy_tadsr(void *data) { sp_tadsr *p = (sp_tadsr *)data; sp_tadsr_destroy(&p); }
+138
static void destroy_tenv(void *data) { sp_tenv *p = (sp_tenv *)data; sp_tenv_destroy(&p); }
+139
static void destroy_line(void *data) { sp_line *p = (sp_line *)data; sp_line_destroy(&p); }
+140
static void destroy_expon(void *data) { sp_expon *p = (sp_expon *)data; sp_expon_destroy(&p); }
+141
static void destroy_port(void *data) { sp_port *p = (sp_port *)data; sp_port_destroy(&p); }
+142
static void destroy_revsc(void *data) { sp_revsc *p = (sp_revsc *)data; sp_revsc_destroy(&p); }
+143
static void destroy_zitarev(void *data) { sp_zitarev *p = (sp_zitarev *)data; sp_zitarev_destroy(&p); }
+144
static void destroy_delay(void *data) { sp_delay *p = (sp_delay *)data; sp_delay_destroy(&p); }
+145
static void destroy_vdelay(void *data) { sp_vdelay *p = (sp_vdelay *)data; sp_vdelay_destroy(&p); }
+146
static void destroy_noise(void *data) { sp_noise *p = (sp_noise *)data; sp_noise_destroy(&p); }
+147
static void destroy_pinknoise(void *data) { sp_pinknoise *p = (sp_pinknoise *)data; sp_pinknoise_destroy(&p); }
+148
static void destroy_brown(void *data) { sp_brown *p = (sp_brown *)data; sp_brown_destroy(&p); }
+149
static void destroy_saturator(void *data) { sp_saturator *p = (sp_saturator *)data; sp_saturator_destroy(&p); }
+150
static void destroy_clip(void *data) { sp_clip *p = (sp_clip *)data; sp_clip_destroy(&p); }
+151
static void destroy_peaklim(void *data) { sp_peaklim *p = (sp_peaklim *)data; sp_peaklim_destroy(&p); }
+152
static void destroy_pan2(void *data) { sp_pan2 *p = (sp_pan2 *)data; sp_pan2_destroy(&p); }
+153
static void destroy_metro(void *data) { sp_metro *p = (sp_metro *)data; sp_metro_destroy(&p); }
+154
static void destroy_clock(void *data) { sp_clock *p = (sp_clock *)data; sp_clock_destroy(&p); }
+155
static void destroy_tgate(void *data) { sp_tgate *p = (sp_tgate *)data; sp_tgate_destroy(&p); }
+156
static void destroy_randh(void *data) { sp_randh *p = (sp_randh *)data; sp_randh_destroy(&p); }
+157
static void destroy_randi(void *data) { sp_randi *p = (sp_randi *)data; sp_randi_destroy(&p); }
+158
static void destroy_scale(void *data) { sp_scale *p = (sp_scale *)data; sp_scale_destroy(&p); }
+159
static void destroy_clamp(void *data) { sp_clamp *p = (sp_clamp *)data; sp_clamp_destroy(&p); }
+160
static void destroy_crossfade(void *data) { sp_crossfade *p = (sp_crossfade *)data; sp_crossfade_destroy(&p); }
+161
static void destroy_wavout(void *data) { sp_wavout *p = (sp_wavout *)data; sp_wavout_destroy(&p); }
+162
static void destroy_ftbl(void *data) { sp_ftbl *p = (sp_ftbl *)data; sp_ftbl_destroy(&p); }
+163
+164
/* ============================================================
+165
* TYPE GETTERS
+166
* ============================================================ */
+167
+168
#define DEF_GETTER(name, sp_type, tag, label) \
+169
static sp_type *get_##name(SigilVM *vm, Value v) { \
+170
ENSURE_TAG(vm, tag, "dsp-" label); \
+171
if (!sigil_is_foreign_type(v, tag)) return NULL; \
+172
return (sp_type *)sigil_foreign_get_data(v); \
+173
}
+174
+175
/* Wrapper getters return the wrapper struct */
+176
static dsp_osc *get_osc(SigilVM *vm, Value v) {
+177
ENSURE_TAG(vm, tt_osc, "dsp-osc");
+178
if (!sigil_is_foreign_type(v, tt_osc)) return NULL;
+179
return (dsp_osc *)sigil_foreign_get_data(v);
+180
}
+181
static dsp_posc3 *get_posc3(SigilVM *vm, Value v) {
+182
ENSURE_TAG(vm, tt_posc3, "dsp-posc3");
+183
if (!sigil_is_foreign_type(v, tt_posc3)) return NULL;
+184
return (dsp_posc3 *)sigil_foreign_get_data(v);
+185
}
+186
static dsp_fosc *get_fosc(SigilVM *vm, Value v) {
+187
ENSURE_TAG(vm, tt_fosc, "dsp-fosc");
+188
if (!sigil_is_foreign_type(v, tt_fosc)) return NULL;
+189
return (dsp_fosc *)sigil_foreign_get_data(v);
+190
}
+191
+192
DEF_GETTER(blsaw, sp_blsaw, tt_blsaw, "blsaw")
+193
DEF_GETTER(blsquare, sp_blsquare, tt_blsquare, "blsquare")
+194
DEF_GETTER(bltriangle, sp_bltriangle, tt_bltriangle, "bltriangle")
+195
DEF_GETTER(phasor, sp_phasor, tt_phasor, "phasor")
+196
DEF_GETTER(moogladder, sp_moogladder, tt_moogladder, "moogladder")
+197
DEF_GETTER(butlp, sp_butlp, tt_butlp, "butlp")
+198
DEF_GETTER(buthp, sp_buthp, tt_buthp, "buthp")
+199
DEF_GETTER(lpf18, sp_lpf18, tt_lpf18, "lpf18")
+200
DEF_GETTER(tone, sp_tone, tt_tone, "tone")
+201
DEF_GETTER(atone, sp_atone, tt_atone, "atone")
+202
DEF_GETTER(dcblock, sp_dcblock, tt_dcblock, "dcblock")
+203
DEF_GETTER(adsr, sp_adsr, tt_adsr, "adsr")
+204
DEF_GETTER(tadsr, sp_tadsr, tt_tadsr, "tadsr")
+205
DEF_GETTER(tenv, sp_tenv, tt_tenv, "tenv")
+206
DEF_GETTER(line, sp_line, tt_line, "line")
+207
DEF_GETTER(expon, sp_expon, tt_expon, "expon")
+208
DEF_GETTER(port, sp_port, tt_port, "port")
+209
DEF_GETTER(revsc, sp_revsc, tt_revsc, "revsc")
+210
DEF_GETTER(zitarev, sp_zitarev, tt_zitarev, "zitarev")
+211
DEF_GETTER(delay, sp_delay, tt_delay, "delay")
+212
DEF_GETTER(vdelay, sp_vdelay, tt_vdelay, "vdelay")
+213
DEF_GETTER(noise, sp_noise, tt_noise, "noise")
+214
DEF_GETTER(pinknoise, sp_pinknoise, tt_pinknoise, "pinknoise")
+215
DEF_GETTER(brown, sp_brown, tt_brown, "brown")
+216
DEF_GETTER(saturator, sp_saturator, tt_saturator, "saturator")
+217
DEF_GETTER(clip, sp_clip, tt_clip, "clip")
+218
DEF_GETTER(peaklim, sp_peaklim, tt_peaklim, "peaklim")
+219
DEF_GETTER(pan2, sp_pan2, tt_pan2, "pan2")
+220
DEF_GETTER(metro, sp_metro, tt_metro, "metro")
+221
DEF_GETTER(clock_mod, sp_clock, tt_clock, "clock")
+222
DEF_GETTER(tgate, sp_tgate, tt_tgate, "tgate")
+223
DEF_GETTER(randh, sp_randh, tt_randh, "randh")
+224
DEF_GETTER(randi, sp_randi, tt_randi, "randi")
+225
DEF_GETTER(scale, sp_scale, tt_scale, "scale")
+226
DEF_GETTER(clamp, sp_clamp, tt_clamp, "clamp")
+227
DEF_GETTER(crossfade, sp_crossfade, tt_crossfade, "crossfade")
+228
DEF_GETTER(wavout, sp_wavout, tt_wavout, "wavout")
+229
+230
/* ============================================================
+231
* CORE — dsp-init, dsp-shutdown, dsp-sample-rate
+232
* ============================================================ */
+233
+234
/* (dsp-init [sample-rate]) */
+235
/* Helper to get a number as double from either fixnum or flonum */
+236
static double as_number(Value v)
+237
{
+238
if (sigil_is_fixnum(v)) return (double)sigil_as_fixnum(v);
+239
return sigil_as_flonum(v);
+240
}
+241
+242
static Value native_dsp_init(SigilVM *vm, int argc, Value *args)
+243
{
+244
(void)vm;
+245
if (g_sp) return SIGIL_TRUE;
+246
+247
sp_create(&g_sp);
+248
if (argc > 0) {
+249
g_sp->sr = (int)as_number(args[0]);
+250
}
+251
return SIGIL_TRUE;
+252
}
+253
+254
/* (dsp-shutdown) */
+255
static Value native_dsp_shutdown(SigilVM *vm, int argc, Value *args)
+256
{
+257
(void)vm; (void)argc; (void)args;
+258
if (g_sp) {
+259
sp_destroy(&g_sp);
+260
g_sp = NULL;
+261
}
+262
return SIGIL_NIL;
+263
}
+264
+265
/* (dsp-sample-rate) -> fixnum */
+266
static Value native_dsp_sample_rate(SigilVM *vm, int argc, Value *args)
+267
{
+268
(void)argc; (void)args;
+269
CHECK_SP(vm, "dsp-sample-rate");
+270
return sigil_fixnum(g_sp->sr);
+271
}
+272
+273
/* ============================================================
+274
* FUNCTION TABLES
+275
* ============================================================ */
+276
+277
/* (make-ftbl size) -> <ftbl> */
+278
static Value native_make_ftbl(SigilVM *vm, int argc, Value *args)
+279
{
+280
CHECK_SP(vm, "make-ftbl");
+281
size_t size = (size_t)sigil_as_flonum(args[0]);
+282
sp_ftbl *ft;
+283
sp_ftbl_create(g_sp, &ft, size);
+284
ENSURE_TAG(vm, tt_ftbl, "dsp-ftbl");
+285
return sigil_make_foreign(vm, tt_ftbl, ft, destroy_ftbl,
+286
sizeof(sp_ftbl) + size * sizeof(SPFLOAT));
+287
}
+288
+289
/* (ftbl-gen-sine ftbl) */
+290
static Value native_ftbl_gen_sine(SigilVM *vm, int argc, Value *args)
+291
{
+292
CHECK_SP(vm, "ftbl-gen-sine");
+293
ENSURE_TAG(vm, tt_ftbl, "dsp-ftbl");
+294
if (!sigil_is_foreign_type(args[0], tt_ftbl)) {
+295
sigil__vm_set_error(vm, SIGIL_ERR_TYPE, "ftbl-gen-sine: expected ftbl");
+296
return SIGIL_FALSE;
+297
}
+298
sp_ftbl *ft = (sp_ftbl *)sigil_foreign_get_data(args[0]);
+299
sp_gen_sine(g_sp, ft);
+300
return SIGIL_NIL;
+301
}
+302
+303
/* (ftbl-gen-triangle ftbl) */
+304
static Value native_ftbl_gen_triangle(SigilVM *vm, int argc, Value *args)
+305
{
+306
CHECK_SP(vm, "ftbl-gen-triangle");
+307
ENSURE_TAG(vm, tt_ftbl, "dsp-ftbl");
+308
if (!sigil_is_foreign_type(args[0], tt_ftbl)) {
+309
sigil__vm_set_error(vm, SIGIL_ERR_TYPE, "ftbl-gen-triangle: expected ftbl");
+310
return SIGIL_FALSE;
+311
}
+312
sp_ftbl *ft = (sp_ftbl *)sigil_foreign_get_data(args[0]);
+313
sp_gen_triangle(g_sp, ft);
+314
return SIGIL_NIL;
+315
}
+316
+317
/* (ftbl-gen-line ftbl argstring) */
+318
static Value native_ftbl_gen_line(SigilVM *vm, int argc, Value *args)
+319
{
+320
CHECK_SP(vm, "ftbl-gen-line");
+321
ENSURE_TAG(vm, tt_ftbl, "dsp-ftbl");
+322
if (!sigil_is_foreign_type(args[0], tt_ftbl)) {
+323
sigil__vm_set_error(vm, SIGIL_ERR_TYPE, "ftbl-gen-line: expected ftbl");
+324
return SIGIL_FALSE;
+325
}
+326
if (!sigil_is_string(args[1])) {
+327
sigil__vm_set_error(vm, SIGIL_ERR_TYPE, "ftbl-gen-line: expected string");
+328
return SIGIL_FALSE;
+329
}
+330
sp_ftbl *ft = (sp_ftbl *)sigil_foreign_get_data(args[0]);
+331
SigilString *s = (SigilString *)sigil_as_ptr(args[1]);
+332
sp_gen_line(g_sp, ft, s->data);
+333
return SIGIL_NIL;
+334
}
+335
+336
/* ============================================================
+337
* OSCILLATORS
+338
* ============================================================ */
+339
+340
/* (make-osc freq amp [phase]) -> <osc>
+341
* Wavetable oscillator with sine wave table */
+342
static Value native_make_osc(SigilVM *vm, int argc, Value *args)
+343
{
+344
CHECK_SP(vm, "make-osc");
+345
SPFLOAT freq = (SPFLOAT)sigil_as_flonum(args[0]);
+346
SPFLOAT amp = (SPFLOAT)sigil_as_flonum(args[1]);
+347
SPFLOAT phase = argc > 2 ? (SPFLOAT)sigil_as_flonum(args[2]) : 0.0f;
+348
+349
sp_ftbl *ft;
+350
sp_ftbl_create(g_sp, &ft, 4096);
+351
sp_gen_sine(g_sp, ft);
+352
+353
sp_osc *osc;
+354
sp_osc_create(&osc);
+355
sp_osc_init(g_sp, osc, ft, phase);
+356
osc->freq = freq;
+357
osc->amp = amp;
+358
+359
dsp_osc *d = malloc(sizeof(dsp_osc));
+360
d->osc = osc;
+361
d->ft = ft;
+362
+363
ENSURE_TAG(vm, tt_osc, "dsp-osc");
+364
return sigil_make_foreign(vm, tt_osc, d, destroy_osc,
+365
sizeof(dsp_osc) + sizeof(sp_osc) + 4096 * sizeof(SPFLOAT));
+366
}
+367
+368
/* (make-osc-ft ftbl freq amp [phase]) -> <osc>
+369
* Wavetable oscillator with custom function table */
+370
static Value native_make_osc_ft(SigilVM *vm, int argc, Value *args)
+371
{
+372
CHECK_SP(vm, "make-osc-ft");
+373
ENSURE_TAG(vm, tt_ftbl, "dsp-ftbl");
+374
if (!sigil_is_foreign_type(args[0], tt_ftbl)) {
+375
sigil__vm_set_error(vm, SIGIL_ERR_TYPE, "make-osc-ft: expected ftbl as first argument");
+376
return SIGIL_FALSE;
+377
}
+378
/* Note: the ftbl is NOT owned by this osc — caller manages its lifetime */
+379
sp_ftbl *ft = (sp_ftbl *)sigil_foreign_get_data(args[0]);
+380
SPFLOAT freq = (SPFLOAT)sigil_as_flonum(args[1]);
+381
SPFLOAT amp = (SPFLOAT)sigil_as_flonum(args[2]);
+382
SPFLOAT phase = argc > 3 ? (SPFLOAT)sigil_as_flonum(args[3]) : 0.0f;
+383
+384
sp_osc *osc;
+385
sp_osc_create(&osc);
+386
sp_osc_init(g_sp, osc, ft, phase);
+387
osc->freq = freq;
+388
osc->amp = amp;
+389
+390
dsp_osc *d = malloc(sizeof(dsp_osc));
+391
d->osc = osc;
+392
d->ft = NULL; /* not owned */
+393
+394
ENSURE_TAG(vm, tt_osc, "dsp-osc");
+395
return sigil_make_foreign(vm, tt_osc, d, destroy_osc,
+396
sizeof(dsp_osc) + sizeof(sp_osc));
+397
}
+398
+399
/* (osc-compute osc) -> flonum */
+400
static Value native_osc_compute(SigilVM *vm, int argc, Value *args)
+401
{
+402
dsp_osc *d = get_osc(vm, args[0]);
+403
if (!d) { sigil__vm_set_error(vm, SIGIL_ERR_TYPE, "osc-compute: expected osc"); return SIGIL_FALSE; }
+404
SPFLOAT in = 0, out = 0;
+405
sp_osc_compute(g_sp, d->osc, &in, &out);
+406
return sigil_flonum((double)out);
+407
}
+408
+409
/* (osc-set-freq! osc freq) */
+410
static Value native_osc_set_freq(SigilVM *vm, int argc, Value *args)
+411
{
+412
dsp_osc *d = get_osc(vm, args[0]);
+413
if (!d) { sigil__vm_set_error(vm, SIGIL_ERR_TYPE, "osc-set-freq!: expected osc"); return SIGIL_FALSE; }
+414
d->osc->freq = (SPFLOAT)sigil_as_flonum(args[1]);
+415
return SIGIL_NIL;
+416
}
+417
+418
/* (osc-set-amp! osc amp) */
+419
static Value native_osc_set_amp(SigilVM *vm, int argc, Value *args)
+420
{
+421
dsp_osc *d = get_osc(vm, args[0]);
+422
if (!d) { sigil__vm_set_error(vm, SIGIL_ERR_TYPE, "osc-set-amp!: expected osc"); return SIGIL_FALSE; }
+423
d->osc->amp = (SPFLOAT)sigil_as_flonum(args[1]);
+424
return SIGIL_NIL;
+425
}
+426
+427
/* (make-posc3 freq amp [phase]) -> <posc3> */
+428
static Value native_make_posc3(SigilVM *vm, int argc, Value *args)
+429
{
+430
CHECK_SP(vm, "make-posc3");
+431
SPFLOAT freq = (SPFLOAT)sigil_as_flonum(args[0]);
+432
SPFLOAT amp = (SPFLOAT)sigil_as_flonum(args[1]);
+433
+434
sp_ftbl *ft;
+435
sp_ftbl_create(g_sp, &ft, 4096);
+436
sp_gen_sine(g_sp, ft);
+437
+438
sp_posc3 *osc;
+439
sp_posc3_create(&osc);
+440
sp_posc3_init(g_sp, osc, ft);
+441
osc->freq = freq;
+442
osc->amp = amp;
+443
+444
dsp_posc3 *d = malloc(sizeof(dsp_posc3));
+445
d->osc = osc;
+446
d->ft = ft;
+447
+448
ENSURE_TAG(vm, tt_posc3, "dsp-posc3");
+449
return sigil_make_foreign(vm, tt_posc3, d, destroy_posc3,
+450
sizeof(dsp_posc3) + sizeof(sp_posc3) + 4096 * sizeof(SPFLOAT));
+451
}
+452
+453
/* (posc3-compute osc) -> flonum */
+454
static Value native_posc3_compute(SigilVM *vm, int argc, Value *args)
+455
{
+456
dsp_posc3 *d = get_posc3(vm, args[0]);
+457
if (!d) { sigil__vm_set_error(vm, SIGIL_ERR_TYPE, "posc3-compute: expected posc3"); return SIGIL_FALSE; }
+458
SPFLOAT in = 0, out = 0;
+459
sp_posc3_compute(g_sp, d->osc, &in, &out);
+460
return sigil_flonum((double)out);
+461
}
+462
+463
/* (posc3-set-freq! osc freq) */
+464
static Value native_posc3_set_freq(SigilVM *vm, int argc, Value *args)
+465
{
+466
dsp_posc3 *d = get_posc3(vm, args[0]);
+467
if (!d) { sigil__vm_set_error(vm, SIGIL_ERR_TYPE, "posc3-set-freq!: expected posc3"); return SIGIL_FALSE; }
+468
d->osc->freq = (SPFLOAT)sigil_as_flonum(args[1]);
+469
return SIGIL_NIL;
+470
}
+471
+472
/* (posc3-set-amp! osc amp) */
+473
static Value native_posc3_set_amp(SigilVM *vm, int argc, Value *args)
+474
{
+475
dsp_posc3 *d = get_posc3(vm, args[0]);
+476
if (!d) { sigil__vm_set_error(vm, SIGIL_ERR_TYPE, "posc3-set-amp!: expected posc3"); return SIGIL_FALSE; }
+477
d->osc->amp = (SPFLOAT)sigil_as_flonum(args[1]);
+478
return SIGIL_NIL;
+479
}
+480
+481
/* (make-blsaw freq amp) -> <blsaw> */
+482
static Value native_make_blsaw(SigilVM *vm, int argc, Value *args)
+483
{
+484
CHECK_SP(vm, "make-blsaw");
+485
SPFLOAT freq = (SPFLOAT)sigil_as_flonum(args[0]);
+486
SPFLOAT amp = (SPFLOAT)sigil_as_flonum(args[1]);
+487
+488
sp_blsaw *p;
+489
sp_blsaw_create(&p);
+490
sp_blsaw_init(g_sp, p);
+491
*p->freq = freq;
+492
*p->amp = amp;
+493
+494
ENSURE_TAG(vm, tt_blsaw, "dsp-blsaw");
+495
return sigil_make_foreign(vm, tt_blsaw, p, destroy_blsaw, sizeof(sp_blsaw));
+496
}
+497
+498
/* (blsaw-compute osc) -> flonum */
+499
static Value native_blsaw_compute(SigilVM *vm, int argc, Value *args)

Showing the first 500 of 1999 diff lines for this file. This diff is INCOMPLETE; read the file or clone the repository for the rest.

src/sigil/dsp/core.sgladded
@@ -0,0 +1,23 @@
+1
;;; (sigil dsp core) - DSP engine lifecycle and function tables
+2
;;;
+3
;;; Initialize the DSP engine before using any other dsp modules.
+4
;;;
+5
;;; ```scheme
+6
;;; (import (sigil dsp core))
+7
;;; (dsp-init 44100)
+8
;;; (dsp-sample-rate) ; => 44100
+9
;;; (dsp-shutdown)
+10
;;; ```
+11
+12
(define-library (sigil dsp core)
+13
(export dsp-init dsp-shutdown dsp-sample-rate
+14
make-ftbl ftbl-gen-sine ftbl-gen-triangle ftbl-gen-line)
+15
+16
(begin
+17
(define-native dsp-init)
+18
(define-native (dsp-shutdown))
+19
(define-native (dsp-sample-rate))
+20
(define-native (make-ftbl size))
+21
(define-native (ftbl-gen-sine ft))
+22
(define-native (ftbl-gen-triangle ft))
+23
(define-native (ftbl-gen-line ft argstring))))
src/sigil/dsp/env.sgladded
@@ -0,0 +1,33 @@
+1
;;; (sigil dsp env) - Envelopes
+2
;;;
+3
;;; ADSR, triggered envelopes, line segments, exponential curves, portamento.
+4
;;;
+5
;;; ```scheme
+6
;;; (import (sigil dsp core) (sigil dsp env))
+7
;;; (dsp-init)
+8
;;; (define env (make-adsr 0.01 0.1 0.7 0.3))
+9
;;; (adsr-compute env 1.0) ; gate on => envelope value
+10
;;; ```
+11
+12
(define-library (sigil dsp env)
+13
(export
+14
make-adsr adsr-compute
+15
make-tadsr tadsr-compute
+16
make-tenv tenv-compute
+17
make-line line-compute
+18
make-expon expon-compute
+19
make-port port-compute)
+20
+21
(begin
+22
(define-native (make-adsr atk dec sus rel))
+23
(define-native (adsr-compute adsr gate))
+24
(define-native (make-tadsr atk dec sus rel))
+25
(define-native (tadsr-compute tadsr trigger))
+26
(define-native (make-tenv atk hold rel))
+27
(define-native (tenv-compute tenv trigger))
+28
(define-native (make-line a dur b))
+29
(define-native (line-compute line trigger))
+30
(define-native (make-expon a dur b))
+31
(define-native (expon-compute expon trigger))
+32
(define-native (make-port smoothing))
+33
(define-native (port-compute port input))))
src/sigil/dsp/filter.sgladded
@@ -0,0 +1,42 @@
+1
;;; (sigil dsp filter) - Filters
+2
;;;
+3
;;; Lowpass, highpass, resonant, and DC blocking filters.
+4
;;;
+5
;;; ```scheme
+6
;;; (import (sigil dsp core) (sigil dsp filter))
+7
;;; (dsp-init)
+8
;;; (define filt (make-filter 'moogladder 1000.0 0.4))
+9
;;; (filter-compute filt 0.5) ; => filtered sample
+10
;;; ```
+11
+12
(define-library (sigil dsp filter)
+13
(export
+14
make-filter
+15
make-moogladder make-butlp make-buthp make-lpf18
+16
make-tone make-atone make-dcblock
+17
filter-compute filter-set-freq! filter-set-res!)
+18
+19
(begin
+20
(define-native (make-moogladder freq res))
+21
(define-native (make-butlp freq))
+22
(define-native (make-buthp freq))
+23
(define-native (make-lpf18 cutoff res dist))
+24
(define-native (make-tone freq))
+25
(define-native (make-atone freq))
+26
(define-native (make-dcblock))
+27
(define-native (filter-compute filter input))
+28
(define-native (filter-set-freq! filter freq))
+29
(define-native (filter-set-res! filter res))
+30
+31
;;; Create a filter by type.
+32
;;; Types: moogladder, butlp, buthp, lpf18, tone, atone, dcblock
+33
(define (make-filter type . args)
+34
(case type
+35
((moogladder) (apply make-moogladder args))
+36
((butlp) (apply make-butlp args))
+37
((buthp) (apply make-buthp args))
+38
((lpf18) (apply make-lpf18 args))
+39
((tone) (apply make-tone args))
+40
((atone) (apply make-atone args))
+41
((dcblock) (make-dcblock))
+42
(else (error "make-filter: unknown type" type))))))
src/sigil/dsp/fx.sgladded
@@ -0,0 +1,34 @@
+1
;;; (sigil dsp fx) - Effects
+2
;;;
+3
;;; Reverb and delay effects.
+4
;;;
+5
;;; ```scheme
+6
;;; (import (sigil dsp core) (sigil dsp fx))
+7
;;; (dsp-init)
+8
;;; (define rev (make-revsc 0.97 10000.0))
+9
;;; (revsc-compute rev 0.5 0.5) ; => (left . right)
+10
;;; ```
+11
+12
(define-library (sigil dsp fx)
+13
(export
+14
make-revsc revsc-compute revsc-set-feedback! revsc-set-lpfreq!
+15
make-zitarev zitarev-compute zitarev-set-mix! zitarev-set-level!
+16
make-delay delay-compute delay-set-feedback!
+17
make-vdelay vdelay-compute vdelay-set-del! vdelay-set-feedback!)
+18
+19
(begin
+20
(define-native (make-revsc feedback lpfreq))
+21
(define-native (revsc-compute revsc in-left in-right))
+22
(define-native (revsc-set-feedback! revsc feedback))
+23
(define-native (revsc-set-lpfreq! revsc lpfreq))
+24
(define-native (make-zitarev))
+25
(define-native (zitarev-compute zitarev in-left in-right))
+26
(define-native (zitarev-set-mix! zitarev mix))
+27
(define-native (zitarev-set-level! zitarev level))
+28
(define-native (make-delay time feedback))
+29
(define-native (delay-compute delay input))
+30
(define-native (delay-set-feedback! delay feedback))
+31
(define-native (make-vdelay maxdel feedback))
+32
(define-native (vdelay-compute vdelay input))
+33
(define-native (vdelay-set-del! vdelay del))
+34
(define-native (vdelay-set-feedback! vdelay feedback))))
src/sigil/dsp/noise.sgladded
@@ -0,0 +1,24 @@
+1
;;; (sigil dsp noise) - Noise generators
+2
;;;
+3
;;; White, pink, and brown noise.
+4
;;;
+5
;;; ```scheme
+6
;;; (import (sigil dsp core) (sigil dsp noise))
+7
;;; (dsp-init)
+8
;;; (define n (make-noise 0.5))
+9
;;; (noise-compute n) ; => random sample
+10
;;; ```
+11
+12
(define-library (sigil dsp noise)
+13
(export
+14
make-noise noise-compute
+15
make-pinknoise pinknoise-compute
+16
make-brown brown-compute)
+17
+18
(begin
+19
(define-native (make-noise amp))
+20
(define-native (noise-compute noise))
+21
(define-native (make-pinknoise amp))
+22
(define-native (pinknoise-compute pinknoise))
+23
(define-native (make-brown))
+24
(define-native (brown-compute brown))))
src/sigil/dsp/osc.sgladded
@@ -0,0 +1,69 @@
+1
;;; (sigil dsp osc) - Oscillators
+2
;;;
+3
;;; Wavetable, bandlimited, FM, and phase oscillators.
+4
;;;
+5
;;; ```scheme
+6
;;; (import (sigil dsp core) (sigil dsp osc))
+7
;;; (dsp-init)
+8
;;; (define osc (make-oscillator 'sine 440.0 0.5))
+9
;;; (osc-compute osc) ; => one sample
+10
;;; ```
+11
+12
(define-library (sigil dsp osc)
+13
(export
+14
make-oscillator
+15
make-osc make-osc-ft osc-compute osc-set-freq! osc-set-amp!
+16
make-posc3 posc3-compute posc3-set-freq! posc3-set-amp!
+17
make-blsaw blsaw-compute blsaw-set-freq! blsaw-set-amp!
+18
make-blsquare blsquare-compute blsquare-set-freq! blsquare-set-amp!
+19
make-bltriangle bltriangle-compute bltriangle-set-freq! bltriangle-set-amp!
+20
make-fosc fosc-compute fosc-set-freq! fosc-set-index! fosc-set-amp!
+21
make-phasor phasor-compute phasor-set-freq!)
+22
+23
(begin
+24
(define-native make-osc)
+25
(define-native make-osc-ft)
+26
(define-native (osc-compute osc))
+27
(define-native (osc-set-freq! osc freq))
+28
(define-native (osc-set-amp! osc amp))
+29
(define-native make-posc3)
+30
(define-native (posc3-compute osc))
+31
(define-native (posc3-set-freq! osc freq))
+32
(define-native (posc3-set-amp! osc amp))
+33
(define-native (make-blsaw freq amp))
+34
(define-native (blsaw-compute osc))
+35
(define-native (blsaw-set-freq! osc freq))
+36
(define-native (blsaw-set-amp! osc amp))
+37
(define-native make-blsquare)
+38
(define-native (blsquare-compute osc))
+39
(define-native (blsquare-set-freq! osc freq))
+40
(define-native (blsquare-set-amp! osc amp))
+41
(define-native (make-bltriangle freq amp))
+42
(define-native (bltriangle-compute osc))
+43
(define-native (bltriangle-set-freq! osc freq))
+44
(define-native (bltriangle-set-amp! osc amp))
+45
(define-native (make-fosc freq car mod indx amp))
+46
(define-native (fosc-compute osc))
+47
(define-native (fosc-set-freq! osc freq))
+48
(define-native (fosc-set-index! osc indx))
+49
(define-native (fosc-set-amp! osc amp))
+50
(define-native make-phasor)
+51
(define-native (phasor-compute phasor))
+52
(define-native (phasor-set-freq! phasor freq))
+53
+54
;;; Create an oscillator by type.
+55
;;; Types: sine, saw, square, triangle, fm
+56
(define (make-oscillator type freq amp . opts)
+57
(case type
+58
((sine) (make-osc freq amp))
+59
((saw) (make-blsaw freq amp))
+60
((square) (if (null? opts)
+61
(make-blsquare freq amp)
+62
(make-blsquare freq amp (car opts))))
+63
((triangle) (make-bltriangle freq amp))
+64
((fm) (if (>= (length opts) 2)
+65
(make-fosc freq (car opts) (cadr opts)
+66
(if (>= (length opts) 3) (caddr opts) 1.0)
+67
amp)
+68
(error "make-oscillator: fm requires car and mod ratios" opts)))
+69
(else (error "make-oscillator: unknown type" type))))))
src/sigil/dsp/test-main.sgladded
@@ -0,0 +1,74 @@
+1
;;; Test entry point for sigil-dsp
+2
+3
(define-library (sigil dsp test-main)
+4
(import (sigil core)
+5
(sigil dsp core)
+6
(sigil dsp osc)
+7
(sigil dsp filter)
+8
(sigil dsp env)
+9
(sigil dsp fx)
+10
(sigil dsp noise)
+11
(sigil dsp util))
+12
+13
(export main)
+14
+15
(begin
+16
(define (main . args)
+17
(display "=== sigil-dsp tests ===\n\n")
+18
+19
;; Core
+20
(dsp-init 44100)
+21
(display (string-append "Sample rate: " (number->string (dsp-sample-rate)) "\n"))
+22
+23
;; Oscillator
+24
(display "\n--- Oscillators ---\n")
+25
(let ((osc (make-osc 440.0 1.0)))
+26
(let ((s (osc-compute osc)))
+27
(display (string-append " Sine: " (number->string s) "\n"))))
+28
+29
(let ((saw (make-blsaw 220.0 0.8)))
+30
(blsaw-compute saw) (blsaw-compute saw)
+31
(display (string-append " Saw: " (number->string (blsaw-compute saw)) "\n")))
+32
+33
(let ((fm (make-fosc 440.0 1.0 2.0 5.0 0.6)))
+34
(display (string-append " FM: " (number->string (fosc-compute fm)) "\n")))
+35
+36
;; Filter
+37
(display "\n--- Filters ---\n")
+38
(let ((filt (make-moogladder 1000.0 0.4)))
+39
(display (string-append " Moogladder: " (number->string (filter-compute filt 0.5)) "\n")))
+40
+41
;; Envelope
+42
(display "\n--- Envelopes ---\n")
+43
(let ((env (make-adsr 0.01 0.1 0.7 0.3)))
+44
(display (string-append " ADSR: " (number->string (adsr-compute env 1.0)) "\n")))
+45
+46
;; Reverb
+47
(display "\n--- Effects ---\n")
+48
(let ((rev (make-revsc 0.97 10000.0)))
+49
(let ((r (revsc-compute rev 0.5 0.5)))
+50
(display (string-append " Reverb L: " (number->string (car r))
+51
" R: " (number->string (cdr r)) "\n"))))
+52
+53
;; Noise
+54
(display "\n--- Noise ---\n")
+55
(let ((n (make-noise 1.0)))
+56
(display (string-append " White: " (number->string (noise-compute n)) "\n")))
+57
+58
;; Utility
+59
(display "\n--- Utility ---\n")
+60
(let ((pan (make-pan2 0.3)))
+61
(let ((r (pan2-compute pan 0.8)))
+62
(display (string-append " Pan L: " (number->string (car r))
+63
" R: " (number->string (cdr r)) "\n"))))
+64
+65
;; Metro
+66
(let ((met (make-metro 2.0)))
+67
(let loop ((i 0) (triggers 0))
+68
(if (> i 44100)
+69
(display (string-append " Metro triggers: " (number->string triggers) "\n"))
+70
(let ((val (metro-compute met)))
+71
(loop (+ i 1) (if (> val 0.0) (+ triggers 1) triggers))))))
+72
+73
(dsp-shutdown)
+74
(display "\n=== All tests passed! ===\n"))))
src/sigil/dsp/util.sgladded
@@ -0,0 +1,51 @@
+1
;;; (sigil dsp util) - Utility DSP modules
+2
;;;
+3
;;; Dynamics, panning, timing, random modulation, scaling, and WAV output.
+4
+5
(define-library (sigil dsp util)
+6
(export
+7
make-saturator saturator-compute
+8
make-clip clip-compute
+9
make-peaklim peaklim-compute
+10
make-pan2 pan2-compute pan2-set-pan!
+11
make-metro metro-compute metro-set-freq!
+12
make-clock clock-compute clock-set-bpm!
+13
make-tgate tgate-compute
+14
make-randh randh-compute
+15
make-randi randi-compute
+16
make-scale scale-compute
+17
make-clamp clamp-compute
+18
make-crossfade crossfade-compute crossfade-set-pos!
+19
make-wavout wavout-compute)
+20
+21
(begin
+22
(define-native (make-saturator drive dcoffset))
+23
(define-native (saturator-compute saturator input))
+24
(define-native (make-clip limit))
+25
(define-native (clip-compute clip input))
+26
(define-native (make-peaklim atk rel thresh))
+27
(define-native (peaklim-compute peaklim input))
+28
(define-native make-pan2)
+29
(define-native (pan2-compute pan2 input))
+30
(define-native (pan2-set-pan! pan2 pan))
+31
(define-native (make-metro freq))
+32
(define-native (metro-compute metro))
+33
(define-native (metro-set-freq! metro freq))
+34
(define-native (make-clock bpm subdiv))
+35
(define-native (clock-compute clock trigger))
+36
(define-native (clock-set-bpm! clock bpm))
+37
(define-native (make-tgate time))
+38
(define-native (tgate-compute tgate trigger))
+39
(define-native (make-randh min max freq))
+40
(define-native (randh-compute randh))
+41
(define-native (make-randi min max freq))
+42
(define-native (randi-compute randi))
+43
(define-native (make-scale min max))
+44
(define-native (scale-compute scale input))
+45
(define-native (make-clamp min max))
+46
(define-native (clamp-compute clamp input))
+47
(define-native make-crossfade)
+48
(define-native (crossfade-compute crossfade in1 in2))
+49
(define-native (crossfade-set-pos! crossfade pos))
+50
(define-native (make-wavout filename))
+51
(define-native (wavout-compute wavout sample))))
test/basic-test.sgladded
@@ -0,0 +1,5 @@
+1
(import (sigil dsp core))
+2
(dsp-init)
+3
(display (dsp-sample-rate))
+4
(newline)
+5
(dsp-shutdown)
vendor/soundpipe/h/adsr.hadded
@@ -0,0 +1,19 @@
+1
typedef struct {
+2
SPFLOAT atk;
+3
SPFLOAT dec;
+4
SPFLOAT sus;
+5
SPFLOAT rel;
+6
uint32_t timer;
+7
uint32_t atk_time;
+8
SPFLOAT a;
+9
SPFLOAT b;
+10
SPFLOAT y;
+11
SPFLOAT x;
+12
SPFLOAT prev;
+13
int mode;
+14
} sp_adsr;
+15
+16
int sp_adsr_create(sp_adsr **p);
+17
int sp_adsr_destroy(sp_adsr **p);
+18
int sp_adsr_init(sp_data *sp, sp_adsr *p);
+19
int sp_adsr_compute(sp_data *sp, sp_adsr *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/atone.hadded
@@ -0,0 +1,10 @@
+1
typedef struct {
+2
SPFLOAT hp;
+3
SPFLOAT c1, c2, yt1, prvhp;
+4
SPFLOAT tpidsr;
+5
} sp_atone;
+6
+7
int sp_atone_create(sp_atone **p);
+8
int sp_atone_destroy(sp_atone **p);
+9
int sp_atone_init(sp_data *sp, sp_atone *p);
+10
int sp_atone_compute(sp_data *sp, sp_atone *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/base.hadded
@@ -0,0 +1,97 @@
+1
#include <stdint.h>
+2
#include <stdio.h>
+3
+4
#define SP_BUFSIZE 4096
+5
#ifndef SPFLOAT
+6
#define SPFLOAT float
+7
#endif
+8
#define SP_OK 1
+9
#define SP_NOT_OK 0
+10
+11
#define SP_RANDMAX 2147483648
+12
+13
typedef unsigned long sp_frame;
+14
+15
typedef struct sp_auxdata {
+16
size_t size;
+17
void *ptr;
+18
} sp_auxdata;
+19
+20
typedef struct sp_data {
+21
SPFLOAT *out;
+22
int sr;
+23
int nchan;
+24
unsigned long len;
+25
unsigned long pos;
+26
char filename[200];
+27
uint32_t rand;
+28
} sp_data;
+29
+30
typedef struct {
+31
char state;
+32
SPFLOAT val;
+33
} sp_param;
+34
+35
int sp_auxdata_alloc(sp_auxdata *aux, size_t size);
+36
int sp_auxdata_free(sp_auxdata *aux);
+37
+38
int sp_create(sp_data **spp);
+39
int sp_createn(sp_data **spp, int nchan);
+40
+41
int sp_destroy(sp_data **spp);
+42
int sp_process(sp_data *sp, void *ud, void (*callback)(sp_data *, void *));
+43
int sp_process_raw(sp_data *sp, void *ud, void (*callback)(sp_data *, void *));
+44
int sp_process_plot(sp_data *sp, void *ud, void (*callback)(sp_data *, void *));
+45
int sp_process_spa(sp_data *sp, void *ud, void (*callback)(sp_data *, void *));
+46
+47
SPFLOAT sp_midi2cps(SPFLOAT nn);
+48
+49
int sp_set(sp_param *p, SPFLOAT val);
+50
+51
int sp_out(sp_data *sp, uint32_t chan, SPFLOAT val);
+52
+53
uint32_t sp_rand(sp_data *sp);
+54
void sp_srand(sp_data *sp, uint32_t val);
+55
+56
+57
typedef struct {
+58
SPFLOAT *utbl;
+59
int16_t *BRLow;
+60
int16_t *BRLowCpx;
+61
} sp_fft;
+62
+63
void sp_fft_create(sp_fft **fft);
+64
void sp_fft_init(sp_fft *fft, int M);
+65
void sp_fftr(sp_fft *fft, SPFLOAT *buf, int FFTsize);
+66
void sp_fft_cpx(sp_fft *fft, SPFLOAT *buf, int FFTsize);
+67
void sp_ifftr(sp_fft *fft, SPFLOAT *buf, int FFTsize);
+68
void sp_fft_destroy(sp_fft *fft);
+69
#ifndef kiss_fft_scalar
+70
#define kiss_fft_scalar SPFLOAT
+71
#endif
+72
typedef struct {
+73
kiss_fft_scalar r;
+74
kiss_fft_scalar i;
+75
}kiss_fft_cpx;
+76
+77
typedef struct kiss_fft_state* kiss_fft_cfg;
+78
typedef struct kiss_fftr_state* kiss_fftr_cfg;
+79
+80
/* SPA: Soundpipe Audio */
+81
+82
enum { SPA_READ, SPA_WRITE, SPA_NULL };
+83
+84
typedef struct {
+85
char magic;
+86
char nchan;
+87
uint16_t sr;
+88
uint32_t len;
+89
} spa_header;
+90
+91
typedef struct {
+92
spa_header header;
+93
size_t offset;
+94
int mode;
+95
FILE *fp;
+96
uint32_t pos;
+97
} sp_audio;
vendor/soundpipe/h/blsaw.hadded
@@ -0,0 +1,12 @@
+1
typedef struct {
+2
void *ud;
+3
int argpos;
+4
SPFLOAT *args[2];
+5
SPFLOAT *freq;
+6
SPFLOAT *amp;
+7
} sp_blsaw;
+8
+9
int sp_blsaw_create(sp_blsaw **p);
+10
int sp_blsaw_destroy(sp_blsaw **p);
+11
int sp_blsaw_init(sp_data *sp, sp_blsaw *p);
+12
int sp_blsaw_compute(sp_data *sp, sp_blsaw *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/blsquare.hadded
@@ -0,0 +1,13 @@
+1
typedef struct {
+2
void *ud;
+3
int argpos;
+4
SPFLOAT *args[3];
+5
SPFLOAT *freq;
+6
SPFLOAT *amp;
+7
SPFLOAT *width;
+8
} sp_blsquare;
+9
+10
int sp_blsquare_create(sp_blsquare **p);
+11
int sp_blsquare_destroy(sp_blsquare **p);
+12
int sp_blsquare_init(sp_data *sp, sp_blsquare *p);
+13
int sp_blsquare_compute(sp_data *sp, sp_blsquare *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/bltriangle.hadded
@@ -0,0 +1,12 @@
+1
typedef struct {
+2
void *ud;
+3
int argpos;
+4
SPFLOAT *args[2];
+5
SPFLOAT *freq;
+6
SPFLOAT *amp;
+7
} sp_bltriangle;
+8
+9
int sp_bltriangle_create(sp_bltriangle **p);
+10
int sp_bltriangle_destroy(sp_bltriangle **p);
+11
int sp_bltriangle_init(sp_data *sp, sp_bltriangle *p);
+12
int sp_bltriangle_compute(sp_data *sp, sp_bltriangle *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/brown.hadded
@@ -0,0 +1,8 @@
+1
typedef struct {
+2
SPFLOAT brown;
+3
} sp_brown;
+4
+5
int sp_brown_create(sp_brown **p);
+6
int sp_brown_destroy(sp_brown **p);
+7
int sp_brown_init(sp_data *sp, sp_brown *p);
+8
int sp_brown_compute(sp_data *sp, sp_brown *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/buthp.hadded
@@ -0,0 +1,11 @@
+1
typedef struct {
+2
SPFLOAT freq;
+3
SPFLOAT lfreq;
+4
SPFLOAT a[7];
+5
SPFLOAT pidsr;
+6
} sp_buthp;
+7
+8
int sp_buthp_create(sp_buthp **p);
+9
int sp_buthp_destroy(sp_buthp **p);
+10
int sp_buthp_init(sp_data *sp, sp_buthp *p);
+11
int sp_buthp_compute(sp_data *sp, sp_buthp *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/butlp.hadded
@@ -0,0 +1,11 @@
+1
typedef struct {
+2
SPFLOAT sr, freq;
+3
SPFLOAT lfreq;
+4
SPFLOAT a[7];
+5
SPFLOAT pidsr;
+6
} sp_butlp;
+7
+8
int sp_butlp_create(sp_butlp **p);
+9
int sp_butlp_destroy(sp_butlp **p);
+10
int sp_butlp_init(sp_data *sp, sp_butlp *p);
+11
int sp_butlp_compute(sp_data *sp, sp_butlp *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/clamp.hadded
@@ -0,0 +1,9 @@
+1
typedef struct {
+2
SPFLOAT min;
+3
SPFLOAT max;
+4
} sp_clamp;
+5
+6
int sp_clamp_create(sp_clamp **p);
+7
int sp_clamp_destroy(sp_clamp **p);
+8
int sp_clamp_init(sp_data *sp, sp_clamp *p);
+9
int sp_clamp_compute(sp_data *sp, sp_clamp *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/clip.hadded
@@ -0,0 +1,8 @@
+1
typedef struct{
+2
SPFLOAT lim, k1;
+3
}sp_clip;
+4
+5
int sp_clip_create(sp_clip **p);
+6
int sp_clip_destroy(sp_clip **p);
+7
int sp_clip_init(sp_data *sp, sp_clip *p);
+8
int sp_clip_compute(sp_data *sp, sp_clip *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/clock.hadded
@@ -0,0 +1,10 @@
+1
typedef struct {
+2
SPFLOAT bpm;
+3
SPFLOAT subdiv;
+4
uint32_t counter;
+5
} sp_clock;
+6
+7
int sp_clock_create(sp_clock **p);
+8
int sp_clock_destroy(sp_clock **p);
+9
int sp_clock_init(sp_data *sp, sp_clock *p);
+10
int sp_clock_compute(sp_data *sp, sp_clock *p, SPFLOAT *trig, SPFLOAT *out);
vendor/soundpipe/h/crossfade.hadded
@@ -0,0 +1,8 @@
+1
typedef struct {
+2
SPFLOAT pos;
+3
} sp_crossfade;
+4
+5
int sp_crossfade_create(sp_crossfade **p);
+6
int sp_crossfade_destroy(sp_crossfade **p);
+7
int sp_crossfade_init(sp_data *sp, sp_crossfade *p);
+8
int sp_crossfade_compute(sp_data *sp, sp_crossfade *p, SPFLOAT *in1, SPFLOAT *in2, SPFLOAT *out);
vendor/soundpipe/h/dcblock.hadded
@@ -0,0 +1,11 @@
+1
typedef struct {
+2
SPFLOAT gg;
+3
SPFLOAT outputs;
+4
SPFLOAT inputs;
+5
SPFLOAT gain;
+6
} sp_dcblock;
+7
+8
int sp_dcblock_create(sp_dcblock **p);
+9
int sp_dcblock_destroy(sp_dcblock **p);
+10
int sp_dcblock_init(sp_data *sp, sp_dcblock *p);
+11
int sp_dcblock_compute(sp_data *sp, sp_dcblock *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/delay.hadded
@@ -0,0 +1,13 @@
+1
typedef struct {
+2
SPFLOAT time;
+3
SPFLOAT feedback;
+4
SPFLOAT last;
+5
sp_auxdata buf;
+6
uint32_t bufsize;
+7
uint32_t bufpos;
+8
} sp_delay;
+9
+10
int sp_delay_create(sp_delay **p);
+11
int sp_delay_destroy(sp_delay **p);
+12
int sp_delay_init(sp_data *sp, sp_delay *p, SPFLOAT time);
+13
int sp_delay_compute(sp_data *sp, sp_delay *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/expon.hadded
@@ -0,0 +1,11 @@
+1
typedef struct {
+2
SPFLOAT a, dur, b;
+3
SPFLOAT val, incr;
+4
uint32_t sdur, stime;
+5
int init;
+6
} sp_expon;
+7
+8
int sp_expon_create(sp_expon **p);
+9
int sp_expon_destroy(sp_expon **p);
+10
int sp_expon_init(sp_data *sp, sp_expon *p);
+11
int sp_expon_compute(sp_data *sp, sp_expon *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/fosc.hadded
@@ -0,0 +1,10 @@
+1
typedef struct sp_fosc{
+2
SPFLOAT amp, freq, car, mod, indx, iphs;
+3
int32_t mphs, cphs;
+4
sp_ftbl *ft;
+5
} sp_fosc;
+6
+7
int sp_fosc_create(sp_fosc **p);
+8
int sp_fosc_destroy(sp_fosc **p);
+9
int sp_fosc_init(sp_data *sp, sp_fosc *p, sp_ftbl *ft);
+10
int sp_fosc_compute(sp_data *sp, sp_fosc *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/ftbl.hadded
@@ -0,0 +1,29 @@
+1
#define SP_FT_MAXLEN 0x1000000L
+2
#define SP_FT_PHMASK 0x0FFFFFFL
+3
+4
typedef struct sp_ftbl{
+5
size_t size;
+6
uint32_t lobits;
+7
uint32_t lomask;
+8
SPFLOAT lodiv;
+9
SPFLOAT sicvt;
+10
SPFLOAT *tbl;
+11
char del;
+12
}sp_ftbl;
+13
+14
int sp_ftbl_create(sp_data *sp, sp_ftbl **ft, size_t size);
+15
int sp_ftbl_init(sp_data *sp, sp_ftbl *ft, size_t size);
+16
int sp_ftbl_bind(sp_data *sp, sp_ftbl **ft, SPFLOAT *tbl, size_t size);
+17
int sp_ftbl_destroy(sp_ftbl **ft);
+18
int sp_gen_vals(sp_data *sp, sp_ftbl *ft, const char *string);
+19
int sp_gen_sine(sp_data *sp, sp_ftbl *ft);
+20
int sp_gen_file(sp_data *sp, sp_ftbl *ft, const char *filename);
+21
int sp_gen_sinesum(sp_data *sp, sp_ftbl *ft, const char *argstring);
+22
int sp_gen_line(sp_data *sp, sp_ftbl *ft, const char *argstring);
+23
int sp_gen_xline(sp_data *sp, sp_ftbl *ft, const char *argstring);
+24
int sp_gen_gauss(sp_data *sp, sp_ftbl *ft, SPFLOAT scale, uint32_t seed);
+25
int sp_ftbl_loadfile(sp_data *sp, sp_ftbl **ft, const char *filename);
+26
int sp_ftbl_loadspa(sp_data *sp, sp_ftbl **ft, const char *filename);
+27
int sp_gen_composite(sp_data *sp, sp_ftbl *ft, const char *argstring);
+28
int sp_gen_rand(sp_data *sp, sp_ftbl *ft, const char *argstring);
+29
int sp_gen_triangle(sp_data *sp, sp_ftbl *ft);
vendor/soundpipe/h/line.hadded
@@ -0,0 +1,11 @@
+1
typedef struct {
+2
SPFLOAT a, dur, b;
+3
SPFLOAT val, incr;
+4
uint32_t sdur, stime;
+5
int init;
+6
} sp_line;
+7
+8
int sp_line_create(sp_line **p);
+9
int sp_line_destroy(sp_line **p);
+10
int sp_line_init(sp_data *sp, sp_line *p);
+11
int sp_line_compute(sp_data *sp, sp_line *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/lpf18.hadded
@@ -0,0 +1,9 @@
+1
typedef struct sp_lpf18{
+2
SPFLOAT cutoff, res, dist;
+3
SPFLOAT ay1, ay2, aout, lastin, onedsr;
+4
} sp_lpf18;
+5
+6
int sp_lpf18_create(sp_lpf18 **p);
+7
int sp_lpf18_destroy(sp_lpf18 **p);
+8
int sp_lpf18_init(sp_data *sp, sp_lpf18 *p);
+9
int sp_lpf18_compute(sp_data *sp, sp_lpf18 *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/metro.hadded
@@ -0,0 +1,11 @@
+1
typedef struct sp_metro{
+2
SPFLOAT freq;
+3
SPFLOAT phs;
+4
int init;
+5
SPFLOAT onedsr;
+6
} sp_metro;
+7
+8
int sp_metro_create(sp_metro **p);
+9
int sp_metro_destroy(sp_metro **p);
+10
int sp_metro_init(sp_data *sp, sp_metro *p);
+11
int sp_metro_compute(sp_data *sp, sp_metro *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/moogladder.hadded
@@ -0,0 +1,17 @@
+1
typedef struct {
+2
SPFLOAT freq;
+3
SPFLOAT res;
+4
SPFLOAT istor;
+5
+6
SPFLOAT delay[6];
+7
SPFLOAT tanhstg[3];
+8
SPFLOAT oldfreq;
+9
SPFLOAT oldres;
+10
SPFLOAT oldacr;
+11
SPFLOAT oldtune;
+12
} sp_moogladder;
+13
+14
int sp_moogladder_create(sp_moogladder **t);
+15
int sp_moogladder_destroy(sp_moogladder **t);
+16
int sp_moogladder_init(sp_data *sp, sp_moogladder *p);
+17
int sp_moogladder_compute(sp_data *sp, sp_moogladder *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/noise.hadded
@@ -0,0 +1,8 @@
+1
typedef struct{
+2
SPFLOAT amp;
+3
}sp_noise;
+4
+5
int sp_noise_create(sp_noise **ns);
+6
int sp_noise_init(sp_data *sp, sp_noise *ns);
+7
int sp_noise_compute(sp_data *sp, sp_noise *ns, SPFLOAT *in, SPFLOAT *out);
+8
int sp_noise_destroy(sp_noise **ns);
vendor/soundpipe/h/osc.hadded
@@ -0,0 +1,11 @@
+1
typedef struct {
+2
SPFLOAT freq, amp, iphs;
+3
int32_t lphs;
+4
sp_ftbl *tbl;
+5
int inc;
+6
} sp_osc;
+7
+8
int sp_osc_create(sp_osc **osc);
+9
int sp_osc_destroy(sp_osc **osc);
+10
int sp_osc_init(sp_data *sp, sp_osc *osc, sp_ftbl *ft, SPFLOAT iphs);
+11
int sp_osc_compute(sp_data *sp, sp_osc *osc, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/pan2.hadded
@@ -0,0 +1,9 @@
+1
typedef struct {
+2
SPFLOAT pan;
+3
uint32_t type;
+4
} sp_pan2;
+5
+6
int sp_pan2_create(sp_pan2 **p);
+7
int sp_pan2_destroy(sp_pan2 **p);
+8
int sp_pan2_init(sp_data *sp, sp_pan2 *p);
+9
int sp_pan2_compute(sp_data *sp, sp_pan2 *p, SPFLOAT *in, SPFLOAT *out1, SPFLOAT *out2);
vendor/soundpipe/h/peaklim.hadded
@@ -0,0 +1,10 @@
+1
typedef struct {
+2
SPFLOAT atk, rel, thresh;
+3
SPFLOAT patk, prel;
+4
SPFLOAT b0_r, a1_r, b0_a, a1_a, level;
+5
} sp_peaklim;
+6
+7
int sp_peaklim_create(sp_peaklim **p);
+8
int sp_peaklim_destroy(sp_peaklim **p);
+9
int sp_peaklim_init(sp_data *sp, sp_peaklim *p);
+10
int sp_peaklim_compute(sp_data *sp, sp_peaklim *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/phasor.hadded
@@ -0,0 +1,9 @@
+1
typedef struct sp_phasor{
+2
SPFLOAT freq, phs;
+3
SPFLOAT onedsr;
+4
} sp_phasor;
+5
+6
int sp_phasor_create(sp_phasor **p);
+7
int sp_phasor_destroy(sp_phasor **p);
+8
int sp_phasor_init(sp_data *sp, sp_phasor *p, SPFLOAT iphs);
+9
int sp_phasor_compute(sp_data *sp, sp_phasor *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/pinknoise.hadded
@@ -0,0 +1,15 @@
+1
typedef struct {
+2
SPFLOAT amp;
+3
unsigned int newrand;
+4
unsigned int prevrand;
+5
unsigned int k;
+6
unsigned int seed;
+7
unsigned int total;
+8
uint32_t counter;
+9
unsigned int dice[7];
+10
} sp_pinknoise;
+11
+12
int sp_pinknoise_create(sp_pinknoise **p);
+13
int sp_pinknoise_destroy(sp_pinknoise **p);
+14
int sp_pinknoise_init(sp_data *sp, sp_pinknoise *p);
+15
int sp_pinknoise_compute(sp_data *sp, sp_pinknoise *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/port.hadded
@@ -0,0 +1,11 @@
+1
typedef struct{
+2
SPFLOAT smooth;
+3
SPFLOAT a1, b0, y0, psmooth;
+4
SPFLOAT onedsr;
+5
}sp_port;
+6
+7
int sp_port_create(sp_port **p);
+8
int sp_port_destroy(sp_port **p);
+9
int sp_port_init(sp_data *sp, sp_port *p);
+10
int sp_port_compute(sp_data *sp, sp_port *p, SPFLOAT *in, SPFLOAT *out);
+11
int sp_port_reset(sp_data *sp, sp_port *p, SPFLOAT *in);
vendor/soundpipe/h/posc3.hadded
@@ -0,0 +1,13 @@
+1
typedef struct {
+2
SPFLOAT freq, amp, iphs;
+3
sp_ftbl *tbl;
+4
int32_t tablen;
+5
SPFLOAT tablenUPsr;
+6
SPFLOAT phs;
+7
SPFLOAT onedsr;
+8
} sp_posc3;
+9
+10
int sp_posc3_create(sp_posc3 **posc3);
+11
int sp_posc3_destroy(sp_posc3 **posc3);
+12
int sp_posc3_init(sp_data *sp, sp_posc3 *posc3, sp_ftbl *ft);
+13
int sp_posc3_compute(sp_data *sp, sp_posc3 *posc3, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/randh.hadded
@@ -0,0 +1,11 @@
+1
typedef struct {
+2
SPFLOAT freq;
+3
SPFLOAT min, max;
+4
SPFLOAT val;
+5
uint32_t counter, dur;
+6
} sp_randh;
+7
+8
int sp_randh_create(sp_randh **p);
+9
int sp_randh_destroy(sp_randh **p);
+10
int sp_randh_init(sp_data *sp, sp_randh *p);
+11
int sp_randh_compute(sp_data *sp, sp_randh *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/randi.hadded
@@ -0,0 +1,13 @@
+1
typedef struct {
+2
SPFLOAT min, max, cps, mode, fstval;
+3
int16_t cpscod;
+4
int32_t phs;
+5
SPFLOAT num1, num2, dfdmax;
+6
int holdrand;
+7
SPFLOAT sicvt;
+8
} sp_randi;
+9
+10
int sp_randi_create(sp_randi **p);
+11
int sp_randi_destroy(sp_randi **p);
+12
int sp_randi_init(sp_data *sp, sp_randi *p);
+13
int sp_randi_compute(sp_data *sp, sp_randi *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/randmt.hadded
@@ -0,0 +1,10 @@
+1
typedef struct {
+2
int mti;
+3
/* do not change value 624 */
+4
uint32_t mt[624];
+5
} sp_randmt;
+6
+7
void sp_randmt_seed(sp_randmt *p,
+8
const uint32_t *initKey, uint32_t keyLength);
+9
+10
uint32_t sp_randmt_compute(sp_randmt *p);
vendor/soundpipe/h/revsc.hadded
@@ -0,0 +1,28 @@
+1
typedef struct {
+2
int writePos;
+3
int bufferSize;
+4
int readPos;
+5
int readPosFrac;
+6
int readPosFrac_inc;
+7
int dummy;
+8
int seedVal;
+9
int randLine_cnt;
+10
SPFLOAT filterState;
+11
SPFLOAT *buf;
+12
} sp_revsc_dl;
+13
+14
typedef struct {
+15
SPFLOAT feedback, lpfreq;
+16
SPFLOAT iSampleRate, iPitchMod, iSkipInit;
+17
SPFLOAT sampleRate;
+18
SPFLOAT dampFact;
+19
SPFLOAT prv_LPFreq;
+20
int initDone;
+21
sp_revsc_dl delayLines[8];
+22
sp_auxdata aux;
+23
} sp_revsc;
+24
+25
int sp_revsc_create(sp_revsc **p);
+26
int sp_revsc_destroy(sp_revsc **p);
+27
int sp_revsc_init(sp_data *sp, sp_revsc *p);
+28
int sp_revsc_compute(sp_data *sp, sp_revsc *p, SPFLOAT *in1, SPFLOAT *in2, SPFLOAT *out1, SPFLOAT *out2);
vendor/soundpipe/h/saturator.hadded
@@ -0,0 +1,15 @@
+1
typedef struct
+2
{
+3
SPFLOAT drive;
+4
SPFLOAT dcoffset;
+5
+6
SPFLOAT dcblocker[2][7];
+7
+8
SPFLOAT ai[6][7];
+9
SPFLOAT aa[6][7];
+10
} sp_saturator;
+11
+12
int sp_saturator_create(sp_saturator **p);
+13
int sp_saturator_destroy(sp_saturator **p);
+14
int sp_saturator_init(sp_data *sp, sp_saturator *p);
+15
int sp_saturator_compute(sp_data *sp, sp_saturator *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/scale.hadded
@@ -0,0 +1,8 @@
+1
typedef struct {
+2
SPFLOAT min, max;
+3
} sp_scale;
+4
+5
int sp_scale_create(sp_scale **p);
+6
int sp_scale_destroy(sp_scale **p);
+7
int sp_scale_init(sp_data *sp, sp_scale *p);
+8
int sp_scale_compute(sp_data *sp, sp_scale *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/soundpipe.hadded
@@ -0,0 +1,617 @@
+1
#ifndef SOUNDPIPE_H
+2
#define SOUNDPIPE_H
+3
#include <stdint.h>
+4
#include <stdio.h>
+5
+6
#define SP_BUFSIZE 4096
+7
#ifndef SPFLOAT
+8
#define SPFLOAT float
+9
#endif
+10
#define SP_OK 1
+11
#define SP_NOT_OK 0
+12
+13
#define SP_RANDMAX 2147483648
+14
+15
typedef unsigned long sp_frame;
+16
+17
typedef struct sp_auxdata {
+18
size_t size;
+19
void *ptr;
+20
} sp_auxdata;
+21
+22
typedef struct sp_data {
+23
SPFLOAT *out;
+24
int sr;
+25
int nchan;
+26
unsigned long len;
+27
unsigned long pos;
+28
char filename[200];
+29
uint32_t rand;
+30
} sp_data;
+31
+32
typedef struct {
+33
char state;
+34
SPFLOAT val;
+35
} sp_param;
+36
+37
int sp_auxdata_alloc(sp_auxdata *aux, size_t size);
+38
int sp_auxdata_free(sp_auxdata *aux);
+39
+40
int sp_create(sp_data **spp);
+41
int sp_createn(sp_data **spp, int nchan);
+42
+43
int sp_destroy(sp_data **spp);
+44
int sp_process(sp_data *sp, void *ud, void (*callback)(sp_data *, void *));
+45
int sp_process_raw(sp_data *sp, void *ud, void (*callback)(sp_data *, void *));
+46
int sp_process_plot(sp_data *sp, void *ud, void (*callback)(sp_data *, void *));
+47
int sp_process_spa(sp_data *sp, void *ud, void (*callback)(sp_data *, void *));
+48
+49
SPFLOAT sp_midi2cps(SPFLOAT nn);
+50
+51
int sp_set(sp_param *p, SPFLOAT val);
+52
+53
int sp_out(sp_data *sp, uint32_t chan, SPFLOAT val);
+54
+55
uint32_t sp_rand(sp_data *sp);
+56
void sp_srand(sp_data *sp, uint32_t val);
+57
+58
+59
typedef struct {
+60
SPFLOAT *utbl;
+61
int16_t *BRLow;
+62
int16_t *BRLowCpx;
+63
} sp_fft;
+64
+65
void sp_fft_create(sp_fft **fft);
+66
void sp_fft_init(sp_fft *fft, int M);
+67
void sp_fftr(sp_fft *fft, SPFLOAT *buf, int FFTsize);
+68
void sp_fft_cpx(sp_fft *fft, SPFLOAT *buf, int FFTsize);
+69
void sp_ifftr(sp_fft *fft, SPFLOAT *buf, int FFTsize);
+70
void sp_fft_destroy(sp_fft *fft);
+71
#ifndef kiss_fft_scalar
+72
#define kiss_fft_scalar SPFLOAT
+73
#endif
+74
typedef struct {
+75
kiss_fft_scalar r;
+76
kiss_fft_scalar i;
+77
}kiss_fft_cpx;
+78
+79
typedef struct kiss_fft_state* kiss_fft_cfg;
+80
typedef struct kiss_fftr_state* kiss_fftr_cfg;
+81
+82
/* SPA: Soundpipe Audio */
+83
+84
enum { SPA_READ, SPA_WRITE, SPA_NULL };
+85
+86
typedef struct {
+87
char magic;
+88
char nchan;
+89
uint16_t sr;
+90
uint32_t len;
+91
} spa_header;
+92
+93
typedef struct {
+94
spa_header header;
+95
size_t offset;
+96
int mode;
+97
FILE *fp;
+98
uint32_t pos;
+99
} sp_audio;
+100
#define SP_FT_MAXLEN 0x1000000L
+101
#define SP_FT_PHMASK 0x0FFFFFFL
+102
+103
typedef struct sp_ftbl{
+104
size_t size;
+105
uint32_t lobits;
+106
uint32_t lomask;
+107
SPFLOAT lodiv;
+108
SPFLOAT sicvt;
+109
SPFLOAT *tbl;
+110
char del;
+111
}sp_ftbl;
+112
+113
int sp_ftbl_create(sp_data *sp, sp_ftbl **ft, size_t size);
+114
int sp_ftbl_init(sp_data *sp, sp_ftbl *ft, size_t size);
+115
int sp_ftbl_bind(sp_data *sp, sp_ftbl **ft, SPFLOAT *tbl, size_t size);
+116
int sp_ftbl_destroy(sp_ftbl **ft);
+117
int sp_gen_vals(sp_data *sp, sp_ftbl *ft, const char *string);
+118
int sp_gen_sine(sp_data *sp, sp_ftbl *ft);
+119
int sp_gen_file(sp_data *sp, sp_ftbl *ft, const char *filename);
+120
int sp_gen_sinesum(sp_data *sp, sp_ftbl *ft, const char *argstring);
+121
int sp_gen_line(sp_data *sp, sp_ftbl *ft, const char *argstring);
+122
int sp_gen_xline(sp_data *sp, sp_ftbl *ft, const char *argstring);
+123
int sp_gen_gauss(sp_data *sp, sp_ftbl *ft, SPFLOAT scale, uint32_t seed);
+124
int sp_ftbl_loadfile(sp_data *sp, sp_ftbl **ft, const char *filename);
+125
int sp_ftbl_loadspa(sp_data *sp, sp_ftbl **ft, const char *filename);
+126
int sp_gen_composite(sp_data *sp, sp_ftbl *ft, const char *argstring);
+127
int sp_gen_rand(sp_data *sp, sp_ftbl *ft, const char *argstring);
+128
int sp_gen_triangle(sp_data *sp, sp_ftbl *ft);
+129
typedef struct {
+130
int mti;
+131
/* do not change value 624 */
+132
uint32_t mt[624];
+133
} sp_randmt;
+134
+135
void sp_randmt_seed(sp_randmt *p,
+136
const uint32_t *initKey, uint32_t keyLength);
+137
+138
uint32_t sp_randmt_compute(sp_randmt *p);
+139
typedef struct {
+140
SPFLOAT atk;
+141
SPFLOAT dec;
+142
SPFLOAT sus;
+143
SPFLOAT rel;
+144
uint32_t timer;
+145
uint32_t atk_time;
+146
SPFLOAT a;
+147
SPFLOAT b;
+148
SPFLOAT y;
+149
SPFLOAT x;
+150
SPFLOAT prev;
+151
int mode;
+152
} sp_adsr;
+153
+154
int sp_adsr_create(sp_adsr **p);
+155
int sp_adsr_destroy(sp_adsr **p);
+156
int sp_adsr_init(sp_data *sp, sp_adsr *p);
+157
int sp_adsr_compute(sp_data *sp, sp_adsr *p, SPFLOAT *in, SPFLOAT *out);
+158
typedef struct {
+159
SPFLOAT hp;
+160
SPFLOAT c1, c2, yt1, prvhp;
+161
SPFLOAT tpidsr;
+162
} sp_atone;
+163
+164
int sp_atone_create(sp_atone **p);
+165
int sp_atone_destroy(sp_atone **p);
+166
int sp_atone_init(sp_data *sp, sp_atone *p);
+167
int sp_atone_compute(sp_data *sp, sp_atone *p, SPFLOAT *in, SPFLOAT *out);
+168
typedef struct {
+169
void *ud;
+170
int argpos;
+171
SPFLOAT *args[2];
+172
SPFLOAT *freq;
+173
SPFLOAT *amp;
+174
} sp_blsaw;
+175
+176
int sp_blsaw_create(sp_blsaw **p);
+177
int sp_blsaw_destroy(sp_blsaw **p);
+178
int sp_blsaw_init(sp_data *sp, sp_blsaw *p);
+179
int sp_blsaw_compute(sp_data *sp, sp_blsaw *p, SPFLOAT *in, SPFLOAT *out);
+180
typedef struct {
+181
void *ud;
+182
int argpos;
+183
SPFLOAT *args[3];
+184
SPFLOAT *freq;
+185
SPFLOAT *amp;
+186
SPFLOAT *width;
+187
} sp_blsquare;
+188
+189
int sp_blsquare_create(sp_blsquare **p);
+190
int sp_blsquare_destroy(sp_blsquare **p);
+191
int sp_blsquare_init(sp_data *sp, sp_blsquare *p);
+192
int sp_blsquare_compute(sp_data *sp, sp_blsquare *p, SPFLOAT *in, SPFLOAT *out);
+193
typedef struct {
+194
void *ud;
+195
int argpos;
+196
SPFLOAT *args[2];
+197
SPFLOAT *freq;
+198
SPFLOAT *amp;
+199
} sp_bltriangle;
+200
+201
int sp_bltriangle_create(sp_bltriangle **p);
+202
int sp_bltriangle_destroy(sp_bltriangle **p);
+203
int sp_bltriangle_init(sp_data *sp, sp_bltriangle *p);
+204
int sp_bltriangle_compute(sp_data *sp, sp_bltriangle *p, SPFLOAT *in, SPFLOAT *out);
+205
typedef struct {
+206
SPFLOAT brown;
+207
} sp_brown;
+208
+209
int sp_brown_create(sp_brown **p);
+210
int sp_brown_destroy(sp_brown **p);
+211
int sp_brown_init(sp_data *sp, sp_brown *p);
+212
int sp_brown_compute(sp_data *sp, sp_brown *p, SPFLOAT *in, SPFLOAT *out);
+213
typedef struct {
+214
SPFLOAT freq;
+215
SPFLOAT lfreq;
+216
SPFLOAT a[7];
+217
SPFLOAT pidsr;
+218
} sp_buthp;
+219
+220
int sp_buthp_create(sp_buthp **p);
+221
int sp_buthp_destroy(sp_buthp **p);
+222
int sp_buthp_init(sp_data *sp, sp_buthp *p);
+223
int sp_buthp_compute(sp_data *sp, sp_buthp *p, SPFLOAT *in, SPFLOAT *out);
+224
typedef struct {
+225
SPFLOAT sr, freq;
+226
SPFLOAT lfreq;
+227
SPFLOAT a[7];
+228
SPFLOAT pidsr;
+229
} sp_butlp;
+230
+231
int sp_butlp_create(sp_butlp **p);
+232
int sp_butlp_destroy(sp_butlp **p);
+233
int sp_butlp_init(sp_data *sp, sp_butlp *p);
+234
int sp_butlp_compute(sp_data *sp, sp_butlp *p, SPFLOAT *in, SPFLOAT *out);
+235
typedef struct {
+236
SPFLOAT min;
+237
SPFLOAT max;
+238
} sp_clamp;
+239
+240
int sp_clamp_create(sp_clamp **p);
+241
int sp_clamp_destroy(sp_clamp **p);
+242
int sp_clamp_init(sp_data *sp, sp_clamp *p);
+243
int sp_clamp_compute(sp_data *sp, sp_clamp *p, SPFLOAT *in, SPFLOAT *out);
+244
typedef struct{
+245
SPFLOAT lim, k1;
+246
}sp_clip;
+247
+248
int sp_clip_create(sp_clip **p);
+249
int sp_clip_destroy(sp_clip **p);
+250
int sp_clip_init(sp_data *sp, sp_clip *p);
+251
int sp_clip_compute(sp_data *sp, sp_clip *p, SPFLOAT *in, SPFLOAT *out);
+252
typedef struct {
+253
SPFLOAT bpm;
+254
SPFLOAT subdiv;
+255
uint32_t counter;
+256
} sp_clock;
+257
+258
int sp_clock_create(sp_clock **p);
+259
int sp_clock_destroy(sp_clock **p);
+260
int sp_clock_init(sp_data *sp, sp_clock *p);
+261
int sp_clock_compute(sp_data *sp, sp_clock *p, SPFLOAT *trig, SPFLOAT *out);
+262
typedef struct {
+263
SPFLOAT pos;
+264
} sp_crossfade;
+265
+266
int sp_crossfade_create(sp_crossfade **p);
+267
int sp_crossfade_destroy(sp_crossfade **p);
+268
int sp_crossfade_init(sp_data *sp, sp_crossfade *p);
+269
int sp_crossfade_compute(sp_data *sp, sp_crossfade *p, SPFLOAT *in1, SPFLOAT *in2, SPFLOAT *out);
+270
typedef struct {
+271
SPFLOAT gg;
+272
SPFLOAT outputs;
+273
SPFLOAT inputs;
+274
SPFLOAT gain;
+275
} sp_dcblock;
+276
+277
int sp_dcblock_create(sp_dcblock **p);
+278
int sp_dcblock_destroy(sp_dcblock **p);
+279
int sp_dcblock_init(sp_data *sp, sp_dcblock *p);
+280
int sp_dcblock_compute(sp_data *sp, sp_dcblock *p, SPFLOAT *in, SPFLOAT *out);
+281
typedef struct {
+282
SPFLOAT time;
+283
SPFLOAT feedback;
+284
SPFLOAT last;
+285
sp_auxdata buf;
+286
uint32_t bufsize;
+287
uint32_t bufpos;
+288
} sp_delay;
+289
+290
int sp_delay_create(sp_delay **p);
+291
int sp_delay_destroy(sp_delay **p);
+292
int sp_delay_init(sp_data *sp, sp_delay *p, SPFLOAT time);
+293
int sp_delay_compute(sp_data *sp, sp_delay *p, SPFLOAT *in, SPFLOAT *out);
+294
typedef struct {
+295
SPFLOAT a, dur, b;
+296
SPFLOAT val, incr;
+297
uint32_t sdur, stime;
+298
int init;
+299
} sp_expon;
+300
+301
int sp_expon_create(sp_expon **p);
+302
int sp_expon_destroy(sp_expon **p);
+303
int sp_expon_init(sp_data *sp, sp_expon *p);
+304
int sp_expon_compute(sp_data *sp, sp_expon *p, SPFLOAT *in, SPFLOAT *out);
+305
typedef struct sp_fosc{
+306
SPFLOAT amp, freq, car, mod, indx, iphs;
+307
int32_t mphs, cphs;
+308
sp_ftbl *ft;
+309
} sp_fosc;
+310
+311
int sp_fosc_create(sp_fosc **p);
+312
int sp_fosc_destroy(sp_fosc **p);
+313
int sp_fosc_init(sp_data *sp, sp_fosc *p, sp_ftbl *ft);
+314
int sp_fosc_compute(sp_data *sp, sp_fosc *p, SPFLOAT *in, SPFLOAT *out);
+315
typedef struct {
+316
SPFLOAT a, dur, b;
+317
SPFLOAT val, incr;
+318
uint32_t sdur, stime;
+319
int init;
+320
} sp_line;
+321
+322
int sp_line_create(sp_line **p);
+323
int sp_line_destroy(sp_line **p);
+324
int sp_line_init(sp_data *sp, sp_line *p);
+325
int sp_line_compute(sp_data *sp, sp_line *p, SPFLOAT *in, SPFLOAT *out);
+326
typedef struct sp_lpf18{
+327
SPFLOAT cutoff, res, dist;
+328
SPFLOAT ay1, ay2, aout, lastin, onedsr;
+329
} sp_lpf18;
+330
+331
int sp_lpf18_create(sp_lpf18 **p);
+332
int sp_lpf18_destroy(sp_lpf18 **p);
+333
int sp_lpf18_init(sp_data *sp, sp_lpf18 *p);
+334
int sp_lpf18_compute(sp_data *sp, sp_lpf18 *p, SPFLOAT *in, SPFLOAT *out);
+335
typedef struct sp_metro{
+336
SPFLOAT freq;
+337
SPFLOAT phs;
+338
int init;
+339
SPFLOAT onedsr;
+340
} sp_metro;
+341
+342
int sp_metro_create(sp_metro **p);
+343
int sp_metro_destroy(sp_metro **p);
+344
int sp_metro_init(sp_data *sp, sp_metro *p);
+345
int sp_metro_compute(sp_data *sp, sp_metro *p, SPFLOAT *in, SPFLOAT *out);
+346
typedef struct {
+347
SPFLOAT freq;
+348
SPFLOAT res;
+349
SPFLOAT istor;
+350
+351
SPFLOAT delay[6];
+352
SPFLOAT tanhstg[3];
+353
SPFLOAT oldfreq;
+354
SPFLOAT oldres;
+355
SPFLOAT oldacr;
+356
SPFLOAT oldtune;
+357
} sp_moogladder;
+358
+359
int sp_moogladder_create(sp_moogladder **t);
+360
int sp_moogladder_destroy(sp_moogladder **t);
+361
int sp_moogladder_init(sp_data *sp, sp_moogladder *p);
+362
int sp_moogladder_compute(sp_data *sp, sp_moogladder *p, SPFLOAT *in, SPFLOAT *out);
+363
typedef struct{
+364
SPFLOAT amp;
+365
}sp_noise;
+366
+367
int sp_noise_create(sp_noise **ns);
+368
int sp_noise_init(sp_data *sp, sp_noise *ns);
+369
int sp_noise_compute(sp_data *sp, sp_noise *ns, SPFLOAT *in, SPFLOAT *out);
+370
int sp_noise_destroy(sp_noise **ns);
+371
typedef struct {
+372
SPFLOAT freq, amp, iphs;
+373
int32_t lphs;
+374
sp_ftbl *tbl;
+375
int inc;
+376
} sp_osc;
+377
+378
int sp_osc_create(sp_osc **osc);
+379
int sp_osc_destroy(sp_osc **osc);
+380
int sp_osc_init(sp_data *sp, sp_osc *osc, sp_ftbl *ft, SPFLOAT iphs);
+381
int sp_osc_compute(sp_data *sp, sp_osc *osc, SPFLOAT *in, SPFLOAT *out);
+382
typedef struct {
+383
SPFLOAT pan;
+384
uint32_t type;
+385
} sp_pan2;
+386
+387
int sp_pan2_create(sp_pan2 **p);
+388
int sp_pan2_destroy(sp_pan2 **p);
+389
int sp_pan2_init(sp_data *sp, sp_pan2 *p);
+390
int sp_pan2_compute(sp_data *sp, sp_pan2 *p, SPFLOAT *in, SPFLOAT *out1, SPFLOAT *out2);
+391
typedef struct {
+392
SPFLOAT atk, rel, thresh;
+393
SPFLOAT patk, prel;
+394
SPFLOAT b0_r, a1_r, b0_a, a1_a, level;
+395
} sp_peaklim;
+396
+397
int sp_peaklim_create(sp_peaklim **p);
+398
int sp_peaklim_destroy(sp_peaklim **p);
+399
int sp_peaklim_init(sp_data *sp, sp_peaklim *p);
+400
int sp_peaklim_compute(sp_data *sp, sp_peaklim *p, SPFLOAT *in, SPFLOAT *out);
+401
typedef struct sp_phasor{
+402
SPFLOAT freq, phs;
+403
SPFLOAT onedsr;
+404
} sp_phasor;
+405
+406
int sp_phasor_create(sp_phasor **p);
+407
int sp_phasor_destroy(sp_phasor **p);
+408
int sp_phasor_init(sp_data *sp, sp_phasor *p, SPFLOAT iphs);
+409
int sp_phasor_compute(sp_data *sp, sp_phasor *p, SPFLOAT *in, SPFLOAT *out);
+410
typedef struct {
+411
SPFLOAT amp;
+412
unsigned int newrand;
+413
unsigned int prevrand;
+414
unsigned int k;
+415
unsigned int seed;
+416
unsigned int total;
+417
uint32_t counter;
+418
unsigned int dice[7];
+419
} sp_pinknoise;
+420
+421
int sp_pinknoise_create(sp_pinknoise **p);
+422
int sp_pinknoise_destroy(sp_pinknoise **p);
+423
int sp_pinknoise_init(sp_data *sp, sp_pinknoise *p);
+424
int sp_pinknoise_compute(sp_data *sp, sp_pinknoise *p, SPFLOAT *in, SPFLOAT *out);
+425
typedef struct{
+426
SPFLOAT smooth;
+427
SPFLOAT a1, b0, y0, psmooth;
+428
SPFLOAT onedsr;
+429
}sp_port;
+430
+431
int sp_port_create(sp_port **p);
+432
int sp_port_destroy(sp_port **p);
+433
int sp_port_init(sp_data *sp, sp_port *p);
+434
int sp_port_compute(sp_data *sp, sp_port *p, SPFLOAT *in, SPFLOAT *out);
+435
int sp_port_reset(sp_data *sp, sp_port *p, SPFLOAT *in);
+436
typedef struct {
+437
SPFLOAT freq, amp, iphs;
+438
sp_ftbl *tbl;
+439
int32_t tablen;
+440
SPFLOAT tablenUPsr;
+441
SPFLOAT phs;
+442
SPFLOAT onedsr;
+443
} sp_posc3;
+444
+445
int sp_posc3_create(sp_posc3 **posc3);
+446
int sp_posc3_destroy(sp_posc3 **posc3);
+447
int sp_posc3_init(sp_data *sp, sp_posc3 *posc3, sp_ftbl *ft);
+448
int sp_posc3_compute(sp_data *sp, sp_posc3 *posc3, SPFLOAT *in, SPFLOAT *out);
+449
typedef struct {
+450
SPFLOAT freq;
+451
SPFLOAT min, max;
+452
SPFLOAT val;
+453
uint32_t counter, dur;
+454
} sp_randh;
+455
+456
int sp_randh_create(sp_randh **p);
+457
int sp_randh_destroy(sp_randh **p);
+458
int sp_randh_init(sp_data *sp, sp_randh *p);
+459
int sp_randh_compute(sp_data *sp, sp_randh *p, SPFLOAT *in, SPFLOAT *out);
+460
typedef struct {
+461
SPFLOAT min, max, cps, mode, fstval;
+462
int16_t cpscod;
+463
int32_t phs;
+464
SPFLOAT num1, num2, dfdmax;
+465
int holdrand;
+466
SPFLOAT sicvt;
+467
} sp_randi;
+468
+469
int sp_randi_create(sp_randi **p);
+470
int sp_randi_destroy(sp_randi **p);
+471
int sp_randi_init(sp_data *sp, sp_randi *p);
+472
int sp_randi_compute(sp_data *sp, sp_randi *p, SPFLOAT *in, SPFLOAT *out);
+473
typedef struct {
+474
int writePos;
+475
int bufferSize;
+476
int readPos;
+477
int readPosFrac;
+478
int readPosFrac_inc;
+479
int dummy;
+480
int seedVal;
+481
int randLine_cnt;
+482
SPFLOAT filterState;
+483
SPFLOAT *buf;
+484
} sp_revsc_dl;
+485
+486
typedef struct {
+487
SPFLOAT feedback, lpfreq;
+488
SPFLOAT iSampleRate, iPitchMod, iSkipInit;
+489
SPFLOAT sampleRate;
+490
SPFLOAT dampFact;
+491
SPFLOAT prv_LPFreq;
+492
int initDone;
+493
sp_revsc_dl delayLines[8];
+494
sp_auxdata aux;
+495
} sp_revsc;
+496
+497
int sp_revsc_create(sp_revsc **p);
+498
int sp_revsc_destroy(sp_revsc **p);
+499
int sp_revsc_init(sp_data *sp, sp_revsc *p);

Showing the first 500 of 618 diff lines for this file. This diff is INCOMPLETE; read the file or clone the repository for the rest.

vendor/soundpipe/h/tadsr.hadded
@@ -0,0 +1,20 @@
+1
typedef struct {
+2
SPFLOAT value;
+3
SPFLOAT target;
+4
SPFLOAT rate;
+5
int state;
+6
SPFLOAT attackRate;
+7
SPFLOAT decayRate;
+8
SPFLOAT sustainLevel;
+9
SPFLOAT releaseRate;
+10
SPFLOAT atk;
+11
SPFLOAT rel;
+12
SPFLOAT sus;
+13
SPFLOAT dec;
+14
int mode;
+15
} sp_tadsr;
+16
+17
int sp_tadsr_create(sp_tadsr **p);
+18
int sp_tadsr_destroy(sp_tadsr **p);
+19
int sp_tadsr_init(sp_data *sp, sp_tadsr *p);
+20
int sp_tadsr_compute(sp_data *sp, sp_tadsr *p, SPFLOAT *trig, SPFLOAT *out);
vendor/soundpipe/h/tenv.hadded
@@ -0,0 +1,14 @@
+1
typedef struct sp_tenv{
+2
uint32_t pos, atk_end, rel_start, sr, totaldur;
+3
SPFLOAT atk, rel, hold;
+4
SPFLOAT atk_slp, rel_slp;
+5
SPFLOAT last;
+6
int sigmode;
+7
SPFLOAT input;
+8
int started;
+9
} sp_tenv;
+10
+11
int sp_tenv_create(sp_tenv **p);
+12
int sp_tenv_destroy(sp_tenv **p);
+13
int sp_tenv_init(sp_data *sp, sp_tenv *p);
+14
int sp_tenv_compute(sp_data *sp, sp_tenv *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/tgate.hadded
@@ -0,0 +1,9 @@
+1
typedef struct {
+2
SPFLOAT time;
+3
uint32_t timer;
+4
} sp_tgate;
+5
+6
int sp_tgate_create(sp_tgate **p);
+7
int sp_tgate_destroy(sp_tgate **p);
+8
int sp_tgate_init(sp_data *sp, sp_tgate *p);
+9
int sp_tgate_compute(sp_data *sp, sp_tgate *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/tone.hadded
@@ -0,0 +1,10 @@
+1
typedef struct {
+2
SPFLOAT hp;
+3
SPFLOAT c1, c2, yt1, prvhp;
+4
SPFLOAT tpidsr;
+5
} sp_tone;
+6
+7
int sp_tone_create(sp_tone **t);
+8
int sp_tone_destroy(sp_tone **t);
+9
int sp_tone_init(sp_data *sp, sp_tone *t);
+10
int sp_tone_compute(sp_data *sp, sp_tone *t, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/vdelay.hadded
@@ -0,0 +1,14 @@
+1
typedef struct sp_vdelay{
+2
SPFLOAT del, maxdel;
+3
SPFLOAT feedback;
+4
SPFLOAT prev;
+5
SPFLOAT sr;
+6
sp_auxdata buf;
+7
int32_t left;
+8
} sp_vdelay;
+9
+10
int sp_vdelay_create(sp_vdelay **p);
+11
int sp_vdelay_destroy(sp_vdelay **p);
+12
int sp_vdelay_init(sp_data *sp, sp_vdelay *p, SPFLOAT maxdel);
+13
int sp_vdelay_compute(sp_data *sp, sp_vdelay *p, SPFLOAT *in, SPFLOAT *out);
+14
int sp_vdelay_reset(sp_data *sp, sp_vdelay *p);
vendor/soundpipe/h/wavout.hadded
@@ -0,0 +1,5 @@
+1
typedef struct sp_wavout sp_wavout;
+2
int sp_wavout_create(sp_wavout **p);
+3
int sp_wavout_destroy(sp_wavout **p);
+4
int sp_wavout_init(sp_data *sp, sp_wavout *p, const char *filename);
+5
int sp_wavout_compute(sp_data *sp, sp_wavout *p, SPFLOAT *in, SPFLOAT *out);
vendor/soundpipe/h/zitarev.hadded
@@ -0,0 +1,21 @@
+1
typedef struct {
+2
void *faust;
+3
int argpos;
+4
SPFLOAT *args[11];
+5
SPFLOAT *in_delay;
+6
SPFLOAT *lf_x;
+7
SPFLOAT *rt60_low;
+8
SPFLOAT *rt60_mid;
+9
SPFLOAT *hf_damping;
+10
SPFLOAT *eq1_freq;
+11
SPFLOAT *eq1_level;
+12
SPFLOAT *eq2_freq;
+13
SPFLOAT *eq2_level;
+14
SPFLOAT *mix;
+15
SPFLOAT *level;
+16
} sp_zitarev;
+17
+18
int sp_zitarev_create(sp_zitarev **p);
+19
int sp_zitarev_destroy(sp_zitarev **p);
+20
int sp_zitarev_init(sp_data *sp, sp_zitarev *p);
+21
int sp_zitarev_compute(sp_data *sp, sp_zitarev *p, SPFLOAT *in1, SPFLOAT *in2, SPFLOAT *out1, SPFLOAT *out2);
vendor/soundpipe/lib/dr_wav/Makefileadded
@@ -0,0 +1,5 @@
+1
CFLAGS += -Ilib/dr_wav/
+2
LPATHS += $(LIBDIR)/dr_wav/dr_wav.o
+3
+4
$(LIBDIR)/dr_wav/dr_wav.o: lib/dr_wav/dr_wav.c | $(LIBDIR)/dr_wav
+5
$(CC) $(CFLAGS) $< -c -o $@
vendor/soundpipe/lib/dr_wav/dr_wav.cadded
@@ -0,0 +1,2 @@
+1
#define DR_WAV_IMPLEMENTATION
+2
#include "dr_wav.h"
vendor/soundpipe/lib/dr_wav/dr_wav.hadded
@@ -0,0 +1,3490 @@
+1
// WAV audio loader and writer. Public domain. See "unlicense" statement at the end of this file.
+2
// dr_wav - v0.7 - 2017-11-04
+3
//
+4
// David Reid - [email protected]
+5
+6
// USAGE
+7
//
+8
// This is a single-file library. To use it, do something like the following in one .c file.
+9
// #define DR_WAV_IMPLEMENTATION
+10
// #include "dr_wav.h"
+11
//
+12
// You can then #include this file in other parts of the program as you would with any other header file. Do something
+13
// like the following to read audio data:
+14
//
+15
// drwav wav;
+16
// if (!drwav_init_file(&wav, "my_song.wav")) {
+17
// // Error opening WAV file.
+18
// }
+19
//
+20
// drwav_int32* pDecodedInterleavedSamples = malloc(wav.totalSampleCount * sizeof(drwav_int32));
+21
// size_t numberOfSamplesActuallyDecoded = drwav_read_s32(&wav, wav.totalSampleCount, pDecodedInterleavedSamples);
+22
//
+23
// ...
+24
//
+25
// drwav_uninit(&wav);
+26
//
+27
// You can also use drwav_open() to allocate and initialize the loader for you:
+28
//
+29
// drwav* pWav = drwav_open_file("my_song.wav");
+30
// if (pWav == NULL) {
+31
// // Error opening WAV file.
+32
// }
+33
//
+34
// ...
+35
//
+36
// drwav_close(pWav);
+37
//
+38
// If you just want to quickly open and read the audio data in a single operation you can do something like this:
+39
//
+40
// unsigned int channels;
+41
// unsigned int sampleRate;
+42
// drwav_uint64 totalSampleCount;
+43
// float* pSampleData = drwav_open_and_read_file_s32("my_song.wav", &channels, &sampleRate, &totalSampleCount);
+44
// if (pSampleData == NULL) {
+45
// // Error opening and reading WAV file.
+46
// }
+47
//
+48
// ...
+49
//
+50
// drwav_free(pSampleData);
+51
//
+52
// The examples above use versions of the API that convert the audio data to a consistent format (32-bit signed PCM, in
+53
// this case), but you can still output the audio data in it's internal format (see notes below for supported formats):
+54
//
+55
// size_t samplesRead = drwav_read(&wav, wav.totalSampleCount, pDecodedInterleavedSamples);
+56
//
+57
// You can also read the raw bytes of audio data, which could be useful if dr_wav does not have native support for
+58
// a particular data format:
+59
//
+60
// size_t bytesRead = drwav_read_raw(&wav, bytesToRead, pRawDataBuffer);
+61
//
+62
//
+63
// dr_wav has seamless support the Sony Wave64 format. The decoder will automatically detect it and it should Just Work
+64
// without any manual intervention.
+65
//
+66
//
+67
// dr_wav can also be used to output WAV files. This does not currently support compressed formats. To use this, look at
+68
// drwav_open_write(), drwav_open_file_write(), etc. Use drwav_write() to write samples, or drwav_write_raw() to write
+69
// raw data in the "data" chunk.
+70
//
+71
// drwav_data_format format;
+72
// format.container = drwav_container_riff; // <-- drwav_container_riff = normal WAV files, drwav_container_w64 = Sony Wave64.
+73
// format.format = DR_WAVE_FORMAT_PCM; // <-- Any of the DR_WAVE_FORMAT_* codes.
+74
// format.channels = 2;
+75
// format.sampleRate = 44100;
+76
// format.bitsPerSample = 16;
+77
// drwav* pWav = drwav_open_file_write("data/recording.wav", &format);
+78
//
+79
// ...
+80
//
+81
// drwav_uint64 samplesWritten = drwav_write(pWav, sampleCount, pSamples);
+82
//
+83
//
+84
//
+85
// OPTIONS
+86
// #define these options before including this file.
+87
//
+88
// #define DR_WAV_NO_CONVERSION_API
+89
// Disables conversion APIs such as drwav_read_f32() and drwav_s16_to_f32().
+90
//
+91
// #define DR_WAV_NO_STDIO
+92
// Disables drwav_open_file(), drwav_open_file_write(), etc.
+93
//
+94
//
+95
//
+96
// QUICK NOTES
+97
// - Samples are always interleaved.
+98
// - The default read function does not do any data conversion. Use drwav_read_f32() to read and convert audio data
+99
// to IEEE 32-bit floating point samples, drwav_read_s32() to read samples as signed 32-bit PCM and drwav_read_s16()
+100
// to read samples as signed 16-bit PCM. Tested and supported internal formats include the following:
+101
// - Unsigned 8-bit PCM
+102
// - Signed 12-bit PCM
+103
// - Signed 16-bit PCM
+104
// - Signed 24-bit PCM
+105
// - Signed 32-bit PCM
+106
// - IEEE 32-bit floating point.
+107
// - IEEE 64-bit floating point.
+108
// - A-law and u-law
+109
// - Microsoft ADPCM
+110
// - IMA ADPCM (DVI, format code 0x11)
+111
// - dr_wav will try to read the WAV file as best it can, even if it's not strictly conformant to the WAV format.
+112
+113
+114
#ifndef dr_wav_h
+115
#define dr_wav_h
+116
+117
#include <stddef.h>
+118
+119
#if defined(_MSC_VER) && _MSC_VER < 1600
+120
typedef signed char drwav_int8;
+121
typedef unsigned char drwav_uint8;
+122
typedef signed short drwav_int16;
+123
typedef unsigned short drwav_uint16;
+124
typedef signed int drwav_int32;
+125
typedef unsigned int drwav_uint32;
+126
typedef signed __int64 drwav_int64;
+127
typedef unsigned __int64 drwav_uint64;
+128
#else
+129
#include <stdint.h>
+130
typedef int8_t drwav_int8;
+131
typedef uint8_t drwav_uint8;
+132
typedef int16_t drwav_int16;
+133
typedef uint16_t drwav_uint16;
+134
typedef int32_t drwav_int32;
+135
typedef uint32_t drwav_uint32;
+136
typedef int64_t drwav_int64;
+137
typedef uint64_t drwav_uint64;
+138
#endif
+139
typedef drwav_uint8 drwav_bool8;
+140
typedef drwav_uint32 drwav_bool32;
+141
#define DRWAV_TRUE 1
+142
#define DRWAV_FALSE 0
+143
+144
#ifdef __cplusplus
+145
extern "C" {
+146
#endif
+147
+148
// Common data formats.
+149
#define DR_WAVE_FORMAT_PCM 0x1
+150
#define DR_WAVE_FORMAT_ADPCM 0x2
+151
#define DR_WAVE_FORMAT_IEEE_FLOAT 0x3
+152
#define DR_WAVE_FORMAT_ALAW 0x6
+153
#define DR_WAVE_FORMAT_MULAW 0x7
+154
#define DR_WAVE_FORMAT_DVI_ADPCM 0x11
+155
#define DR_WAVE_FORMAT_EXTENSIBLE 0xFFFE
+156
+157
typedef enum
+158
{
+159
drwav_seek_origin_start,
+160
drwav_seek_origin_current
+161
} drwav_seek_origin;
+162
+163
typedef enum
+164
{
+165
drwav_container_riff,
+166
drwav_container_w64
+167
} drwav_container;
+168
+169
// Callback for when data is read. Return value is the number of bytes actually read.
+170
//
+171
// pUserData [in] The user data that was passed to drwav_init(), drwav_open() and family.
+172
// pBufferOut [out] The output buffer.
+173
// bytesToRead [in] The number of bytes to read.
+174
//
+175
// Returns the number of bytes actually read.
+176
//
+177
// A return value of less than bytesToRead indicates the end of the stream. Do _not_ return from this callback until
+178
// either the entire bytesToRead is filled or you have reached the end of the stream.
+179
typedef size_t (* drwav_read_proc)(void* pUserData, void* pBufferOut, size_t bytesToRead);
+180
+181
// Callback for when data is written. Returns value is the number of bytes actually written.
+182
//
+183
// pUserData [in] The user data that was passed to drwav_init_write(), drwav_open_write() and family.
+184
// pData [out] A pointer to the data to write.
+185
// bytesToWrite [in] The number of bytes to write.
+186
//
+187
// Returns the number of bytes actually written.
+188
//
+189
// If the return value differs from bytesToWrite, it indicates an error.
+190
typedef size_t (* drwav_write_proc)(void* pUserData, const void* pData, size_t bytesToWrite);
+191
+192
// Callback for when data needs to be seeked.
+193
//
+194
// pUserData [in] The user data that was passed to drwav_init(), drwav_open() and family.
+195
// offset [in] The number of bytes to move, relative to the origin. Will never be negative.
+196
// origin [in] The origin of the seek - the current position or the start of the stream.
+197
//
+198
// Returns whether or not the seek was successful.
+199
//
+200
// Whether or not it is relative to the beginning or current position is determined by the "origin" parameter which
+201
// will be either drwav_seek_origin_start or drwav_seek_origin_current.
+202
typedef drwav_bool32 (* drwav_seek_proc)(void* pUserData, int offset, drwav_seek_origin origin);
+203
+204
// Structure for internal use. Only used for loaders opened with drwav_open_memory().
+205
typedef struct
+206
{
+207
const drwav_uint8* data;
+208
size_t dataSize;
+209
size_t currentReadPos;
+210
} drwav__memory_stream;
+211
+212
// Structure for internal use. Only used for writers opened with drwav_open_memory_write().
+213
typedef struct
+214
{
+215
void** ppData;
+216
size_t* pDataSize;
+217
size_t dataSize;
+218
size_t dataCapacity;
+219
size_t currentWritePos;
+220
} drwav__memory_stream_write;
+221
+222
typedef struct
+223
{
+224
drwav_container container; // RIFF, W64.
+225
drwav_uint32 format; // DR_WAVE_FORMAT_*
+226
drwav_uint32 channels;
+227
drwav_uint32 sampleRate;
+228
drwav_uint32 bitsPerSample;
+229
} drwav_data_format;
+230
+231
typedef struct
+232
{
+233
// The format tag exactly as specified in the wave file's "fmt" chunk. This can be used by applications
+234
// that require support for data formats not natively supported by dr_wav.
+235
drwav_uint16 formatTag;
+236
+237
// The number of channels making up the audio data. When this is set to 1 it is mono, 2 is stereo, etc.
+238
drwav_uint16 channels;
+239
+240
// The sample rate. Usually set to something like 44100.
+241
drwav_uint32 sampleRate;
+242
+243
// Average bytes per second. You probably don't need this, but it's left here for informational purposes.
+244
drwav_uint32 avgBytesPerSec;
+245
+246
// Block align. This is equal to the number of channels * bytes per sample.
+247
drwav_uint16 blockAlign;
+248
+249
// Bit's per sample.
+250
drwav_uint16 bitsPerSample;
+251
+252
// The size of the extended data. Only used internally for validation, but left here for informational purposes.
+253
drwav_uint16 extendedSize;
+254
+255
// The number of valid bits per sample. When <formatTag> is equal to WAVE_FORMAT_EXTENSIBLE, <bitsPerSample>
+256
// is always rounded up to the nearest multiple of 8. This variable contains information about exactly how
+257
// many bits a valid per sample. Mainly used for informational purposes.
+258
drwav_uint16 validBitsPerSample;
+259
+260
// The channel mask. Not used at the moment.
+261
drwav_uint32 channelMask;
+262
+263
// The sub-format, exactly as specified by the wave file.
+264
drwav_uint8 subFormat[16];
+265
} drwav_fmt;
+266
+267
typedef struct
+268
{
+269
// A pointer to the function to call when more data is needed.
+270
drwav_read_proc onRead;
+271
+272
// A pointer to the function to call when data needs to be written. Only used when the drwav object is opened in write mode.
+273
drwav_write_proc onWrite;
+274
+275
// A pointer to the function to call when the wav file needs to be seeked.
+276
drwav_seek_proc onSeek;
+277
+278
// The user data to pass to callbacks.
+279
void* pUserData;
+280
+281
+282
// Whether or not the WAV file is formatted as a standard RIFF file or W64.
+283
drwav_container container;
+284
+285
+286
// Structure containing format information exactly as specified by the wav file.
+287
drwav_fmt fmt;
+288
+289
// The sample rate. Will be set to something like 44100.
+290
drwav_uint32 sampleRate;
+291
+292
// The number of channels. This will be set to 1 for monaural streams, 2 for stereo, etc.
+293
drwav_uint16 channels;
+294
+295
// The bits per sample. Will be set to somthing like 16, 24, etc.
+296
drwav_uint16 bitsPerSample;
+297
+298
// The number of bytes per sample.
+299
drwav_uint16 bytesPerSample;
+300
+301
// Equal to fmt.formatTag, or the value specified by fmt.subFormat if fmt.formatTag is equal to 65534 (WAVE_FORMAT_EXTENSIBLE).
+302
drwav_uint16 translatedFormatTag;
+303
+304
// The total number of samples making up the audio data. Use <totalSampleCount> * <bytesPerSample> to calculate
+305
// the required size of a buffer to hold the entire audio data.
+306
drwav_uint64 totalSampleCount;
+307
+308
+309
// The size in bytes of the data chunk.
+310
drwav_uint64 dataChunkDataSize;
+311
+312
// The position in the stream of the first byte of the data chunk. This is used for seeking.
+313
drwav_uint64 dataChunkDataPos;
+314
+315
// The number of bytes remaining in the data chunk.
+316
drwav_uint64 bytesRemaining;
+317
+318
+319
// A hack to avoid a DRWAV_MALLOC() when opening a decoder with drwav_open_memory().
+320
drwav__memory_stream memoryStream;
+321
drwav__memory_stream_write memoryStreamWrite;
+322
+323
// Generic data for compressed formats. This data is shared across all block-compressed formats.
+324
struct
+325
{
+326
drwav_uint64 iCurrentSample; // The index of the next sample that will be read by drwav_read_*(). This is used with "totalSampleCount" to ensure we don't read excess samples at the end of the last block.
+327
} compressed;
+328
+329
// Microsoft ADPCM specific data.
+330
struct
+331
{
+332
drwav_uint32 bytesRemainingInBlock;
+333
drwav_uint16 predictor[2];
+334
drwav_int32 delta[2];
+335
drwav_int32 cachedSamples[4]; // Samples are stored in this cache during decoding.
+336
drwav_uint32 cachedSampleCount;
+337
drwav_int32 prevSamples[2][2]; // The previous 2 samples for each channel (2 channels at most).
+338
} msadpcm;
+339
+340
// IMA ADPCM specific data.
+341
struct
+342
{
+343
drwav_uint32 bytesRemainingInBlock;
+344
drwav_int32 predictor[2];
+345
drwav_int32 stepIndex[2];
+346
drwav_int32 cachedSamples[16]; // Samples are stored in this cache during decoding.
+347
drwav_uint32 cachedSampleCount;
+348
} ima;
+349
} drwav;
+350
+351
+352
// Initializes a pre-allocated drwav object.
+353
//
+354
// onRead [in] The function to call when data needs to be read from the client.
+355
// onSeek [in] The function to call when the read position of the client data needs to move.
+356
// pUserData [in, optional] A pointer to application defined data that will be passed to onRead and onSeek.
+357
//
+358
// Returns true if successful; false otherwise.
+359
//
+360
// Close the loader with drwav_uninit().
+361
//
+362
// This is the lowest level function for initializing a WAV file. You can also use drwav_init_file() and drwav_init_memory()
+363
// to open the stream from a file or from a block of memory respectively.
+364
//
+365
// If you want dr_wav to manage the memory allocation for you, consider using drwav_open() instead. This will allocate
+366
// a drwav object on the heap and return a pointer to it.
+367
//
+368
// See also: drwav_init_file(), drwav_init_memory(), drwav_uninit()
+369
drwav_bool32 drwav_init(drwav* pWav, drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData);
+370
+371
// Initializes a pre-allocated drwav object for writing.
+372
//
+373
// onWrite [in] The function to call when data needs to be written.
+374
// onSeek [in] The function to call when the write position needs to move.
+375
// pUserData [in, optional] A pointer to application defined data that will be passed to onWrite and onSeek.
+376
//
+377
// Returns true if successful; false otherwise.
+378
//
+379
// Close the writer with drwav_uninit().
+380
//
+381
// This is the lowest level function for initializing a WAV file. You can also use drwav_init_file() and drwav_init_memory()
+382
// to open the stream from a file or from a block of memory respectively.
+383
//
+384
// If you want dr_wav to manage the memory allocation for you, consider using drwav_open() instead. This will allocate
+385
// a drwav object on the heap and return a pointer to it.
+386
//
+387
// See also: drwav_init_file_write(), drwav_init_memory_write(), drwav_uninit()
+388
drwav_bool32 drwav_init_write(drwav* pWav, const drwav_data_format* pFormat, drwav_write_proc onWrite, drwav_seek_proc onSeek, void* pUserData);
+389
+390
// Uninitializes the given drwav object.
+391
//
+392
// Use this only for objects initialized with drwav_init().
+393
void drwav_uninit(drwav* pWav);
+394
+395
+396
// Opens a wav file using the given callbacks.
+397
//
+398
// onRead [in] The function to call when data needs to be read from the client.
+399
// onSeek [in] The function to call when the read position of the client data needs to move.
+400
// pUserData [in, optional] A pointer to application defined data that will be passed to onRead and onSeek.
+401
//
+402
// Returns null on error.
+403
//
+404
// Close the loader with drwav_close().
+405
//
+406
// This is the lowest level function for opening a WAV file. You can also use drwav_open_file() and drwav_open_memory()
+407
// to open the stream from a file or from a block of memory respectively.
+408
//
+409
// This is different from drwav_init() in that it will allocate the drwav object for you via DRWAV_MALLOC() before
+410
// initializing it.
+411
//
+412
// See also: drwav_open_file(), drwav_open_memory(), drwav_close()
+413
drwav* drwav_open(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData);
+414
+415
// Opens a wav file for writing using the given callbacks.
+416
//
+417
// onWrite [in] The function to call when data needs to be written.
+418
// onSeek [in] The function to call when the write position needs to move.
+419
// pUserData [in, optional] A pointer to application defined data that will be passed to onWrite and onSeek.
+420
//
+421
// Returns null on error.
+422
//
+423
// Close the loader with drwav_close().
+424
//
+425
// This is the lowest level function for opening a WAV file. You can also use drwav_open_file_write() and drwav_open_memory_write()
+426
// to open the stream from a file or from a block of memory respectively.
+427
//
+428
// This is different from drwav_init_write() in that it will allocate the drwav object for you via DRWAV_MALLOC() before
+429
// initializing it.
+430
//
+431
// See also: drwav_open_file_write(), drwav_open_memory_write(), drwav_close()
+432
drwav* drwav_open_write(const drwav_data_format* pFormat, drwav_write_proc onWrite, drwav_seek_proc onSeek, void* pUserData);
+433
+434
// Uninitializes and deletes the the given drwav object.
+435
//
+436
// Use this only for objects created with drwav_open().
+437
void drwav_close(drwav* pWav);
+438
+439
+440
// Reads raw audio data.
+441
//
+442
// This is the lowest level function for reading audio data. It simply reads the given number of
+443
// bytes of the raw internal sample data.
+444
//
+445
// Consider using drwav_read_s16(), drwav_read_s32() or drwav_read_f32() for reading sample data in
+446
// a consistent format.
+447
//
+448
// Returns the number of bytes actually read.
+449
size_t drwav_read_raw(drwav* pWav, size_t bytesToRead, void* pBufferOut);
+450
+451
// Reads a chunk of audio data in the native internal format.
+452
//
+453
// This is typically the most efficient way to retrieve audio data, but it does not do any format
+454
// conversions which means you'll need to convert the data manually if required.
+455
//
+456
// If the return value is less than <samplesToRead> it means the end of the file has been reached or
+457
// you have requested more samples than can possibly fit in the output buffer.
+458
//
+459
// This function will only work when sample data is of a fixed size and uncompressed. If you are
+460
// using a compressed format consider using drwav_read_raw() or drwav_read_s16/s32/f32/etc().
+461
drwav_uint64 drwav_read(drwav* pWav, drwav_uint64 samplesToRead, void* pBufferOut);
+462
+463
// Seeks to the given sample.
+464
//
+465
// Returns true if successful; false otherwise.
+466
drwav_bool32 drwav_seek_to_sample(drwav* pWav, drwav_uint64 sample);
+467
+468
+469
// Writes raw audio data.
+470
//
+471
// Returns the number of bytes actually written. If this differs from bytesToWrite, it indicates an error.
+472
size_t drwav_write_raw(drwav* pWav, size_t bytesToWrite, const void* pData);
+473
+474
// Writes audio data based on sample counts.
+475
//
+476
// Returns the number of samples written.
+477
drwav_uint64 drwav_write(drwav* pWav, drwav_uint64 samplesToWrite, const void* pData);
+478
+479
+480
+481
//// Convertion Utilities ////
+482
#ifndef DR_WAV_NO_CONVERSION_API
+483
+484
// Reads a chunk of audio data and converts it to signed 16-bit PCM samples.
+485
//
+486
// Returns the number of samples actually read.
+487
//
+488
// If the return value is less than <samplesToRead> it means the end of the file has been reached.
+489
drwav_uint64 drwav_read_s16(drwav* pWav, drwav_uint64 samplesToRead, drwav_int16* pBufferOut);
+490
+491
// Low-level function for converting unsigned 8-bit PCM samples to signed 16-bit PCM samples.
+492
void drwav_u8_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount);
+493
+494
// Low-level function for converting signed 24-bit PCM samples to signed 16-bit PCM samples.
+495
void drwav_s24_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount);
+496
+497
// Low-level function for converting signed 32-bit PCM samples to signed 16-bit PCM samples.
+498
void drwav_s32_to_s16(drwav_int16* pOut, const drwav_int32* pIn, size_t sampleCount);
+499

Showing the first 500 of 3491 diff lines for this file. This diff is INCOMPLETE; read the file or clone the repository for the rest.

vendor/soundpipe/lib/faust/CUI.hadded
@@ -0,0 +1,16 @@
+1
#include <stdlib.h>
+2
+3
#ifndef FAUSTFLOAT
+4
#define FAUSTFLOAT SPFLOAT
+5
#endif
+6
+7
typedef void (* addHorizontalSliderFun) (void* ui_interface, const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step);
+8
typedef void (* addVerticalSliderFun) (void* ui_interface, const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step);
+9
typedef void (* addCheckButtonFun) (void* ui_interface, const char* label, FAUSTFLOAT* zone);
+10
+11
typedef struct {
+12
void* uiInterface;
+13
addHorizontalSliderFun addHorizontalSlider;
+14
addVerticalSliderFun addVerticalSlider;
+15
addCheckButtonFun addCheckButton;
+16
} UIGlue;
vendor/soundpipe/modules/adsr.cadded
@@ -0,0 +1,95 @@
+1
#include <stdlib.h>
+2
#include <math.h>
+3
#include "soundpipe.h"
+4
+5
enum { CLEAR, ATTACK, DECAY, SUSTAIN, RELEASE };
+6
+7
int sp_adsr_create(sp_adsr **p)
+8
{
+9
*p = malloc(sizeof(sp_adsr));
+10
return SP_OK;
+11
}
+12
+13
int sp_adsr_destroy(sp_adsr **p)
+14
{
+15
free(*p);
+16
return SP_OK;
+17
}
+18
+19
int sp_adsr_init(sp_data *sp, sp_adsr *p)
+20
{
+21
p->atk = 0.1;
+22
p->dec = 0.1;
+23
p->sus = 0.5;
+24
p->rel = 0.3;
+25
p->timer = 0;
+26
p->a = 0;
+27
p->b = 0;
+28
p->y = 0;
+29
p->x = 0;
+30
p->prev = 0;
+31
p->atk_time = p->atk * sp->sr;
+32
p->mode = CLEAR;
+33
return SP_OK;
+34
}
+35
+36
static SPFLOAT tau2pole(sp_data *sp, sp_adsr *p, SPFLOAT tau)
+37
{
+38
return exp(-1.0 / (tau * sp->sr));
+39
}
+40
+41
static SPFLOAT adsr_filter(sp_data *sp, sp_adsr *p)
+42
{
+43
p->y = p->b * p->x + p->a * p->y;
+44
return p->y;
+45
}
+46
+47
int sp_adsr_compute(sp_data *sp, sp_adsr *p, SPFLOAT *in, SPFLOAT *out)
+48
{
+49
SPFLOAT pole;
+50
if (p->prev < *in && p->mode != DECAY) {
+51
p->mode = ATTACK;
+52
p->timer = 0;
+53
/* quick fix: uncomment if broken */
+54
/* pole = tau2pole(sp, p, p->atk * 0.75); */
+55
/* p->atk_time = p->atk * sp->sr * 1.5; */
+56
pole = tau2pole(sp, p, p->atk * 0.6);
+57
p->atk_time = p->atk * sp->sr;
+58
p->a = pole;
+59
p->b = 1 - pole;
+60
} else if (p->prev > *in) {
+61
p->mode = RELEASE;
+62
pole = tau2pole(sp, p, p->rel);
+63
p->a = pole;
+64
p->b = 1 - pole;
+65
}
+66
+67
p->x = *in;
+68
p->prev = *in;
+69
+70
switch (p->mode) {
+71
case CLEAR:
+72
*out = 0;
+73
break;
+74
case ATTACK:
+75
p->timer++;
+76
*out = adsr_filter(sp, p);
+77
/* quick fix: uncomment if broken */
+78
/* if(p->timer > p->atk_time) { */
+79
if (*out > 0.99) {
+80
p->mode = DECAY;
+81
pole = tau2pole(sp, p, p->dec);
+82
p->a = pole;
+83
p->b = 1 - pole;
+84
}
+85
break;
+86
case DECAY:
+87
case RELEASE:
+88
p->x *= p->sus;
+89
*out = adsr_filter(sp, p);
+90
default:
+91
break;
+92
}
+93
+94
return SP_OK;
+95
}
vendor/soundpipe/modules/atone.cadded
@@ -0,0 +1,63 @@
+1
/*
+2
* ATone
+3
*
+4
* This code has been extracted from the Csound opcode "atone".
+5
* It has been modified to work as a Soundpipe module.
+6
*
+7
* Original Author(s): Barry Vercoe, John FFitch, Gabriel Maldonado
+8
* Year: 1991
+9
* Location: OOps/ugens5.c
+10
*
+11
*/
+12
+13
#include <stdlib.h>
+14
#include <math.h>
+15
#include "soundpipe.h"
+16
+17
#ifndef M_PI
+18
#define M_PI 3.14159265358979323846
+19
#endif
+20
+21
int sp_atone_create(sp_atone **p)
+22
{
+23
*p = malloc(sizeof(sp_atone));
+24
return SP_OK;
+25
}
+26
+27
int sp_atone_destroy(sp_atone **p)
+28
{
+29
free(*p);
+30
return SP_OK;
+31
}
+32
+33
int sp_atone_init(sp_data *sp, sp_atone *p)
+34
{
+35
p->hp = 1000;
+36
SPFLOAT b;
+37
p->tpidsr = (2.0 * M_PI) / sp->sr * 1.0;
+38
p->prvhp = (SPFLOAT)p->hp;
+39
b = 2.0 - cos((SPFLOAT)(p->prvhp * p->tpidsr));
+40
p->c2 = b - sqrt(b * b - 1.0);
+41
p->c1 = 1.0 - p->c2;
+42
p->yt1 = 0.0;
+43
return SP_OK;
+44
}
+45
+46
int sp_atone_compute(sp_data *sp, sp_atone *p, SPFLOAT *in, SPFLOAT *out)
+47
{
+48
SPFLOAT c2 = p->c2, yt1 = p->yt1;
+49
SPFLOAT x;
+50
+51
if (p->hp != p->prvhp) {
+52
SPFLOAT b;
+53
p->prvhp = p->hp;
+54
b = 2.0 - cos((SPFLOAT)(p->hp * p->tpidsr));
+55
p->c2 = c2 = b - sqrt(b * b - 1.0);
+56
}
+57
+58
x = yt1 = c2 * (yt1 + *in);
+59
*out = x;
+60
yt1 -= *in;
+61
p->yt1 = yt1;
+62
return SP_OK;
+63
}
vendor/soundpipe/modules/base.cadded
@@ -0,0 +1,198 @@
+1
#include <stdlib.h>
+2
#include <stdio.h>
+3
#include <string.h>
+4
#include <math.h>
+5
#ifndef NO_LIBSNDFILE
+6
#include <sndfile.h>
+7
#endif
+8
#include "soundpipe.h"
+9
+10
int sp_create(sp_data **spp)
+11
{
+12
*spp = (sp_data *) malloc(sizeof(sp_data));
+13
sp_data *sp = *spp;
+14
sprintf(sp->filename, "test.wav");
+15
sp->nchan = 1;
+16
SPFLOAT *out = malloc(sizeof(SPFLOAT) * sp->nchan);
+17
*out = 0;
+18
sp->out = out;
+19
sp->sr = 44100;
+20
sp->len = 5 * sp->sr;
+21
sp->pos = 0;
+22
sp->rand = 0;
+23
return 0;
+24
}
+25
+26
int sp_createn(sp_data **spp, int nchan)
+27
{
+28
*spp = (sp_data *) malloc(sizeof(sp_data));
+29
sp_data *sp = *spp;
+30
sprintf(sp->filename, "test.wav");
+31
sp->nchan = nchan;
+32
SPFLOAT *out = malloc(sizeof(SPFLOAT) * sp->nchan);
+33
*out = 0;
+34
sp->out = out;
+35
sp->sr = 44100;
+36
sp->len = 5 * sp->sr;
+37
sp->pos = 0;
+38
sp->rand = 0;
+39
return 0;
+40
}
+41
+42
int sp_destroy(sp_data **spp)
+43
{
+44
sp_data *sp = *spp;
+45
free(sp->out);
+46
free(*spp);
+47
return 0;
+48
}
+49
+50
#ifndef NO_LIBSNDFILE
+51
+52
int sp_process(sp_data *sp, void *ud, void (*callback)(sp_data *, void *))
+53
{
+54
SNDFILE *sf[sp->nchan];
+55
char tmp[140];
+56
SF_INFO info;
+57
memset(&info, 0, sizeof(SF_INFO));
+58
SPFLOAT buf[sp->nchan][SP_BUFSIZE];
+59
info.samplerate = sp->sr;
+60
info.channels = 1;
+61
info.format = SF_FORMAT_WAV | SF_FORMAT_PCM_24;
+62
int numsamps, i, chan;
+63
+64
if (sp->nchan == 1) {
+65
sf[0] = sf_open(sp->filename, SFM_WRITE, &info);
+66
} else {
+67
for (chan = 0; chan < sp->nchan; chan++) {
+68
sprintf(tmp, "%02d_%s", chan, sp->filename);
+69
sf[chan] = sf_open(tmp, SFM_WRITE, &info);
+70
}
+71
}
+72
+73
while (sp->len > 0) {
+74
if (sp->len < SP_BUFSIZE) {
+75
numsamps = sp->len;
+76
} else {
+77
numsamps = SP_BUFSIZE;
+78
}
+79
+80
for (i = 0; i < numsamps; i++) {
+81
callback(sp, ud);
+82
for (chan = 0; chan < sp->nchan; chan++) {
+83
buf[chan][i] = sp->out[chan];
+84
}
+85
sp->pos++;
+86
}
+87
+88
for (chan = 0; chan < sp->nchan; chan++) {
+89
#ifdef USE_DOUBLE
+90
sf_write_double(sf[chan], buf[chan], numsamps);
+91
#else
+92
sf_write_float(sf[chan], buf[chan], numsamps);
+93
#endif
+94
}
+95
sp->len -= numsamps;
+96
}
+97
for (i = 0; i < sp->nchan; i++) {
+98
sf_close(sf[i]);
+99
}
+100
return 0;
+101
}
+102
+103
#endif
+104
+105
int sp_process_raw(sp_data *sp, void *ud, void (*callback)(sp_data *, void *))
+106
{
+107
int chan;
+108
if (sp->len == 0) {
+109
while(1) {
+110
callback(sp, ud);
+111
for (chan = 0; chan < sp->nchan; chan++) {
+112
fwrite(&sp->out[chan], sizeof(SPFLOAT), 1, stdout);
+113
}
+114
sp->len--;
+115
}
+116
} else {
+117
while (sp->len > 0) {
+118
callback(sp, ud);
+119
for (chan = 0; chan < sp->nchan; chan++) {
+120
fwrite(&sp->out[chan], sizeof(SPFLOAT), 1, stdout);
+121
}
+122
sp->len--;
+123
sp->pos++;
+124
}
+125
}
+126
return SP_OK;
+127
}
+128
+129
int sp_process_plot(sp_data *sp, void *ud, void (*callback)(sp_data *, void *))
+130
{
+131
int chan;
+132
fprintf(stdout, "sp_out = [ ... \n");
+133
while (sp->len > 0) {
+134
callback(sp, ud);
+135
for (chan = 0; chan < sp->nchan; chan++) {
+136
/* fwrite(&sp->out[chan], sizeof(SPFLOAT), 1, stdout); */
+137
fprintf(stdout, "%g ", sp->out[chan]);
+138
}
+139
fprintf(stdout, "; ...\n");
+140
sp->len--;
+141
sp->pos++;
+142
}
+143
fprintf(stdout, "];\n");
+144
+145
fprintf(stdout, "plot(sp_out);\n");
+146
fprintf(stdout, "title('Plot generated by Soundpipe');\n");
+147
fprintf(stdout, "xlabel('Time (samples)');\n");
+148
fprintf(stdout, "ylabel('Amplitude');\n");
+149
return SP_OK;
+150
}
+151
+152
int sp_auxdata_alloc(sp_auxdata *aux, size_t size)
+153
{
+154
aux->ptr = malloc(size);
+155
aux->size = size;
+156
memset(aux->ptr, 0, size);
+157
return SP_OK;
+158
}
+159
+160
int sp_auxdata_free(sp_auxdata *aux)
+161
{
+162
free(aux->ptr);
+163
return SP_OK;
+164
}
+165
+166
+167
SPFLOAT sp_midi2cps(SPFLOAT nn)
+168
{
+169
return pow(2, (nn - 69.0) / 12.0) * 440.0;
+170
}
+171
+172
int sp_set(sp_param *p, SPFLOAT val) {
+173
p->state = 1;
+174
p->val = val;
+175
return SP_OK;
+176
}
+177
+178
int sp_out(sp_data *sp, uint32_t chan, SPFLOAT val)
+179
{
+180
if (chan > sp->nchan - 1) {
+181
fprintf(stderr, "sp_out: Invalid channel\n");
+182
return SP_NOT_OK;
+183
}
+184
sp->out[chan] = val;
+185
return SP_OK;
+186
}
+187
+188
uint32_t sp_rand(sp_data *sp)
+189
{
+190
uint32_t val = (1103515245 * sp->rand + 12345) % SP_RANDMAX;
+191
sp->rand = val;
+192
return val;
+193
}
+194
+195
void sp_srand(sp_data *sp, uint32_t val)
+196
{
+197
sp->rand = val;
+198
}
vendor/soundpipe/modules/blsaw.cadded
@@ -0,0 +1,171 @@
+1
/*
+2
* Saw
+3
*
+4
* This code was generated by Faust. It utilizes the saw2 Faust
+5
* module coded by Julius Smith. See oscillator.lib for more details.
+6
*
+7
*/
+8
+9
#include <stdlib.h>
+10
#include <math.h>
+11
#include "soundpipe.h"
+12
#include "CUI.h"
+13
+14
#define max(a,b) ((a < b) ? b : a)
+15
#define min(a,b) ((a < b) ? a : b)
+16
+17
#ifndef FAUSTFLOAT
+18
#define FAUSTFLOAT float
+19
#endif
+20
+21
static float faustpower2_f(float value) {
+22
return (value * value);
+23
+24
}
+25
+26
typedef struct {
+27
+28
float fRec0[2];
+29
float fVec0[2];
+30
float fVec1[2];
+31
int fSamplingFreq;
+32
int iConst0;
+33
FAUSTFLOAT fHslider0;
+34
FAUSTFLOAT fHslider1;
+35
float fConst1;
+36
float fConst2;
+37
} blsaw;
+38
+39
blsaw* newblsaw() {
+40
blsaw* dsp = (blsaw*)malloc(sizeof(blsaw));
+41
return dsp;
+42
}
+43
+44
void deleteblsaw(blsaw* dsp) {
+45
free(dsp);
+46
}
+47
+48
void instanceInitblsaw(blsaw* dsp, int samplingFreq) {
+49
dsp->fSamplingFreq = samplingFreq;
+50
dsp->iConst0 = min(192000, max(1, dsp->fSamplingFreq));
+51
dsp->fHslider0 = (FAUSTFLOAT)1.;
+52
dsp->fHslider1 = (FAUSTFLOAT)440.;
+53
dsp->fConst1 = (float)dsp->iConst0;
+54
dsp->fConst2 = (2.f / dsp->fConst1);
+55
/* C99 loop */
+56
{
+57
int i0;
+58
for (i0 = 0; (i0 < 2); i0 = (i0 + 1)) {
+59
dsp->fRec0[i0] = 0.f;
+60
+61
}
+62
+63
}
+64
/* C99 loop */
+65
{
+66
int i1;
+67
for (i1 = 0; (i1 < 2); i1 = (i1 + 1)) {
+68
dsp->fVec0[i1] = 0.f;
+69
+70
}
+71
+72
}
+73
/* C99 loop */
+74
{
+75
int i2;
+76
for (i2 = 0; (i2 < 2); i2 = (i2 + 1)) {
+77
dsp->fVec1[i2] = 0.f;
+78
+79
}
+80
+81
}
+82
+83
}
+84
+85
void initblsaw(blsaw* dsp, int samplingFreq) {
+86
instanceInitblsaw(dsp, samplingFreq);
+87
}
+88
+89
void buildUserInterfaceblsaw(blsaw* dsp, UIGlue* interface) {
+90
interface->addHorizontalSlider(interface->uiInterface, "freq", &dsp->fHslider1, 440.f, 0.f, 20000.f, 0.0001f);
+91
interface->addHorizontalSlider(interface->uiInterface, "amp", &dsp->fHslider0, 1.f, 0.f, 1.f, 0.0001f);
+92
}
+93
+94
void computeblsaw(blsaw* dsp, int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
+95
FAUSTFLOAT* output0 = outputs[0];
+96
float fSlow0 = (float)dsp->fHslider1;
+97
float fSlow1 = ((float)dsp->iConst0 * ((float)dsp->fHslider0 / fSlow0));
+98
float fSlow2 = (dsp->fConst2 * fSlow0);
+99
float fSlow3 = (dsp->fConst1 / fSlow0);
+100
/* C99 loop */
+101
{
+102
int i;
+103
for (i = 0; (i < count); i = (i + 1)) {
+104
dsp->fRec0[0] = fmod((1.f + dsp->fRec0[1]), fSlow3);
+105
float fTemp0 = faustpower2_f(((fSlow2 * dsp->fRec0[0]) - 1.f));
+106
dsp->fVec0[0] = fTemp0;
+107
dsp->fVec1[0] = 0.25f;
+108
output0[i] = (FAUSTFLOAT)(fSlow1 * ((fTemp0 - dsp->fVec0[1]) * dsp->fVec1[1]));
+109
dsp->fRec0[1] = dsp->fRec0[0];
+110
dsp->fVec0[1] = dsp->fVec0[0];
+111
dsp->fVec1[1] = dsp->fVec1[0];
+112
+113
}
+114
+115
}
+116
+117
}
+118
+119
+120
static void addHorizontalSlider(void* ui_interface, const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step)
+121
{
+122
sp_blsaw *p = ui_interface;
+123
p->args[p->argpos] = zone;
+124
p->argpos++;
+125
}
+126
+127
int sp_blsaw_create(sp_blsaw **p)
+128
{
+129
*p = malloc(sizeof(sp_blsaw));
+130
return SP_OK;
+131
}
+132
+133
int sp_blsaw_destroy(sp_blsaw **p)
+134
{
+135
sp_blsaw *pp = *p;
+136
blsaw *dsp = pp->ud;
+137
deleteblsaw (dsp);
+138
free(*p);
+139
return SP_OK;
+140
}
+141
+142
int sp_blsaw_init(sp_data *sp, sp_blsaw *p)
+143
{
+144
blsaw *dsp = newblsaw();
+145
UIGlue UI;
+146
p->argpos = 0;
+147
UI.addHorizontalSlider= addHorizontalSlider;
+148
UI.uiInterface = p;
+149
buildUserInterfaceblsaw(dsp, &UI);
+150
initblsaw(dsp, sp->sr);
+151
+152
+153
p->freq = p->args[0];
+154
p->amp = p->args[1];
+155
+156
p->ud = dsp;
+157
return SP_OK;
+158
}
+159
+160
int sp_blsaw_compute(sp_data *sp, sp_blsaw *p, SPFLOAT *in, SPFLOAT *out)
+161
{
+162
+163
blsaw *dsp = p->ud;
+164
SPFLOAT out1 = 0;
+165
SPFLOAT *faust_out[] = {&out1};
+166
SPFLOAT *faust_in[] = {in};
+167
computeblsaw(dsp, 1, faust_in, faust_out);
+168
+169
*out = out1;
+170
return SP_OK;
+171
}
vendor/soundpipe/modules/blsquare.cadded
@@ -0,0 +1,185 @@
+1
#include <math.h>
+2
#include <stdlib.h>
+3
#include "soundpipe.h"
+4
#include "CUI.h"
+5
+6
#define max(a,b) ((a < b) ? b : a)
+7
#define min(a,b) ((a < b) ? a : b)
+8
+9
#ifndef FAUSTFLOAT
+10
#define FAUSTFLOAT float
+11
#endif
+12
+13
float fmodf(float dummy0, float dummy1);
+14
static float faustpower2_f(float value) {
+15
return (value * value);
+16
}
+17
+18
typedef struct {
+19
float fVec2[4096];
+20
int iVec0[2];
+21
float fRec0[2];
+22
float fVec1[2];
+23
FAUSTFLOAT fHslider0;
+24
int fSamplingFreq;
+25
float fConst0;
+26
FAUSTFLOAT fHslider1;
+27
FAUSTFLOAT fHslider2;
+28
float fConst1;
+29
float fConst2;
+30
int IOTA;
+31
} blsquare;
+32
+33
blsquare* newblsquare() {
+34
blsquare* dsp = (blsquare*)malloc(sizeof(blsquare));
+35
return dsp;
+36
}
+37
+38
void deleteblsquare(blsquare* dsp) {
+39
free(dsp);
+40
}
+41
+42
+43
void instanceInitblsquare(blsquare* dsp, int samplingFreq) {
+44
dsp->fSamplingFreq = samplingFreq;
+45
dsp->fHslider0 = (FAUSTFLOAT)1.;
+46
/* C99 loop */
+47
{
+48
int i0;
+49
for (i0 = 0; (i0 < 2); i0 = (i0 + 1)) {
+50
dsp->iVec0[i0] = 0;
+51
+52
}
+53
+54
}
+55
dsp->fConst0 = (float)min(192000, max(1, dsp->fSamplingFreq));
+56
dsp->fHslider1 = (FAUSTFLOAT)0.5;
+57
dsp->fHslider2 = (FAUSTFLOAT)440.;
+58
dsp->fConst1 = (0.25f * dsp->fConst0);
+59
dsp->fConst2 = (1.f / dsp->fConst0);
+60
/* C99 loop */
+61
{
+62
int i1;
+63
for (i1 = 0; (i1 < 2); i1 = (i1 + 1)) {
+64
dsp->fRec0[i1] = 0.f;
+65
+66
}
+67
+68
}
+69
/* C99 loop */
+70
{
+71
int i2;
+72
for (i2 = 0; (i2 < 2); i2 = (i2 + 1)) {
+73
dsp->fVec1[i2] = 0.f;
+74
+75
}
+76
+77
}
+78
dsp->IOTA = 0;
+79
/* C99 loop */
+80
{
+81
int i3;
+82
for (i3 = 0; (i3 < 4096); i3 = (i3 + 1)) {
+83
dsp->fVec2[i3] = 0.f;
+84
+85
}
+86
+87
}
+88
+89
}
+90
+91
void initblsquare(blsquare* dsp, int samplingFreq) {
+92
instanceInitblsquare(dsp, samplingFreq);
+93
}
+94
+95
void buildUserInterfaceblsquare(blsquare* dsp, UIGlue* interface) {
+96
interface->addHorizontalSlider(interface->uiInterface, "frequency", &dsp->fHslider2, 440.f, 0.f, 20000.f, 0.0001f);
+97
interface->addHorizontalSlider(interface->uiInterface, "amp", &dsp->fHslider0, 1.f, 0.f, 1.f, 1e-05f);
+98
interface->addHorizontalSlider(interface->uiInterface, "width", &dsp->fHslider1, 0.5f, 0.f, 1.f, 0.f);
+99
}
+100
+101
void computeblsquare(blsquare* dsp, int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
+102
FAUSTFLOAT* output0 = outputs[0];
+103
float fSlow0 = (float)dsp->fHslider0;
+104
float fSlow1 = max((float)dsp->fHslider2, 23.4489f);
+105
float fSlow2 = max(0.f, min(2047.f, (dsp->fConst0 * ((float)dsp->fHslider1 / fSlow1))));
+106
int iSlow3 = (int)fSlow2;
+107
int iSlow4 = (1 + iSlow3);
+108
float fSlow5 = ((float)iSlow4 - fSlow2);
+109
float fSlow6 = (dsp->fConst1 / fSlow1);
+110
float fSlow7 = (dsp->fConst2 * fSlow1);
+111
float fSlow8 = (fSlow2 - (float)iSlow3);
+112
/* C99 loop */
+113
{
+114
int i;
+115
for (i = 0; (i < count); i = (i + 1)) {
+116
dsp->iVec0[0] = 1;
+117
dsp->fRec0[0] = fmodf((dsp->fRec0[1] + fSlow7), 1.f);
+118
float fTemp0 = faustpower2_f(((2.f * dsp->fRec0[0]) - 1.f));
+119
dsp->fVec1[0] = fTemp0;
+120
float fTemp1 = (fSlow6 * ((fTemp0 - dsp->fVec1[1]) * (float)dsp->iVec0[1]));
+121
dsp->fVec2[(dsp->IOTA & 4095)] = fTemp1;
+122
output0[i] = (FAUSTFLOAT)(fSlow0 * (0.f - (((fSlow5 * dsp->fVec2[((dsp->IOTA - iSlow3) & 4095)]) + (fSlow8 * dsp->fVec2[((dsp->IOTA - iSlow4) & 4095)])) - fTemp1)));
+123
dsp->iVec0[1] = dsp->iVec0[0];
+124
dsp->fRec0[1] = dsp->fRec0[0];
+125
dsp->fVec1[1] = dsp->fVec1[0];
+126
dsp->IOTA = (dsp->IOTA + 1);
+127
+128
}
+129
+130
}
+131
+132
}
+133
+134
static void addHorizontalSlider(void* ui_interface, const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step)
+135
{
+136
sp_blsquare *p = ui_interface;
+137
p->args[p->argpos] = zone;
+138
p->argpos++;
+139
}
+140
+141
int sp_blsquare_create(sp_blsquare **p)
+142
{
+143
*p = malloc(sizeof(sp_blsquare));
+144
return SP_OK;
+145
}
+146
+147
int sp_blsquare_destroy(sp_blsquare **p)
+148
{
+149
sp_blsquare *pp = *p;
+150
blsquare *dsp = pp->ud;
+151
deleteblsquare (dsp);
+152
free(*p);
+153
return SP_OK;
+154
}
+155
+156
int sp_blsquare_init(sp_data *sp, sp_blsquare *p)
+157
{
+158
blsquare *dsp = newblsquare(); UIGlue UI;
+159
p->argpos = 0;
+160
UI.addHorizontalSlider= addHorizontalSlider;
+161
UI.uiInterface = p;
+162
buildUserInterfaceblsquare(dsp, &UI);
+163
initblsquare(dsp, sp->sr);
+164
+165
+166
p->freq = p->args[0];
+167
p->amp = p->args[1];
+168
p->width = p->args[2];
+169
+170
p->ud = dsp;
+171
return SP_OK;
+172
}
+173
+174
int sp_blsquare_compute(sp_data *sp, sp_blsquare *p, SPFLOAT *in, SPFLOAT *out)
+175
{
+176
+177
blsquare *dsp = p->ud;
+178
SPFLOAT out1 = 0;
+179
SPFLOAT *faust_out[] = {&out1};
+180
SPFLOAT *faust_in[] = {in};
+181
computeblsquare(dsp, 1, faust_in, faust_out);
+182
+183
*out = out1;
+184
return SP_OK;
+185
}
vendor/soundpipe/modules/bltriangle.cadded
@@ -0,0 +1,202 @@
+1
#include <math.h>
+2
#include <stdlib.h>
+3
#include "soundpipe.h"
+4
#include "CUI.h"
+5
+6
#define max(a,b) ((a < b) ? b : a)
+7
#define min(a,b) ((a < b) ? a : b)
+8
+9
#ifndef FAUSTFLOAT
+10
#define FAUSTFLOAT float
+11
#endif
+12
+13
float fmodf(float dummy0, float dummy1);
+14
static float faustpower2_f(float value) {
+15
return (value * value);
+16
+17
}
+18
+19
typedef struct {
+20
+21
float fVec2[4096];
+22
int iVec0[2];
+23
float fRec1[2];
+24
float fVec1[2];
+25
float fRec0[2];
+26
int fSamplingFreq;
+27
int iConst0;
+28
float fConst1;
+29
FAUSTFLOAT fHslider0;
+30
FAUSTFLOAT fHslider1;
+31
float fConst2;
+32
float fConst3;
+33
float fConst4;
+34
float fConst5;
+35
int IOTA;
+36
+37
} bltriangle;
+38
+39
bltriangle* newbltriangle() {
+40
bltriangle* dsp = (bltriangle*)malloc(sizeof(bltriangle));
+41
return dsp;
+42
}
+43
+44
void deletebltriangle(bltriangle* dsp) {
+45
free(dsp);
+46
}
+47
+48
void instanceInitbltriangle(bltriangle* dsp, int samplingFreq) {
+49
dsp->fSamplingFreq = samplingFreq;
+50
/* C99 loop */
+51
{
+52
int i0;
+53
for (i0 = 0; (i0 < 2); i0 = (i0 + 1)) {
+54
dsp->iVec0[i0] = 0;
+55
+56
}
+57
+58
}
+59
dsp->iConst0 = min(192000, max(1, dsp->fSamplingFreq));
+60
dsp->fConst1 = (4.f / (float)dsp->iConst0);
+61
dsp->fHslider0 = (FAUSTFLOAT)440.;
+62
dsp->fHslider1 = (FAUSTFLOAT)1.;
+63
dsp->fConst2 = (float)dsp->iConst0;
+64
dsp->fConst3 = (0.5f * dsp->fConst2);
+65
dsp->fConst4 = (0.25f * dsp->fConst2);
+66
dsp->fConst5 = (1.f / dsp->fConst2);
+67
/* C99 loop */
+68
{
+69
int i1;
+70
for (i1 = 0; (i1 < 2); i1 = (i1 + 1)) {
+71
dsp->fRec1[i1] = 0.f;
+72
+73
}
+74
+75
}
+76
/* C99 loop */
+77
{
+78
int i2;
+79
for (i2 = 0; (i2 < 2); i2 = (i2 + 1)) {
+80
dsp->fVec1[i2] = 0.f;
+81
+82
}
+83
+84
}
+85
dsp->IOTA = 0;
+86
/* C99 loop */
+87
{
+88
int i3;
+89
for (i3 = 0; (i3 < 4096); i3 = (i3 + 1)) {
+90
dsp->fVec2[i3] = 0.f;
+91
+92
}
+93
+94
}
+95
/* C99 loop */
+96
{
+97
int i4;
+98
for (i4 = 0; (i4 < 2); i4 = (i4 + 1)) {
+99
dsp->fRec0[i4] = 0.f;
+100
+101
}
+102
+103
}
+104
+105
}
+106
+107
void initbltriangle(bltriangle* dsp, int samplingFreq) {
+108
instanceInitbltriangle(dsp, samplingFreq);
+109
}
+110
+111
void buildUserInterfacebltriangle(bltriangle* dsp, UIGlue* interface) {
+112
interface->addHorizontalSlider(interface->uiInterface, "freq", &dsp->fHslider0, 440.f, 0.f, 20000.f, 0.0001f);
+113
interface->addHorizontalSlider(interface->uiInterface, "amp", &dsp->fHslider1, 1.f, 0.f, 1.f, 1e-05f);
+114
}
+115
+116
void computebltriangle(bltriangle* dsp, int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
+117
FAUSTFLOAT* output0 = outputs[0];
+118
float fSlow0 = (float)dsp->fHslider0;
+119
float fSlow1 = (dsp->fConst1 * (fSlow0 * (float)dsp->fHslider1));
+120
float fSlow2 = max(fSlow0, 23.4489f);
+121
float fSlow3 = max(0.f, min(2047.f, (dsp->fConst3 / fSlow2)));
+122
int iSlow4 = (int)fSlow3;
+123
int iSlow5 = (1 + iSlow4);
+124
float fSlow6 = ((float)iSlow5 - fSlow3);
+125
float fSlow7 = (dsp->fConst4 / fSlow2);
+126
float fSlow8 = (dsp->fConst5 * fSlow2);
+127
float fSlow9 = (fSlow3 - (float)iSlow4);
+128
/* C99 loop */
+129
{
+130
int i;
+131
for (i = 0; (i < count); i = (i + 1)) {
+132
dsp->iVec0[0] = 1;
+133
dsp->fRec1[0] = fmodf((dsp->fRec1[1] + fSlow8), 1.f);
+134
float fTemp0 = faustpower2_f(((2.f * dsp->fRec1[0]) - 1.f));
+135
dsp->fVec1[0] = fTemp0;
+136
float fTemp1 = (fSlow7 * ((fTemp0 - dsp->fVec1[1]) * (float)dsp->iVec0[1]));
+137
dsp->fVec2[(dsp->IOTA & 4095)] = fTemp1;
+138
dsp->fRec0[0] = (0.f - (((fSlow6 * dsp->fVec2[((dsp->IOTA - iSlow4) & 4095)]) + (fSlow9 * dsp->fVec2[((dsp->IOTA - iSlow5) & 4095)])) - ((0.999f * dsp->fRec0[1]) + fTemp1)));
+139
output0[i] = (FAUSTFLOAT)(fSlow1 * dsp->fRec0[0]);
+140
dsp->iVec0[1] = dsp->iVec0[0];
+141
dsp->fRec1[1] = dsp->fRec1[0];
+142
dsp->fVec1[1] = dsp->fVec1[0];
+143
dsp->IOTA = (dsp->IOTA + 1);
+144
dsp->fRec0[1] = dsp->fRec0[0];
+145
+146
}
+147
+148
}
+149
+150
}
+151
+152
static void addHorizontalSlider(void* ui_interface, const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step)
+153
{
+154
sp_bltriangle *p = ui_interface;
+155
p->args[p->argpos] = zone;
+156
p->argpos++;
+157
}
+158
+159
int sp_bltriangle_create(sp_bltriangle **p)
+160
{
+161
*p = malloc(sizeof(sp_bltriangle));
+162
return SP_OK;
+163
}
+164
+165
int sp_bltriangle_destroy(sp_bltriangle **p)
+166
{
+167
sp_bltriangle *pp = *p;
+168
bltriangle *dsp = pp->ud;
+169
deletebltriangle (dsp);
+170
free(*p);
+171
return SP_OK;
+172
}
+173
+174
int sp_bltriangle_init(sp_data *sp, sp_bltriangle *p)
+175
{
+176
bltriangle *dsp = newbltriangle(); UIGlue UI;
+177
p->argpos = 0;
+178
UI.addHorizontalSlider= addHorizontalSlider;
+179
UI.uiInterface = p;
+180
buildUserInterfacebltriangle(dsp, &UI);
+181
initbltriangle(dsp, sp->sr);
+182
+183
+184
p->freq = p->args[0];
+185
p->amp = p->args[1];
+186
+187
p->ud = dsp;
+188
return SP_OK;
+189
}
+190
+191
int sp_bltriangle_compute(sp_data *sp, sp_bltriangle *p, SPFLOAT *in, SPFLOAT *out)
+192
{
+193
+194
bltriangle *dsp = p->ud;
+195
SPFLOAT out1 = 0;
+196
SPFLOAT *faust_out[] = {&out1};
+197
SPFLOAT *faust_in[] = {in};
+198
computebltriangle(dsp, 1, faust_in, faust_out);
+199
+200
*out = out1;
+201
return SP_OK;
+202
}
vendor/soundpipe/modules/brown.cadded
@@ -0,0 +1,47 @@
+1
/*
+2
* Brown
+3
*
+4
* Brownian noise algorithm based on implementation found here:
+5
* http://vellocet.com/dsp/noise/VRand.h
+6
*
+7
*
+8
*/
+9
+10
#include <stdlib.h>
+11
#include "soundpipe.h"
+12
+13
int sp_brown_create(sp_brown **p)
+14
{
+15
*p = malloc(sizeof(sp_brown));
+16
return SP_OK;
+17
}
+18
+19
int sp_brown_destroy(sp_brown **p)
+20
{
+21
free(*p);
+22
return SP_OK;
+23
}
+24
+25
int sp_brown_init(sp_data *sp, sp_brown *p)
+26
{
+27
p->brown = 0.0;
+28
return SP_OK;
+29
}
+30
+31
int sp_brown_compute(sp_data *sp, sp_brown *p, SPFLOAT *in, SPFLOAT *out)
+32
{
+33
SPFLOAT r;
+34
while (1) {
+35
r = (sp_rand(sp) % SP_RANDMAX) / (SPFLOAT)(SP_RANDMAX);
+36
r = ((r * 2) - 1) * 0.5;
+37
p->brown += r;
+38
if (p->brown < -8.0f || p->brown > 8.0f) {
+39
p->brown -= r;
+40
} else {
+41
break;
+42
}
+43
}
+44
+45
*out = p->brown * 0.0625;
+46
return SP_OK;
+47
}
vendor/soundpipe/modules/buthp.cadded
@@ -0,0 +1,83 @@
+1
/*
+2
* Buthp
+3
*
+4
* This is an implementation of a 2nd-order butterworth
+5
* highpass filter, discretized using the bilinear transform.
+6
*
+7
* For more information on using the BLT on 2nd-order
+8
* butterworth filters, see:
+9
*
+10
* https://ccrma.stanford.edu/~jos/filters/Example_Second_Order_Butterworth_Lowpass.html
+11
*/
+12
+13
#include <math.h>
+14
#include <stdint.h>
+15
#include <stdlib.h>
+16
#define ROOT2 (1.4142135623730950488)
+17
+18
#ifndef M_PI
+19
#define M_PI 3.14159265358979323846
+20
#endif
+21
+22
#include "soundpipe.h"
+23
+24
static int filter(SPFLOAT *in, SPFLOAT *out, SPFLOAT *a)
+25
{
+26
SPFLOAT t, y;
+27
+28
/* a5 = t(n - 1); a6 = t(n - 2) */
+29
t = *in - a[3]*a[5] - a[4]*a[6];
+30
y = t*a[0] + a[1]*a[5] + a[2]*a[6];
+31
a[6] = a[5];
+32
a[5] = t;
+33
*out = y;
+34
return SP_OK;
+35
}
+36
+37
+38
int sp_buthp_create(sp_buthp **p)
+39
{
+40
*p = malloc(sizeof(sp_buthp));
+41
return SP_OK;
+42
}
+43
+44
int sp_buthp_destroy(sp_buthp **p)
+45
{
+46
free(*p);
+47
return SP_OK;
+48
}
+49
+50
int sp_buthp_init(sp_data *sp, sp_buthp *p)
+51
{
+52
p->freq = 1000;
+53
p->pidsr = M_PI / sp->sr * 1.0;
+54
p->a[5] = p->a[6] = 0.0;
+55
p->lfreq = 0.0;
+56
return SP_OK;
+57
}
+58
+59
int sp_buthp_compute(sp_data *sp, sp_buthp *p, SPFLOAT *in, SPFLOAT *out)
+60
{
+61
if (p->freq <= 0.0) {
+62
*out = 0;
+63
return SP_OK;
+64
}
+65
+66
if (p->freq != p->lfreq) {
+67
SPFLOAT *a, c;
+68
a = p->a;
+69
p->lfreq = p->freq;
+70
/* derive C constant used in BLT */
+71
c = tan((SPFLOAT)(p->pidsr * p->freq));
+72
+73
/* perform BLT, store components */
+74
a[0] = 1.0 / (1.0 + c*ROOT2 + c*c);
+75
a[1] = -2*a[0];
+76
a[2] = a[0];
+77
a[3] = 2.0 * (c*c - 1.0) * a[0];
+78
a[4] = (1.0 - c*ROOT2 + c*c) * a[0];
+79
}
+80
+81
filter(in, out, p->a);
+82
return SP_OK;
+83
}
vendor/soundpipe/modules/butlp.cadded
@@ -0,0 +1,81 @@
+1
/*
+2
* Butlp
+3
*
+4
* This is an implementation of a 2nd-order butterworth
+5
* lowpass filter, discretized using the bilinear transform.
+6
*
+7
* For more information on using the BLT on 2nd-order
+8
* butterworth filters, see:
+9
*
+10
* https://ccrma.stanford.edu/~jos/filters/Example_Second_Order_Butterworth_Lowpass.html
+11
*/
+12
+13
#include <math.h>
+14
#include <stdint.h>
+15
#include <stdlib.h>
+16
#define ROOT2 (1.4142135623730950488)
+17
+18
#ifndef M_PI
+19
#define M_PI 3.14159265358979323846
+20
#endif
+21
+22
#include "soundpipe.h"
+23
+24
static int filter(SPFLOAT *in, SPFLOAT *out, SPFLOAT *a)
+25
{
+26
SPFLOAT t, y;
+27
/* a5 = t(n - 1); a6 = t(n - 2) */
+28
t = *in - a[3]*a[5] - a[4]*a[6];
+29
y = t*a[0] + a[1]*a[5] + a[2]*a[6];
+30
a[6] = a[5];
+31
a[5] = t;
+32
*out = y;
+33
return SP_OK;
+34
}
+35
+36
int sp_butlp_create(sp_butlp **p)
+37
{
+38
*p = malloc(sizeof(sp_butlp));
+39
return SP_OK;
+40
}
+41
+42
int sp_butlp_destroy(sp_butlp **p)
+43
{
+44
free(*p);
+45
return SP_OK;
+46
}
+47
+48
int sp_butlp_init(sp_data *sp, sp_butlp *p)
+49
{
+50
p->freq = 1000;
+51
p->pidsr = M_PI / sp->sr * 1.0;
+52
p->a[5] = p->a[6] = 0.0;
+53
p->lfreq = 0.0;
+54
return SP_OK;
+55
}
+56
+57
int sp_butlp_compute(sp_data *sp, sp_butlp *p, SPFLOAT *in, SPFLOAT *out)
+58
{
+59
if (p->freq <= 0.0) {
+60
*out = 0;
+61
return SP_NOT_OK;
+62
}
+63
+64
if (p->freq != p->lfreq) {
+65
SPFLOAT *a, c;
+66
a = p->a;
+67
p->lfreq = p->freq;
+68
/* derive C constant used in BLT */
+69
c = 1.0 / tan((SPFLOAT)(p->pidsr * p->lfreq));
+70
+71
/* perform BLT, store components */
+72
a[0] = 1.0 / (1.0 + c*ROOT2 + c*c);
+73
a[1] = 2*a[0];
+74
a[2] = a[0];
+75
a[3] = 2.0 * (1.0 - c*c) * a[0];
+76
a[4] = (1.0 - c*ROOT2 + c*c) * a[0];
+77
}
+78
+79
filter(in, out, p->a);
+80
return SP_OK;
+81
}
vendor/soundpipe/modules/clamp.cadded
@@ -0,0 +1,29 @@
+1
#include <stdlib.h>
+2
#include "soundpipe.h"
+3
+4
int sp_clamp_create(sp_clamp **p)
+5
{
+6
*p = malloc(sizeof(sp_clamp));
+7
return SP_OK;
+8
}
+9
+10
int sp_clamp_destroy(sp_clamp **p)
+11
{
+12
free(*p);
+13
return SP_OK;
+14
}
+15
+16
int sp_clamp_init(sp_data *sp, sp_clamp *p)
+17
{
+18
p->min = 0;
+19
p->max = 1;
+20
return SP_OK;
+21
}
+22
+23
int sp_clamp_compute(sp_data *sp, sp_clamp *p, SPFLOAT *in, SPFLOAT *out)
+24
{
+25
if (*in < p->min) *out = p->min;
+26
else if (*in > p->max) *out = p->max;
+27
else *out = *in;
+28
return SP_OK;
+29
}
vendor/soundpipe/modules/clip.cadded
@@ -0,0 +1,61 @@
+1
/*
+2
* Clip
+3
*
+4
* This code has been extracted from the Csound opcode "clip".
+5
* It has been modified to work as a Soundpipe module.
+6
*
+7
* Original Author(s): John ffitch, Istvan Varga, Peter Neubäcker,
+8
rasmus ekman, Phil Burk
+9
* Year: 1999
+10
* Location: Opcodes/pitch.c
+11
*
+12
*/
+13
+14
#include <math.h>
+15
#include <stdint.h>
+16
#include <stdlib.h>
+17
+18
#ifndef M_PI
+19
#define M_PI 3.14159265358979323846
+20
#endif
+21
+22
#include "soundpipe.h"
+23
+24
int sp_clip_create(sp_clip **p)
+25
{
+26
*p = malloc(sizeof(sp_clip));
+27
return SP_OK;
+28
}
+29
+30
int sp_clip_destroy(sp_clip **p)
+31
{
+32
free(*p);
+33
return SP_OK;
+34
}
+35
+36
int sp_clip_init(sp_data *sp, sp_clip *p)
+37
{
+38
p->lim = 1;
+39
p->k1 = M_PI / (2.0 * p->lim);
+40
return SP_OK;
+41
}
+42
+43
int sp_clip_compute(sp_data *sp, sp_clip *p, SPFLOAT *in, SPFLOAT *out)
+44
{
+45
p->k1 = M_PI / (2.0 * p->lim);
+46
SPFLOAT k1 = p->k1;
+47
SPFLOAT limit = p->lim;
+48
SPFLOAT x;
+49
+50
x = *in;
+51
if (x >= limit) {
+52
x = limit;
+53
} else if (x <= -limit) {
+54
x = -limit;
+55
} else {
+56
x = limit * sin(k1 * x);
+57
}
+58
*out = x;
+59
+60
return SP_OK;
+61
}
vendor/soundpipe/modules/clock.cadded
@@ -0,0 +1,41 @@
+1
/*
+2
* Foo
+3
*
+4
* This is a dummy module. It doesn't do much.
+5
* Feel free to use this as a boilerplate template.
+6
*
+7
*/
+8
+9
#include <stdlib.h>
+10
#include "soundpipe.h"
+11
+12
int sp_clock_create(sp_clock **p)
+13
{
+14
*p = malloc(sizeof(sp_clock));
+15
return SP_OK;
+16
}
+17
+18
int sp_clock_destroy(sp_clock **p)
+19
{
+20
free(*p);
+21
return SP_OK;
+22
}
+23
+24
int sp_clock_init(sp_data *sp, sp_clock *p)
+25
{
+26
p->subdiv = 1.0;
+27
p->bpm = 120;
+28
p->counter = 0;
+29
return SP_OK;
+30
}
+31
+32
int sp_clock_compute(sp_data *sp, sp_clock *p, SPFLOAT *in, SPFLOAT *out)
+33
{
+34
*out = 0.0;
+35
if (p->counter == 0 || *in != 0) {
+36
*out = 1.0;
+37
p->counter = (int)(sp->sr * (60.0 / (p->bpm * p->subdiv))) + 1;
+38
}
+39
p->counter--;
+40
return SP_OK;
+41
}
vendor/soundpipe/modules/crossfade.cadded
@@ -0,0 +1,26 @@
+1
#include <stdlib.h>
+2
#include "soundpipe.h"
+3
+4
int sp_crossfade_create(sp_crossfade **p)
+5
{
+6
*p = malloc(sizeof(sp_crossfade));
+7
return SP_OK;
+8
}
+9
+10
int sp_crossfade_destroy(sp_crossfade **p)
+11
{
+12
free(*p);
+13
return SP_OK;
+14
}
+15
+16
int sp_crossfade_init(sp_data *sp, sp_crossfade *p)
+17
{
+18
p->pos = 0.5;
+19
return SP_OK;
+20
}
+21
+22
int sp_crossfade_compute(sp_data *sp, sp_crossfade *p, SPFLOAT *in1, SPFLOAT *in2, SPFLOAT *out)
+23
{
+24
*out = *in2 * p->pos + *in1 * (1 - p->pos);
+25
return SP_OK;
+26
}
vendor/soundpipe/modules/dcblock.cadded
@@ -0,0 +1,51 @@
+1
/*
+2
* DCblock
+3
*
+4
* This code has been extracted from the Csound opcode "dcblock".
+5
* It has been modified to work as a Soundpipe module.
+6
*
+7
* Original Author(s): Perry R. Cook
+8
* Year: 1995
+9
* Location: Opcodes/biquad.c
+10
*
+11
*/
+12
+13
#include <stdlib.h>
+14
#include "soundpipe.h"
+15
+16
int sp_dcblock_create(sp_dcblock **p)
+17
{
+18
*p = malloc(sizeof(sp_dcblock));
+19
return SP_OK;
+20
}
+21
+22
int sp_dcblock_destroy(sp_dcblock **p)
+23
{
+24
free(*p);
+25
return SP_OK;
+26
}
+27
+28
int sp_dcblock_init(sp_data *sp, sp_dcblock *p)
+29
{
+30
p->outputs = 0.0;
+31
p->inputs = 0.0;
+32
p->gain = 0.99;
+33
if (p->gain == 0.0 || p->gain>=1.0 || p->gain<=-1.0)
+34
p->gain = 0.99;
+35
return SP_OK;
+36
}
+37
+38
int sp_dcblock_compute(sp_data *sp, sp_dcblock *p, SPFLOAT *in, SPFLOAT *out)
+39
{
+40
SPFLOAT gain = p->gain;
+41
SPFLOAT outputs = p->outputs;
+42
SPFLOAT inputs = p->inputs;
+43
+44
SPFLOAT sample = *in;
+45
outputs = sample - inputs + (gain * outputs);
+46
inputs = sample;
+47
*out = outputs;
+48
p->outputs = outputs;
+49
p->inputs = inputs;
+50
return SP_OK;
+51
}
vendor/soundpipe/modules/delay.cadded
@@ -0,0 +1,40 @@
+1
#include <stdlib.h>
+2
#include <math.h>
+3
#include "soundpipe.h"
+4
+5
int sp_delay_create(sp_delay **p)
+6
{
+7
*p = malloc(sizeof(sp_delay));
+8
return SP_OK;
+9
}
+10
+11
int sp_delay_destroy(sp_delay **p)
+12
{
+13
sp_delay *pp = *p;
+14
sp_auxdata_free(&pp->buf);
+15
free(*p);
+16
return SP_OK;
+17
}
+18
+19
int sp_delay_init(sp_data *sp, sp_delay *p, SPFLOAT time)
+20
{
+21
p->time = time;
+22
p->bufsize = round(time * sp->sr);
+23
sp_auxdata_alloc(&p->buf, p->bufsize * sizeof(SPFLOAT));
+24
p->bufpos = 0;
+25
p->feedback = 0;
+26
p->last = 0;
+27
return SP_OK;
+28
}
+29
+30
int sp_delay_compute(sp_data *sp, sp_delay *p, SPFLOAT *in, SPFLOAT *out)
+31
{
+32
SPFLOAT delay = 0, sig = 0;
+33
SPFLOAT *buf = (SPFLOAT *)p->buf.ptr;
+34
delay = buf[p->bufpos];
+35
sig = (delay * p->feedback) + *in;
+36
buf[p->bufpos] = sig;
+37
p->bufpos = (p->bufpos + 1) % p->bufsize;
+38
*out = delay;
+39
return SP_OK;
+40
}
vendor/soundpipe/modules/expon.cadded
@@ -0,0 +1,78 @@
+1
/*
+2
* Expon
+3
*
+4
* This code has been extracted from the Csound opcode "expon".
+5
* It has been modified to work as a Soundpipe module.
+6
*
+7
* Original Author(s): Barry Vercoe
+8
* Year: 1991
+9
* Location: OOps/ugens1.c
+10
*
+11
*/
+12
+13
#include <math.h>
+14
#include <stdlib.h>
+15
#include "soundpipe.h"
+16
+17
int sp_expon_create(sp_expon **p)
+18
{
+19
*p = malloc(sizeof(sp_expon));
+20
return SP_OK;
+21
}
+22
+23
int sp_expon_destroy(sp_expon **p)
+24
{
+25
free(*p);
+26
return SP_OK;
+27
}
+28
+29
static void expon_reinit(sp_data *sp, sp_expon *p)
+30
{
+31
p->stime = 0;
+32
p->sdur = p->dur * sp->sr;
+33
SPFLOAT onedsr = 1.0 / sp->sr;
+34
+35
if ((p->a * p->b) > 0.0) {
+36
p->incr = pow((SPFLOAT)(p->b / p->a), onedsr / p->dur);
+37
} else {
+38
fprintf(stderr, "Warning: p values must be non-zero\n");
+39
p->incr = 1;
+40
p->val = p->a;
+41
}
+42
+43
p->val = p->a;
+44
}
+45
+46
int sp_expon_init(sp_data *sp, sp_expon *p)
+47
{
+48
p->a = 0.000001;
+49
p->b = 1;
+50
p->dur = 1;
+51
expon_reinit(sp, p);
+52
p->init = 1;
+53
return SP_OK;
+54
}
+55
+56
int sp_expon_compute(sp_data *sp, sp_expon *p, SPFLOAT *in, SPFLOAT *out)
+57
{
+58
if (*in) {
+59
expon_reinit(sp, p);
+60
p->init = 0;
+61
}
+62
+63
if (p->init) {
+64
*out = 0;
+65
return SP_OK;
+66
}
+67
+68
if (p->stime < p->sdur) {
+69
SPFLOAT val = p->val;
+70
p->val *= p->incr;
+71
p->stime++;
+72
*out = val;
+73
} else {
+74
*out = p->b;
+75
}
+76
+77
return SP_OK;
+78
}
vendor/soundpipe/modules/fosc.cadded
@@ -0,0 +1,101 @@
+1
/*
+2
* Fosc
+3
*
+4
* This code has been extracted from the Csound opcode "foscili".
+5
* It has been modified to work as a Soundpipe module.
+6
*
+7
* Original Author(s): Barry Vercoe, John ffitch
+8
* Year: 1991
+9
* Location: OOps/ugens3.c
+10
*
+11
*/
+12
+13
#include <stdlib.h>
+14
#include "soundpipe.h"
+15
+16
int sp_fosc_create(sp_fosc **p)
+17
{
+18
*p = malloc(sizeof(sp_fosc));
+19
return SP_OK;
+20
}
+21
+22
int sp_fosc_destroy(sp_fosc **p)
+23
{
+24
free(*p);
+25
return SP_OK;
+26
}
+27
+28
int sp_fosc_init(sp_data *sp, sp_fosc *p, sp_ftbl *ft)
+29
{
+30
p->freq = 440;
+31
p->amp = 0.4;
+32
p->iphs = 0.0;
+33
p->ft = ft;
+34
+35
p->mod = 1.0;
+36
p->car = 1.0;
+37
p->indx = 1.0;
+38
+39
p->cphs = p->mphs = (int32_t)(p->iphs * SP_FT_MAXLEN);
+40
+41
return SP_OK;
+42
}
+43
+44
int sp_fosc_compute(sp_data *sp, sp_fosc *p, SPFLOAT *in, SPFLOAT *out)
+45
{
+46
+47
sp_ftbl *ftp;
+48
+49
SPFLOAT amp, cps, fract, v1, v2, car, fmod, cfreq, mod;
+50
SPFLOAT xcar, xmod, ndx, *ftab;
+51
int32_t mphs, cphs, minc, cinc, lobits;
+52
SPFLOAT sicvt = p->ft->sicvt;
+53
SPFLOAT *ft;
+54
+55
ftp = p->ft;
+56
ft = ftp->tbl;
+57
lobits = ftp->lobits;
+58
mphs = p->mphs;
+59
cphs = p->cphs;
+60
cps = p->freq;
+61
amp = p->amp;
+62
xcar = p->car;
+63
xmod = p->mod;
+64
+65
car = cps * xcar;
+66
mod = cps * xmod;
+67
ndx = p->indx * mod;
+68
minc = (int32_t)(mod * sicvt);
+69
mphs &= SP_FT_PHMASK;
+70
fract = ((mphs) & ftp->lomask) * ftp->lodiv;
+71
ftab = ft + (mphs >> lobits);
+72
v1 = ftab[0];
+73
+74
if (ftab[0] == p->ft->tbl[p->ft->size - 1]) {
+75
v2 = p->ft->tbl[0];
+76
} else {
+77
v2 = ftab[1];
+78
}
+79
+80
fmod = (v1 + (v2 - v1) * fract) * ndx;
+81
mphs += minc;
+82
cfreq = car + fmod;
+83
cinc = (int32_t)(cfreq * sicvt);
+84
cphs &= SP_FT_PHMASK;
+85
fract = ((cphs) & ftp->lomask) * ftp->lodiv;
+86
ftab = ft + (cphs >>lobits);
+87
v1 = ftab[0];
+88
+89
if (ftab[0] == p->ft->tbl[p->ft->size - 1]) {
+90
v2 = p->ft->tbl[0];
+91
} else {
+92
v2 = ftab[1];
+93
}
+94
+95
*out = (v1 + (v2 - v1) * fract) * amp;
+96
cphs += cinc;
+97
p->mphs = mphs;
+98
p->cphs = cphs;
+99
+100
return SP_OK;
+101
}
vendor/soundpipe/modules/ftbl.cadded
@@ -0,0 +1,406 @@
+1
#include <math.h>
+2
#include <stdio.h>
+3
#include <stdlib.h>
+4
#include <string.h>
+5
#ifndef NO_LIBSNDFILE
+6
#include <sndfile.h>
+7
#endif
+8
#include "soundpipe.h"
+9
+10
#ifndef M_PI
+11
#define M_PI 3.14159265358979323846
+12
#endif
+13
+14
#define tpd360 0.0174532925199433
+15
+16
/* initialize constants in ftable */
+17
int sp_ftbl_init(sp_data *sp, sp_ftbl *ft, size_t size)
+18
{
+19
ft->size = size;
+20
ft->sicvt = 1.0 * SP_FT_MAXLEN / sp->sr;
+21
ft->lobits = log2(SP_FT_MAXLEN / size);
+22
ft->lomask = (1<<ft->lobits) - 1;
+23
ft->lodiv = 1.0 / (1<<ft->lobits);
+24
ft->del = 1;
+25
return SP_OK;
+26
}
+27
+28
int sp_ftbl_create(sp_data *sp, sp_ftbl **ft, size_t size)
+29
{
+30
*ft = malloc(sizeof(sp_ftbl));
+31
sp_ftbl *ftp = *ft;
+32
ftp->tbl = malloc(sizeof(SPFLOAT) * (size + 1));
+33
memset(ftp->tbl, 0, sizeof(SPFLOAT) * (size + 1));
+34
+35
sp_ftbl_init(sp, ftp, size);
+36
return SP_OK;
+37
}
+38
+39
int sp_ftbl_bind(sp_data *sp, sp_ftbl **ft, SPFLOAT *tbl, size_t size)
+40
{
+41
*ft = malloc(sizeof(sp_ftbl));
+42
sp_ftbl *ftp = *ft;
+43
ftp->tbl = tbl;
+44
sp_ftbl_init(sp, ftp, size);
+45
ftp->del = 0;
+46
return SP_OK;
+47
}
+48
+49
int sp_ftbl_destroy(sp_ftbl **ft)
+50
{
+51
sp_ftbl *ftp = *ft;
+52
if (ftp->del) free(ftp->tbl);
+53
free(*ft);
+54
return SP_OK;
+55
}
+56
+57
/* TODO: handle spaces at beginning of string */
+58
static char * tokenize(char **next, int *size)
+59
{
+60
if (*size <= 0) return NULL;
+61
char *token = *next;
+62
char *str = *next;
+63
+64
char *peak = str + 1;
+65
+66
while ((*size)--) {
+67
if (*str == ' ') {
+68
*str = 0;
+69
if (*peak != ' ') break;
+70
}
+71
str = str + 1;
+72
peak = str + 1;
+73
}
+74
*next = peak;
+75
return token;
+76
}
+77
+78
int sp_gen_vals(sp_data *sp, sp_ftbl *ft, const char *string)
+79
{
+80
int size = strlen(string);
+81
char *str = malloc(sizeof(char) * size + 1);
+82
strcpy(str, string);
+83
char *out;
+84
char *ptr = str;
+85
int j = 0;
+86
while (size > 0) {
+87
out = tokenize(&str, &size);
+88
if (ft->size < j + 1) {
+89
ft->tbl = realloc(ft->tbl, sizeof(SPFLOAT) * (ft->size + 2));
+90
/* zero out new tables */
+91
ft->tbl[ft->size] = 0;
+92
ft->tbl[ft->size + 1] = 0;
+93
ft->size++;
+94
}
+95
ft->tbl[j] = atof(out);
+96
j++;
+97
}
+98
+99
sp_ftbl_init(sp, ft, ft->size);
+100
free(ptr);
+101
return SP_OK;
+102
}
+103
+104
int sp_gen_sine(sp_data *sp, sp_ftbl *ft)
+105
{
+106
unsigned long i;
+107
SPFLOAT step = 2 * M_PI / ft->size;
+108
for (i = 0; i < ft->size; i++) {
+109
ft->tbl[i] = sin(i * step);
+110
}
+111
return SP_OK;
+112
}
+113
+114
#ifndef NO_LIBSNDFILE
+115
/*TODO: add error checking, make tests */
+116
int sp_gen_file(sp_data *sp, sp_ftbl *ft, const char *filename)
+117
{
+118
SF_INFO info;
+119
memset(&info, 0, sizeof(SF_INFO));
+120
info.format = 0;
+121
SNDFILE *snd = sf_open(filename, SFM_READ, &info);
+122
#ifdef USE_DOUBLE
+123
sf_readf_double(snd, ft->tbl, ft->size);
+124
#else
+125
sf_readf_float(snd, ft->tbl, ft->size);
+126
#endif
+127
sf_close(snd);
+128
return SP_OK;
+129
}
+130
+131
int sp_ftbl_loadfile(sp_data *sp, sp_ftbl **ft, const char *filename)
+132
{
+133
*ft = malloc(sizeof(sp_ftbl));
+134
sp_ftbl *ftp = *ft;
+135
SF_INFO info;
+136
memset(&info, 0, sizeof(SF_INFO));
+137
info.format = 0;
+138
SNDFILE *snd = sf_open(filename, SFM_READ, &info);
+139
if (snd == NULL) {
+140
return SP_NOT_OK;
+141
}
+142
size_t size = info.frames * info.channels;
+143
+144
ftp->tbl = malloc(sizeof(SPFLOAT) * (size + 1));
+145
+146
sp_ftbl_init(sp, ftp, size);
+147
+148
#ifdef USE_DOUBLE
+149
sf_readf_double(snd, ftp->tbl, ftp->size);
+150
#else
+151
sf_readf_float(snd, ftp->tbl, ftp->size);
+152
#endif
+153
sf_close(snd);
+154
return SP_OK;
+155
}
+156
#endif
+157
+158
/* port of GEN10 from Csound */
+159
int sp_gen_sinesum(sp_data *sp, sp_ftbl *ft, const char *argstring)
+160
{
+161
sp_ftbl *args;
+162
sp_ftbl_create(sp, &args, 1);
+163
sp_gen_vals(sp, args, argstring);
+164
+165
int32_t phs;
+166
SPFLOAT amp;
+167
int32_t flen = (int32_t)ft->size;
+168
SPFLOAT tpdlen = 2.0 * M_PI / (SPFLOAT) flen;
+169
+170
int32_t i, n;
+171
+172
for (i = (int32_t)args->size; i > 0; i--) {
+173
amp = args->tbl[i - 1];
+174
if (amp != 0) {
+175
for (phs = 0, n = 0; n < ft->size; n++) {
+176
ft->tbl[n] += sin(phs * tpdlen) * amp;
+177
phs += i;
+178
phs %= flen;
+179
}
+180
}
+181
}
+182
sp_ftbl_destroy(&args);
+183
return SP_OK;
+184
}
+185
+186
int sp_gen_line(sp_data *sp, sp_ftbl *ft, const char *argstring)
+187
{
+188
uint16_t i, n = 0, seglen;
+189
SPFLOAT incr, amp = 0;
+190
SPFLOAT x1, x2, y1, y2;
+191
sp_ftbl *args;
+192
sp_ftbl_create(sp, &args, 1);
+193
sp_gen_vals(sp, args, argstring);
+194
+195
if ((args->size % 2) == 1 || args->size == 1) {
+196
fprintf(stderr, "Error: not enough arguments for gen_line.\n");
+197
sp_ftbl_destroy(&args);
+198
return SP_NOT_OK;
+199
} else if (args->size == 2) {
+200
for (i = 0; i < ft->size; i++) {
+201
ft->tbl[i] = args->tbl[1];
+202
}
+203
return SP_OK;
+204
}
+205
+206
x1 = args->tbl[0];
+207
y1 = args->tbl[1];
+208
for (i = 2; i < args->size; i += 2) {
+209
x2 = args->tbl[i];
+210
y2 = args->tbl[i + 1];
+211
+212
if (x2 < x1) {
+213
fprintf(stderr, "Error: x coordiates must be sequential!\n");
+214
break;
+215
}
+216
+217
seglen = (x2 - x1);
+218
incr = (SPFLOAT)(y2 - y1) / (seglen - 1);
+219
amp = y1;
+220
+221
while (seglen != 0) {
+222
if (n < ft->size) {
+223
ft->tbl[n] = amp;
+224
amp += incr;
+225
seglen--;
+226
n++;
+227
} else {
+228
break;
+229
}
+230
}
+231
y1 = y2;
+232
x1 = x2;
+233
}
+234
+235
sp_ftbl_destroy(&args);
+236
return SP_OK;
+237
}
+238
+239
int sp_gen_xline(sp_data *sp, sp_ftbl *ft, const char *argstring)
+240
{
+241
uint16_t i, n = 0, seglen;
+242
SPFLOAT mult, amp = 0;
+243
SPFLOAT x1, x2, y1, y2;
+244
sp_ftbl *args;
+245
sp_ftbl_create(sp, &args, 1);
+246
sp_gen_vals(sp, args, argstring);
+247
+248
if ((args->size % 2) == 1 || args->size == 1) {
+249
fprintf(stderr, "Error: not enough arguments for gen_line.\n");
+250
sp_ftbl_destroy(&args);
+251
return SP_NOT_OK;
+252
} else if (args->size == 2) {
+253
for (i = 0; i < ft->size; i++) {
+254
ft->tbl[i] = args->tbl[1];
+255
}
+256
return SP_OK;
+257
}
+258
+259
x1 = args->tbl[0];
+260
y1 = args->tbl[1];
+261
for (i = 2; i < args->size; i += 2) {
+262
x2 = args->tbl[i];
+263
y2 = args->tbl[i + 1];
+264
+265
if (x2 < x1) {
+266
fprintf(stderr, "Error: x coordiates must be sequential!\n");
+267
break;
+268
}
+269
+270
if (y1 == 0) {
+271
y1 = 0.000001;
+272
}
+273
+274
if (y2 == 0) {
+275
y2 = 0.000001;
+276
}
+277
+278
seglen = (uint32_t)(x2 - x1);
+279
mult = (y2 / y1);
+280
mult = pow(mult, (SPFLOAT)1.0 / seglen);
+281
amp = y1;
+282
+283
while (seglen != 0) {
+284
if (n < ft->size) {
+285
ft->tbl[n] = amp;
+286
amp *= mult;
+287
seglen--;
+288
n++;
+289
} else {
+290
break;
+291
}
+292
}
+293
y1 = y2;
+294
x1 = x2;
+295
}
+296
+297
sp_ftbl_destroy(&args);
+298
return SP_OK;
+299
+300
}
+301
+302
+303
static SPFLOAT gaussrand(sp_randmt *p, SPFLOAT scale)
+304
{
+305
int64_t r1 = -((int64_t)0xFFFFFFFFU * 6);
+306
int n = 12;
+307
SPFLOAT x;
+308
+309
do {
+310
r1 += (int64_t)sp_randmt_compute(p);
+311
} while (--n);
+312
+313
x = (SPFLOAT)r1;
+314
return (SPFLOAT)(x * ((SPFLOAT)scale * (1.0 / (3.83 * 4294967295.03125))));
+315
}
+316
+317
int sp_gen_gauss(sp_data *sp, sp_ftbl *ft, SPFLOAT scale, uint32_t seed)
+318
{
+319
int n;
+320
+321
sp_randmt rand;
+322
+323
sp_randmt_seed(&rand, NULL, seed);
+324
+325
for (n = 0; n < ft->size; n++) {
+326
ft->tbl[n] = gaussrand(&rand, scale);
+327
}
+328
+329
return SP_OK;
+330
}
+331
+332
/* based off of GEN 19 */
+333
int sp_gen_composite(sp_data *sp, sp_ftbl *ft, const char *argstring)
+334
{
+335
SPFLOAT phs, inc, amp, dc, tpdlen = 2 * M_PI/ (SPFLOAT) ft->size;
+336
int i, n;
+337
+338
sp_ftbl *args;
+339
sp_ftbl_create(sp, &args, 1);
+340
sp_gen_vals(sp, args, argstring);
+341
+342
for (n = 0; n < args->size; n += 4) {
+343
inc = args->tbl[n] * tpdlen;
+344
amp = args->tbl[n + 1];
+345
phs = args->tbl[n + 2] * tpd360;
+346
dc = args->tbl[n + 3];
+347
+348
for (i = 0; i <ft->size ; i++) {
+349
ft->tbl[i] += (SPFLOAT) (sin(phs) * amp + dc);
+350
if ((phs += inc) >= 2 * M_PI) phs -= 2 * M_PI;
+351
}
+352
}
+353
+354
sp_ftbl_destroy(&args);
+355
return SP_OK;
+356
}
+357
+358
int sp_gen_rand(sp_data *sp, sp_ftbl *ft, const char *argstring)
+359
{
+360
sp_ftbl *args;
+361
sp_ftbl_create(sp, &args, 1);
+362
sp_gen_vals(sp, args, argstring);
+363
int n, pos = 0, i, size = 0;
+364
+365
for (n = 0; n < args->size; n += 2) {
+366
size = round(ft->size * args->tbl[n + 1]);
+367
for (i = 0; i < size; i++) {
+368
if (pos < ft->size) {
+369
ft->tbl[pos] = args->tbl[n];
+370
pos++;
+371
}
+372
}
+373
}
+374
if (pos <= ft->size) {
+375
ft->size = pos;
+376
}
+377
sp_ftbl_destroy(&args);
+378
return SP_OK;
+379
}
+380
+381
int sp_gen_triangle(sp_data *sp, sp_ftbl *ft)
+382
{
+383
unsigned int i;
+384
unsigned int counter;
+385
SPFLOAT incr;
+386
int step;
+387
+388
incr = 1.0f / (SPFLOAT)ft->size;
+389
incr *= 2;
+390
+391
step = 1;
+392
+393
counter = 0;
+394
+395
for (i = 0; i < ft->size; i++) {
+396
if (i == ft->size / 2) {
+397
step = -1;
+398
}
+399
+400
ft->tbl[i] = (2.f*(counter * incr) - 1.f);
+401
+402
counter += step;
+403
}
+404
+405
return SP_OK;
+406
}
vendor/soundpipe/modules/line.cadded
@@ -0,0 +1,57 @@
+1
#include <stdlib.h>
+2
#include "soundpipe.h"
+3
+4
int sp_line_create(sp_line **p)
+5
{
+6
*p = malloc(sizeof(sp_line));
+7
return SP_OK;
+8
}
+9
+10
int sp_line_destroy(sp_line **p)
+11
{
+12
free(*p);
+13
return SP_OK;
+14
}
+15
+16
static void line_reinit(sp_data *sp, sp_line *p)
+17
{
+18
SPFLOAT onedsr = 1.0 / sp->sr;
+19
p->incr = (SPFLOAT)((p->b - p->a) / (p->dur)) * onedsr;
+20
p->val = p->a;
+21
p->stime = 0;
+22
p->sdur = sp->sr * p->dur;
+23
}
+24
+25
int sp_line_init(sp_data *sp, sp_line *p)
+26
{
+27
p->a = 0;
+28
p->dur = 0.5;
+29
p->b = 1;
+30
line_reinit(sp, p);
+31
p->init = 1;
+32
return SP_OK;
+33
}
+34
+35
int sp_line_compute(sp_data *sp, sp_line *p, SPFLOAT *in, SPFLOAT *out)
+36
{
+37
if (*in != 0 ) {
+38
line_reinit(sp, p);
+39
p->init = 0;
+40
}
+41
+42
if (p->init) {
+43
*out = 0;
+44
return SP_OK;
+45
}
+46
+47
if (p->stime < p->sdur) {
+48
SPFLOAT val = p->val;
+49
p->val += p->incr;
+50
p->stime++;
+51
*out = val;
+52
} else {
+53
*out = p->b;
+54
}
+55
+56
return SP_OK;
+57
}
vendor/soundpipe/modules/lpf18.cadded
@@ -0,0 +1,98 @@
+1
/*
+2
* LPF18
+3
*
+4
* This code has been extracted from the Csound opcode "lpf18".
+5
* It has been modified to work as a Soundpipe module.
+6
*
+7
* Original Author(s): John ffitch, Josep Comajuncosas
+8
* Year: 2000
+9
* Location: Opcodes/pitch.c
+10
*
+11
*/
+12
+13
#include <math.h>
+14
#include <stdlib.h>
+15
#include "soundpipe.h"
+16
+17
int sp_lpf18_create(sp_lpf18 **p)
+18
{
+19
*p = malloc(sizeof(sp_lpf18));
+20
return SP_OK;
+21
}
+22
+23
int sp_lpf18_destroy(sp_lpf18 **p)
+24
{
+25
free(*p);
+26
return SP_OK;
+27
}
+28
+29
int sp_lpf18_init(sp_data *sp, sp_lpf18 *p)
+30
{
+31
p->cutoff = 1000;
+32
p->res = 0.8;
+33
p->dist = 2;
+34
+35
p->ay1 = 0.0;
+36
p->ay2 = 0.0;
+37
p->aout = 0.0;
+38
p->lastin = 0.0;
+39
p->onedsr = 1.0 / sp->sr;
+40
return SP_OK;
+41
}
+42
+43
int sp_lpf18_compute(sp_data *sp, sp_lpf18 *p, SPFLOAT *in, SPFLOAT *out)
+44
{
+45
SPFLOAT ay1 = p->ay1;
+46
SPFLOAT ay2 = p->ay2;
+47
SPFLOAT aout = p->aout;
+48
SPFLOAT lastin = p->lastin;
+49
double value = 0.0;
+50
int flag = 1;
+51
SPFLOAT lfc=0, lrs=0, kres=0, kfcn=0, kp=0, kp1=0, kp1h=0;
+52
double lds = 0.0;
+53
+54
SPFLOAT fco, res, dist;
+55
SPFLOAT ax1 = lastin;
+56
SPFLOAT ay11 = ay1;
+57
SPFLOAT ay31 = ay2;
+58
+59
fco = p->cutoff;
+60
res = p->res;
+61
dist = p->dist;
+62
+63
if (fco != lfc || flag) {
+64
lfc = fco;
+65
kfcn = 2.0 * fco * p->onedsr;
+66
kp = ((-2.7528 * kfcn + 3.0429) * kfcn +
+67
1.718) * kfcn - 0.9984;
+68
kp1 = kp + 1.0;
+69
kp1h = 0.5 * kp1;
+70
flag = 1;
+71
}
+72
+73
if (res != lrs || flag) {
+74
lrs = res;
+75
kres = res * (((-2.7079 * kp1 + 10.963) * kp1
+76
- 14.934) * kp1 + 8.4974);
+77
flag = 1;
+78
}
+79
+80
if (dist != lds || flag) {
+81
lds = dist;
+82
value = 1.0 + (dist * (1.5 + 2.0 * res * (1.0 - kfcn)));
+83
}
+84
+85
flag = 0;
+86
lastin = *in - tanh(kres*aout);
+87
ay1 = kp1h * (lastin + ax1) - kp * ay1;
+88
ay2 = kp1h * (ay1 + ay11) - kp * ay2;
+89
aout = kp1h * (ay2 + ay31) - kp * aout;
+90
+91
*out = tanh(aout * value);
+92
+93
p->ay1 = ay1;
+94
p->ay2 = ay2;
+95
p->aout = aout;
+96
p->lastin = lastin;
+97
return SP_OK;
+98
}
vendor/soundpipe/modules/metro.cadded
@@ -0,0 +1,60 @@
+1
/*
+2
* Metro
+3
*
+4
* Metro produces a signal steady sequence of impulses,
+5
* which is typically used as a clock signal to for other
+6
* modules.
+7
*
+8
* Metro is very similar to the "metro" object in puredata,
+9
* except that the rate parameter unit is supplied in Hz,
+10
* not ms.
+11
*/
+12
+13
#include <stdlib.h>
+14
#include "soundpipe.h"
+15
+16
int sp_metro_create(sp_metro **p)
+17
{
+18
*p = malloc(sizeof(sp_metro));
+19
return SP_OK;
+20
}
+21
+22
int sp_metro_destroy(sp_metro **p)
+23
{
+24
free(*p);
+25
return SP_OK;
+26
}
+27
+28
int sp_metro_init(sp_data *sp, sp_metro *p)
+29
{
+30
p->freq = 2.0;
+31
p->phs = 0;
+32
p->init = 1;
+33
p->onedsr = 1.0 / sp->sr;
+34
return SP_OK;
+35
}
+36
+37
int sp_metro_compute(sp_data *sp, sp_metro *p, SPFLOAT *in, SPFLOAT *out)
+38
{
+39
SPFLOAT phs;
+40
+41
phs = p->phs;
+42
+43
*out = 0;
+44
+45
if (p->init) {
+46
*out = 1.0;
+47
p->init = 0;
+48
} else {
+49
phs += p->freq * p->onedsr;
+50
+51
if (phs >= 1) {
+52
*out = 1.0;
+53
phs -= 1.0;
+54
}
+55
}
+56
+57
p->phs = phs;
+58
+59
return SP_OK;
+60
}
vendor/soundpipe/modules/moogladder.cadded
@@ -0,0 +1,122 @@
+1
/*
+2
* Moogladder
+3
*
+4
* This code has been extracted from the Csound opcode "Moogladder".
+5
* It has been modified to work as a Soundpipe module.
+6
*
+7
* Original Author(s): Victor Lazzarini
+8
* Year: 2001
+9
* Location: Opcodes/newfils.c
+10
*/
+11
+12
#include <stdint.h>
+13
#include <stdlib.h>
+14
#include <math.h>
+15
#include "soundpipe.h"
+16
+17
#ifndef M_PI
+18
#define M_PI 3.14159265358979323846
+19
#endif
+20
+21
#define SPFLOAT2LONG(x) lrintf(x)
+22
+23
+24
/* John ffitch tanh function to speed up inner loop */
+25
+26
static double my_tanh(double x)
+27
{
+28
/* use the fact that tanh(-x) = - tanh(x)
+29
and if x>~4 tanh is approx constant 1
+30
and for small x tanh(x) =~ x
+31
So giving a cheap approximation */
+32
int sign = 1;
+33
if (x<0) {
+34
sign=-1;
+35
x= -x;
+36
}
+37
if (x>=4.0) {
+38
return sign;
+39
}
+40
if (x<0.5) return x*sign;
+41
return sign*tanh(x);
+42
}
+43
+44
int sp_moogladder_create(sp_moogladder **t){
+45
*t = malloc(sizeof(sp_moogladder));
+46
return SP_OK;
+47
}
+48
+49
int sp_moogladder_destroy(sp_moogladder **t){
+50
free(*t);
+51
return SP_OK;
+52
}
+53
+54
int sp_moogladder_init(sp_data *sp, sp_moogladder *p){
+55
p->istor = 0.0;
+56
p->res = 0.4;
+57
p->freq = 1000;
+58
int i;
+59
+60
if (p->istor == 0.0) {
+61
for (i = 0; i < 6; i++) p->delay[i] = 0.0;
+62
for (i = 0; i < 3; i++) p->tanhstg[i] = 0.0;
+63
p->oldfreq = 0.0;
+64
p->oldres = -1.0; /* ensure calculation on first cycle */
+65
}
+66
return SP_OK;
+67
}
+68
+69
int sp_moogladder_compute(sp_data *sp, sp_moogladder *p, SPFLOAT *in, SPFLOAT *out){
+70
SPFLOAT freq = p->freq;
+71
SPFLOAT res = p->res;
+72
SPFLOAT res4;
+73
SPFLOAT *delay = p->delay;
+74
SPFLOAT *tanhstg = p->tanhstg;
+75
SPFLOAT stg[4], input;
+76
SPFLOAT acr, tune;
+77
#define THERMAL (0.000025) /* (1.0 / 40000.0) transistor thermal voltage */
+78
int j, k;
+79
+80
if (res < 0) res = 0;
+81
+82
if (p->oldfreq != freq || p->oldres != res) {
+83
SPFLOAT f, fc, fc2, fc3, fcr;
+84
p->oldfreq = freq;
+85
/* sr is half the actual filter sampling rate */
+86
fc = (SPFLOAT)(freq/sp->sr);
+87
f = 0.5*fc;
+88
fc2 = fc*fc;
+89
fc3 = fc2*fc;
+90
/* frequency & amplitude correction */
+91
fcr = 1.8730*fc3 + 0.4955*fc2 - 0.6490*fc + 0.9988;
+92
acr = -3.9364*fc2 + 1.8409*fc + 0.9968;
+93
tune = (1.0 - exp(-((2 * M_PI)*f*fcr))) / THERMAL; /* filter tuning */
+94
p->oldres = res;
+95
p->oldacr = acr;
+96
p->oldtune = tune;
+97
} else {
+98
res = p->oldres;
+99
acr = p->oldacr;
+100
tune = p->oldtune;
+101
}
+102
res4 = 4.0*(SPFLOAT)res*acr;
+103
+104
/* oversampling */
+105
for (j = 0; j < 2; j++) {
+106
/* filter stages */
+107
input = *in - res4 /*4.0*res*acr*/ *delay[5];
+108
delay[0] = stg[0] = delay[0] + tune*(my_tanh(input*THERMAL) - tanhstg[0]);
+109
for (k = 1; k < 4; k++) {
+110
input = stg[k-1];
+111
stg[k] = delay[k]
+112
+ tune*((tanhstg[k-1] = my_tanh(input*THERMAL))
+113
- (k != 3 ? tanhstg[k] : my_tanh(delay[k]*THERMAL)));
+114
delay[k] = stg[k];
+115
}
+116
/* 1/2-sample delay for phase compensation */
+117
delay[5] = (stg[3] + delay[4])*0.5;
+118
delay[4] = stg[3];
+119
}
+120
*out = (SPFLOAT) delay[5];
+121
return SP_OK;
+122
}
vendor/soundpipe/modules/noise.cadded
@@ -0,0 +1,29 @@
+1
#include <math.h>
+2
#include <stdlib.h>
+3
#include "soundpipe.h"
+4
+5
int sp_noise_create(sp_noise **ns)
+6
{
+7
*ns = malloc(sizeof(sp_noise));
+8
return SP_OK;
+9
}
+10
+11
int sp_noise_init(sp_data *sp, sp_noise *ns)
+12
{
+13
ns->amp = 1.0;
+14
return SP_OK;
+15
}
+16
+17
int sp_noise_compute(sp_data *sp, sp_noise *ns, SPFLOAT *in, SPFLOAT *out)
+18
{
+19
*out = ((sp_rand(sp) % SP_RANDMAX) / (SP_RANDMAX * 1.0));
+20
*out = (*out * 2) - 1;
+21
*out *= ns->amp;
+22
return SP_OK;
+23
}
+24
+25
int sp_noise_destroy(sp_noise **ns)
+26
{
+27
free(*ns);
+28
return SP_OK;
+29
}
vendor/soundpipe/modules/osc.cadded
@@ -0,0 +1,71 @@
+1
/*
+2
* Osc
+3
*
+4
* This code has been extracted from the Csound opcode "oscili".
+5
* It has been modified to work as a Soundpipe module.
+6
*
+7
* Original Author(s): Barry Vercoe, John FFitch, Robin Whittle
+8
* Year: 1991
+9
* Location: OOps/ugens2.c
+10
*
+11
*/
+12
+13
#include <stdlib.h>
+14
#include <math.h>
+15
#include "soundpipe.h"
+16
+17
int sp_osc_create(sp_osc **osc)
+18
{
+19
*osc = malloc(sizeof(sp_osc));
+20
return SP_OK;
+21
}
+22
+23
int sp_osc_destroy(sp_osc **osc)
+24
{
+25
free(*osc);
+26
return SP_NOT_OK;
+27
}
+28
+29
int sp_osc_init(sp_data *sp, sp_osc *osc, sp_ftbl *ft, SPFLOAT iphs)
+30
{
+31
osc->freq = 440.0;
+32
osc->amp = 0.2;
+33
osc->tbl = ft;
+34
osc->iphs = fabs(iphs);
+35
osc->inc = 0;
+36
+37
if (osc->iphs >= 0) {
+38
osc->lphs = ((int32_t)(osc->iphs * SP_FT_MAXLEN)) & SP_FT_PHMASK;
+39
}
+40
+41
return SP_OK;
+42
}
+43
+44
int sp_osc_compute(sp_data *sp, sp_osc *osc, SPFLOAT *in, SPFLOAT *out)
+45
{
+46
sp_ftbl *ftp;
+47
SPFLOAT amp, cps, fract, v1, v2, *ft;
+48
int32_t phs, lobits;
+49
int32_t pos;
+50
SPFLOAT sicvt = osc->tbl->sicvt;
+51
+52
ftp = osc->tbl;
+53
lobits = osc->tbl->lobits;
+54
amp = osc->amp;
+55
cps = osc->freq;
+56
phs = osc->lphs;
+57
ft = osc->tbl->tbl;
+58
+59
osc->inc = (int32_t)lrintf(cps * sicvt);
+60
+61
fract = ((phs) & ftp->lomask) * ftp->lodiv;
+62
pos = phs>>lobits;
+63
v1 = *(ft + pos);
+64
v2 = *(ft + ((pos + 1) % ftp->size));
+65
*out = (v1 + (v2 - v1) * fract) * amp;
+66
phs += osc->inc;
+67
phs &= SP_FT_PHMASK;
+68
+69
osc->lphs = phs;
+70
return SP_OK;
+71
}
vendor/soundpipe/modules/pan2.cadded
@@ -0,0 +1,83 @@
+1
/*
+2
* Pan2
+3
*
+4
* This code has been extracted from the Csound opcode "pan2"
+5
* It has been modified to work as a Soundpipe module.
+6
*
+7
* Original Author(s): John ffitch
+8
* Year: 2007
+9
* Location: Opcodes/pan2.c
+10
*
+11
*/
+12
+13
#include <stdlib.h>
+14
#include <math.h>
+15
#include "soundpipe.h"
+16
+17
#ifndef M_PI
+18
#define M_PI 3.14159265358979323846
+19
#endif
+20
+21
#define SQRT2 1.41421356237309504880
+22
+23
int sp_pan2_create(sp_pan2 **p)
+24
{
+25
*p = malloc(sizeof(sp_pan2));
+26
return SP_OK;
+27
}
+28
+29
int sp_pan2_destroy(sp_pan2 **p)
+30
{
+31
free(*p);
+32
return SP_OK;
+33
}
+34
+35
int sp_pan2_init(sp_data *sp, sp_pan2 *p)
+36
{
+37
p->type = 0;
+38
p->pan = 0;
+39
return SP_OK;
+40
}
+41
+42
int sp_pan2_compute(sp_data *sp, sp_pan2 *p, SPFLOAT *in, SPFLOAT *out1, SPFLOAT *out2)
+43
{
+44
/* Send the signal's input to the output */
+45
uint32_t type = p->type;
+46
SPFLOAT pan = (1 + p->pan) * 0.5;
+47
SPFLOAT cc, ss, l, r;
+48
+49
type %= 4;
+50
+51
switch (type) {
+52
/* Equal power */
+53
case 0:
+54
pan = M_PI * 0.5 * pan;
+55
*out1 = *in * cos(pan);
+56
*out2 = *in * sin(pan);
+57
break;
+58
+59
/* Square root */
+60
case 1:
+61
*out1 = *in * sqrt(pan);
+62
*out2 = *in * sqrt(1.0 - pan);
+63
break;
+64
+65
/* simple linear */
+66
case 2:
+67
*out1 = *in * (1.0 - pan);
+68
*out2 = *in * pan;
+69
break;
+70
+71
/* Equal power (alternative) */
+72
case 3:
+73
cc = cos(M_PI * pan * 0.5);
+74
ss = sin(M_PI * pan * 0.5);
+75
l = SQRT2 * (cc + ss) * 0.5;
+76
r = SQRT2 * (cc - ss) * 0.5;
+77
*out1 = *in * l;
+78
*out2 = *in * r;
+79
break;
+80
}
+81
+82
return SP_OK;
+83
}
vendor/soundpipe/modules/peaklim.cadded
@@ -0,0 +1,80 @@
+1
#include <stdlib.h>
+2
#include <math.h>
+3
#include "soundpipe.h"
+4
+5
#ifndef max
+6
#define max(a,b) (((a) > (b)) ? (a) : (b))
+7
#endif
+8
+9
#ifndef min
+10
#define min(a,b) (((a) < (b)) ? (a) : (b))
+11
#endif
+12
+13
#ifndef dB
+14
/* if below -100dB, set to -100dB to prevent taking log of zero */
+15
#define dB(x) 20.0 * ((x) > 0.00001 ? log10(x) : log10(0.00001))
+16
#endif
+17
+18
#ifndef dB2lin
+19
#define dB2lin(x) pow( 10.0, (x) / 20.0 )
+20
#endif
+21
+22
int sp_peaklim_create(sp_peaklim **p)
+23
{
+24
*p = malloc(sizeof(sp_peaklim));
+25
return SP_OK;
+26
}
+27
+28
int sp_peaklim_destroy(sp_peaklim **p)
+29
{
+30
free(*p);
+31
return SP_OK;
+32
}
+33
+34
int sp_peaklim_init(sp_data *sp, sp_peaklim *p)
+35
{
+36
p->a1_r = 0;
+37
p->b0_r = 1;
+38
p->a1_a = 0;
+39
p->b0_a = 1;
+40
p->atk = 0.1;
+41
p->rel = 0.1;
+42
p->patk = -100;
+43
p->prel = -100;
+44
p->level = 0;
+45
return SP_OK;
+46
}
+47
+48
int sp_peaklim_compute(sp_data *sp, sp_peaklim *p, SPFLOAT *in, SPFLOAT *out)
+49
{
+50
+51
SPFLOAT db_gain = 0;
+52
SPFLOAT gain = 0;
+53
+54
/* change coefficients, if needed */
+55
+56
if (p->patk != p->atk) {
+57
p->patk = p->atk;
+58
p->a1_a = exp( -1.0 / ( p->rel * sp->sr ) );
+59
p->b0_a = 1 - p->a1_a;
+60
}
+61
+62
if (p->prel != p->rel) {
+63
p->prel = p->rel;
+64
p->a1_r = exp( -1.0 / ( p->rel * sp->sr ) );
+65
p->b0_r = 1 - p->a1_r;
+66
}
+67
+68
+69
if ( fabs(*in) > p->level)
+70
p->level += p->b0_a * ( fabs(*in) - p->level);
+71
else
+72
p->level += p->b0_r * ( fabs(*in) - p->level);
+73
+74
db_gain = min(0.0, dB(dB2lin(p->thresh)/p->level));
+75
gain = dB2lin(db_gain);
+76
+77
*out = *in * gain;
+78
+79
return SP_OK;
+80
}
vendor/soundpipe/modules/phasor.cadded
@@ -0,0 +1,52 @@
+1
/*
+2
* Phasor
+3
*
+4
* A phasor produces a non-bandlimited sawtooth wave,
+5
* normalized to be in range 0-1. Phasors are most
+6
* frequently used to create table-lookup oscillators.
+7
*/
+8
+9
#include <stdlib.h>
+10
#include "soundpipe.h"
+11
+12
int sp_phasor_create(sp_phasor **p)
+13
{
+14
*p = malloc(sizeof(sp_phasor));
+15
return SP_OK;
+16
}
+17
+18
int sp_phasor_destroy(sp_phasor **p)
+19
{
+20
free(*p);
+21
return SP_OK;
+22
}
+23
+24
int sp_phasor_init(sp_data *sp, sp_phasor *p, SPFLOAT iphs)
+25
{
+26
p->freq = 440;
+27
p->phs = iphs;
+28
p->onedsr = 1.0 / sp->sr;
+29
return SP_OK;
+30
}
+31
+32
int sp_phasor_compute(sp_data *sp, sp_phasor *p, SPFLOAT *in, SPFLOAT *out)
+33
{
+34
SPFLOAT phs;
+35
SPFLOAT incr;
+36
+37
phs = p->phs;
+38
incr = p->freq * p->onedsr;
+39
+40
*out = phs;
+41
+42
phs += incr;
+43
+44
if (phs >= 1.0) {
+45
phs -= 1.0;
+46
} else if (phs < 0.0) {
+47
phs += 1.0;
+48
}
+49
+50
p->phs = phs;
+51
return SP_OK;
+52
}
vendor/soundpipe/modules/pinknoise.cadded
@@ -0,0 +1,69 @@
+1
/*
+2
* Pinknoise
+3
*
+4
* This code has been extracted the pink noise synthesizer from Protrekkr
+5
* It has been modified to work as a Soundpipe module.
+6
*
+7
* Original Author(s): McCartney, Juan Antonio Arguelles
+8
* Location: release/distrib/replay/lib/replay.cpp
+9
*
+10
*/
+11
#include <stdlib.h>
+12
#include <math.h>
+13
#include "soundpipe.h"
+14
+15
+16
static uint32_t ctz[64] =
+17
{
+18
6, 0, 1, 0, 2, 0, 1, 0,
+19
3, 0, 1, 0, 2, 0, 1, 0,
+20
4, 0, 1, 0, 2, 0, 1, 0,
+21
3, 0, 1, 0, 2, 0, 1, 0,
+22
5, 0, 1, 0, 2, 0, 1, 0,
+23
3, 0, 1, 0, 2, 0, 1, 0,
+24
4, 0, 1, 0, 2, 0, 1, 0,
+25
3, 0, 1, 0, 2, 0, 1, 0,
+26
};
+27
+28
int sp_pinknoise_create(sp_pinknoise **p)
+29
{
+30
*p = malloc(sizeof(sp_pinknoise));
+31
return SP_OK;
+32
}
+33
+34
int sp_pinknoise_destroy(sp_pinknoise **p)
+35
{
+36
free(*p);
+37
return SP_OK;
+38
}
+39
+40
int sp_pinknoise_init(sp_data *sp, sp_pinknoise *p)
+41
{
+42
int i;
+43
+44
p->amp = 1.0;
+45
p->seed = sp_rand(sp);
+46
p->total = 0;
+47
p->counter = 0;
+48
+49
for (i = 0; i < 7; i++) p->dice[i] = 0;
+50
+51
return SP_OK;
+52
}
+53
+54
int sp_pinknoise_compute(sp_data *sp, sp_pinknoise *p, SPFLOAT *in, SPFLOAT *out)
+55
{
+56
uint32_t k = ctz[p->counter & 63];
+57
p->prevrand = p->dice[k];
+58
p->seed = 1664525 * p->seed + 1013904223;
+59
p->newrand = p->seed >> 3;
+60
p->dice[k] = p->newrand;
+61
p->total += (p->newrand - p->prevrand);
+62
p->seed = 1103515245 * p->seed + 12345;
+63
p->newrand = p->seed >> 3;
+64
short tmp = (short) ((((p->total + p->newrand) * (1.0f / (3 << 29)) - 1) - .25f) * 16384.0f);
+65
+66
*out = ((SPFLOAT) tmp / 32767) * p->amp;
+67
p->counter = (p->counter + 1) % 0xFFFFFFFF;
+68
return SP_OK;
+69
}
vendor/soundpipe/modules/port.cadded
@@ -0,0 +1,66 @@
+1
/*
+2
* Port
+3
*
+4
* Port is a one-pole smoothing filter, typically used on
+5
* control signals to create a "portamenteau" effect.
+6
*
+7
* This filter design uses the difference equation:
+8
*
+9
* y(n) = b0*x(n) - a1*y(n - 1)
+10
*
+11
* Where a1 is (0.5^(1/(t * sr))), and b0 is (1 - a1).
+12
*
+13
* More information on one-pole smoothers can be found here:
+14
* https://ccrma.stanford.edu/~jos/filters/One_Pole.html
+15
*/
+16
+17
+18
#include <math.h>
+19
#include <stdint.h>
+20
#include <stdlib.h>
+21
+22
#include "soundpipe.h"
+23
+24
int sp_port_create(sp_port **p)
+25
{
+26
*p = malloc(sizeof(sp_port));
+27
return SP_OK;
+28
}
+29
+30
int sp_port_destroy(sp_port **p)
+31
{
+32
free(*p);
+33
return SP_OK;
+34
}
+35
+36
int sp_port_init(sp_data *sp, sp_port *p)
+37
{
+38
p->y0 = 0;
+39
p->b0 = 0;
+40
p->a1 = 0;
+41
p->psmooth = -100.0;
+42
p->smooth = 0.01;
+43
+44
/* using this constant shaves off a multiply operation */
+45
p->onedsr = 1.0/sp->sr;
+46
return SP_OK;
+47
}
+48
+49
int sp_port_compute(sp_data *sp, sp_port *p, SPFLOAT *in, SPFLOAT *out)
+50
{
+51
if (p->psmooth != p->smooth) {
+52
p->a1 = pow(0.5, p->onedsr/p->smooth);
+53
p->b0 = 1.0 - p->a1;
+54
p->psmooth = p->smooth;
+55
}
+56
+57
p->y0 = p->b0 * (*in) + p->a1 * p->y0;
+58
*out = p->y0;
+59
return SP_OK;
+60
}
+61
+62
int sp_port_reset(sp_data *sp, sp_port *p, SPFLOAT *in)
+63
{
+64
p->y0 = *in;
+65
return SP_OK;
+66
}
vendor/soundpipe/modules/posc3.cadded
@@ -0,0 +1,93 @@
+1
/*
+2
* posc3
+3
*
+4
* This code has been extracted from the Csound opcode "poscil3".
+5
* It has been modified to work as a Soundpipe module.
+6
*
+7
* Original Author(s): Gabriel Maldonado, John ffitch
+8
* Year: 1998
+9
* Location: Opcodes/uggab.c
+10
*
+11
*/
+12
+13
#include <stdlib.h>
+14
#include <math.h>
+15
#include "soundpipe.h"
+16
+17
int sp_posc3_create(sp_posc3 **posc3)
+18
{
+19
*posc3 = malloc(sizeof(sp_posc3));
+20
return SP_OK;
+21
}
+22
+23
int sp_posc3_destroy(sp_posc3 **posc3)
+24
{
+25
free(*posc3);
+26
return SP_NOT_OK;
+27
}
+28
+29
int sp_posc3_init(sp_data *sp, sp_posc3 *posc3, sp_ftbl *ft)
+30
{
+31
+32
posc3->amp = 0.2;
+33
posc3->freq = 440.0;
+34
posc3->iphs = 0.0;
+35
posc3->onedsr = 1.0 / sp->sr;
+36
+37
posc3->tbl = ft;
+38
posc3->tablen = (int32_t) ft->size;
+39
posc3->tablenUPsr = posc3->tablen * posc3->onedsr;
+40
posc3->phs = posc3->iphs * posc3->tablen;
+41
return SP_OK;
+42
}
+43
+44
int sp_posc3_compute(sp_data *sp, sp_posc3 *posc3, SPFLOAT *in, SPFLOAT *out)
+45
{
+46
SPFLOAT *ftab;
+47
SPFLOAT fract;
+48
SPFLOAT phs = posc3->phs;
+49
SPFLOAT si = posc3->freq * posc3->tablen * posc3->onedsr;
+50
SPFLOAT amp = posc3->amp;
+51
int x0;
+52
SPFLOAT y0, y1, ym1, y2;
+53
+54
ftab = posc3->tbl->tbl;
+55
+56
x0 = (int32_t )phs;
+57
fract = (SPFLOAT)(phs - (SPFLOAT)x0);
+58
x0--;
+59
+60
if (x0 < 0) {
+61
ym1 = ftab[posc3->tablen-1]; x0 = 0;
+62
} else ym1 = ftab[x0++];
+63
+64
y0 = ftab[x0++];
+65
y1 = ftab[x0++];
+66
+67
if (x0>posc3->tablen) y2 = ftab[1];
+68
else y2 = ftab[x0];
+69
+70
{
+71
SPFLOAT frsq = fract*fract;
+72
SPFLOAT frcu = frsq*ym1;
+73
SPFLOAT t1 = y2 + y0+y0+y0;
+74
*out = amp * (y0 + 0.5 *frcu +
+75
fract*(y1 - frcu/6.0 - t1/6.0
+76
- ym1/3.0) +
+77
frsq*fract*(t1/6.0 - 0.5*y1) +
+78
frsq*(0.5* y1 - y0));
+79
}
+80
+81
phs += si;
+82
+83
while (phs >= posc3->tablen) {
+84
phs -= posc3->tablen;
+85
}
+86
+87
while (phs < 0.0) {
+88
phs += posc3->tablen;
+89
posc3->phs = phs;
+90
}
+91
posc3->phs = phs;
+92
return SP_OK;
+93
}
vendor/soundpipe/modules/randh.cadded
@@ -0,0 +1,44 @@
+1
#include <stdlib.h>
+2
#include "soundpipe.h"
+3
+4
int sp_randh_create(sp_randh **p)
+5
{
+6
*p = malloc(sizeof(sp_randh));
+7
return SP_OK;
+8
}
+9
+10
int sp_randh_destroy(sp_randh **p)
+11
{
+12
free(*p);
+13
return SP_OK;
+14
}
+15
+16
int sp_randh_init(sp_data *sp, sp_randh *p)
+17
{
+18
p->counter = 0;
+19
p->freq = 10;
+20
p->dur = (sp->sr / p->freq);
+21
p->min = 0;
+22
p->max = 1;
+23
p->val = 0;
+24
return SP_OK;
+25
}
+26
+27
int sp_randh_compute(sp_data *sp, sp_randh *p, SPFLOAT *in, SPFLOAT *out)
+28
{
+29
if (p->counter == 0) {
+30
p->val = p->min + ((SPFLOAT) sp_rand(sp) / SP_RANDMAX) * (p->max - p->min);
+31
+32
if (p->freq == 0) {
+33
p->dur = 1;
+34
} else {
+35
p->dur = (sp->sr / p->freq) + 1;
+36
}
+37
+38
*out = p->val;
+39
} else {
+40
*out = p->val;
+41
}
+42
p->counter = (p->counter + 1) % p->dur;
+43
return SP_OK;
+44
}
vendor/soundpipe/modules/randi.cadded
@@ -0,0 +1,98 @@
+1
/*
+2
* Randi
+3
*
+4
* This code has been extracted from the Csound opcode "randi".
+5
* It has been modified to work as a Soundpipe module.
+6
*
+7
* Original Author(s): Barry Vercoe, John ffitch
+8
* Year: 1991
+9
* Location: OOps/ugens4.c
+10
*
+11
* Randi needs the ftbl Soundpipe module in order to work.
+12
*
+13
*/
+14
+15
#include <stdlib.h>
+16
#include <math.h>
+17
#include "soundpipe.h"
+18
+19
#define sp_oneUp31Bit (4.656612875245796924105750827168e-10)
+20
+21
#define sp_randGab ((SPFLOAT) \
+22
(((p->holdrand = p->holdrand * 214013 + 2531011) >> 1) \
+23
& 0x7fffffff) * sp_oneUp31Bit)
+24
+25
+26
int sp_randi_create(sp_randi **p)
+27
{
+28
*p = malloc(sizeof(sp_randi));
+29
return SP_OK;
+30
}
+31
+32
int sp_randi_destroy(sp_randi **p)
+33
{
+34
free(*p);
+35
return SP_OK;
+36
}
+37
+38
int sp_randi_init(sp_data *sp, sp_randi *p)
+39
{
+40
p->sicvt = 1.0 * SP_FT_MAXLEN / sp->sr;
+41
p->phs = 0;
+42
p->min = 0;
+43
p->max = 1;
+44
p->cps = 3;
+45
p->mode = 3;
+46
p->holdrand = sp_rand(sp);
+47
p->fstval = 0;
+48
+49
int mode = (int)(p->mode);
+50
+51
switch (mode) {
+52
case 1: /* immediate interpolation between kmin and 1st random number */
+53
p->num1 = 0.0;
+54
p->num2 = sp_randGab;
+55
p->dfdmax = (p->num2 - p->num1) / SP_FT_MAXLEN * 1.0;
+56
break;
+57
case 2: /* immediate interpolation between ifirstval and 1st random number */
+58
p->num1 = (p->max - p->min) ?
+59
(p->fstval - p->min) / (p->max - p->min) : 0.0;
+60
p->num2 = sp_randGab;
+61
p->dfdmax = (p->num2 - p->num1) / SP_FT_MAXLEN * 1.0;
+62
break;
+63
case 3: /* immediate interpolation between 1st and 2nd random number */
+64
p->num1 = sp_randGab;
+65
p->num2 = sp_randGab;
+66
p->dfdmax = (p->num2 - p->num1) / SP_FT_MAXLEN * 1.0;
+67
break;
+68
default: /* old behaviour as developped by Gabriel */
+69
p->num1 = p->num2 = 0.0;
+70
p->dfdmax = 0.0;
+71
}
+72
+73
return SP_OK;
+74
}
+75
+76
int sp_randi_compute(sp_data *sp, sp_randi *p, SPFLOAT *in, SPFLOAT *out)
+77
{
+78
int32_t phs = p->phs, inc;
+79
SPFLOAT cpsp;
+80
SPFLOAT amp, min;
+81
+82
cpsp = p->cps;
+83
min = p->min;
+84
amp = (p->max - min);
+85
inc = (int32_t)(cpsp * p->sicvt);
+86
+87
*out = (p->num1 + (SPFLOAT)phs * p->dfdmax) * amp + min;
+88
phs += inc;
+89
if (phs >= SP_FT_MAXLEN) {
+90
phs &= SP_FT_PHMASK;
+91
p->num1 = p->num2;
+92
p->num2 = sp_randGab;
+93
p->dfdmax = 1.0 * (p->num2 - p->num1) / SP_FT_MAXLEN;
+94
}
+95
p->phs = phs;
+96
+97
return SP_OK;
+98
}
vendor/soundpipe/modules/randmt.cadded
@@ -0,0 +1,135 @@
+1
/*
+2
A C-program for MT19937, with initialisation improved 2002/1/26.
+3
Coded by Takuji Nishimura and Makoto Matsumoto.
+4
+5
Before using, initialise the state by using csoundSeedRandMT().
+6
+7
Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
+8
All rights reserved.
+9
+10
Redistribution and use in source and binary forms, with or without
+11
modification, are permitted provided that the following conditions
+12
are met:
+13
+14
1. Redistributions of source code must retain the above copyright
+15
notice, this list of conditions and the following disclaimer.
+16
+17
2. Redistributions in binary form must reproduce the above copyright
+18
notice, this list of conditions and the following disclaimer in the
+19
documentation and/or other materials provided with the distribution.
+20
+21
3. The names of its contributors may not be used to endorse or promote
+22
products derived from this software without specific prior written
+23
permission.
+24
+25
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+26
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+27
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+28
A PARTICULAR PURPOSE ARE DISCLAIMED.
+29
IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+30
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+31
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+32
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+33
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+34
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+35
IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+36
POSSIBILITY OF SUCH DAMAGE.
+37
+38
Any feedback is very welcome.
+39
http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
+40
email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
+41
*/
+42
+43
#include "soundpipe.h"
+44
#define N (624)
+45
#define M (397)
+46
#define MATRIX_A 0x9908B0DFU /* constant vector a */
+47
#define UPPER_MASK 0x80000000U /* most significant w-r bits */
+48
#define LOWER_MASK 0x7FFFFFFFU /* least significant r bits */
+49
+50
static void MT_update_state(uint32_t *mt)
+51
{
+52
/* mag01[x] = x * MATRIX_A for x=0,1 */
+53
const uint32_t mag01[2] = { (uint32_t) 0, (uint32_t) MATRIX_A };
+54
int i;
+55
uint32_t y;
+56
+57
for (i = 0; i < (N - M); i++) {
+58
y = (mt[i] & UPPER_MASK) | (mt[i + 1] & LOWER_MASK);
+59
mt[i] = mt[i + M] ^ (y >> 1) ^ mag01[y & (uint32_t) 1];
+60
}
+61
for ( ; i < (N - 1); i++) {
+62
y = (mt[i] & UPPER_MASK) | (mt[i + 1] & LOWER_MASK);
+63
mt[i] = mt[i + (M - N)] ^ (y >> 1) ^ mag01[y & (uint32_t) 1];
+64
}
+65
y = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK);
+66
mt[N - 1] = mt[M - 1] ^ (y >> 1) ^ mag01[y & (uint32_t) 1];
+67
}
+68
+69
/* generates a random number on [0,0xffffffff]-interval */
+70
+71
uint32_t sp_randmt_compute(sp_randmt *p)
+72
{
+73
int i = p->mti;
+74
uint32_t y;
+75
+76
if (i >= N) { /* generate N words at one time */
+77
MT_update_state(&(p->mt[0]));
+78
i = 0;
+79
}
+80
y = p->mt[i];
+81
p->mti = i + 1;
+82
/* Tempering */
+83
y ^= (y >> 11);
+84
y ^= (y << 7) & (uint32_t) 0x9D2C5680U;
+85
y ^= (y << 15) & (uint32_t) 0xEFC60000U;
+86
y ^= (y >> 18);
+87
+88
return y;
+89
}
+90
+91
void sp_randmt_seed(sp_randmt *p,
+92
const uint32_t *initKey, uint32_t keyLength)
+93
{
+94
int i, j, k;
+95
uint32_t x;
+96
+97
/* if array is NULL, use length parameter as simple 32 bit seed */
+98
x = (initKey == NULL ? keyLength : (uint32_t) 19650218);
+99
p->mt[0] = x;
+100
for (i = 1; i < N; i++) {
+101
/* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
+102
/* In the previous versions, MSBs of the seed affect */
+103
/* only MSBs of the array mt[]. */
+104
/* 2002/01/09 modified by Makoto Matsumoto */
+105
x = ((uint32_t) 1812433253 * (x ^ (x >> 30)) + (uint32_t) i);
+106
p->mt[i] = x;
+107
}
+108
p->mti = N;
+109
if (initKey == NULL)
+110
return;
+111
i = 0; j = 0;
+112
k = (N > (int) keyLength ? N : (int) keyLength);
+113
for ( ; k; k--) {
+114
x = p->mt[i++];
+115
p->mt[i] = (p->mt[i] ^ ((x ^ (x >> 30)) * (uint32_t) 1664525))
+116
+ initKey[j] + (uint32_t) j; /* non linear */
+117
if (i == (N - 1)) {
+118
p->mt[0] = p->mt[N - 1];
+119
i = 0;
+120
}
+121
if (++j >= (int) keyLength)
+122
j = 0;
+123
}
+124
for (k = (N - 1); k; k--) {
+125
x = p->mt[i++];
+126
p->mt[i] = (p->mt[i] ^ ((x ^ (x >> 30)) * (uint32_t) 1566083941))
+127
- (uint32_t) i; /* non linear */
+128
if (i == (N - 1)) {
+129
p->mt[0] = p->mt[N - 1];
+130
i = 0;
+131
}
+132
}
+133
/* MSB is 1; assuring non-zero initial array */
+134
p->mt[0] = (uint32_t) 0x80000000U;
+135
}
vendor/soundpipe/modules/revsc.cadded
@@ -0,0 +1,279 @@
+1
/*
+2
* RevSC
+3
*
+4
* This code has been extracted from the Csound opcode "reverbsc".
+5
* It has been modified to work as a Soundpipe module.
+6
*
+7
* Original Author(s): Sean Costello, Istvan Varga
+8
* Year: 1999, 2005
+9
* Location: Opcodes/reverbsc.c
+10
*
+11
*/
+12
+13
#include <math.h>
+14
#include <stdlib.h>
+15
#include <stdint.h>
+16
#include <string.h>
+17
#include "soundpipe.h"
+18
+19
#define DEFAULT_SRATE 44100.0
+20
#define MIN_SRATE 5000.0
+21
#define MAX_SRATE 1000000.0
+22
#define MAX_PITCHMOD 20.0
+23
#define DELAYPOS_SHIFT 28
+24
#define DELAYPOS_SCALE 0x10000000
+25
#define DELAYPOS_MASK 0x0FFFFFFF
+26
+27
#ifndef M_PI
+28
#define M_PI 3.14159265358979323846 /* pi */
+29
#endif
+30
+31
/* reverbParams[n][0] = delay time (in seconds) */
+32
/* reverbParams[n][1] = random variation in delay time (in seconds) */
+33
/* reverbParams[n][2] = random variation frequency (in 1/sec) */
+34
/* reverbParams[n][3] = random seed (0 - 32767) */
+35
+36
static const SPFLOAT reverbParams[8][4] = {
+37
{ (2473.0 / DEFAULT_SRATE), 0.0010, 3.100, 1966.0 },
+38
{ (2767.0 / DEFAULT_SRATE), 0.0011, 3.500, 29491.0 },
+39
{ (3217.0 / DEFAULT_SRATE), 0.0017, 1.110, 22937.0 },
+40
{ (3557.0 / DEFAULT_SRATE), 0.0006, 3.973, 9830.0 },
+41
{ (3907.0 / DEFAULT_SRATE), 0.0010, 2.341, 20643.0 },
+42
{ (4127.0 / DEFAULT_SRATE), 0.0011, 1.897, 22937.0 },
+43
{ (2143.0 / DEFAULT_SRATE), 0.0017, 0.891, 29491.0 },
+44
{ (1933.0 / DEFAULT_SRATE), 0.0006, 3.221, 14417.0 }
+45
};
+46
+47
static int delay_line_max_samples(SPFLOAT sr, SPFLOAT iPitchMod, int n);
+48
static int init_delay_line(sp_revsc *p, sp_revsc_dl *lp, int n);
+49
static int delay_line_bytes_alloc(SPFLOAT sr, SPFLOAT iPitchMod, int n);
+50
static const SPFLOAT outputGain = 0.35;
+51
static const SPFLOAT jpScale = 0.25;
+52
int sp_revsc_create(sp_revsc **p){
+53
*p = malloc(sizeof(sp_revsc));
+54
return SP_OK;
+55
}
+56
+57
int sp_revsc_init(sp_data *sp, sp_revsc *p)
+58
{
+59
p->iSampleRate = sp->sr;
+60
p->sampleRate = sp->sr;
+61
p->feedback = 0.97;
+62
p->lpfreq = 10000;
+63
p->iPitchMod = 1;
+64
p->iSkipInit = 0;
+65
p->dampFact = 1.0;
+66
p->prv_LPFreq = 0.0;
+67
p->initDone = 1;
+68
int i, nBytes = 0;
+69
+70
for (i = 0; i < 8; i++) {
+71
nBytes += delay_line_bytes_alloc(sp->sr, 1, i);
+72
}
+73
+74
sp_auxdata_alloc(&p->aux, nBytes);
+75
nBytes = 0;
+76
+77
for (i = 0; i < 8; i++) {
+78
p->delayLines[i].buf = (p->aux.ptr) + nBytes;
+79
init_delay_line(p, &p->delayLines[i], i);
+80
nBytes += delay_line_bytes_alloc(sp->sr, 1, i);
+81
}
+82
+83
return SP_OK;
+84
}
+85
+86
+87
int sp_revsc_destroy(sp_revsc **p)
+88
{
+89
sp_revsc *pp = *p;
+90
sp_auxdata_free(&pp->aux);
+91
free(*p);
+92
return SP_OK;
+93
}
+94
+95
static int delay_line_max_samples(SPFLOAT sr, SPFLOAT iPitchMod, int n)
+96
{
+97
SPFLOAT maxDel;
+98
+99
maxDel = reverbParams[n][0];
+100
maxDel += (reverbParams[n][1] * (SPFLOAT) iPitchMod * 1.125);
+101
return (int) (maxDel * sr + 16.5);
+102
}
+103
+104
static int delay_line_bytes_alloc(SPFLOAT sr, SPFLOAT iPitchMod, int n)
+105
{
+106
int nBytes = 0;
+107
+108
nBytes += (delay_line_max_samples(sr, iPitchMod, n) * (int) sizeof(SPFLOAT));
+109
return nBytes;
+110
}
+111
+112
static void next_random_lineseg(sp_revsc *p, sp_revsc_dl *lp, int n)
+113
{
+114
SPFLOAT prvDel, nxtDel, phs_incVal;
+115
+116
/* update random seed */
+117
if (lp->seedVal < 0)
+118
lp->seedVal += 0x10000;
+119
lp->seedVal = (lp->seedVal * 15625 + 1) & 0xFFFF;
+120
if (lp->seedVal >= 0x8000)
+121
lp->seedVal -= 0x10000;
+122
/* length of next segment in samples */
+123
lp->randLine_cnt = (int) ((p->sampleRate / reverbParams[n][2]) + 0.5);
+124
prvDel = (SPFLOAT) lp->writePos;
+125
prvDel -= ((SPFLOAT) lp->readPos
+126
+ ((SPFLOAT) lp->readPosFrac / (SPFLOAT) DELAYPOS_SCALE));
+127
while (prvDel < 0.0)
+128
prvDel += lp->bufferSize;
+129
prvDel = prvDel / p->sampleRate; /* previous delay time in seconds */
+130
nxtDel = (SPFLOAT) lp->seedVal * reverbParams[n][1] / 32768.0;
+131
/* next delay time in seconds */
+132
nxtDel = reverbParams[n][0] + (nxtDel * (SPFLOAT) p->iPitchMod);
+133
/* calculate phase increment per sample */
+134
phs_incVal = (prvDel - nxtDel) / (SPFLOAT) lp->randLine_cnt;
+135
phs_incVal = phs_incVal * p->sampleRate + 1.0;
+136
lp->readPosFrac_inc = (int) (phs_incVal * DELAYPOS_SCALE + 0.5);
+137
}
+138
+139
static int init_delay_line(sp_revsc *p, sp_revsc_dl *lp, int n)
+140
{
+141
SPFLOAT readPos;
+142
/* int i; */
+143
+144
/* calculate length of delay line */
+145
lp->bufferSize = delay_line_max_samples(p->sampleRate, 1, n);
+146
lp->dummy = 0;
+147
lp->writePos = 0;
+148
/* set random seed */
+149
lp->seedVal = (int) (reverbParams[n][3] + 0.5);
+150
/* set initial delay time */
+151
readPos = (SPFLOAT) lp->seedVal * reverbParams[n][1] / 32768;
+152
readPos = reverbParams[n][0] + (readPos * (SPFLOAT) p->iPitchMod);
+153
readPos = (SPFLOAT) lp->bufferSize - (readPos * p->sampleRate);
+154
lp->readPos = (int) readPos;
+155
readPos = (readPos - (SPFLOAT) lp->readPos) * (SPFLOAT) DELAYPOS_SCALE;
+156
lp->readPosFrac = (int) (readPos + 0.5);
+157
/* initialise first random line segment */
+158
next_random_lineseg(p, lp, n);
+159
/* clear delay line to zero */
+160
lp->filterState = 0.0;
+161
memset(lp->buf, 0, sizeof(SPFLOAT) * lp->bufferSize);
+162
return SP_OK;
+163
}
+164
+165
+166
int sp_revsc_compute(sp_data *sp, sp_revsc *p, SPFLOAT *in1, SPFLOAT *in2, SPFLOAT *out1, SPFLOAT *out2)
+167
{
+168
SPFLOAT ainL, ainR, aoutL, aoutR;
+169
SPFLOAT vm1, v0, v1, v2, am1, a0, a1, a2, frac;
+170
sp_revsc_dl *lp;
+171
int readPos;
+172
uint32_t n;
+173
int bufferSize; /* Local copy */
+174
SPFLOAT dampFact = p->dampFact;
+175
+176
if (p->initDone <= 0) return SP_NOT_OK;
+177
+178
/* calculate tone filter coefficient if frequency changed */
+179
+180
if (p->lpfreq != p->prv_LPFreq) {
+181
p->prv_LPFreq = p->lpfreq;
+182
dampFact = 2.0 - cos(p->prv_LPFreq * (2 * M_PI) / p->sampleRate);
+183
dampFact = p->dampFact = dampFact - sqrt(dampFact * dampFact - 1.0);
+184
}
+185
+186
/* calculate "resultant junction pressure" and mix to input signals */
+187
+188
ainL = aoutL = aoutR = 0.0;
+189
for (n = 0; n < 8; n++) {
+190
ainL += p->delayLines[n].filterState;
+191
}
+192
ainL *= jpScale;
+193
ainR = ainL + *in2;
+194
ainL = ainL + *in1;
+195
+196
/* loop through all delay lines */
+197
+198
for (n = 0; n < 8; n++) {
+199
lp = &p->delayLines[n];
+200
bufferSize = lp->bufferSize;
+201
+202
/* send input signal and feedback to delay line */
+203
+204
lp->buf[lp->writePos] = (SPFLOAT) ((n & 1 ? ainR : ainL)
+205
- lp->filterState);
+206
if (++lp->writePos >= bufferSize) {
+207
lp->writePos -= bufferSize;
+208
}
+209
+210
/* read from delay line with cubic interpolation */
+211
+212
if (lp->readPosFrac >= DELAYPOS_SCALE) {
+213
lp->readPos += (lp->readPosFrac >> DELAYPOS_SHIFT);
+214
lp->readPosFrac &= DELAYPOS_MASK;
+215
}
+216
if (lp->readPos >= bufferSize)
+217
lp->readPos -= bufferSize;
+218
readPos = lp->readPos;
+219
frac = (SPFLOAT) lp->readPosFrac * (1.0 / (SPFLOAT) DELAYPOS_SCALE);
+220
+221
/* calculate interpolation coefficients */
+222
+223
a2 = frac * frac; a2 -= 1.0; a2 *= (1.0 / 6.0);
+224
a1 = frac; a1 += 1.0; a1 *= 0.5; am1 = a1 - 1.0;
+225
a0 = 3.0 * a2; a1 -= a0; am1 -= a2; a0 -= frac;
+226
+227
/* read four samples for interpolation */
+228
+229
if (readPos > 0 && readPos < (bufferSize - 2)) {
+230
vm1 = (SPFLOAT) (lp->buf[readPos - 1]);
+231
v0 = (SPFLOAT) (lp->buf[readPos]);
+232
v1 = (SPFLOAT) (lp->buf[readPos + 1]);
+233
v2 = (SPFLOAT) (lp->buf[readPos + 2]);
+234
}
+235
else {
+236
+237
/* at buffer wrap-around, need to check index */
+238
+239
if (--readPos < 0) readPos += bufferSize;
+240
vm1 = (SPFLOAT) lp->buf[readPos];
+241
if (++readPos >= bufferSize) readPos -= bufferSize;
+242
v0 = (SPFLOAT) lp->buf[readPos];
+243
if (++readPos >= bufferSize) readPos -= bufferSize;
+244
v1 = (SPFLOAT) lp->buf[readPos];
+245
if (++readPos >= bufferSize) readPos -= bufferSize;
+246
v2 = (SPFLOAT) lp->buf[readPos];
+247
}
+248
v0 = (am1 * vm1 + a0 * v0 + a1 * v1 + a2 * v2) * frac + v0;
+249
+250
/* update buffer read position */
+251
+252
lp->readPosFrac += lp->readPosFrac_inc;
+253
+254
/* apply feedback gain and lowpass filter */
+255
+256
v0 *= (SPFLOAT) p->feedback;
+257
v0 = (lp->filterState - v0) * dampFact + v0;
+258
lp->filterState = v0;
+259
+260
/* mix to output */
+261
+262
if (n & 1) {
+263
aoutR += v0;
+264
}else{
+265
aoutL += v0;
+266
}
+267
+268
/* start next random line segment if current one has reached endpoint */
+269
+270
if (--(lp->randLine_cnt) <= 0) {
+271
next_random_lineseg(p, lp, n);
+272
}
+273
}
+274
/* someday, use aoutR for multimono out */
+275
+276
*out1 = aoutL * outputGain;
+277
*out2 = aoutR * outputGain;
+278
return SP_OK;
+279
}
vendor/soundpipe/modules/saturator.cadded
@@ -0,0 +1,109 @@
+1
#include <stdlib.h>
+2
#include <math.h>
+3
#include "soundpipe.h"
+4
+5
#ifndef M_PI
+6
#define M_PI 3.14159265358979323846
+7
#endif
+8
+9
static void bilinear_transform(SPFLOAT acoefs[], SPFLOAT dcoefs[], SPFLOAT fs)
+10
{
+11
SPFLOAT b0, b1, b2, a0, a1, a2;
+12
SPFLOAT bz0, bz1, bz2, az0, az1, az2;
+13
+14
b0 = acoefs[0]; b1 = acoefs[1]; b2 = acoefs[2];
+15
a0 = acoefs[3]; a1 = acoefs[4]; a2 = acoefs[5];
+16
+17
bz0 = 1.0; bz1 = 0.0; bz2 = 0.0;
+18
az0 = 1.0; az1 = 0.0; az2 = 0.0;
+19
+20
az0 = a2*4*fs*fs + a1*2*fs + a0;
+21
+22
bz2 = (b2*4*fs*fs - b1*2*fs + b0) / az0;
+23
bz1 = (-b2*8*fs*fs + 2*b0) / az0;
+24
bz0 = (b2*4*fs*fs+ b1*2*fs + b0) / az0;
+25
az2 = (a2*4*fs*fs - a1*2*fs + a0) / az0;
+26
az1 = (-a2*8*fs*fs + 2*a0) / az0;
+27
+28
dcoefs[0] = bz0; dcoefs[1] = bz1; dcoefs[2] = bz2;
+29
dcoefs[3] = az1; dcoefs[4] = az2;
+30
}
+31
+32
int sp_saturator_create(sp_saturator **p)
+33
{
+34
*p = malloc(sizeof(sp_saturator));
+35
return SP_OK;
+36
}
+37
+38
int sp_saturator_destroy(sp_saturator **p)
+39
{
+40
free(*p);
+41
return SP_OK;
+42
}
+43
+44
int sp_saturator_init(sp_data *sp, sp_saturator *p)
+45
{
+46
int i, j;
+47
const SPFLOAT aacoefs[6][7] =
+48
{
+49
{2.60687e-05, 2.98697e-05, 2.60687e-05, -1.31885, 0.437162, 0.0, 0.0},
+50
{1, -0.800256, 1, -1.38301, 0.496576, 0.0, 0.0},
+51
{1, -1.42083, 1, -1.48787, 0.594413, 0.0, 0.0},
+52
{1, -1.6374, 1, -1.60688, 0.707142, 0.0, 0.0},
+53
{1, -1.7261, 1, -1.7253, 0.822156, 0.0, 0.0},
+54
{1, -1.75999, 1, -1.84111, 0.938811, 0.0, 0.0}
+55
};
+56
+57
SPFLOAT wc_dc = 5*2*M_PI;
+58
SPFLOAT scoeffs[6] = { 0, 1, 0, wc_dc, 1, 0 };
+59
SPFLOAT zcoeffs[5];
+60
p->drive = 1;
+61
p->dcoffset = 0;
+62
+63
for(i = 0; i < 6; i++){
+64
for(j = 0; j < 7; j++){
+65
p->aa[i][j] = aacoefs[i][j];
+66
p->ai[i][j] = aacoefs[i][j];
+67
}
+68
}
+69
bilinear_transform(scoeffs, zcoeffs, sp->sr*8);
+70
for(i = 0; i < 2; i++){
+71
for(j = 0; j < 5; j++)
+72
p->dcblocker[i][j] = zcoeffs[j];
+73
p->dcblocker[i][5] = 0.0;
+74
p->dcblocker[i][6] = 0.0;
+75
}
+76
return SP_OK;
+77
}
+78
+79
static int quad_compute(SPFLOAT p[7], SPFLOAT *input, SPFLOAT* output)
+80
{
+81
SPFLOAT in = *input;
+82
*output = p[5] + in * p[0];
+83
p[5] = p[6] + in * p[1] - *output*p[3];
+84
p[6] = in * p[2] - *output*p[4];
+85
return SP_OK;
+86
}
+87
+88
+89
int sp_saturator_compute(sp_data *sp, sp_saturator *p, SPFLOAT *in, SPFLOAT *out)
+90
{
+91
int i, j;
+92
SPFLOAT fsignal, usignal, dsignal;
+93
+94
fsignal = p->drive * *in;
+95
for(i = 0; i < 8; i++){
+96
usignal = (i == 0) ? 8 *fsignal : 0.0;
+97
for(j = 0; j < 6; j++)
+98
quad_compute(p->ai[j], &usignal, &usignal);
+99
+100
dsignal = (usignal + p->dcoffset) / (1.0 + fabs(usignal + p->dcoffset));
+101
+102
quad_compute(p->dcblocker[0], &dsignal, &dsignal);
+103
quad_compute(p->dcblocker[1], &dsignal, &dsignal);
+104
+105
for(j = 0; j < 6; j++)
+106
quad_compute(p->aa[j], &dsignal, out);
+107
}
+108
return SP_OK;
+109
}
vendor/soundpipe/modules/scale.cadded
@@ -0,0 +1,27 @@
+1
#include <stdlib.h>
+2
#include "soundpipe.h"
+3
+4
int sp_scale_create(sp_scale **p)
+5
{
+6
*p = malloc(sizeof(sp_scale));
+7
return SP_OK;
+8
}
+9
+10
int sp_scale_destroy(sp_scale **p)
+11
{
+12
free(*p);
+13
return SP_OK;
+14
}
+15
+16
int sp_scale_init(sp_data *sp, sp_scale *p)
+17
{
+18
p->min = -1;
+19
p->max = 1;
+20
return SP_OK;
+21
}
+22
+23
int sp_scale_compute(sp_data *sp, sp_scale *p, SPFLOAT *in, SPFLOAT *out)
+24
{
+25
*out = *in * (p->max - p->min) + p->min;
+26
return SP_OK;
+27
}
vendor/soundpipe/modules/tadsr.cadded
@@ -0,0 +1,152 @@
+1
/*
+2
* TADSR
+3
*
+4
* This module uses modified code from Perry Cook's ADSR STK module.
+5
*
+6
*/
+7
+8
#include <stdlib.h>
+9
#include <math.h>
+10
#include "soundpipe.h"
+11
+12
enum{ ATTACK, DECAY, SUSTAIN, RELEASE, CLEAR, KEY_ON, KEY_OFF };
+13
+14
static void make_Envelope(sp_tadsr *e)
+15
{
+16
e->target = 0.0;
+17
e->value = 0.0;
+18
e->rate = 0.001;
+19
e->state = 1;
+20
}
+21
+22
static void make_ADSR(sp_tadsr *a)
+23
{
+24
make_Envelope(a);
+25
a->target = 0.0;
+26
a->value = 0.0;
+27
a->attackRate = 0.001;
+28
a->decayRate = 0.001;
+29
a->sustainLevel = 0.0;
+30
a->releaseRate = 0.01;
+31
a->state = CLEAR;
+32
}
+33
+34
static void ADSR_keyOn(sp_tadsr *a)
+35
{
+36
a->target = 1.0;
+37
a->rate = a->attackRate;
+38
a->state = ATTACK;
+39
}
+40
+41
static void ADSR_keyOff(sp_tadsr *a)
+42
{
+43
a->target = 0.0;
+44
a->rate = a->releaseRate;
+45
a->state = RELEASE;
+46
}
+47
+48
static void ADSR_setSustainLevel(sp_data *sp, sp_tadsr *a, SPFLOAT aLevel)
+49
{
+50
a->sustainLevel = aLevel;
+51
}
+52
+53
static void ADSR_setAttackTime(sp_data *sp, sp_tadsr *a, SPFLOAT aTime)
+54
{
+55
a->attackRate = 1.0 / (aTime * sp->sr);
+56
}
+57
+58
static void ADSR_setDecayTime(sp_data *sp, sp_tadsr *a, SPFLOAT aTime)
+59
{
+60
a->decayRate = 1.0 / (aTime * sp->sr);
+61
}
+62
+63
static void ADSR_setReleaseTime(sp_data *sp, sp_tadsr *a, SPFLOAT aTime)
+64
{
+65
a->releaseRate = 1.0 / (aTime * sp->sr);
+66
}
+67
+68
static void ADSR_setAllTimes(sp_data *sp, sp_tadsr *a, SPFLOAT attTime, SPFLOAT decTime,
+69
SPFLOAT susLevel, SPFLOAT relTime)
+70
{
+71
ADSR_setAttackTime(sp, a, attTime);
+72
ADSR_setDecayTime(sp, a, decTime);
+73
ADSR_setSustainLevel(sp, a, susLevel);
+74
ADSR_setReleaseTime(sp, a, relTime);
+75
}
+76
+77
static SPFLOAT ADSR_tick(sp_tadsr *a)
+78
{
+79
SPFLOAT out = 0;
+80
if (a->state == ATTACK) {
+81
a->value += a->rate;
+82
if (a->value >= a->target) {
+83
a->value = a->target;
+84
a->rate = a->decayRate;
+85
a->target = a->sustainLevel;
+86
a->state = DECAY;
+87
}
+88
out = a->value;
+89
} else if (a->state == DECAY) {
+90
a->value -= a->decayRate;
+91
out = a->value;
+92
if (a->value <= a->sustainLevel) {
+93
a->value = a->sustainLevel;
+94
out = a->sustainLevel;
+95
a->rate = 0.0;
+96
a->state = SUSTAIN;
+97
}
+98
} else if (a->state == RELEASE) {
+99
a->value -= a->releaseRate;
+100
if (a->value <= 0.0) {
+101
a->value = 0.0;
+102
a->state = CLEAR;
+103
}
+104
out = a->value;
+105
} else if (a->state == SUSTAIN) {
+106
out = a->sustainLevel;
+107
}
+108
return out;
+109
}
+110
+111
int sp_tadsr_create(sp_tadsr **p)
+112
{
+113
*p = malloc(sizeof(sp_tadsr));
+114
return SP_OK;
+115
}
+116
+117
int sp_tadsr_destroy(sp_tadsr **p)
+118
{
+119
free(*p);
+120
return SP_OK;
+121
}
+122
+123
int sp_tadsr_init(sp_data *sp, sp_tadsr *p)
+124
{
+125
make_ADSR(p);
+126
p->atk = 0.5;
+127
p->dec = 0.5;
+128
p->sus = 0.0;
+129
p->rel = 0.5;
+130
p->mode = KEY_OFF;
+131
return SP_OK;
+132
}
+133
+134
int sp_tadsr_compute(sp_data *sp, sp_tadsr *p, SPFLOAT *trig, SPFLOAT *out)
+135
{
+136
if(*trig != 0) {
+137
+138
if(*trig == 2) {
+139
ADSR_keyOff(p);
+140
p->mode = KEY_OFF;
+141
}else if(p->mode == KEY_OFF) {
+142
ADSR_setAllTimes(sp, p, p->atk, p->dec, p->sus, p->rel);
+143
ADSR_keyOn(p);
+144
p->mode = KEY_ON;
+145
} else {
+146
ADSR_keyOff(p);
+147
p->mode = KEY_OFF;
+148
}
+149
}
+150
*out = ADSR_tick(p);
+151
return SP_OK;
+152
}
vendor/soundpipe/modules/tenv.cadded
@@ -0,0 +1,90 @@
+1
#include <stdlib.h>
+2
#include "soundpipe.h"
+3
+4
int sp_tenv_create(sp_tenv **p)
+5
{
+6
*p = malloc(sizeof(sp_tenv));
+7
return SP_OK;
+8
}
+9
+10
int sp_tenv_destroy(sp_tenv **p)
+11
{
+12
free(*p);
+13
return SP_OK;
+14
}
+15
+16
static void sp_tenv_reinit(void *ud)
+17
{
+18
sp_tenv *env = ud;
+19
env->pos = 0;
+20
env->atk_end = env->sr * env->atk;
+21
env->rel_start = env->sr * (env->atk + env->hold);
+22
env->atk_slp = 1.0 / env->atk_end;
+23
env->rel_slp = -1.0 / (env->sr * env->rel);
+24
env->totaldur = env->sr * (env->atk + env->hold + env->rel);
+25
}
+26
+27
static void sp_tenv_comp(void *ud, SPFLOAT *out)
+28
{
+29
sp_tenv *env = ud;
+30
SPFLOAT sig = 0;
+31
uint32_t pos = env->pos;
+32
*out = 0.0;
+33
+34
if (pos < env->atk_end) {
+35
sig = env->last + env->atk_slp;
+36
} else if (pos < env->rel_start) {
+37
sig = 1.0;
+38
} else if (pos < env->totaldur) {
+39
sig = env->last + env->rel_slp;
+40
} else{
+41
sig = 0.0;
+42
}
+43
+44
sig = (sig > 1.0) ? 1.0 : sig;
+45
sig = (sig < 0.0) ? 0.0 : sig;
+46
+47
/* Internal input signal mode */
+48
if (env->sigmode) {
+49
*out = env->input * sig;
+50
} else {
+51
*out = sig;
+52
}
+53
+54
env->pos++;
+55
env->last = sig;
+56
}
+57
+58
int sp_tenv_init(sp_data *sp, sp_tenv *p)
+59
{
+60
p->pos = 0;
+61
p->last = 0;
+62
p->atk = 0.1;
+63
p->hold = 0.3;
+64
p->rel = 0.2;
+65
p->sigmode = 0;
+66
p->input = 0;
+67
+68
p->sr = sp->sr;
+69
p->atk_end = p->sr * p->atk;
+70
p->rel_start = p->sr * (p->atk + p->hold);
+71
p->atk_slp = 1.0 / p->atk_end;
+72
p->rel_slp = -1.0 / (p->sr * p->rel);
+73
p->totaldur = p->sr * (p->atk + p->hold + p->rel);
+74
+75
p->started = 0;
+76
return SP_OK;
+77
}
+78
+79
int sp_tenv_compute(sp_data *sp, sp_tenv *p, SPFLOAT *in, SPFLOAT *out)
+80
{
+81
if (*in) {
+82
sp_tenv_reinit(p);
+83
p->started = 1;
+84
}
+85
+86
if (p->started) sp_tenv_comp(p, out);
+87
else *out = 0;
+88
+89
return SP_OK;
+90
}
vendor/soundpipe/modules/tgate.cadded
@@ -0,0 +1,34 @@
+1
#include <stdlib.h>
+2
#include "soundpipe.h"
+3
+4
int sp_tgate_create(sp_tgate **p)
+5
{
+6
*p = malloc(sizeof(sp_tgate));
+7
return SP_OK;
+8
}
+9
+10
int sp_tgate_destroy(sp_tgate **p)
+11
{
+12
free(*p);
+13
return SP_OK;
+14
}
+15
+16
int sp_tgate_init(sp_data *sp, sp_tgate *p)
+17
{
+18
p->time = 0;
+19
p->timer = 0;
+20
return SP_OK;
+21
}
+22
+23
int sp_tgate_compute(sp_data *sp, sp_tgate *p, SPFLOAT *in, SPFLOAT *out)
+24
{
+25
*out = 0;
+26
if(*in != 0) {
+27
p->timer = p->time * sp->sr;
+28
}
+29
if(p->timer != 0) {
+30
*out = 1;
+31
p->timer--;
+32
}
+33
return SP_OK;
+34
}
vendor/soundpipe/modules/tone.cadded
@@ -0,0 +1,68 @@
+1
/*
+2
* Tone
+3
*
+4
* This code has been extracted from the Csound opcode "tone".
+5
* It has been modified to work as a Soundpipe module.
+6
*
+7
* Original Author(s): Barry Vercoe, John FFitch, Gabriel Maldonado
+8
* Year: 1991
+9
* Location: OOps/ugens5.c
+10
*
+11
*/
+12
+13
#include <stdlib.h>
+14
#include <math.h>
+15
#include <stdint.h>
+16
+17
#ifndef M_PI
+18
#define M_PI 3.14159265358979323846
+19
#endif
+20
+21
#include "soundpipe.h"
+22
+23
+24
int sp_tone_create(sp_tone **t)
+25
{
+26
*t = malloc(sizeof(sp_tone));
+27
return SP_OK;
+28
}
+29
+30
int sp_tone_destroy(sp_tone **t)
+31
{
+32
free(*t);
+33
return SP_OK;
+34
}
+35
+36
int sp_tone_init(sp_data *sp, sp_tone *p)
+37
{
+38
p->hp = 1000;
+39
SPFLOAT b;
+40
p->tpidsr = (2.0 * M_PI) / sp->sr * 1.0;
+41
p->prvhp = (SPFLOAT)p->hp;
+42
b = 2.0 - cos((SPFLOAT)(p->prvhp * p->tpidsr));
+43
p->c2 = b - sqrt(b * b - 1.0);
+44
p->c1 = 1.0 - p->c2;
+45
p->yt1 = 0.0;
+46
+47
return SP_OK;
+48
}
+49
+50
int sp_tone_compute(sp_data *sp, sp_tone *p, SPFLOAT *in, SPFLOAT *out)
+51
{
+52
SPFLOAT c1 = p->c1, c2 = p->c2;
+53
SPFLOAT yt1 = p->yt1;
+54
+55
if (p->hp != p->prvhp) {
+56
SPFLOAT b;
+57
p->prvhp = p->hp;
+58
b = 2.0 - cos((p->prvhp * p->tpidsr));
+59
p->c2 = c2 = b - sqrt(b * b - 1.0);
+60
p->c1 = c1 = 1.0 - c2;
+61
}
+62
+63
yt1 = c1 * (*in) + c2 * yt1;
+64
*out = yt1;
+65
+66
p->yt1 = yt1;
+67
return SP_OK;
+68
}
vendor/soundpipe/modules/vdelay.cadded
@@ -0,0 +1,116 @@
+1
/*
+2
* Del
+3
*
+4
* This code has been extracted from the Csound opcode "vdelay3".
+5
* It has been modified to work as a Soundpipe module.
+6
*
+7
* Original Author(s): Paris Smaradgis, Istvan Varga
+8
* Year: 1994
+9
* Location: OOps/vdelay.c
+10
*
+11
*/
+12
+13
#include <stdlib.h>
+14
#include "soundpipe.h"
+15
+16
int sp_vdelay_create(sp_vdelay **p)
+17
{
+18
*p = malloc(sizeof(sp_vdelay));
+19
return SP_OK;
+20
}
+21
+22
int sp_vdelay_destroy(sp_vdelay **p)
+23
{
+24
sp_vdelay *pp = *p;
+25
sp_auxdata_free(&pp->buf);
+26
free(*p);
+27
return SP_OK;
+28
}
+29
+30
int sp_vdelay_init(sp_data *sp, sp_vdelay *p, SPFLOAT maxdel)
+31
{
+32
uint32_t n = (int32_t)(maxdel * sp->sr)+1;
+33
p->sr = sp->sr;
+34
p->del = maxdel * 0.5;
+35
p->maxdel = maxdel;
+36
sp_auxdata_alloc(&p->buf, n * sizeof(SPFLOAT));
+37
p->left = 0;
+38
p->feedback = 0;
+39
p->prev = 0;
+40
return SP_OK;
+41
}
+42
+43
int sp_vdelay_compute(sp_data *sp, sp_vdelay *p, SPFLOAT *in, SPFLOAT *out)
+44
{
+45
int32_t maxd, indx;
+46
*out = p->sr;
+47
SPFLOAT del = p->del;
+48
SPFLOAT b0, b1, b2, b3;
+49
int32_t v0, v1, v2, v3;
+50
SPFLOAT fv1;
+51
indx = p->left;
+52
SPFLOAT *buf = (SPFLOAT *)p->buf.ptr;
+53
+54
buf[indx] = *in + p->prev*p->feedback;
+55
+56
fv1 = del * (-1.0 * sp->sr);
+57
v1 = (int32_t)fv1;
+58
fv1 -= (SPFLOAT) v1;
+59
v1 += (int32_t)indx;
+60
maxd = (uint32_t) (p->maxdel * p->sr);
+61
/* Make sure we're inside the buffer */
+62
if ((v1 < 0) || (fv1 < 0.0)) {
+63
fv1++; v1--;
+64
while (v1 < 0) {
+65
v1 += (int32_t)maxd;
+66
}
+67
} else {
+68
while (v1 >= (int32_t)maxd) {
+69
v1 -= (int32_t)maxd;
+70
}
+71
}
+72
/* Find next sample for interpolation */
+73
v2 = (v1 == (int32_t)(maxd - 1UL) ? 0L : v1 + 1L);
+74
+75
if (maxd<4) {
+76
b1 = buf[v1];
+77
b2 = buf[v2];
+78
*out = b1 + fv1 * (b2 - b1);
+79
} else {
+80
v0 = (v1==0 ? maxd-1 : v1-1);
+81
v3 = (v2==(int32_t)maxd-1 ? 0 : v2+1);
+82
{
+83
SPFLOAT w, x, y, z;
+84
z = fv1 * fv1; z--;
+85
z *= 0.1666666667;
+86
y = fv1;
+87
y++; w = (y *= 0.5); w--;
+88
x = 3.0 * z; y -= x; w -= z; x -= fv1;
+89
b0 = buf[v0];
+90
b1 = buf[v1];
+91
b2 = buf[v2];
+92
b3 = buf[v3];
+93
*out = (w*b0 + x*b1 + y*b2 + z*b3)
+94
* fv1 + b1;
+95
}
+96
}
+97
if (++indx == maxd) indx = 0;
+98
p->left = indx;
+99
p->prev = *out;
+100
return SP_OK;
+101
}
+102
+103
int sp_vdelay_reset(sp_data *sp, sp_vdelay *p)
+104
{
+105
SPFLOAT *buf;
+106
uint32_t n;
+107
int32_t maxd;
+108
+109
buf = (SPFLOAT *)p->buf.ptr;
+110
p->left = 0;
+111
maxd = (uint32_t) (p->maxdel * p->sr);
+112
+113
for(n = 0; n < maxd; n++) buf[n] = 0;
+114
+115
return SP_OK;
+116
}
vendor/soundpipe/modules/wavout.cadded
@@ -0,0 +1,53 @@
+1
#include <stdlib.h>
+2
#include "soundpipe.h"
+3
#include "dr_wav.h"
+4
+5
#define WAVOUT_BUFSIZE 1024
+6
+7
struct sp_wavout {
+8
drwav *wav;
+9
drwav_data_format format;
+10
SPFLOAT buf[WAVOUT_BUFSIZE];
+11
int count;
+12
};
+13
+14
int sp_wavout_create(sp_wavout **p)
+15
{
+16
*p = malloc(sizeof(sp_wavout));
+17
return SP_OK;
+18
}
+19
+20
int sp_wavout_destroy(sp_wavout **p)
+21
{
+22
/* write any remaining samples */
+23
if((*p)->count != 0) {
+24
drwav_write((*p)->wav, (*p)->count, (*p)->buf);
+25
}
+26
drwav_close((*p)->wav);
+27
free(*p);
+28
return SP_OK;
+29
}
+30
+31
int sp_wavout_init(sp_data *sp, sp_wavout *p, const char *filename)
+32
{
+33
p->count = 0;
+34
p->format.container = drwav_container_riff;
+35
p->format.format = DR_WAVE_FORMAT_IEEE_FLOAT;
+36
p->format.channels = 1;
+37
p->format.sampleRate = sp->sr;
+38
p->format.bitsPerSample = 32;
+39
p->wav = drwav_open_file_write(filename, &p->format);
+40
return SP_OK;
+41
}
+42
+43
int sp_wavout_compute(sp_data *sp, sp_wavout *p, SPFLOAT *in, SPFLOAT *out)
+44
{
+45
*out = *in;
+46
if(p->count == WAVOUT_BUFSIZE) {
+47
drwav_write(p->wav, WAVOUT_BUFSIZE, p->buf);
+48
p->count = 0;
+49
}
+50
p->buf[p->count] = *in;
+51
p->count++;
+52
return SP_OK;
+53
}
vendor/soundpipe/modules/zitarev.cadded
@@ -0,0 +1,1062 @@
+1
/*
+2
* Zitarev
+3
*
+4
* This code has been generated FAUST.
+5
* It uses the zitarev module included in the FAUST
+6
* standard library (FAUST port by Julius Smith).
+7
* It has been modified to work as a Soundpipe module.
+8
*
+9
* Original Author: Fons Adriaensen
+10
*
+11
*/
+12
+13
#include <stdlib.h>
+14
#include <math.h>
+15
#include "soundpipe.h"
+16
#include "CUI.h"
+17
+18
#define max(a,b) ((a < b) ? b : a)
+19
#define min(a,b) ((a < b) ? a : b)
+20
+21
#ifndef FAUSTFLOAT
+22
#define FAUSTFLOAT float
+23
#endif
+24
+25
float powf(float dummy0, float dummy1);
+26
float sqrtf(float dummy0);
+27
float cosf(float dummy0);
+28
float floorf(float dummy0);
+29
float expf(float dummy0);
+30
static float faustpower2_f(float value) {
+31
return (value * value);
+32
+33
}
+34
float tanf(float dummy0);
+35
+36
+37
typedef struct {
+38
+39
float fVec1[32768];
+40
float fVec4[32768];
+41
float fVec8[32768];
+42
float fVec6[16384];
+43
float fVec10[16384];
+44
float fVec12[16384];
+45
float fVec14[16384];
+46
float fVec16[16384];
+47
float fVec0[8192];
+48
float fVec2[8192];
+49
float fVec5[4096];
+50
float fVec7[4096];
+51
float fVec9[4096];
+52
float fVec13[4096];
+53
float fVec15[4096];
+54
float fVec3[2048];
+55
float fVec11[2048];
+56
float fVec17[2048];
+57
float fRec4[3];
+58
float fRec5[3];
+59
float fRec6[3];
+60
float fRec7[3];
+61
float fRec8[3];
+62
float fRec9[3];
+63
float fRec10[3];
+64
float fRec11[3];
+65
float fRec3[3];
+66
float fRec2[3];
+67
float fRec45[3];
+68
float fRec44[3];
+69
float fRec0[2];
+70
float fRec1[2];
+71
float fRec15[2];
+72
float fRec14[2];
+73
float fRec12[2];
+74
float fRec19[2];
+75
float fRec18[2];
+76
float fRec16[2];
+77
float fRec23[2];
+78
float fRec22[2];
+79
float fRec20[2];
+80
float fRec27[2];
+81
float fRec26[2];
+82
float fRec24[2];
+83
float fRec31[2];
+84
float fRec30[2];
+85
float fRec28[2];
+86
float fRec35[2];
+87
float fRec34[2];
+88
float fRec32[2];
+89
float fRec39[2];
+90
float fRec38[2];
+91
float fRec36[2];
+92
float fRec43[2];
+93
float fRec42[2];
+94
float fRec40[2];
+95
FAUSTFLOAT fHslider0;
+96
FAUSTFLOAT fHslider1;
+97
int IOTA;
+98
int fSamplingFreq;
+99
int iConst0;
+100
float fConst1;
+101
FAUSTFLOAT fHslider2;
+102
FAUSTFLOAT fHslider3;
+103
FAUSTFLOAT fHslider4;
+104
FAUSTFLOAT fHslider5;
+105
float fConst2;
+106
float fConst3;
+107
FAUSTFLOAT fHslider6;
+108
float fConst4;
+109
FAUSTFLOAT fHslider7;
+110
FAUSTFLOAT fHslider8;
+111
float fConst5;
+112
FAUSTFLOAT fHslider9;
+113
float fConst6;
+114
int iConst7;
+115
float fConst8;
+116
FAUSTFLOAT fHslider10;
+117
int iConst9;
+118
float fConst10;
+119
float fConst11;
+120
float fConst12;
+121
int iConst13;
+122
int iConst14;
+123
float fConst15;
+124
float fConst16;
+125
float fConst17;
+126
int iConst18;
+127
int iConst19;
+128
float fConst20;
+129
float fConst21;
+130
float fConst22;
+131
int iConst23;
+132
int iConst24;
+133
float fConst25;
+134
float fConst26;
+135
float fConst27;
+136
int iConst28;
+137
int iConst29;
+138
float fConst30;
+139
float fConst31;
+140
float fConst32;
+141
int iConst33;
+142
int iConst34;
+143
float fConst35;
+144
float fConst36;
+145
float fConst37;
+146
int iConst38;
+147
int iConst39;
+148
float fConst40;
+149
float fConst41;
+150
float fConst42;
+151
int iConst43;
+152
int iConst44;
+153
+154
} zitarev;
+155
+156
static zitarev* newzitarev() {
+157
zitarev* dsp = (zitarev*)malloc(sizeof(zitarev));
+158
return dsp;
+159
}
+160
+161
static void deletezitarev(zitarev* dsp) {
+162
free(dsp);
+163
}
+164
+165
static void instanceInitzitarev(zitarev* dsp, int samplingFreq) {
+166
dsp->fSamplingFreq = samplingFreq;
+167
dsp->fHslider0 = (FAUSTFLOAT)-20.;
+168
/* C99 loop */
+169
{
+170
int i0;
+171
for (i0 = 0; (i0 < 2); i0 = (i0 + 1)) {
+172
dsp->fRec0[i0] = 0.f;
+173
+174
}
+175
+176
}
+177
dsp->fHslider1 = (FAUSTFLOAT)1.;
+178
/* C99 loop */
+179
{
+180
int i1;
+181
for (i1 = 0; (i1 < 2); i1 = (i1 + 1)) {
+182
dsp->fRec1[i1] = 0.f;
+183
+184
}
+185
+186
}
+187
dsp->IOTA = 0;
+188
/* C99 loop */
+189
{
+190
int i2;
+191
for (i2 = 0; (i2 < 8192); i2 = (i2 + 1)) {
+192
dsp->fVec0[i2] = 0.f;
+193
+194
}
+195
+196
}
+197
dsp->iConst0 = min(192000, max(1, dsp->fSamplingFreq));
+198
dsp->fConst1 = (6.28319f / (float)dsp->iConst0);
+199
dsp->fHslider2 = (FAUSTFLOAT)1500.;
+200
dsp->fHslider3 = (FAUSTFLOAT)0.;
+201
dsp->fHslider4 = (FAUSTFLOAT)315.;
+202
dsp->fHslider5 = (FAUSTFLOAT)0.;
+203
dsp->fConst2 = floorf((0.5f + (0.219991f * (float)dsp->iConst0)));
+204
dsp->fConst3 = ((0.f - (6.90776f * dsp->fConst2)) / (float)dsp->iConst0);
+205
dsp->fHslider6 = (FAUSTFLOAT)2.;
+206
dsp->fConst4 = (6.28319f / (float)dsp->iConst0);
+207
dsp->fHslider7 = (FAUSTFLOAT)6000.;
+208
dsp->fHslider8 = (FAUSTFLOAT)3.;
+209
dsp->fConst5 = (3.14159f / (float)dsp->iConst0);
+210
dsp->fHslider9 = (FAUSTFLOAT)200.;
+211
/* C99 loop */
+212
{
+213
int i3;
+214
for (i3 = 0; (i3 < 2); i3 = (i3 + 1)) {
+215
dsp->fRec15[i3] = 0.f;
+216
+217
}
+218
+219
}
+220
/* C99 loop */
+221
{
+222
int i4;
+223
for (i4 = 0; (i4 < 2); i4 = (i4 + 1)) {
+224
dsp->fRec14[i4] = 0.f;
+225
+226
}
+227
+228
}
+229
/* C99 loop */
+230
{
+231
int i5;
+232
for (i5 = 0; (i5 < 32768); i5 = (i5 + 1)) {
+233
dsp->fVec1[i5] = 0.f;
+234
+235
}
+236
+237
}
+238
dsp->fConst6 = floorf((0.5f + (0.019123f * (float)dsp->iConst0)));
+239
dsp->iConst7 = (int)((int)(dsp->fConst2 - dsp->fConst6) & 32767);
+240
/* C99 loop */
+241
{
+242
int i6;
+243
for (i6 = 0; (i6 < 8192); i6 = (i6 + 1)) {
+244
dsp->fVec2[i6] = 0.f;
+245
+246
}
+247
+248
}
+249
dsp->fConst8 = (0.001f * (float)dsp->iConst0);
+250
dsp->fHslider10 = (FAUSTFLOAT)60.;
+251
/* C99 loop */
+252
{
+253
int i7;
+254
for (i7 = 0; (i7 < 2048); i7 = (i7 + 1)) {
+255
dsp->fVec3[i7] = 0.f;
+256
+257
}
+258
+259
}
+260
dsp->iConst9 = (int)((int)(dsp->fConst6 - 1.f) & 2047);
+261
/* C99 loop */
+262
{
+263
int i8;
+264
for (i8 = 0; (i8 < 2); i8 = (i8 + 1)) {
+265
dsp->fRec12[i8] = 0.f;
+266
+267
}
+268
+269
}
+270
dsp->fConst10 = floorf((0.5f + (0.256891f * (float)dsp->iConst0)));
+271
dsp->fConst11 = ((0.f - (6.90776f * dsp->fConst10)) / (float)dsp->iConst0);
+272
/* C99 loop */
+273
{
+274
int i9;
+275
for (i9 = 0; (i9 < 2); i9 = (i9 + 1)) {
+276
dsp->fRec19[i9] = 0.f;
+277
+278
}
+279
+280
}
+281
/* C99 loop */
+282
{
+283
int i10;
+284
for (i10 = 0; (i10 < 2); i10 = (i10 + 1)) {
+285
dsp->fRec18[i10] = 0.f;
+286
+287
}
+288
+289
}
+290
/* C99 loop */
+291
{
+292
int i11;
+293
for (i11 = 0; (i11 < 32768); i11 = (i11 + 1)) {
+294
dsp->fVec4[i11] = 0.f;
+295
+296
}
+297
+298
}
+299
dsp->fConst12 = floorf((0.5f + (0.027333f * (float)dsp->iConst0)));
+300
dsp->iConst13 = (int)((int)(dsp->fConst10 - dsp->fConst12) & 32767);
+301
/* C99 loop */
+302
{
+303
int i12;
+304
for (i12 = 0; (i12 < 4096); i12 = (i12 + 1)) {
+305
dsp->fVec5[i12] = 0.f;
+306
+307
}
+308
+309
}
+310
dsp->iConst14 = (int)((int)(dsp->fConst12 - 1.f) & 4095);
+311
/* C99 loop */
+312
{
+313
int i13;
+314
for (i13 = 0; (i13 < 2); i13 = (i13 + 1)) {
+315
dsp->fRec16[i13] = 0.f;
+316
+317
}
+318
+319
}
+320
dsp->fConst15 = floorf((0.5f + (0.192303f * (float)dsp->iConst0)));
+321
dsp->fConst16 = ((0.f - (6.90776f * dsp->fConst15)) / (float)dsp->iConst0);
+322
/* C99 loop */
+323
{
+324
int i14;
+325
for (i14 = 0; (i14 < 2); i14 = (i14 + 1)) {
+326
dsp->fRec23[i14] = 0.f;
+327
+328
}
+329
+330
}
+331
/* C99 loop */
+332
{
+333
int i15;
+334
for (i15 = 0; (i15 < 2); i15 = (i15 + 1)) {
+335
dsp->fRec22[i15] = 0.f;
+336
+337
}
+338
+339
}
+340
/* C99 loop */
+341
{
+342
int i16;
+343
for (i16 = 0; (i16 < 16384); i16 = (i16 + 1)) {
+344
dsp->fVec6[i16] = 0.f;
+345
+346
}
+347
+348
}
+349
dsp->fConst17 = floorf((0.5f + (0.029291f * (float)dsp->iConst0)));
+350
dsp->iConst18 = (int)((int)(dsp->fConst15 - dsp->fConst17) & 16383);
+351
/* C99 loop */
+352
{
+353
int i17;
+354
for (i17 = 0; (i17 < 4096); i17 = (i17 + 1)) {
+355
dsp->fVec7[i17] = 0.f;
+356
+357
}
+358
+359
}
+360
dsp->iConst19 = (int)((int)(dsp->fConst17 - 1.f) & 4095);
+361
/* C99 loop */
+362
{
+363
int i18;
+364
for (i18 = 0; (i18 < 2); i18 = (i18 + 1)) {
+365
dsp->fRec20[i18] = 0.f;
+366
+367
}
+368
+369
}
+370
dsp->fConst20 = floorf((0.5f + (0.210389f * (float)dsp->iConst0)));
+371
dsp->fConst21 = ((0.f - (6.90776f * dsp->fConst20)) / (float)dsp->iConst0);
+372
/* C99 loop */
+373
{
+374
int i19;
+375
for (i19 = 0; (i19 < 2); i19 = (i19 + 1)) {
+376
dsp->fRec27[i19] = 0.f;
+377
+378
}
+379
+380
}
+381
/* C99 loop */
+382
{
+383
int i20;
+384
for (i20 = 0; (i20 < 2); i20 = (i20 + 1)) {
+385
dsp->fRec26[i20] = 0.f;
+386
+387
}
+388
+389
}
+390
/* C99 loop */
+391
{
+392
int i21;
+393
for (i21 = 0; (i21 < 32768); i21 = (i21 + 1)) {
+394
dsp->fVec8[i21] = 0.f;
+395
+396
}
+397
+398
}
+399
dsp->fConst22 = floorf((0.5f + (0.024421f * (float)dsp->iConst0)));
+400
dsp->iConst23 = (int)((int)(dsp->fConst20 - dsp->fConst22) & 32767);
+401
/* C99 loop */
+402
{
+403
int i22;
+404
for (i22 = 0; (i22 < 4096); i22 = (i22 + 1)) {
+405
dsp->fVec9[i22] = 0.f;
+406
+407
}
+408
+409
}
+410
dsp->iConst24 = (int)((int)(dsp->fConst22 - 1.f) & 4095);
+411
/* C99 loop */
+412
{
+413
int i23;
+414
for (i23 = 0; (i23 < 2); i23 = (i23 + 1)) {
+415
dsp->fRec24[i23] = 0.f;
+416
+417
}
+418
+419
}
+420
dsp->fConst25 = floorf((0.5f + (0.125f * (float)dsp->iConst0)));
+421
dsp->fConst26 = ((0.f - (6.90776f * dsp->fConst25)) / (float)dsp->iConst0);
+422
/* C99 loop */
+423
{
+424
int i24;
+425
for (i24 = 0; (i24 < 2); i24 = (i24 + 1)) {
+426
dsp->fRec31[i24] = 0.f;
+427
+428
}
+429
+430
}
+431
/* C99 loop */
+432
{
+433
int i25;
+434
for (i25 = 0; (i25 < 2); i25 = (i25 + 1)) {
+435
dsp->fRec30[i25] = 0.f;
+436
+437
}
+438
+439
}
+440
/* C99 loop */
+441
{
+442
int i26;
+443
for (i26 = 0; (i26 < 16384); i26 = (i26 + 1)) {
+444
dsp->fVec10[i26] = 0.f;
+445
+446
}
+447
+448
}
+449
dsp->fConst27 = floorf((0.5f + (0.013458f * (float)dsp->iConst0)));
+450
dsp->iConst28 = (int)((int)(dsp->fConst25 - dsp->fConst27) & 16383);
+451
/* C99 loop */
+452
{
+453
int i27;
+454
for (i27 = 0; (i27 < 2048); i27 = (i27 + 1)) {
+455
dsp->fVec11[i27] = 0.f;
+456
+457
}
+458
+459
}
+460
dsp->iConst29 = (int)((int)(dsp->fConst27 - 1.f) & 2047);
+461
/* C99 loop */
+462
{
+463
int i28;
+464
for (i28 = 0; (i28 < 2); i28 = (i28 + 1)) {
+465
dsp->fRec28[i28] = 0.f;
+466
+467
}
+468
+469
}
+470
dsp->fConst30 = floorf((0.5f + (0.127837f * (float)dsp->iConst0)));
+471
dsp->fConst31 = ((0.f - (6.90776f * dsp->fConst30)) / (float)dsp->iConst0);
+472
/* C99 loop */
+473
{
+474
int i29;
+475
for (i29 = 0; (i29 < 2); i29 = (i29 + 1)) {
+476
dsp->fRec35[i29] = 0.f;
+477
+478
}
+479
+480
}
+481
/* C99 loop */
+482
{
+483
int i30;
+484
for (i30 = 0; (i30 < 2); i30 = (i30 + 1)) {
+485
dsp->fRec34[i30] = 0.f;
+486
+487
}
+488
+489
}
+490
/* C99 loop */
+491
{
+492
int i31;
+493
for (i31 = 0; (i31 < 16384); i31 = (i31 + 1)) {
+494
dsp->fVec12[i31] = 0.f;
+495
+496
}
+497
+498
}
+499
dsp->fConst32 = floorf((0.5f + (0.031604f * (float)dsp->iConst0)));

Showing the first 500 of 1063 diff lines for this file. This diff is INCOMPLETE; read the file or clone the repository for the rest.