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; }