static int search_for_ft(plumber_data *pd, sporth_oscmorph *om)
{
int n;
for(n = 0; n < om->nft; n++) {
if(plumber_ftmap_search(pd, om->ftname[n], &om->ft[n]) == PLUMBER_NOTOK) {
return PLUMBER_NOTOK;
}
}
return PLUMBER_OK;
}
int sporth_tset(sporth_stack *stack, void *ud)
{
plumber_data *pd = ud;
sporth_tbl_d *td;
char *ftname;
switch(pd->mode){
case PLUMBER_CREATE:
td = malloc(sizeof(sporth_tbl_d));
plumber_add_ugen(pd, SPORTH_TSET, td);
if(sporth_check_args(stack, "ffs") != SPORTH_OK) {
plumber_print(pd,"Init: not enough arguments for tset\n");
return PLUMBER_NOTOK;
}
ftname = sporth_stack_pop_string(stack);
td->index = floor(sporth_stack_pop_float(stack));
td->val = sporth_stack_pop_float(stack);
if(plumber_ftmap_search(pd, ftname, &td->ft) == PLUMBER_NOTOK) {
plumber_print(pd, "tset: could not find table '%s'\n", ftname);
stack->error++;
return PLUMBER_NOTOK;
}
td->ft->tbl[td->index] = td->val;
break;
case PLUMBER_INIT:
td = pd->last->ud;
ftname = sporth_stack_pop_string(stack);
td->index = floor(sporth_stack_pop_float(stack));
td->val = sporth_stack_pop_float(stack);
td->ft->tbl[td->index] = td->val;
break;
case PLUMBER_COMPUTE:
td = pd->last->ud;
td->index = (unsigned int) floor(sporth_stack_pop_float(stack)) % td->ft->size;
td->val = sporth_stack_pop_float(stack);
td->ft->tbl[td->index] = td->val;
break;
case PLUMBER_DESTROY:
td = pd->last->ud;
free(td);
break;
default:
plumber_print(pd,"Error: Unknown mode!");
break;
}
return PLUMBER_OK;
}
int sporth_tblsize(sporth_stack *stack, void *ud)
{
plumber_data *pd = ud;
char *ftname;
sp_ftbl *ft;
size_t *tsize;
switch(pd->mode){
case PLUMBER_CREATE:
tsize = malloc(sizeof(uint32_t));
plumber_add_ugen(pd, SPORTH_TBLSIZE, tsize);
if(sporth_check_args(stack, "s") != SPORTH_OK) {
fprintf(stderr,"Init: not enough arguments for tblsize\n");
return PLUMBER_NOTOK;
}
ftname = sporth_stack_pop_string(stack);
if(plumber_ftmap_search(pd, ftname, &ft) == PLUMBER_NOTOK) {
fprintf(stderr, "tblsize: could not find table '%s'\n", ftname);
stack->error++;
return PLUMBER_NOTOK;
}
*tsize = ft->size;
free(ftname);
sporth_stack_push_float(stack, *tsize);
break;
case PLUMBER_INIT:
tsize = pd->last->ud;
ftname = sporth_stack_pop_string(stack);
*tsize = ft->size;
free(ftname);
sporth_stack_push_float(stack, *tsize);
break;
case PLUMBER_COMPUTE:
tsize = pd->last->ud;
sporth_stack_push_float(stack, (SPFLOAT) *tsize);
break;
case PLUMBER_DESTROY:
tsize = pd->last->ud;
free(tsize);
break;
default:
fprintf(stderr,"Error: Unknown mode!");
break;
}
return PLUMBER_OK;
}
int sporth_talias(sporth_stack *stack, void *ud)
{
plumber_data *pd = ud;
char *ftname;
char *varname;
uint32_t index;
SPFLOAT *var;
sp_ftbl *ft;
switch(pd->mode){
case PLUMBER_CREATE:
plumber_add_ugen(pd, SPORTH_TALIAS, NULL);
if(sporth_check_args(stack, "sfs") != SPORTH_OK) {
plumber_print(pd,"Init: incorrect arguments for talias\n");
return PLUMBER_NOTOK;
}
ftname = sporth_stack_pop_string(stack);
index = sporth_stack_pop_float(stack);
varname = sporth_stack_pop_string(stack);
if(plumber_ftmap_search(pd, ftname, &ft) == PLUMBER_NOTOK) {
plumber_print(pd, "talias: could not find table '%s'\n", ftname);
stack->error++;
return PLUMBER_NOTOK;
}
var = &ft->tbl[index];
plumber_ftmap_delete(pd, 0);
plumber_ftmap_add_userdata(pd, varname, var);
plumber_ftmap_delete(pd, 1);
break;
case PLUMBER_INIT:
ftname = sporth_stack_pop_string(stack);
index = sporth_stack_pop_float(stack);
varname = sporth_stack_pop_string(stack);
break;
case PLUMBER_COMPUTE:
sporth_stack_pop_float(stack);
break;
case PLUMBER_DESTROY:
break;
}
return PLUMBER_OK;
}
int sporth_tbldur(sporth_stack *stack, void *ud)
{
plumber_data *pd = ud;
char *ftname;
sp_ftbl *ft;
SPFLOAT *tlen;
switch(pd->mode){
case PLUMBER_CREATE:
tlen = malloc(sizeof(SPFLOAT));
plumber_add_ugen(pd, SPORTH_TBLDUR, tlen);
if(sporth_check_args(stack, "s") != SPORTH_OK) {
plumber_print(pd,"Init: not enough arguments for tget\n");
return PLUMBER_NOTOK;
}
ftname = sporth_stack_pop_string(stack);
if(plumber_ftmap_search(pd, ftname, &ft) == PLUMBER_NOTOK) {
plumber_print(pd, "tblen: could not find table '%s'\n", ftname);
stack->error++;
return PLUMBER_NOTOK;
}
*tlen = (SPFLOAT) ft->size / pd->sp->sr;
sporth_stack_push_float(stack, (SPFLOAT) *tlen);
break;
case PLUMBER_INIT:
tlen = pd->last->ud;
ftname = sporth_stack_pop_string(stack);
sporth_stack_push_float(stack, (SPFLOAT) *tlen);
break;
case PLUMBER_COMPUTE:
tlen = pd->last->ud;
sporth_stack_push_float(stack, (SPFLOAT) *tlen);
break;
case PLUMBER_DESTROY:
tlen = pd->last->ud;
free(tlen);
break;
default:
plumber_print(pd,"Error: Unknown mode!");
break;
}
return PLUMBER_OK;
}
int sporth_scrambler(sporth_stack *stack, void *ud)
{
plumber_data *pd = ud;
sp_ftbl *ft_s, *ft_d;
char *src, *dst;
switch(pd->mode){
case PLUMBER_CREATE:
plumber_add_ugen(pd, SPORTH_SCRAMBLER, NULL);
if(sporth_check_args(stack, "ss") != SPORTH_OK) {
fprintf(stderr, "Init: not enough arguments for gen_line\n");
return PLUMBER_NOTOK;
}
src = sporth_stack_pop_string(stack);
dst = sporth_stack_pop_string(stack);
if(plumber_ftmap_search(pd, src, &ft_s) != PLUMBER_OK) {
fprintf(stderr,
"scrambler: could not find ftable %s",
src);
}
sp_gen_scrambler(pd->sp, ft_s, &ft_d);
plumber_ftmap_add(pd, dst, ft_d);
break;
case PLUMBER_INIT:
sporth_stack_pop_string(stack);
sporth_stack_pop_string(stack);
break;
case PLUMBER_COMPUTE:
break;
case PLUMBER_DESTROY:
break;
default:
break;
}
return PLUMBER_OK;
}
int sporth_posc3(sporth_stack *stack, void *ud)
{
plumber_data *pd = ud;
SPFLOAT out;
sp_ftbl *tbl;
const char *str;
SPFLOAT freq;
SPFLOAT amp;
sp_posc3 *posc3;
switch(pd->mode) {
case PLUMBER_CREATE:
#ifdef DEBUG_MODE
plumber_print(pd, "posc3: Creating\n");
#endif
sp_posc3_create(&posc3);
plumber_add_ugen(pd, SPORTH_POSC3, posc3);
if(sporth_check_args(stack, "ffs") != SPORTH_OK) {
plumber_print(pd,"Not enough arguments for posc3\n");
stack->error++;
return PLUMBER_NOTOK;
}
str = sporth_stack_pop_string(stack);
amp = sporth_stack_pop_float(stack);
freq = sporth_stack_pop_float(stack);
if(plumber_ftmap_search(pd, str, &tbl) == PLUMBER_NOTOK) {
stack->error++;
return PLUMBER_NOTOK;
}
sp_posc3_init(pd->sp, posc3, tbl);
sporth_stack_push_float(stack, 0);
break;
case PLUMBER_INIT:
#ifdef DEBUG_MODE
plumber_print(pd, "posc3: Initialising\n");
#endif
str = sporth_stack_pop_string(stack);
amp = sporth_stack_pop_float(stack);
freq = sporth_stack_pop_float(stack);
posc3 = pd->last->ud;
sporth_stack_push_float(stack, 0);
break;
case PLUMBER_COMPUTE:
amp = sporth_stack_pop_float(stack);
freq = sporth_stack_pop_float(stack);
posc3 = pd->last->ud;
posc3->freq = freq;
posc3->amp = amp;
sp_posc3_compute(pd->sp, posc3, NULL, &out);
sporth_stack_push_float(stack, out);
break;
case PLUMBER_DESTROY:
posc3 = pd->last->ud;
sp_posc3_destroy(&posc3);
break;
default:
plumber_print(pd, "posc3: Unknown mode!\n");
break;
}
return PLUMBER_OK;
}
int sporth_gen_padsynth(sporth_stack *stack, void *ud)
{
plumber_data *pd = ud;
sp_ftbl *ft, *amps;
char *ftname, *ampname;
uint32_t size;
SPFLOAT freq, bw;
switch(pd->mode){
case PLUMBER_CREATE:
plumber_add_ugen(pd, SPORTH_GEN_PADSYNTH, NULL);
if(sporth_check_args(stack, "sfffs") != SPORTH_OK) {
fprintf(stderr,"Padsynth: not enough arguments for gen_padsynth\n");
return PLUMBER_NOTOK;
}
ampname = sporth_stack_pop_string(stack);
bw = sporth_stack_pop_float(stack);
freq = sporth_stack_pop_float(stack);
size = (uint32_t)sporth_stack_pop_float(stack);
ftname = sporth_stack_pop_string(stack);
if(plumber_ftmap_search(pd, ampname, &s) == PLUMBER_NOTOK) {
stack->error++;
return PLUMBER_NOTOK;
}
sp_ftbl_create(pd->sp, &ft, size);
#ifdef DEBUG_MODE
fprintf(stderr,"Running padsynth function\n");
#endif
sp_gen_padsynth(pd->sp, ft, amps, freq, bw);
plumber_ftmap_add(pd, ftname, ft);
break;
case PLUMBER_INIT:
ampname = sporth_stack_pop_string(stack);
bw = sporth_stack_pop_float(stack);
freq = sporth_stack_pop_float(stack);
size = (uint32_t)sporth_stack_pop_float(stack);
ftname = sporth_stack_pop_string(stack);
break;
case PLUMBER_COMPUTE:
sporth_stack_pop_float(stack);
sporth_stack_pop_float(stack);
sporth_stack_pop_float(stack);
break;
case PLUMBER_DESTROY:
break;
default:
fprintf(stderr,"Error: Unknown mode!");
break;
}
return PLUMBER_OK;
}
int sporth_conv(sporth_stack *stack, void *ud)
{
plumber_data *pd = ud;
SPFLOAT input;
SPFLOAT out;
const char *ftname;
sp_ftbl *ft;
SPFLOAT iPartLen;
sp_conv *conv;
switch(pd->mode) {
case PLUMBER_CREATE:
#ifdef DEBUG_MODE
plumber_print(pd, "conv: Creating\n");
#endif
sp_conv_create(&conv);
plumber_add_ugen(pd, SPORTH_CONV, conv);
if(sporth_check_args(stack, "ffs") != SPORTH_OK) {
plumber_print(pd,"Not enough arguments for conv\n");
stack->error++;
return PLUMBER_NOTOK;
}
ftname = sporth_stack_pop_string(stack);
iPartLen = sporth_stack_pop_float(stack);
input = sporth_stack_pop_float(stack);
sporth_stack_push_float(stack, 0);
break;
case PLUMBER_INIT:
#ifdef DEBUG_MODE
plumber_print(pd, "conv: Initialising\n");
#endif
ftname = sporth_stack_pop_string(stack);
iPartLen = sporth_stack_pop_float(stack);
input = sporth_stack_pop_float(stack);
conv = pd->last->ud;
if(plumber_ftmap_search(pd, ftname, &ft) == PLUMBER_NOTOK) {
stack->error++;
return PLUMBER_NOTOK;
}
sp_conv_init(pd->sp, conv, ft, iPartLen);
sporth_stack_push_float(stack, 0);
break;
case PLUMBER_COMPUTE:
sporth_stack_pop_float(stack);
input = sporth_stack_pop_float(stack);
conv = pd->last->ud;
sp_conv_compute(pd->sp, conv, &input, &out);
sporth_stack_push_float(stack, out);
break;
case PLUMBER_DESTROY:
conv = pd->last->ud;
sp_conv_destroy(&conv);
break;
default:
plumber_print(pd, "conv: Unknown mode!\n");
break;
}
return PLUMBER_OK;
}
int sporth_fog(sporth_stack *stack, void *ud)
{
plumber_data *pd = ud;
SPFLOAT out;
char *wavstr, *winstr;
sp_ftbl *wav;
sp_ftbl *win;
int iolaps;
SPFLOAT iphs;
SPFLOAT amp;
SPFLOAT dense;
SPFLOAT trans;
SPFLOAT spd;
SPFLOAT oct;
SPFLOAT band;
SPFLOAT ris;
SPFLOAT dec;
SPFLOAT dur;
sp_fog *fog;
switch(pd->mode) {
case PLUMBER_CREATE:
#ifdef DEBUG_MODE
fprintf(stderr, "fog: Creating\n");
#endif
sp_fog_create(&fog);
plumber_add_ugen(pd, SPORTH_FOG, fog);
if(sporth_check_args(stack, "fffffffffffss") != SPORTH_OK) {
fprintf(stderr,"Not enough arguments for fog\n");
stack->error++;
return PLUMBER_NOTOK;
}
wavstr = sporth_stack_pop_string(stack);
winstr = sporth_stack_pop_string(stack);
iolaps = sporth_stack_pop_float(stack);
iphs = sporth_stack_pop_float(stack);
dur = sporth_stack_pop_float(stack);
dec = sporth_stack_pop_float(stack);
ris = sporth_stack_pop_float(stack);
band = sporth_stack_pop_float(stack);
oct = sporth_stack_pop_float(stack);
spd = sporth_stack_pop_float(stack);
trans = sporth_stack_pop_float(stack);
dense = sporth_stack_pop_float(stack);
amp = sporth_stack_pop_float(stack);
free(wavstr);
free(winstr);
sporth_stack_push_float(stack, 0);
break;
case PLUMBER_INIT:
#ifdef DEBUG_MODE
fprintf(stderr, "fog: Initialising\n");
#endif
wavstr = sporth_stack_pop_string(stack);
winstr = sporth_stack_pop_string(stack);
iolaps = sporth_stack_pop_float(stack);
iphs = sporth_stack_pop_float(stack);
dur = sporth_stack_pop_float(stack);
dec = sporth_stack_pop_float(stack);
ris = sporth_stack_pop_float(stack);
band = sporth_stack_pop_float(stack);
oct = sporth_stack_pop_float(stack);
spd = sporth_stack_pop_float(stack);
trans = sporth_stack_pop_float(stack);
dense = sporth_stack_pop_float(stack);
amp = sporth_stack_pop_float(stack);
fog = pd->last->ud;
if(plumber_ftmap_search(pd, wavstr, &wav) == PLUMBER_NOTOK) {
free(wavstr);
free(winstr);
stack->error++;
return PLUMBER_NOTOK;
}
if(plumber_ftmap_search(pd, winstr, &win) == PLUMBER_NOTOK) {
free(winstr);
stack->error++;
return PLUMBER_NOTOK;
}
sp_fog_init(pd->sp, fog, wav, win, iolaps, iphs);
free(wavstr);
free(winstr);
sporth_stack_push_float(stack, 0);
break;
case PLUMBER_COMPUTE:
iolaps = sporth_stack_pop_float(stack);
iphs = sporth_stack_pop_float(stack);
dur = sporth_stack_pop_float(stack);
dec = sporth_stack_pop_float(stack);
ris = sporth_stack_pop_float(stack);
band = sporth_stack_pop_float(stack);
oct = sporth_stack_pop_float(stack);
spd = sporth_stack_pop_float(stack);
trans = sporth_stack_pop_float(stack);
dense = sporth_stack_pop_float(stack);
amp = sporth_stack_pop_float(stack);
fog = pd->last->ud;
fog->amp = amp;
fog->dens = dense;
fog->trans = trans;
fog->spd = spd;
fog->oct = oct;
fog->band = band;
fog->ris = ris;
fog->dec = dec;
fog->dur = dur;
sp_fog_compute(pd->sp, fog, NULL, &out);
sporth_stack_push_float(stack, out);
break;
case PLUMBER_DESTROY:
fog = pd->last->ud;
sp_fog_destroy(&fog);
break;
default:
fprintf(stderr, "fog: Unknown mode!\n");
break;
}
return PLUMBER_OK;
}
int sporth_mincer(sporth_stack *stack, void *ud)
{
plumber_data *pd = ud;
SPFLOAT out = 0;
sp_ftbl * ft = NULL;
const char *ftname = NULL;
SPFLOAT time = 0;
SPFLOAT amp = 0;
SPFLOAT pitch = 0;
SPFLOAT winsize = 0;
sp_mincer *mincer = NULL;
switch(pd->mode) {
case PLUMBER_CREATE:
#ifdef DEBUG_MODE
plumber_print(pd, "mincer: Creating\n");
#endif
sp_mincer_create(&mincer);
plumber_add_ugen(pd, SPORTH_MINCER, mincer);
if(sporth_check_args(stack, "ffffs") != SPORTH_OK) {
plumber_print(pd,"Not enough arguments for mincer\n");
stack->error++;
return PLUMBER_NOTOK;
}
ftname = sporth_stack_pop_string(stack);
winsize = sporth_stack_pop_float(stack);
pitch = sporth_stack_pop_float(stack);
amp = sporth_stack_pop_float(stack);
time = sporth_stack_pop_float(stack);
sporth_stack_push_float(stack, 0);
break;
case PLUMBER_INIT:
#ifdef DEBUG_MODE
plumber_print(pd, "mincer: Initialising\n");
#endif
ftname = sporth_stack_pop_string(stack);
winsize = sporth_stack_pop_float(stack);
pitch = sporth_stack_pop_float(stack);
amp = sporth_stack_pop_float(stack);
time = sporth_stack_pop_float(stack);
mincer = pd->last->ud;
if(plumber_ftmap_search(pd, ftname, &ft) == PLUMBER_NOTOK) {
stack->error++;
return PLUMBER_NOTOK;
}
sp_mincer_init(pd->sp, mincer, ft, winsize);
sporth_stack_push_float(stack, 0);
break;
case PLUMBER_COMPUTE:
winsize = sporth_stack_pop_float(stack);
pitch = sporth_stack_pop_float(stack);
amp = sporth_stack_pop_float(stack);
time = sporth_stack_pop_float(stack);
mincer = pd->last->ud;
mincer->time = time;
mincer->amp = amp;
mincer->pitch = pitch;
sp_mincer_compute(pd->sp, mincer, NULL, &out);
sporth_stack_push_float(stack, out);
break;
case PLUMBER_DESTROY:
mincer = pd->last->ud;
sp_mincer_destroy(&mincer);
break;
default:
plumber_print(pd, "mincer: Unknown mode!\n");
break;
}
return PLUMBER_OK;
}
int sporth_polyget(sporth_stack *stack, void *ud)
{
plumber_data *pd = ud;
sporth_poly_d *poly;
char *ftname;
int voice;
uint32_t param;
uint32_t max_p;
switch(pd->mode) {
case PLUMBER_CREATE:
#ifdef DEBUG_MODE
fprintf(stderr, "polyget: Creating\n");
#endif
poly = malloc(sizeof(sporth_poly_d));
plumber_add_ugen(pd, SPORTH_POLYGET, poly);
if(sporth_check_args(stack, "ffs") != SPORTH_OK) {
fprintf(stderr,"Invalid arguments for polyget\n");
stack->error++;
return PLUMBER_NOTOK;
}
ftname = sporth_stack_pop_string(stack);
voice = (int)sporth_stack_pop_float(stack);
param = (uint32_t)sporth_stack_pop_float(stack);
if(plumber_ftmap_search(pd, ftname, &poly->ft) == PLUMBER_NOTOK) {
stack->error++;
free(ftname);
return PLUMBER_NOTOK;
}
free(ftname);
sporth_stack_push_float(stack, 0);
break;
case PLUMBER_INIT:
#ifdef DEBUG_MODE
fprintf(stderr, "polyget: Initialising\n");
#endif
poly = pd->last->ud;
ftname = sporth_stack_pop_string(stack);
voice = (int)sporth_stack_pop_float(stack);
param = (uint32_t)sporth_stack_pop_float(stack);
free(ftname);
sporth_stack_push_float(stack, 0);
break;
case PLUMBER_COMPUTE:
poly = pd->last->ud;
param = (uint32_t)sporth_stack_pop_float(stack);
voice = (uint32_t)sporth_stack_pop_float(stack);
max_p = (uint32_t)poly->ft->tbl[0] + 2;
sporth_stack_push_float(stack, poly->ft->tbl[1 + (max_p * voice) + param]);
break;
case PLUMBER_DESTROY:
poly = pd->last->ud;
free(poly);
break;
default:
fprintf(stderr, "polyget: Unknown mode!\n");
break;
}
return PLUMBER_OK;
}
int sporth_tpoly(sporth_stack *stack, void *ud)
{
plumber_data *pd = ud;
sporth_poly_d *poly;
poly_voice *voice;
SPFLOAT trig = 0;
uint32_t nvoices;
char *poly_ft;
char *arg_ft;
uint32_t n, p;
int id;
switch(pd->mode) {
case PLUMBER_CREATE:
#ifdef DEBUG_MODE
fprintf(stderr, "poly: Creating\n");
#endif
poly = malloc(sizeof(sporth_poly_d));
plumber_add_ugen(pd, SPORTH_TPOLY, poly);
if(sporth_check_args(stack, "fffss") != SPORTH_OK) {
fprintf(stderr,"Invalid arguments for tpoly\n");
stack->error++;
return PLUMBER_NOTOK;
}
poly_ft = sporth_stack_pop_string(stack);
arg_ft = sporth_stack_pop_string(stack);
poly->max_params = (uint32_t)sporth_stack_pop_float(stack);
poly->max_voices = (uint32_t)sporth_stack_pop_float(stack);
trig = sporth_stack_pop_float(stack);
if(plumber_ftmap_search(pd, arg_ft, &poly->arg_ft) == PLUMBER_NOTOK) {
fprintf(stderr, "Could not find table %s\n", arg_ft);
free(poly_ft);
free(arg_ft);
stack->error++;
return PLUMBER_NOTOK;
}
poly->dur = malloc(sizeof(uint32_t) * poly->max_voices);
poly_cluster_init(&poly->clust, poly->max_voices);
sp_ftbl_create(pd->sp, &poly->ft,
1 + poly->max_voices * (2 + poly->max_params));
memset(poly->ft->tbl, 0, poly->ft->size * sizeof(SPFLOAT));
poly->ft->tbl[0] = poly->max_params;
plumber_ftmap_add(pd, poly_ft, poly->ft);
free(poly_ft);
free(arg_ft);
break;
case PLUMBER_INIT:
#ifdef DEBUG_MODE
fprintf(stderr, "poly: Initialising\n");
#endif
poly = pd->last->ud;
poly_ft = sporth_stack_pop_string(stack);
arg_ft = sporth_stack_pop_string(stack);
poly->max_params = (uint32_t)sporth_stack_pop_float(stack);
poly->max_voices = (uint32_t)sporth_stack_pop_float(stack);
trig = sporth_stack_pop_float(stack);
free(poly_ft);
free(arg_ft);
break;
case PLUMBER_COMPUTE:
sporth_stack_pop_float(stack);
sporth_stack_pop_float(stack);
trig = sporth_stack_pop_float(stack);
poly = pd->last->ud;
for(n = 0; n < poly->max_voices; n++) {
poly->ft->tbl[1 + n * (poly->max_params + 2)] = 0.0;
}
if(trig != 0) {
if(poly_cluster_add(&poly->clust, &id) == 0) {
poly->dur[id] = poly->arg_ft->tbl[0] * pd->sp->sr;
poly->ft->tbl[1 + id * (poly->max_params + 2)] = 1.0;
poly->ft->tbl[2 + id * (poly->max_params + 2)] = poly->arg_ft->tbl[0];
for(p = 1; p < poly->arg_ft->size; p++) {
poly->ft->tbl[2 + id * (poly->max_params + 2) + p] = poly->arg_ft->tbl[p];
}
}
for(n = 0; n < poly->ft->size; n++) {
fprintf(stderr, "%g ", poly->ft->tbl[n]);
}
fprintf(stderr, "\n");
}
poly_cluster_reset(&poly->clust);
nvoices = poly_cluster_nvoices(&poly->clust);
for(n = 0; n < nvoices; n++) {
voice = poly_next_voice(&poly->clust);
poly->dur[voice->val] -= 1;
}
poly_cluster_reset(&poly->clust);
nvoices = poly_cluster_nvoices(&poly->clust);
for(n = 0; n < nvoices; n++) {
voice = poly_next_voice(&poly->clust);
if(poly->dur[voice->val] <= 0) {
poly_cluster_remove(&poly->clust, voice->val);
}
}
break;
case PLUMBER_DESTROY:
poly = pd->last->ud;
poly_cluster_destroy(&poly->clust);
free(poly->dur);
free(poly);
break;
default:
fprintf(stderr, "tpoly: Uknown mode!\n");
break;
}
return PLUMBER_OK;
}
int sporth_osc(sporth_stack *stack, void *ud)
{
if(stack->error > 0) return PLUMBER_NOTOK;
plumber_data *pd = ud;
SPFLOAT out = 0, amp, freq, phs;
char *ftname;
sp_ftbl *ft;
sp_osc *osc;
switch(pd->mode){
case PLUMBER_CREATE:
#ifdef DEBUGMODE
fprintf(stderr, "Creating osc function... \n");
#endif
sp_osc_create(&osc);
plumber_add_module(pd, SPORTH_OSC, sizeof(sp_osc), osc);
break;
case PLUMBER_INIT:
if(sporth_check_args(stack, "fffs") != SPORTH_OK) {
stack->error++;
fprintf(stderr,"Invalid arguments for osc.\n");
return PLUMBER_NOTOK;
}
osc = pd->last->ud;
ftname = sporth_stack_pop_string(stack);
phs = sporth_stack_pop_float(stack);
amp = sporth_stack_pop_float(stack);
freq = sporth_stack_pop_float(stack);
if(plumber_ftmap_search(pd, ftname, &ft) == PLUMBER_NOTOK) {
stack->error++;
return PLUMBER_NOTOK;
}
sp_osc_init(pd->sp, osc, ft, phs);
sporth_stack_push_float(stack, 0.0);
free(ftname);
break;
case PLUMBER_COMPUTE:
osc = pd->last->ud;
phs = sporth_stack_pop_float(stack);
amp = sporth_stack_pop_float(stack);
freq = sporth_stack_pop_float(stack);
osc->amp = amp;
osc->freq = freq;
sp_osc_compute(pd->sp, osc, NULL, &out);
sporth_stack_push_float(stack, out);
break;
case PLUMBER_DESTROY:
osc = pd->last->ud;
sp_osc_destroy(&osc);
break;
default:
fprintf(stderr,"Error: Unknown mode!");
stack->error++;
return PLUMBER_NOTOK;
break;
}
return PLUMBER_OK;
}
int sporth_nsmp(sporth_stack *stack, void *ud)
{
if(stack->error > 0) return PLUMBER_NOTOK;
plumber_data *pd = ud;
SPFLOAT out = 0, trig = 0, index = 0, sr = 0;
char *wav, *ini;
sp_ftbl *ft;
sp_nsmp *nsmp;
switch(pd->mode){
case PLUMBER_CREATE:
#ifdef DEBUG_MODE
fprintf(stderr,"Creating nsmp function... \n");
#endif
sp_nsmp_create(&nsmp);
plumber_add_ugen(pd, SPORTH_NSMP, nsmp);
if(sporth_check_args(stack, "fffss") != SPORTH_OK) {
stack->error++;
fprintf(stderr, "Invalid arguments for nsmp.\n");
return PLUMBER_NOTOK;
}
wav = sporth_stack_pop_string(stack);
ini = sporth_stack_pop_string(stack);
sr = sporth_stack_pop_float(stack);
index = sporth_stack_pop_float(stack);
trig = sporth_stack_pop_float(stack);
if(plumber_ftmap_search(pd, wav, &ft) == PLUMBER_NOTOK) {
stack->error++;
return PLUMBER_NOTOK;
}
if(sp_nsmp_init(pd->sp, nsmp, ft, sr, ini) == SP_NOT_OK) {
fprintf(stderr, "nsmp: there was an error opening the files\n");
stack->error++;
return PLUMBER_NOTOK;
};
sporth_stack_push_float(stack, 0.0);
break;
case PLUMBER_INIT:
nsmp = pd->last->ud;
wav = sporth_stack_pop_string(stack);
ini = sporth_stack_pop_string(stack);
sr = sporth_stack_pop_float(stack);
index = sporth_stack_pop_float(stack);
trig = sporth_stack_pop_float(stack);
sporth_stack_push_float(stack, 0.0);
break;
case PLUMBER_COMPUTE:
nsmp = pd->last->ud;
sporth_stack_pop_float(stack);
index = sporth_stack_pop_float(stack);
trig = sporth_stack_pop_float(stack);
nsmp->index = (uint32_t) index;
sp_nsmp_compute(pd->sp, nsmp, &trig, &out);
sporth_stack_push_float(stack, out);
break;
case PLUMBER_DESTROY:
nsmp = pd->last->ud;
sp_nsmp_destroy(&nsmp);
break;
default:
fprintf(stderr,"Error: Unknown mode!");
stack->error++;
return PLUMBER_NOTOK;
break;
}
return PLUMBER_OK;
}
int sporth_tblrec(sporth_stack *stack, void *ud)
{
plumber_data *pd = ud;
sp_tblrec *td;
sp_ftbl *ft;
const char *ftname;
SPFLOAT trig = 0;
SPFLOAT in = 0;
SPFLOAT out = 0;
switch(pd->mode){
case PLUMBER_CREATE:
sp_tblrec_create(&td);
plumber_add_ugen(pd, SPORTH_TBLREC, td);
if(sporth_check_args(stack, "ffs") != SPORTH_OK) {
plumber_print(pd,"Init: not enough arguments for tblrec\n");
return PLUMBER_NOTOK;
}
ftname = sporth_stack_pop_string(stack);
trig = sporth_stack_pop_float(stack);
in = sporth_stack_pop_float(stack);
td->index = 0;
td->record = 0;
if(plumber_ftmap_search(pd, ftname, &ft) == PLUMBER_NOTOK) {
plumber_print(pd, "tblrec: could not find table '%s'\n", ftname);
stack->error++;
return PLUMBER_NOTOK;
}
sp_tblrec_init(pd->sp, td, ft);
sporth_stack_push_float(stack, in);
break;
case PLUMBER_INIT:
td = pd->last->ud;
ftname = sporth_stack_pop_string(stack);
sporth_stack_pop_float(stack);
in = sporth_stack_pop_float(stack);
td->index = 0;
td->record = 0;
sporth_stack_push_float(stack, in);
break;
case PLUMBER_COMPUTE:
td = pd->last->ud;
trig = sporth_stack_pop_float(stack);
in = sporth_stack_pop_float(stack);
sp_tblrec_compute(pd->sp, td, &in, &trig, &out);
sporth_stack_push_float(stack, out);
break;
case PLUMBER_DESTROY:
td = pd->last->ud;
sp_tblrec_destroy(&td);
break;
default:
plumber_print(pd,"Error: Unknown mode!\n");
break;
}
return PLUMBER_OK;
}
