static void pop_args(sporth_stack *stack, sporth_oscmorph *om) { om->phase = sporth_stack_pop_float(stack); om->wtpos = sporth_stack_pop_float(stack); om->amp = sporth_stack_pop_float(stack); om->freq = sporth_stack_pop_float(stack); }
int sporth_f(sporth_stack *stack, void *ud) { plumber_data *pd = ud; unsigned int fnum; sporth_func_d *fd; switch(pd->mode) { case PLUMBER_CREATE: #ifdef DEBUG_MODE fprintf(stderr, "aux (f)unction: creating\n"); #endif fd = malloc(sizeof(sporth_func_d)); plumber_add_module(pd, SPORTH_F, sizeof(sporth_func_d), fd); break; case PLUMBER_INIT: #ifdef DEBUG_MODE fprintf(stderr, "aux (f)unction: initialising\n"); #endif if(sporth_check_args(stack, "f") != SPORTH_OK) { fprintf(stderr,"Not enough arguments for aux (f)unction\n"); stack->error++; return PLUMBER_NOTOK; } fnum = (int)sporth_stack_pop_float(stack); if(fnum > 16) { fprintf(stderr, "Invalid function number %d\n", fnum); stack->error++; return PLUMBER_NOTOK; } fd = pd->last->ud; fd->fun = pd->f[fnum]; pd->mode = PLUMBER_CREATE; fd->fun(stack, ud); pd->mode = PLUMBER_INIT; fd->fun(stack, ud); break; case PLUMBER_COMPUTE: fnum = (int)sporth_stack_pop_float(stack); fd = pd->last->ud; fd->fun(stack, ud); break; case PLUMBER_DESTROY: fd = pd->last->ud; fd->fun(stack, ud); free(fd); break; default: fprintf(stderr, "aux (f)unction: unknown mode!\n"); break; } return PLUMBER_OK; }
int sporth_palias(sporth_stack *stack, void *ud) { plumber_data *pd = ud; char *name; int id; SPFLOAT *foo; switch(pd->mode) { case PLUMBER_CREATE: plumber_add_ugen(pd, SPORTH_PALIAS, NULL); if(sporth_check_args(stack, "sf") != SPORTH_OK) { fprintf(stderr,"palias: Not enough arguments\n"); stack->error++; return PLUMBER_NOTOK; } id = floor(sporth_stack_pop_float(stack)); name = sporth_stack_pop_string(stack); foo = &pd->p[id]; plumber_ftmap_delete(pd, 0); plumber_set_var(pd, name, foo); plumber_ftmap_delete(pd, 1); break; case PLUMBER_INIT: sporth_stack_pop_float(stack); sporth_stack_pop_string(stack); break; case PLUMBER_COMPUTE: sporth_stack_pop_float(stack); break; default: break; } return PLUMBER_OK; }
int sporth_bpm2dur(sporth_stack *stack, void *ud) { plumber_data *pd = ud; bpm2val *data; SPFLOAT val; switch(pd->mode){ case PLUMBER_CREATE: #ifdef DEBUG_MODE fprintf(stderr, "bpm2dur: Creating\n"); #endif data = malloc(sizeof(bpm2val)); data->pbpm = -100; data->val= -100; if(sporth_check_args(stack, "f") != SPORTH_OK) { fprintf(stderr, "bpm2dur: not enough args\n"); stack->error++; return PLUMBER_NOTOK; } val = sporth_stack_pop_float(stack); data->pbpm= val; data->val= 60.0 / val; plumber_add_ugen(pd, SPORTH_BPM2DUR, data); sporth_stack_push_float(stack, data->val); break; case PLUMBER_INIT: #ifdef DEBUG_MODE fprintf(stderr, "bpm2dur: Initializing\n"); #endif data = pd->last->ud; val = sporth_stack_pop_float(stack); if(data->pbpm != val) { data->pbpm= val; data->val= 60.0 / val; } sporth_stack_push_float(stack, data->val); break; case PLUMBER_COMPUTE: data = pd->last->ud; val = sporth_stack_pop_float(stack); if(data->pbpm != val) { data->pbpm= val; data->val = 60.0 / val; } sporth_stack_push_float(stack, data->val); break; case PLUMBER_DESTROY: data = pd->last->ud; free(data); break; default: fprintf(stderr,"bpm2dur: unknown mode!"); stack->error++; return PLUMBER_NOTOK; break; } return PLUMBER_OK; }
int sporth_print(sporth_stack *stack, void *ud) { plumber_data *pd = ud; sporth_print_d *prnt; char *str = NULL; SPFLOAT val = 0; switch(pd->mode) { case PLUMBER_CREATE: #ifdef DEBUG_MODE fprintf(stderr, "print: Creating\n"); #endif prnt = malloc(sizeof(sporth_print_d)); plumber_add_ugen(pd, SPORTH_PRINT, prnt); if(sporth_check_args(stack, "fs") != SPORTH_OK) { fprintf(stderr,"Not enough arguments for print\n"); stack->error++; return PLUMBER_NOTOK; } str = sporth_stack_pop_string(stack); val = sporth_stack_pop_float(stack); strncpy(prnt->label, str, 128); prnt->pval = val; prnt->init = 1; sporth_stack_push_float(stack, val); break; case PLUMBER_INIT: #ifdef DEBUG_MODE fprintf(stderr, "print: Initialising\n"); #endif prnt = pd->last->ud; str = sporth_stack_pop_string(stack); val = sporth_stack_pop_float(stack); sporth_stack_push_float(stack, val); break; case PLUMBER_COMPUTE: prnt = pd->last->ud; val = sporth_stack_pop_float(stack); if(val != prnt->pval || prnt->init) { prnt->pval = val; prnt->init = 0; printf("%s: %g\n", prnt->label, val); } sporth_stack_push_float(stack, val); break; case PLUMBER_DESTROY: prnt = pd->last->ud; free(prnt); break; default: fprintf(stderr, "print: Unknown mode!\n"); break; } return PLUMBER_OK; }
int sporth_dmetro(sporth_stack *stack, void *ud) { plumber_data *pd = ud; SPFLOAT out; SPFLOAT time; sp_dmetro *dmetro; switch(pd->mode) { case PLUMBER_CREATE: #ifdef DEBUG_MODE fprintf(stderr, "dmetro: Creating\n"); #endif sp_dmetro_create(&dmetro); plumber_add_ugen(pd, SPORTH_DMETRO, dmetro); if(sporth_check_args(stack, "f") != SPORTH_OK) { fprintf(stderr,"Not enough arguments for dmetro\n"); stack->error++; return PLUMBER_NOTOK; } time = sporth_stack_pop_float(stack); sporth_stack_push_float(stack, 0); break; case PLUMBER_INIT: #ifdef DEBUG_MODE fprintf(stderr, "dmetro: Initialising\n"); #endif time = sporth_stack_pop_float(stack); dmetro = pd->last->ud; sp_dmetro_init(pd->sp, dmetro); sporth_stack_push_float(stack, 0); break; case PLUMBER_COMPUTE: if(sporth_check_args(stack, "f") != SPORTH_OK) { fprintf(stderr,"Not enough arguments for dmetro\n"); stack->error++; return PLUMBER_NOTOK; } time = sporth_stack_pop_float(stack); dmetro = pd->last->ud; dmetro->time = time; sp_dmetro_compute(pd->sp, dmetro, NULL, &out); sporth_stack_push_float(stack, out); break; case PLUMBER_DESTROY: dmetro = pd->last->ud; sp_dmetro_destroy(&dmetro); break; default: fprintf(stderr, "dmetro: Uknown mode!\n"); break; } return PLUMBER_OK; }
int sporth_comb(sporth_stack *stack, void *ud) { plumber_data *pd = ud; SPFLOAT input; SPFLOAT out; SPFLOAT looptime; SPFLOAT revtime; sp_comb *comb; switch(pd->mode) { case PLUMBER_CREATE: #ifdef DEBUG_MODE plumber_print(pd, "comb: Creating\n"); #endif sp_comb_create(&comb); plumber_add_ugen(pd, SPORTH_COMB, comb); if(sporth_check_args(stack, "fff") != SPORTH_OK) { plumber_print(pd,"Not enough arguments for comb\n"); stack->error++; return PLUMBER_NOTOK; } looptime = sporth_stack_pop_float(stack); revtime = 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, "comb: Initialising\n"); #endif looptime = sporth_stack_pop_float(stack); revtime = sporth_stack_pop_float(stack); input = sporth_stack_pop_float(stack); comb = pd->last->ud; sp_comb_init(pd->sp, comb, looptime); sporth_stack_push_float(stack, 0); break; case PLUMBER_COMPUTE: looptime = sporth_stack_pop_float(stack); revtime = sporth_stack_pop_float(stack); input = sporth_stack_pop_float(stack); comb = pd->last->ud; comb->revtime = revtime; sp_comb_compute(pd->sp, comb, &input, &out); sporth_stack_push_float(stack, out); break; case PLUMBER_DESTROY: comb = pd->last->ud; sp_comb_destroy(&comb); break; default: plumber_print(pd, "comb: Unknown mode!\n"); break; } return PLUMBER_OK; }
int sporth_waveset(sporth_stack *stack, void *ud) { plumber_data *pd = ud; SPFLOAT input; SPFLOAT out; SPFLOAT ilen; SPFLOAT rep; sp_waveset *waveset; switch(pd->mode) { case PLUMBER_CREATE: #ifdef DEBUG_MODE plumber_print(pd, "waveset: Creating\n"); #endif sp_waveset_create(&waveset); plumber_add_ugen(pd, SPORTH_WAVESET, waveset); if(sporth_check_args(stack, "fff") != SPORTH_OK) { plumber_print(pd,"Not enough arguments for waveset\n"); stack->error++; return PLUMBER_NOTOK; } ilen = sporth_stack_pop_float(stack); rep = 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, "waveset: Initialising\n"); #endif ilen = sporth_stack_pop_float(stack); rep = sporth_stack_pop_float(stack); input = sporth_stack_pop_float(stack); waveset = pd->last->ud; sp_waveset_init(pd->sp, waveset, ilen); sporth_stack_push_float(stack, 0); break; case PLUMBER_COMPUTE: ilen = sporth_stack_pop_float(stack); rep = sporth_stack_pop_float(stack); input = sporth_stack_pop_float(stack); waveset = pd->last->ud; waveset->rep = rep; sp_waveset_compute(pd->sp, waveset, &input, &out); sporth_stack_push_float(stack, out); break; case PLUMBER_DESTROY: waveset = pd->last->ud; sp_waveset_destroy(&waveset); break; default: plumber_print(pd, "waveset: Unknown mode!\n"); break; } return PLUMBER_OK; }
int sporth_crossfade(sporth_stack *stack, void *ud) { plumber_data *pd = ud; SPFLOAT in1; SPFLOAT in2; SPFLOAT out; SPFLOAT pos; sp_crossfade *crossfade; switch(pd->mode) { case PLUMBER_CREATE: #ifdef DEBUG_MODE plumber_print(pd, "crossfade: Creating\n"); #endif sp_crossfade_create(&crossfade); plumber_add_ugen(pd, SPORTH_CROSSFADE, crossfade); if(sporth_check_args(stack, "fff") != SPORTH_OK) { plumber_print(pd,"Not enough arguments for crossfade\n"); stack->error++; return PLUMBER_NOTOK; } pos = sporth_stack_pop_float(stack); in1 = sporth_stack_pop_float(stack); in2 = sporth_stack_pop_float(stack); sporth_stack_push_float(stack, 0); break; case PLUMBER_INIT: #ifdef DEBUG_MODE plumber_print(pd, "crossfade: Initialising\n"); #endif pos = sporth_stack_pop_float(stack); in1 = sporth_stack_pop_float(stack); in2 = sporth_stack_pop_float(stack); crossfade = pd->last->ud; sp_crossfade_init(pd->sp, crossfade); sporth_stack_push_float(stack, 0); break; case PLUMBER_COMPUTE: pos = sporth_stack_pop_float(stack); in1 = sporth_stack_pop_float(stack); in2 = sporth_stack_pop_float(stack); crossfade = pd->last->ud; crossfade->pos = pos; sp_crossfade_compute(pd->sp, crossfade, &in1, &in2, &out); sporth_stack_push_float(stack, out); break; case PLUMBER_DESTROY: crossfade = pd->last->ud; sp_crossfade_destroy(&crossfade); break; default: plumber_print(pd, "crossfade: Unknown mode!\n"); break; } return PLUMBER_OK; }
int sporth_moogladder(sporth_stack *stack, void *ud) { plumber_data *pd = ud; SPFLOAT input; SPFLOAT out; SPFLOAT freq; SPFLOAT res; sp_moogladder *moogladder; switch(pd->mode) { case PLUMBER_CREATE: #ifdef DEBUG_MODE fprintf(stderr, "moogladder: Creating\n"); #endif sp_moogladder_create(&moogladder); plumber_add_ugen(pd, SPORTH_MOOGLADDER, moogladder); if(sporth_check_args(stack, "fff") != SPORTH_OK) { fprintf(stderr,"Not enough arguments for moogladder\n"); stack->error++; return PLUMBER_NOTOK; } res = sporth_stack_pop_float(stack); freq = sporth_stack_pop_float(stack); input = sporth_stack_pop_float(stack); sporth_stack_push_float(stack, 0); break; case PLUMBER_INIT: #ifdef DEBUG_MODE fprintf(stderr, "moogladder: Initialising\n"); #endif res = sporth_stack_pop_float(stack); freq = sporth_stack_pop_float(stack); input = sporth_stack_pop_float(stack); moogladder = pd->last->ud; sp_moogladder_init(pd->sp, moogladder); sporth_stack_push_float(stack, 0); break; case PLUMBER_COMPUTE: res = sporth_stack_pop_float(stack); freq = sporth_stack_pop_float(stack); input = sporth_stack_pop_float(stack); moogladder = pd->last->ud; moogladder->freq = freq; moogladder->res = res; sp_moogladder_compute(pd->sp, moogladder, &input, &out); sporth_stack_push_float(stack, out); break; case PLUMBER_DESTROY: moogladder = pd->last->ud; sp_moogladder_destroy(&moogladder); break; default: fprintf(stderr, "moogladder: Unknown mode!\n"); break; } return PLUMBER_OK; }
int sporth_delay(sporth_stack *stack, void *ud) { plumber_data *pd = ud; SPFLOAT input; SPFLOAT out; SPFLOAT time; SPFLOAT feedback; sp_delay *delay; switch(pd->mode) { case PLUMBER_CREATE: #ifdef DEBUG_MODE fprintf(stderr, "delay: Creating\n"); #endif sp_delay_create(&delay); plumber_add_ugen(pd, SPORTH_DELAY, delay); if(sporth_check_args(stack, "fff") != SPORTH_OK) { fprintf(stderr,"Not enough arguments for delay\n"); stack->error++; return PLUMBER_NOTOK; } time = sporth_stack_pop_float(stack); feedback = sporth_stack_pop_float(stack); input = sporth_stack_pop_float(stack); sporth_stack_push_float(stack, 0); break; case PLUMBER_INIT: #ifdef DEBUG_MODE fprintf(stderr, "delay: Initialising\n"); #endif time = sporth_stack_pop_float(stack); feedback = sporth_stack_pop_float(stack); input = sporth_stack_pop_float(stack); delay = pd->last->ud; sp_delay_init(pd->sp, delay, time); sporth_stack_push_float(stack, 0); break; case PLUMBER_COMPUTE: time = sporth_stack_pop_float(stack); feedback = sporth_stack_pop_float(stack); input = sporth_stack_pop_float(stack); delay = pd->last->ud; delay->feedback = feedback; sp_delay_compute(pd->sp, delay, &input, &out); sporth_stack_push_float(stack, out); break; case PLUMBER_DESTROY: delay = pd->last->ud; sp_delay_destroy(&delay); break; default: fprintf(stderr, "delay: Unknown mode!\n"); break; } return PLUMBER_OK; }
int sporth_gen_line(sporth_stack *stack, void *ud) { plumber_data *pd = ud; int size; sp_ftbl *ft; char *str; char *args; switch(pd->mode){ case PLUMBER_CREATE: #ifdef DEBUG_MODE fprintf(stderr, "gen_line: create mode\n"); #endif plumber_add_ugen(pd, SPORTH_GEN_LINE, NULL); if(sporth_check_args(stack, "sfs") != SPORTH_OK) { fprintf(stderr, "Init: not enough arguments for gen_line\n"); return PLUMBER_NOTOK; } args = sporth_stack_pop_string(stack); size = (int)sporth_stack_pop_float(stack); str = sporth_stack_pop_string(stack); #ifdef DEBUG_MODE fprintf(stderr, "Creating line table %s of size %d\n", str, size); #endif sp_ftbl_create(pd->sp, &ft, size); if(sp_gen_line(pd->sp, ft, args) == SP_NOT_OK) { fprintf(stderr, "There was an issue creating the line ftable \"%s\".\n", str); stack->error++; return PLUMBER_NOTOK; } plumber_ftmap_add(pd, str, ft); break; case PLUMBER_INIT: args = sporth_stack_pop_string(stack); size = (int)sporth_stack_pop_float(stack); str = sporth_stack_pop_string(stack); break; case PLUMBER_COMPUTE: sporth_stack_pop_float(stack); break; case PLUMBER_DESTROY: break; default: printf("Error: Unknown mode!"); break; } return PLUMBER_OK; }
int sporth_sget(sporth_stack *stack, void *ud) { plumber_data *pd = ud; char *ftname; uint32_t index = 0; slist_d *sl; char **str = NULL; switch(pd->mode){ case PLUMBER_CREATE: str = malloc(sizeof(char *)); plumber_add_ugen(pd, SPORTH_SGET, str); if(sporth_check_args(stack, "fs") != SPORTH_OK) { plumber_print(pd,"Not enough arguments for sget\n"); return PLUMBER_NOTOK; } ftname = sporth_stack_pop_string(stack); index = sporth_stack_pop_float(stack); if(plumber_ftmap_search_userdata(pd,ftname, (void *)&sl) != PLUMBER_OK) { plumber_print(pd, "Could not find ftable %s\n", ftname); return PLUMBER_NOTOK; } if(index > sl->len - 1) { plumber_print(pd, "Index %d exceeds slist length %d\n", index, sl->len); return PLUMBER_NOTOK; } *str = sl->list[index]; sporth_stack_push_string(stack, &sl->list[index]); break; case PLUMBER_INIT: str = pd->last->ud; sporth_stack_pop_string(stack); sporth_stack_pop_float(stack); sporth_stack_push_string(stack, str); break; case PLUMBER_COMPUTE: sporth_stack_pop_float(stack); break; case PLUMBER_DESTROY: str = pd->last->ud; free(str); break; default: plumber_print(pd,"Error: Unknown mode!"); break; } return PLUMBER_OK; }
int sporth_tin(sporth_stack *stack, void *ud) { plumber_data *pd = ud; SPFLOAT trig; SPFLOAT out; sp_tin *tin; switch(pd->mode) { case PLUMBER_CREATE: #ifdef DEBUG_MODE fprintf(stderr, "tin: Creating\n"); #endif sp_tin_create(&tin); plumber_add_module(pd, SPORTH_TIN, sizeof(sp_tin), tin); break; case PLUMBER_INIT: #ifdef DEBUG_MODE fprintf(stderr, "tin: Initialising\n"); #endif if(sporth_check_args(stack, "f") != SPORTH_OK) { fprintf(stderr,"Not enough arguments for tin\n"); stack->error++; return PLUMBER_NOTOK; } trig = sporth_stack_pop_float(stack); tin = pd->last->ud; sp_tin_init(pd->sp, tin); sporth_stack_push_float(stack, 0); break; case PLUMBER_COMPUTE: if(sporth_check_args(stack, "f") != SPORTH_OK) { fprintf(stderr,"Not enough arguments for tin\n"); stack->error++; return PLUMBER_NOTOK; } trig = sporth_stack_pop_float(stack); tin = pd->last->ud; sp_tin_compute(pd->sp, tin, &trig, &out); sporth_stack_push_float(stack, out); break; case PLUMBER_DESTROY: tin = pd->last->ud; sp_tin_destroy(&tin); break; default: fprintf(stderr, "tin: Uknown mode!\n"); break; } return PLUMBER_OK; }
int sporth_prop(sporth_stack *stack, void *ud) { plumber_data *pd = ud; SPFLOAT bpm; SPFLOAT out; sp_prop *data; char *str; switch(pd->mode){ case PLUMBER_CREATE: sp_prop_create(&data); plumber_add_module(pd, SPORTH_PROP, sizeof(sp_prop), data); break; case PLUMBER_INIT: if(sporth_check_args(stack, "fs") != SPORTH_OK) { fprintf(stderr, "Not enough arguments for prop\n"); stack->error++; return PLUMBER_NOTOK; } data = pd->last->ud; str = sporth_stack_pop_string(stack); bpm = sporth_stack_pop_float(stack); if(sp_prop_init(pd->sp, data, str) == SP_NOT_OK) { stack->error++; free(str); return PLUMBER_NOTOK; } sporth_stack_push_float(stack, 0); free(str); break; case PLUMBER_COMPUTE: if(sporth_check_args(stack, "f") != SPORTH_OK) { fprintf(stderr, "Not enough arguments for prop\n"); stack->error++; return PLUMBER_NOTOK; } bpm = sporth_stack_pop_float(stack); data = pd->last->ud; data->bpm = bpm; sp_prop_compute(pd->sp, data, NULL, &out); sporth_stack_push_float(stack, out); break; case PLUMBER_DESTROY: data = pd->last->ud; sp_prop_destroy(&data); break; default: printf("Error: Unknown mode!"); break; } return PLUMBER_NOTOK; }
int sporth_gen_composite(sporth_stack *stack, void *ud) { plumber_data *pd = ud; uint32_t size; sp_ftbl *ft; char *str, *args; switch(pd->mode){ case PLUMBER_CREATE: plumber_add_ugen(pd, SPORTH_GEN_COMPOSITE, NULL); if(sporth_check_args(stack, "sfs") != SPORTH_OK) { fprintf(stderr,"composite: not enough arguments for gen_vals\n"); return PLUMBER_NOTOK; } args = sporth_stack_pop_string(stack); size = (uint32_t)sporth_stack_pop_float(stack); str = sporth_stack_pop_string(stack); sp_ftbl_create(pd->sp, &ft, size); sp_gen_composite(pd->sp, ft, args); plumber_ftmap_add(pd, str, ft); free(args); free(str); break; case PLUMBER_INIT: args = sporth_stack_pop_string(stack); size = (uint32_t)sporth_stack_pop_float(stack); str = sporth_stack_pop_string(stack); free(str); free(args); break; case PLUMBER_COMPUTE: sporth_stack_pop_float(stack); break; case PLUMBER_DESTROY: break; default: fprintf(stderr,"Error: Unknown mode!"); break; } return PLUMBER_OK; }
int sporth_pinknoise(sporth_stack *stack, void *ud) { plumber_data *pd = ud; SPFLOAT out; SPFLOAT amp; sp_pinknoise *pinknoise; switch(pd->mode) { case PLUMBER_CREATE: #ifdef DEBUG_MODE fprintf(stderr, "pinknoise: Creating\n"); #endif sp_pinknoise_create(&pinknoise); plumber_add_ugen(pd, SPORTH_PINKNOISE, pinknoise); if(sporth_check_args(stack, "f") != SPORTH_OK) { fprintf(stderr,"Not enough arguments for pinknoise\n"); stack->error++; return PLUMBER_NOTOK; } amp = sporth_stack_pop_float(stack); sporth_stack_push_float(stack, 0); break; case PLUMBER_INIT: #ifdef DEBUG_MODE fprintf(stderr, "pinknoise: Initialising\n"); #endif amp = sporth_stack_pop_float(stack); pinknoise = pd->last->ud; sp_pinknoise_init(pd->sp, pinknoise); sporth_stack_push_float(stack, 0); break; case PLUMBER_COMPUTE: amp = sporth_stack_pop_float(stack); pinknoise = pd->last->ud; pinknoise->amp = amp; sp_pinknoise_compute(pd->sp, pinknoise, NULL, &out); sporth_stack_push_float(stack, out); break; case PLUMBER_DESTROY: pinknoise = pd->last->ud; sp_pinknoise_destroy(&pinknoise); break; default: fprintf(stderr, "pinknoise: Unknown mode!\n"); break; } return PLUMBER_OK; }
int sporth_slist(sporth_stack *stack, void *ud) { plumber_data *pd = ud; char *ftname; char *filename; uint32_t size; slist_d *sl; switch(pd->mode){ case PLUMBER_CREATE: sl = malloc(sizeof(slist_d)); sl->list = NULL; plumber_add_ugen(pd, SPORTH_SLIST, sl); if(sporth_check_args(stack, "sfs") != SPORTH_OK) { plumber_print(pd,"Not enough arguments for slist\n"); return PLUMBER_NOTOK; } filename = sporth_stack_pop_string(stack); size = sporth_stack_pop_float(stack); ftname = sporth_stack_pop_string(stack); if(slist_parse(sl, filename, size) != PLUMBER_OK) { plumber_print(pd, "slist: could not load file %s\n", filename); return PLUMBER_NOTOK; } plumber_ftmap_add_userdata(pd, ftname, sl); break; case PLUMBER_INIT: sporth_stack_pop_string(stack); sporth_stack_pop_float(stack); sporth_stack_pop_string(stack); break; case PLUMBER_COMPUTE: sporth_stack_pop_float(stack); break; case PLUMBER_DESTROY: sl = pd->last->ud; slist_destroy(sl); break; default: plumber_print(pd,"Error: Unknown mode!"); break; } return PLUMBER_OK; }
int sporth_gen_file(sporth_stack *stack, void *ud) { #ifndef NO_LIBSNDFILE plumber_data *pd = ud; sp_ftbl *ft; char *str; char *filename; int size; switch(pd->mode){ case PLUMBER_CREATE: plumber_add_ugen(pd, SPORTH_GEN_FILE, NULL); if(sporth_check_args(stack, "sfs") != SPORTH_OK) { fprintf(stderr, "Init: not enough arguments for gen_file\n"); return PLUMBER_NOTOK; } filename = sporth_stack_pop_string(stack); size = (int)sporth_stack_pop_float(stack); str = sporth_stack_pop_string(stack); sp_ftbl_create(pd->sp, &ft, size); if(sp_gen_file(pd->sp, ft, filename) == SP_NOT_OK) { fprintf(stderr, "There was an issue creating the ftable \"%s\".\n", str); stack->error++; return PLUMBER_NOTOK; } plumber_ftmap_add(pd, str, ft); break; case PLUMBER_INIT: filename = sporth_stack_pop_string(stack); size = (int)sporth_stack_pop_float(stack); str = sporth_stack_pop_string(stack); break; case PLUMBER_COMPUTE: sporth_stack_pop_float(stack); break; case PLUMBER_DESTROY: break; default: printf("Error: Unknown mode!"); break; } return PLUMBER_OK; #else return PLUMBER_NOTOK; #endif }
int sporth_tget(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_TGET, td); if(sporth_check_args(stack, "fs") != SPORTH_OK) { fprintf(stderr,"Init: not enough arguments for tget\n"); return PLUMBER_NOTOK; } ftname = sporth_stack_pop_string(stack); td->index = floor(sporth_stack_pop_float(stack)); if(plumber_ftmap_search(pd, ftname, &td->ft) == PLUMBER_NOTOK) { fprintf(stderr, "tget: could not find table '%s'\n", ftname); stack->error++; return PLUMBER_NOTOK; } free(ftname); sporth_stack_push_float(stack, 0.0); break; case PLUMBER_INIT: td = pd->last->ud; ftname = sporth_stack_pop_string(stack); td->index = floor(sporth_stack_pop_float(stack)); free(ftname); sporth_stack_push_float(stack, 0.0); break; case PLUMBER_COMPUTE: td = pd->last->ud; td->index = (unsigned int) floor(sporth_stack_pop_float(stack)) % td->ft->size; sporth_stack_push_float(stack, td->ft->tbl[td->index]); break; case PLUMBER_DESTROY: td = pd->last->ud; free(td); 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_p(sporth_stack *stack, void *ud) { plumber_data *pd = ud; int n; switch(pd->mode) { case PLUMBER_CREATE: #ifdef DEBUG_MODE fprintf(stderr, "p: creating\n"); #endif plumber_add_ugen(pd, SPORTH_P, NULL); if(sporth_check_args(stack, "f") != SPORTH_OK) { fprintf(stderr,"Not enough arguments for P\n"); stack->error++; return PLUMBER_NOTOK; } n = (int)sporth_stack_pop_float(stack); if(n < 16) sporth_stack_push_float(stack, pd->p[n]); else sporth_stack_push_float(stack, 0); break; case PLUMBER_INIT: n = (int)sporth_stack_pop_float(stack); if(n < 16) sporth_stack_push_float(stack, pd->p[n]); else sporth_stack_push_float(stack, 0); break; case PLUMBER_COMPUTE: n = (int)sporth_stack_pop_float(stack); if(n < 16) sporth_stack_push_float(stack, pd->p[n]); else sporth_stack_push_float(stack, 0); break; case PLUMBER_DESTROY: break; default: fprintf(stderr, "switch: unknown mode!\n"); break; } return PLUMBER_OK; }
int sporth_set(sporth_stack *stack, void *ud) { plumber_data *pd = ud; char *ftname; SPFLOAT **var; SPFLOAT val; switch(pd->mode){ case PLUMBER_CREATE: var = malloc(sizeof(SPFLOAT *)); plumber_add_ugen(pd, SPORTH_SET, var); if(sporth_check_args(stack, "fs") != SPORTH_OK) { fprintf(stderr,"Not enough arguments for get\n"); return PLUMBER_NOTOK; } ftname = sporth_stack_pop_string(stack); val = sporth_stack_pop_float(stack); if(plumber_ftmap_search_userdata(pd, ftname, (void **)var) == PLUMBER_NOTOK) { fprintf(stderr, "set: could not find table '%s'\n", ftname); stack->error++; return PLUMBER_NOTOK; } **var = val; break; case PLUMBER_INIT: var = pd->last->ud; sporth_stack_pop_string(stack); val = sporth_stack_pop_float(stack); **var = val; break; case PLUMBER_COMPUTE: var = pd->last->ud; val = sporth_stack_pop_float(stack); **var = val; break; case PLUMBER_DESTROY: var = pd->last->ud; free(var); break; default: fprintf(stderr,"Error: Unknown mode!"); break; } return PLUMBER_OK; }
int sporth_noise(sporth_stack *stack, void *ud) { plumber_data *pd = ud; SPFLOAT gain; SPFLOAT out; sp_noise *data; switch(pd->mode){ case PLUMBER_CREATE: sp_noise_create(&data); plumber_add_module(pd, SPORTH_NOISE, sizeof(sp_noise), data); break; case PLUMBER_INIT: if(sporth_check_args(stack, "f") != SPORTH_OK) { fprintf(stderr, "Not enough arguments for noise\n"); stack->error++; return PLUMBER_NOTOK; } data = pd->last->ud; gain = sporth_stack_pop_float(stack); if(sp_noise_init(pd->sp, data) == SP_NOT_OK) { stack->error++; return PLUMBER_NOTOK; } sporth_stack_push_float(stack, 0); break; case PLUMBER_COMPUTE: if(sporth_check_args(stack, "f") != SPORTH_OK) { fprintf(stderr, "Not enough arguments for noise\n"); stack->error++; return PLUMBER_NOTOK; } gain = sporth_stack_pop_float(stack); data = pd->last->ud; data->gain = gain; sp_noise_compute(pd->sp, data, NULL, &out); sporth_stack_push_float(stack, out); break; case PLUMBER_DESTROY: data = pd->last->ud; sp_noise_destroy(&data); break; default: printf("Error: Unknown mode!"); break; } return PLUMBER_NOTOK; }
void process(sp_data *sp, void *ud) { plumber_data *pd = ud; plumber_compute(pd, PLUMBER_COMPUTE); SPFLOAT out; sp->out[0] = sporth_stack_pop_float(&pd->sporth.stack); }
static void process(sp_data *sp, void *udp) { UserData *ud = udp; plumber_data *pd = &ud->pd; plumber_compute(pd, PLUMBER_COMPUTE); sp->out[0] = sporth_stack_pop_float(&pd->sporth.stack); }
void process(AUAudioFrameCount frameCount, AUAudioFrameCount bufferOffset) override { if (!started) { outBufferListPtr->mBuffers[0] = inBufferListPtr->mBuffers[0]; outBufferListPtr->mBuffers[1] = inBufferListPtr->mBuffers[1]; return; } for (int frameIndex = 0; frameIndex < frameCount; ++frameIndex) { int frameOffset = int(frameIndex + bufferOffset); for (int channel = 0; channel < channels; ++channel) { float *in = (float *)inBufferListPtr->mBuffers[channel].mData + frameOffset; if (channel < 2) { pd.p[channel+14] = *in; } } for (int i = 0; i < 14; i++) { pd.p[i] = parameters[i]; } plumber_compute(&pd, PLUMBER_COMPUTE); for (int channel = 0; channel < channels; ++channel) { float *out = (float *)outBufferListPtr->mBuffers[channel].mData + frameOffset; *out = sporth_stack_pop_float(&pd.sporth.stack); } for (int i = 0; i < 14; i++) { parameters[i] = pd.p[i]; } } }
static void process(sp_data *sp, void *udata){ UserData *ud = udata; plumber_data *pd = &ud->pd; int rc; if(ud->counter == 0) { struct stat attrib; stat(pd->filename, &attrib); if(attrib.st_mtime != ud->ltime) { plumber_recompile(pd); ud->ltime = attrib.st_mtime; } } rc = plumber_compute(pd, PLUMBER_COMPUTE); SPFLOAT out = 0; int chan; for (chan = 0; chan < pd->nchan; chan++) { if(rc == PLUMBER_OK) { out = sporth_stack_pop_float(&pd->sporth.stack); } sp->out[chan] = out; } ud->counter++; ud->counter %= 4096; }
void process(AUAudioFrameCount frameCount, AUAudioFrameCount bufferOffset) override { // For each sample. for (int frameIndex = 0; frameIndex < frameCount; ++frameIndex) { int frameOffset = int(frameIndex + bufferOffset); pd.p[0] = internalTrigger; pd.p[1] = internalTrigger; for (int i = 0; i < 10; i++) { pd.p[i+2] = parameters[i]; } if (started) { plumber_compute(&pd, PLUMBER_COMPUTE); } for (int channel = 0; channel < channels; ++channel) { float *out = (float *)outBufferListPtr->mBuffers[channel].mData + frameOffset; if (started) { *out = sporth_stack_pop_float(&pd.sporth.stack); } else { *out = 0; } } } if (internalTrigger == 1) { internalTrigger = 0; } }
int sporth_metro(sporth_stack *stack, void *ud) { DSP_data *data; int i; jwjw_data *pd = (jwjw_data *) ud; switch(pd->mode){ case PLUMBER_CREATE: fdsp_create(pd, &data); jwjw_add_ugen(pd, SPORTH_METRO, data); for(i = 0; i < data->nargs; i++) { *data->argtbl[i] = (FAUSTFLOAT) sporth_stack_pop_float(stack); } sporth_stack_push_float(stack, 0); break; case PLUMBER_INIT: data = (DSP_data *) pd->last->ud; for(i = 0; i < data->nargs; i++) { *data->argtbl[i] = (FAUSTFLOAT) sporth_stack_pop_float(stack); } sporth_stack_push_float(stack, 0); break; case PLUMBER_COMPUTE: data = (DSP_data *) pd->last->ud; for(i = 0; i < data->noutputs; i++) { data->out_tbl[i] = &pd->reg[i]; } for(i = data->nargs; i > 0; i--) { *data->argtbl[i - 1] = (FAUSTFLOAT) sporth_stack_pop_float(stack); } data->s->compute(1, data->in_tbl, data->out_tbl); sporth_stack_push_float(stack, (JWFLOAT)*data->out_tbl[0]); break; case PLUMBER_DESTROY: data = (DSP_data *) pd->last->ud; fdsp_destroy(&data); break; default: fprintf(stderr,"Error: Unknown mode!"); break; } return PLUMBER_OK; }