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_ref(sporth_stack *stack, void *ud) { plumber_data *pd = ud; char *str; switch(pd->mode) { case PLUMBER_CREATE: plumber_add_ugen(pd, SPORTH_REF, NULL); if(sporth_check_args(stack, "s") != SPORTH_OK) { stack->error++; fprintf(stderr, "ref: Invalid arguments."); return PLUMBER_NOTOK; } sporth_stack_pop_string(stack); break; case PLUMBER_INIT: str = sporth_stack_pop_string(stack); plumber_ftmap_delete(pd, 0); /* get reference of the *next* pipe in the plumbing */ plumber_ftmap_add_userdata(pd, str, pd->next->ud); plumber_ftmap_delete(pd, 1); break; case PLUMBER_COMPUTE: break; case PLUMBER_DESTROY: break; } return PLUMBER_OK; }
int sporth_in(sporth_stack *stack, void *ud) { plumber_data *pd = ud; SPFLOAT out; sp_in *data; switch(pd->mode){ case PLUMBER_CREATE: sp_in_create(&data); plumber_add_ugen(pd, SPORTH_IN, data); break; case PLUMBER_INIT: data = pd->last->ud; sp_in_init(pd->sp, data); sporth_stack_push_float(stack, 0); break; case PLUMBER_COMPUTE: data = pd->last->ud; sp_in_compute(pd->sp, data, NULL, &out); sporth_stack_push_float(stack, out); break; case PLUMBER_DESTROY: data = pd->last->ud; sp_in_destroy(&data); break; default: printf("Error: Unknown mode!"); 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_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_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)); if(sporth_check_args(stack, "f") != SPORTH_OK) { fprintf(stderr,"Not enough arguments for aux (f)unction\n"); stack->error++; return PLUMBER_NOTOK; } plumber_add_ugen(pd, SPORTH_F, fd); break; case PLUMBER_INIT: #ifdef DEBUG_MODE fprintf(stderr, "aux (f)unction: initialising\n"); #endif 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_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_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_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_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_maygate(sporth_stack *stack, void *ud) { plumber_data *pd = ud; SPFLOAT trig; SPFLOAT out; SPFLOAT prob; sp_maygate *maygate; switch(pd->mode) { case PLUMBER_CREATE: #ifdef DEBUG_MODE fprintf(stderr, "maygate: Creating\n"); #endif sp_maygate_create(&maygate); plumber_add_ugen(pd, SPORTH_MAYGATE, maygate); if(sporth_check_args(stack, "ff") != SPORTH_OK) { fprintf(stderr,"Not enough arguments for maygate\n"); stack->error++; return PLUMBER_NOTOK; } prob = sporth_stack_pop_float(stack); trig = sporth_stack_pop_float(stack); sporth_stack_push_float(stack, 0); break; case PLUMBER_INIT: #ifdef DEBUG_MODE fprintf(stderr, "maygate: Initialising\n"); #endif prob = sporth_stack_pop_float(stack); trig = sporth_stack_pop_float(stack); maygate = pd->last->ud; sp_maygate_init(pd->sp, maygate); maygate->mode = 0; sporth_stack_push_float(stack, 0); break; case PLUMBER_COMPUTE: prob = sporth_stack_pop_float(stack); trig = sporth_stack_pop_float(stack); maygate = pd->last->ud; maygate->prob = prob; sp_maygate_compute(pd->sp, maygate, &trig, &out); sporth_stack_push_float(stack, out); break; case PLUMBER_DESTROY: maygate = pd->last->ud; sp_maygate_destroy(&maygate); break; default: fprintf(stderr, "maygate: Unknown mode!\n"); 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_pdhalf(sporth_stack *stack, void *ud) { plumber_data *pd = ud; SPFLOAT sig; SPFLOAT out; SPFLOAT amount; sp_pdhalf *pdhalf; switch(pd->mode) { case PLUMBER_CREATE: #ifdef DEBUG_MODE fprintf(stderr, "pdhalf: Creating\n"); #endif sp_pdhalf_create(&pdhalf); plumber_add_ugen(pd, SPORTH_PDHALF, pdhalf); if(sporth_check_args(stack, "ff") != SPORTH_OK) { fprintf(stderr,"Not enough arguments for pdhalf\n"); stack->error++; return PLUMBER_NOTOK; } amount = sporth_stack_pop_float(stack); sig = sporth_stack_pop_float(stack); sporth_stack_push_float(stack, 0); break; case PLUMBER_INIT: #ifdef DEBUG_MODE fprintf(stderr, "pdhalf: Initialising\n"); #endif amount = sporth_stack_pop_float(stack); sig = sporth_stack_pop_float(stack); pdhalf = pd->last->ud; sp_pdhalf_init(pd->sp, pdhalf); sporth_stack_push_float(stack, 0); break; case PLUMBER_COMPUTE: amount = sporth_stack_pop_float(stack); sig = sporth_stack_pop_float(stack); pdhalf = pd->last->ud; pdhalf->amount = amount; sp_pdhalf_compute(pd->sp, pdhalf, &sig, &out); sporth_stack_push_float(stack, out); break; case PLUMBER_DESTROY: pdhalf = pd->last->ud; sp_pdhalf_destroy(&pdhalf); break; default: fprintf(stderr, "pdhalf: Unknown mode!\n"); break; } return PLUMBER_OK; }
int sporth_blsaw(sporth_stack *stack, void *ud) { plumber_data *pd = ud; SPFLOAT out; SPFLOAT freq; SPFLOAT amp; sp_blsaw *blsaw; switch(pd->mode) { case PLUMBER_CREATE: #ifdef DEBUG_MODE fprintf(stderr, "blsaw: Creating\n"); #endif sp_blsaw_create(&blsaw); plumber_add_ugen(pd, SPORTH_SAW, blsaw); if(sporth_check_args(stack, "ff") != SPORTH_OK) { fprintf(stderr,"Not enough arguments for blsaw\n"); stack->error++; return PLUMBER_NOTOK; } amp = sporth_stack_pop_float(stack); freq = sporth_stack_pop_float(stack); sporth_stack_push_float(stack, 0); break; case PLUMBER_INIT: #ifdef DEBUG_MODE fprintf(stderr, "blsaw: Initialising\n"); #endif amp = sporth_stack_pop_float(stack); freq = sporth_stack_pop_float(stack); blsaw = pd->last->ud; sp_blsaw_init(pd->sp, blsaw); sporth_stack_push_float(stack, 0); break; case PLUMBER_COMPUTE: amp = sporth_stack_pop_float(stack); freq = sporth_stack_pop_float(stack); blsaw = pd->last->ud; *blsaw->freq = freq; *blsaw->amp = amp; sp_blsaw_compute(pd->sp, blsaw, NULL, &out); sporth_stack_push_float(stack, out); break; case PLUMBER_DESTROY: blsaw = pd->last->ud; sp_blsaw_destroy(&blsaw); break; default: fprintf(stderr, "blsaw: Unknown mode!\n"); break; } return PLUMBER_OK; }
int sporth_clip(sporth_stack *stack, void *ud) { plumber_data *pd = ud; SPFLOAT in; SPFLOAT out; SPFLOAT lim; sp_clip *clip; switch(pd->mode) { case PLUMBER_CREATE: #ifdef DEBUG_MODE plumber_print(pd, "clip: Creating\n"); #endif sp_clip_create(&clip); plumber_add_ugen(pd, SPORTH_CLIP, clip); if(sporth_check_args(stack, "ff") != SPORTH_OK) { plumber_print(pd,"Not enough arguments for clip\n"); stack->error++; return PLUMBER_NOTOK; } lim = sporth_stack_pop_float(stack); in = sporth_stack_pop_float(stack); sporth_stack_push_float(stack, 0); break; case PLUMBER_INIT: #ifdef DEBUG_MODE plumber_print(pd, "clip: Initialising\n"); #endif lim = sporth_stack_pop_float(stack); in = sporth_stack_pop_float(stack); clip = pd->last->ud; sp_clip_init(pd->sp, clip); sporth_stack_push_float(stack, 0); break; case PLUMBER_COMPUTE: lim = sporth_stack_pop_float(stack); in = sporth_stack_pop_float(stack); clip = pd->last->ud; clip->lim = lim; sp_clip_compute(pd->sp, clip, &in, &out); sporth_stack_push_float(stack, out); break; case PLUMBER_DESTROY: clip = pd->last->ud; sp_clip_destroy(&clip); break; default: plumber_print(pd, "clip: Unknown mode!\n"); break; } return PLUMBER_OK; }
int sporth_atone(sporth_stack *stack, void *ud) { plumber_data *pd = ud; SPFLOAT in; SPFLOAT out; SPFLOAT hp; sp_atone *atone; switch(pd->mode) { case PLUMBER_CREATE: #ifdef DEBUG_MODE fprintf(stderr, "atone: Creating\n"); #endif sp_atone_create(&atone); plumber_add_ugen(pd, SPORTH_ATONE, atone); if(sporth_check_args(stack, "f") != SPORTH_OK) { fprintf(stderr,"Not enough arguments for atone\n"); stack->error++; return PLUMBER_NOTOK; } hp = sporth_stack_pop_float(stack); in = sporth_stack_pop_float(stack); sporth_stack_push_float(stack, 0); break; case PLUMBER_INIT: #ifdef DEBUG_MODE fprintf(stderr, "atone: Initialising\n"); #endif hp = sporth_stack_pop_float(stack); in = sporth_stack_pop_float(stack); atone = pd->last->ud; sp_atone_init(pd->sp, atone); sporth_stack_push_float(stack, 0); break; case PLUMBER_COMPUTE: hp = sporth_stack_pop_float(stack); in = sporth_stack_pop_float(stack); atone = pd->last->ud; atone->hp = hp; sp_atone_compute(pd->sp, atone, &in, &out); sporth_stack_push_float(stack, out); break; case PLUMBER_DESTROY: atone = pd->last->ud; sp_atone_destroy(&atone); break; default: fprintf(stderr, "atone: Uknown mode!\n"); break; } return PLUMBER_OK; }
int sporth_phasor(sporth_stack *stack, void *ud) { plumber_data *pd = ud; SPFLOAT out; SPFLOAT iphs; SPFLOAT freq; sp_phasor *phasor; switch(pd->mode) { case PLUMBER_CREATE: #ifdef DEBUG_MODE fprintf(stderr, "phasor: Creating\n"); #endif sp_phasor_create(&phasor); plumber_add_ugen(pd, SPORTH_PHASOR, phasor); if(sporth_check_args(stack, "ff") != SPORTH_OK) { fprintf(stderr,"Not enough arguments for phasor\n"); stack->error++; return PLUMBER_NOTOK; } iphs = sporth_stack_pop_float(stack); freq = sporth_stack_pop_float(stack); sporth_stack_push_float(stack, 0); break; case PLUMBER_INIT: #ifdef DEBUG_MODE fprintf(stderr, "phasor: Initialising\n"); #endif iphs = sporth_stack_pop_float(stack); freq = sporth_stack_pop_float(stack); phasor = pd->last->ud; sp_phasor_init(pd->sp, phasor, iphs); sporth_stack_push_float(stack, 0); break; case PLUMBER_COMPUTE: iphs = sporth_stack_pop_float(stack); freq = sporth_stack_pop_float(stack); phasor = pd->last->ud; phasor->freq = freq; sp_phasor_compute(pd->sp, phasor, NULL, &out); sporth_stack_push_float(stack, out); break; case PLUMBER_DESTROY: phasor = pd->last->ud; sp_phasor_destroy(&phasor); break; default: fprintf(stderr, "phasor: Unknown mode!\n"); break; } return PLUMBER_OK; }
int sporth_switch(sporth_stack *stack, void *ud) { plumber_data *pd = ud; SPFLOAT trig; SPFLOAT input_1; SPFLOAT input_2; SPFLOAT out; sp_switch *sw; switch(pd->mode) { case PLUMBER_CREATE: #ifdef DEBUG_MODE plumber_print(pd, "switch: creating\n"); #endif sp_switch_create(&sw); plumber_add_ugen(pd, SPORTH_SWITCH, sw); break; case PLUMBER_INIT: #ifdef DEBUG_MODE plumber_print(pd, "switch: initialising\n"); #endif if(sporth_check_args(stack, "fff") != SPORTH_OK) { plumber_print(pd,"Not enough arguments for switch\n"); stack->error++; return PLUMBER_NOTOK; } trig = sporth_stack_pop_float(stack); input_1 = sporth_stack_pop_float(stack); input_2 = sporth_stack_pop_float(stack); sw = pd->last->ud; sp_switch_init(pd->sp, sw); sporth_stack_push_float(stack, 0); break; case PLUMBER_COMPUTE: input_2 = sporth_stack_pop_float(stack); input_1 = sporth_stack_pop_float(stack); trig = sporth_stack_pop_float(stack); sw = pd->last->ud; sp_switch_compute(pd->sp, sw, &trig, &input_1, &input_2, &out); sporth_stack_push_float(stack, out); break; case PLUMBER_DESTROY: sw = pd->last->ud; sp_switch_destroy(&sw); break; default: plumber_print(pd, "switch: unknown mode!\n"); break; } return PLUMBER_OK; }
int sporth_sdelay(sporth_stack *stack, void *ud) { plumber_data *pd = ud; SPFLOAT input; SPFLOAT out; SPFLOAT size; sp_sdelay *sdelay; switch(pd->mode) { case PLUMBER_CREATE: #ifdef DEBUG_MODE plumber_print(pd, "sdelay: Creating\n"); #endif sp_sdelay_create(&sdelay); plumber_add_ugen(pd, SPORTH_SDELAY, sdelay); if(sporth_check_args(stack, "ff") != SPORTH_OK) { plumber_print(pd,"Not enough arguments for sdelay\n"); stack->error++; return PLUMBER_NOTOK; } size = 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, "sdelay: Initialising\n"); #endif size = sporth_stack_pop_float(stack); input = sporth_stack_pop_float(stack); sdelay = pd->last->ud; sp_sdelay_init(pd->sp, sdelay, size); sporth_stack_push_float(stack, 0); break; case PLUMBER_COMPUTE: size = sporth_stack_pop_float(stack); input = sporth_stack_pop_float(stack); sdelay = pd->last->ud; sp_sdelay_compute(pd->sp, sdelay, &input, &out); sporth_stack_push_float(stack, out); break; case PLUMBER_DESTROY: sdelay = pd->last->ud; sp_sdelay_destroy(&sdelay); break; default: plumber_print(pd, "sdelay: 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_fexec(sporth_stack *stack, void *ud) { plumber_data *pd = ud; sporth_fload_d *fexec; sporth_fload_d *fload; switch(pd->mode) { case PLUMBER_CREATE: #ifdef DEBUG_MODE fprintf(stderr, "fexec: creating\n"); #endif fexec = malloc(sizeof(sporth_fload_d)); plumber_add_ugen(pd, SPORTH_FEXEC, fexec); if(sporth_check_args(stack, "s") != SPORTH_OK) { fprintf(stderr,"Not enough arguments for fclose\n"); stack->error++; return PLUMBER_NOTOK; } fexec->name = sporth_stack_pop_string(stack); if(plumber_ftmap_search_userdata(pd, fexec->name, (void *)&fload) == PLUMBER_NOTOK) { stack->error++; return PLUMBER_NOTOK; } fexec->fun = fload->fun; fexec->fun(pd, stack, &fexec->ud); break; case PLUMBER_INIT: #ifdef DEBUG_MODE fprintf(stderr, "fexec: initialising\n"); #endif fexec = pd->last->ud; fexec->name = sporth_stack_pop_string(stack); fexec->fun(pd, stack, &fexec->ud); break; case PLUMBER_COMPUTE: fexec = pd->last->ud; fexec->fun(pd, stack, &fexec->ud); break; case PLUMBER_DESTROY: fexec = pd->last->ud; fexec->fun(pd, stack, &fexec->ud); free(fexec); break; default: fprintf(stderr, "fexec: unknown mode!\n"); 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_fclose(sporth_stack *stack, void *ud) { plumber_data *pd = ud; sporth_fclose_d *fclose; sporth_fload_d *fload; switch(pd->mode) { case PLUMBER_CREATE: #ifdef DEBUG_MODE fprintf(stderr, "fclose: creating\n"); #endif fclose = malloc(sizeof(sporth_fclose_d)); plumber_add_ugen(pd, SPORTH_FCLOSE, fclose); if(sporth_check_args(stack, "s") != SPORTH_OK) { fprintf(stderr,"Not enough arguments for fclose\n"); stack->error++; return PLUMBER_NOTOK; } fclose->name = sporth_stack_pop_string(stack); if(plumber_ftmap_search_userdata(pd, fclose->name, (void *)&fload) == PLUMBER_NOTOK) { stack->error++; return PLUMBER_NOTOK; } fclose->handle = fload->handle; break; case PLUMBER_INIT: #ifdef DEBUG_MODE fprintf(stderr, "fclose: initialising\n"); #endif fclose = pd->last->ud; fclose->name = sporth_stack_pop_string(stack); break; case PLUMBER_COMPUTE: break; case PLUMBER_DESTROY: #ifdef DEBUG_MODE fprintf(stderr, "fclose: destroying\n"); #endif fclose= pd->last->ud; dlclose(fclose->handle); free(fclose); break; default: fprintf(stderr, "fclose: unknown mode!\n"); break; } return PLUMBER_OK; }
int sporth_port(sporth_stack *stack, void *ud) { plumber_data *pd = ud; SPFLOAT htime; SPFLOAT in = 0, out = 0; sp_port *data; switch(pd->mode){ case PLUMBER_CREATE: sp_port_create(&data); plumber_add_ugen(pd, SPORTH_PORT, data); if(sporth_check_args(stack, "ff") != SPORTH_OK) { fprintf(stderr,"Not enough arguments for port\n"); stack->error++; return PLUMBER_NOTOK; } htime = sporth_stack_pop_float(stack); in = sporth_stack_pop_float(stack); sporth_stack_push_float(stack, 0); break; case PLUMBER_INIT: data = pd->last->ud; htime = sporth_stack_pop_float(stack); in = sporth_stack_pop_float(stack); sp_port_init(pd->sp, data, htime); sporth_stack_push_float(stack, 0); break; case PLUMBER_COMPUTE: data = pd->last->ud; htime = sporth_stack_pop_float(stack); in = sporth_stack_pop_float(stack); data->htime = htime; sp_port_compute(pd->sp, data, &in, &out); sporth_stack_push_float(stack, out); break; case PLUMBER_DESTROY: data = pd->last->ud; sp_port_destroy(&data); break; default: fprintf(stderr,"Error: Unknown mode!"); break; } return PLUMBER_OK; }
int sporth_fload(sporth_stack *stack, void *ud) { plumber_data *pd = ud; sporth_fload_d *fload; switch(pd->mode) { case PLUMBER_CREATE: #ifdef DEBUG_MODE fprintf(stderr, "fload: creating\n"); #endif fload = malloc(sizeof(sporth_fload_d)); plumber_add_ugen(pd, SPORTH_FLOAD, fload); if(sporth_check_args(stack, "ss") != SPORTH_OK) { fprintf(stderr,"Not enough arguments for fload\n"); stack->error++; return PLUMBER_NOTOK; } fload->filename= sporth_stack_pop_string(stack); fload->name = sporth_stack_pop_string(stack); fload->handle = dlopen(fload->filename, RTLD_NOW); if(fload->handle == NULL) { fprintf(stderr, "Error loading %s: %s\n", fload->name, dlerror()); return PLUMBER_NOTOK; } fload->getter = dlsym(fload->handle, "sporth_return_ugen"); fload->fun = fload->getter(); plumber_ftmap_add_userdata(pd, fload->name, (void *)fload); break; case PLUMBER_INIT: #ifdef DEBUG_MODE fprintf(stderr, "fload: initialising\n"); #endif fload = pd->last->ud; fload->filename= sporth_stack_pop_string(stack); fload->name = sporth_stack_pop_string(stack); break; case PLUMBER_COMPUTE: break; case PLUMBER_DESTROY: break; default: fprintf(stderr, "fload: unknown mode!\n"); break; } 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_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_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_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; }