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_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 sp_gen_line(sp_data *sp, sp_ftbl *ft, const char *argstring)
{
uint16_t i, n = 0, seglen;
SPFLOAT incr, amp = 0;
SPFLOAT x1, x2, y1, y2;
sp_ftbl *args;
sp_ftbl_create(sp, &args, 1);
sp_gen_vals(sp, args, argstring);
if((args->size % 2) == 1 || args->size == 1) {
fprintf(stderr, "Error: not enough arguments for gen_line.\n");
sp_ftbl_destroy(&args);
return SP_NOT_OK;
} else if(args->size == 2) {
for(i = 0; i < ft->size; i++) {
ft->tbl[i] = args->tbl[1];
}
return SP_OK;
}
x1 = args->tbl[0];
y1 = args->tbl[1];
for(i = 2; i < args->size; i += 2) {
x2 = args->tbl[i];
y2 = args->tbl[i + 1];
if(x2 < x1) {
fprintf(stderr, "Error: x coordiates must be sequential!\n");
break;
}
seglen = (x2 - x1);
incr = (SPFLOAT)(y2 - y1) / (seglen - 1);
amp = y1;
while(seglen != 0){
if(n < ft->size) {
ft->tbl[n] = amp;
amp += incr;
seglen--;
n++;
} else {
break;
}
}
y1 = y2;
x1 = x2;
}
sp_ftbl_destroy(&args);
return SP_OK;
}
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;
}
void samp_create(sp_data *sp, samp_data *sd,
size_t size, char *file, char *dtrig, SPFLOAT tempo, SPFLOAT delay) {
int i;
SPFLOAT tscale = 60.0 / tempo;
sp_ftbl_create(sp, &sd->delta, 1);
sp_gen_vals(sp, sd->delta, dtrig);
sp_dtrig_create(&sd->dt);
for(i = 0; i < sd->delta->size; i++) {
sd->delta->tbl[i] *= tscale;
}
sp_dtrig_init(sp, sd->dt, sd->delta);
sd->dt->delay = delay * tscale;
sp_ftbl_create(sp, &sd->ft, 5574);
sp_gen_file(sp, sd->ft, file);
sp_tevent_create(&sd->te);
sp_tevent_init(sp, sd->te, samp_reinit, samp_compute, sd);
sd->pos = 0;
}
void WavePlayBack(uint32_t AudioFreq)
{
/* note: these mallocs are NOT freed at the moment */
sp_create(&sp);
sp->sr = AudioFreq;
sp_ftbl_create(sp, &ft, 8192);
sp_gen_sine(sp, ft);
sp_osc_create(&osc);
sp_osc_init(sp, osc, ft, 0);
osc->freq = 0.2f;
osc->amp = 1.f;
uint32_t i;
for(i = 0; i < NOSCS; i++) {
sp_fosc_create(&fosc[i]);
sp_fosc_init(sp, fosc[i], ft);
fosc[i]->freq = sp_midi2cps(scale[i]);
fosc[i]->amp = 0.1f;
}
for(i = 0; i < MY_BUFSIZE; i++) {
buf0[i] = 0;
buf1[i] = 0;
}
sp_revsc_create(&revsc);
sp_revsc_init(sp, revsc);
/* Initialize wave player (Codec, DMA, I2C) */
WavePlayerInit(AudioFreq);
nextbuf = 1;
compute_buffer(buf1, MY_BUFSIZE);
Audio_MAL_Play((uint32_t)buf0, MY_BUFSIZE / 2);
EVAL_AUDIO_Mute(AUDIO_MUTE_ON);
while(1) {
while(nextbuf == 1);
if(please_play == 0) {
EVAL_AUDIO_Mute(AUDIO_MUTE_OFF);
please_play = 1;
}
compute_buffer(buf0, MY_BUFSIZE);
while(nextbuf == 0);
compute_buffer(buf1, MY_BUFSIZE);
};
}
int t_delay(sp_test *tst, sp_data *sp, const char *hash)
{
uint32_t n;
int fail = 0;
SPFLOAT osc = 0, delay = 0, met = 0, tenv = 0;
UserData ud;
sp_delay_create(&ud.delay);
sp_osc_create(&ud.osc);
sp_ftbl_create(sp, &ud.ft, 2048);
sp_metro_create(&ud.met);
sp_tenv_create(&ud.tenv);
sp_delay_init(sp, ud.delay, 0.75 * 0.5);
ud.delay->feedback = 0.5;
sp_gen_sine(sp, ud.ft);
sp_osc_init(sp, ud.osc, ud.ft, 0);
ud.osc->amp = 0.5;
sp_metro_init(sp, ud.met);
ud.met->freq = 1;
sp_tenv_init(sp, ud.tenv);
ud.tenv->atk = 0.005;
ud.tenv->hold = 0.1;
ud.tenv->rel = 0.1;
for(n = 0; n < tst->size; n++) {
osc = 0, delay = 0, met = 0, tenv = 0;
sp_metro_compute(sp, ud.met, NULL, &met);
sp_tenv_compute(sp, ud.tenv, &met, &tenv);
if(met) {
ud.osc->freq = 100 + sp_rand(sp) % 500;
}
sp_osc_compute(sp, ud.osc, NULL, &osc);
osc *= tenv;
sp_delay_compute(sp, ud.delay, &osc, &delay);
sp_test_add_sample(tst, osc + delay);
}
if(sp_test_compare(tst, hash) == SP_NOT_OK) {
printf("Generated hash %s does not match reference hash %s\n",
tst->md5string, hash);
fail = 1;
}
if(fail) return SP_NOT_OK;
else return SP_OK;
}
int t_pitchamdf(sp_test *tst, sp_data *sp, const char *hash)
{
uint32_t n;
int fail = 0;
SPFLOAT freq = 0, amp = 0, blsaw = 0, randh = 0, osc = 0;
sp_srand(sp, 1234567);
UserData ud;
sp_pitchamdf_create(&ud.pitchamdf);
sp_osc_create(&ud.osc);
sp_ftbl_create(sp, &ud.ft, 2048);
sp_blsaw_create(&ud.blsaw);
sp_randh_create(&ud.randh);
sp_pitchamdf_init(sp, ud.pitchamdf, 200, 500);
sp_randh_init(sp, ud.randh);
ud.randh->max = 500;
ud.randh->min = 200;
ud.randh->freq = 6;
sp_blsaw_init(sp, ud.blsaw);
sp_gen_sine(sp, ud.ft);
sp_osc_init(sp, ud.osc, ud.ft, 0);
for(n = 0; n < tst->size; n++) {
freq = 0, amp = 0, blsaw = 0, randh = 0, osc = 0;
sp_randh_compute(sp, ud.randh, NULL, &randh);
*ud.blsaw->freq = randh;
sp_blsaw_compute(sp, ud.blsaw, NULL, &blsaw);
sp_pitchamdf_compute(sp, ud.pitchamdf, &blsaw, &freq, &);
ud.osc->freq = freq;
sp_osc_compute(sp, ud.osc, NULL, &osc);
sp_test_add_sample(tst, osc);
}
fail = sp_test_verify(tst, hash);
sp_blsaw_destroy(&ud.blsaw);
sp_randh_destroy(&ud.randh);
sp_pitchamdf_destroy(&ud.pitchamdf);
sp_ftbl_destroy(&ud.ft);
sp_osc_destroy(&ud.osc);
if(fail) return SP_NOT_OK;
else return SP_OK;
}
int main() {
srand(time(NULL));
int i;
UserData ud;
sp_data *sp;
sp_create(&sp);
sp_ftbl_create(sp, &ud.ft, 4096);
for(i = 0; i < 3; i++) sp_osc_create(&ud.osc[i]);
sp_lpf18_create(&ud.lpf);
sp_osc_create(&ud.lfo);
sp_ftbl_create(sp, &ud.sine_ft, 4096);
sp_gen_sine(sp, ud.sine_ft);
sp_gen_line(sp, ud.ft, "0 1 4096 -1");
sp_osc_init(sp, ud.osc[0], ud.ft);
ud.osc[0]->freq = sp_midi2cps(40 - 0.05);
sp_osc_init(sp, ud.osc[1], ud.ft);
ud.osc[1]->freq = sp_midi2cps(40 - 12);
sp_osc_init(sp, ud.osc[2], ud.ft);
ud.osc[2]->freq = sp_midi2cps(40 + 0.05);
sp_lpf18_init(sp, ud.lpf);
sp_osc_init(sp, ud.lfo, ud.sine_ft);
ud.lfo->freq = 0.4;
sp->len = 44100 * 5;
sp_process(sp, &ud, write_osc);
sp_ftbl_destroy(&ud.ft);
for(i = 0; i < 3; i++) sp_osc_destroy(&ud.osc[i]);
sp_lpf18_destroy(&ud.lpf);
sp_osc_destroy(&ud.lfo);
sp_ftbl_destroy(&ud.sine_ft);
sp_destroy(&sp);
return 0;
}
int main()
{
UserData ud;
/* allocate and initialize */
sp_create(&ud.sp);
plumber_register(&ud.pd);
plumber_init(&ud.pd);
/* create an ftable with a size 1, which will be expanded with gen_vals */
sp_ftbl_create(ud.sp, &ud.seq, 1);
/* Gen_vals will create a table from a string of numbers */
sp_gen_vals(ud.sp, ud.seq, "60 63 67 72");
/* Sporth code to be parsed, using a ftable generated in c called 'seq' */
char *str =
"0.1 dmetro "
"0 'seq' tseq "
"0.01 port mtof "
"0.5 1 1 1 fm";
/* Tell plumber that that we will take care of removing the following ftables */
/* This is needed for persistant ftables that don't get cleaned for
* recompilation */
plumber_ftmap_delete(&ud.pd, 0);
/* add ftable to plumber and call it "seq" */
plumber_ftmap_add(&ud.pd, "seq", ud.seq);
/* Turn automatic deletion back "on" */
plumber_ftmap_delete(&ud.pd, 1);
/* make plumber know about the soundpipe instance */
ud.pd.sp = ud.sp;
/* parse string and allocate plumbing */
plumber_parse_string(&ud.pd, str);
/* initialize the plumbing */
plumber_compute(&ud.pd, PLUMBER_INIT);
/* run */
sp_process(ud.sp, &ud, process);
/* Cleanup */
/* Plumber will handle freeing the memory of the ftable we added */
/* no need to call sp_ftbl_destroy */
plumber_clean(&ud.pd);
sp_ftbl_destroy(&ud.seq);
sp_destroy(&ud.sp);
return 0;
}
int sporth_gen_sine(sporth_stack *stack, void *ud)
{
plumber_data *pd = ud;
int size;
sp_ftbl *ft;
char *str;
switch(pd->mode){
case PLUMBER_CREATE:
plumber_add_ugen(pd, SPORTH_GEN_SINE, NULL);
if(sporth_check_args(stack, "sf") != SPORTH_OK) {
fprintf(stderr, "Init: not enough arguments for gen_sine\n");
return PLUMBER_NOTOK;
}
size = (int)sporth_stack_pop_float(stack);
str = sporth_stack_pop_string(stack);
#ifdef DEBUG_MODE
fprintf(stderr, "Creating sine table %s of size %d\n", str, size);
#endif
sp_ftbl_create(pd->sp, &ft, size);
sp_gen_sine(pd->sp, ft);
plumber_ftmap_add(pd, str, ft);
free(str);
break;
case PLUMBER_INIT:
size = (int)sporth_stack_pop_float(stack);
str = sporth_stack_pop_string(stack);
free(str);
break;
case PLUMBER_COMPUTE:
size = (int)sporth_stack_pop_float(stack);
break;
case PLUMBER_DESTROY:
break;
default:
printf("Error: Unknown mode!");
break;
}
return PLUMBER_OK;
}
int main() {
sp_data *sp;
sp_create(&sp);
sp_ftbl *ft;
sp_ftbl_create(sp, &ft, 4096);
sp_gen_line(sp, ft, "0 -1 2048 1 4096 -1");
int i;
FILE *fp= fopen("plot.dat", "w");
for(i = 0; i < ft->size; i++) {
fprintf(fp, "%d %g\n", i, ft->tbl[i]);
}
printf("%d plot points written to plot.dat. Run write_plot.sh to see the result.\n", ft->size);
fclose(fp);
sp_ftbl_destroy(&ft);
sp_destroy(&sp);
return 0;
}
int main() {
srand(time(NULL));
udata ud;
sp_data *sp;
sp_create(&sp);
sp_ftbl_create(sp, &ud.ft, 2048);
sp_gbuzz_create(&ud.buzz);
sp_gen_sine(sp, ud.ft);
sp_gbuzz_init(sp, ud.buzz, ud.ft);
sp->len = 44100 * 5;
sp_process(sp, &ud, process);
sp_ftbl_destroy(&ud.ft);
sp_gbuzz_destroy(&ud.buzz);
sp_destroy(&sp);
return 0;
}
int main() {
srand(time(NULL));
udata ud;
sp_data *sp;
sp_create(&sp);
sp_ftbl_create(sp, &ud.ft, 4096);
sp_osc_create(&ud.osc);
sp_gen_sinesum(sp, ud.ft, "1 0 0 1");
sp_osc_init(sp, ud.osc, ud.ft);
ud.osc->freq = 500;
sp->len = 44100 * 5;
sp_process(sp, &ud, write_osc);
sp_ftbl_destroy(&ud.ft);
sp_osc_destroy(&ud.osc);
sp_destroy(&sp);
return 0;
}
int sporth_zeros(sporth_stack *stack, void *ud)
{
plumber_data *pd = ud;
int size;
sp_ftbl *ft;
const char *str;
switch(pd->mode){
case PLUMBER_CREATE:
plumber_add_ugen(pd, SPORTH_ZEROS, NULL);
if(sporth_check_args(stack, "sf") != SPORTH_OK) {
plumber_print(pd, "Init: not enough arguments for zeros\n");
return PLUMBER_NOTOK;
}
size = (int)sporth_stack_pop_float(stack);
str = sporth_stack_pop_string(stack);
#ifdef DEBUG_MODE
plumber_print(pd, "Zeros: creating table %s of size %d\n", str, size);
#endif
sp_ftbl_create(pd->sp, &ft, size);
plumber_ftmap_add(pd, str, ft);
break;
case PLUMBER_INIT:
size = (int)sporth_stack_pop_float(stack);
str = sporth_stack_pop_string(stack);
break;
case PLUMBER_COMPUTE:
size = (int)sporth_stack_pop_float(stack);
break;
case PLUMBER_DESTROY:
break;
default:
plumber_print(pd, "Error: Unknown mode!\n");
break;
}
return PLUMBER_OK;
}
int t_mode(sp_test *tst, sp_data *sp, const char *hash)
{
uint32_t n;
int fail = 0;
UserData ud;
SPFLOAT met = 0, mod = 0, nn;
modal_create(&ud.mod);
modal_init(sp, ud.mod);
sp_metro_create(&ud.met);
sp_metro_init(sp, ud.met);
ud.met->freq = 3.0;
sp_ftbl_create(sp, &ud.notes, 1);
sp_gen_vals(sp, ud.notes, "60 67 62 69 76");
sp_tseq_create(&ud.seq);
sp_tseq_init(sp, ud.seq, ud.notes);
for(n = 0; n < tst->size; n++) {
met = 0;
mod = 0;
nn = 0;
sp_metro_compute(sp, ud.met, NULL, &met);
sp_tseq_compute(sp, ud.seq, &met, &nn);
*ud.mod->freq = sp_midi2cps(nn);
modal_compute(sp, ud.mod, &met, &mod);
sp->out[0] = mod;
sp_test_add_sample(tst, sp->out[0]);
}
fail = sp_test_verify(tst, hash);
modal_destroy(&ud.mod);
sp_metro_destroy(&ud.met);
sp_ftbl_destroy(&ud.notes);
sp_tseq_destroy(&ud.seq);
if(fail) return SP_NOT_OK;
else return SP_OK;
}
int main() {
srand(time(NULL));
udata ud;
ud.counter = 0;
sp_data *sp;
sp_create(&sp);
sp_ftbl_create(sp, &ud.ft, 1024);
sp_posc3_create(&ud.posc3);
sp_gen_sine(sp, ud.ft);
sp_posc3_init(sp, ud.posc3, ud.ft);
ud.posc3->freq = 500;
sp->len = 44100 * 5;
sp_process(sp, &ud, write_posc3);
sp_ftbl_destroy(&ud.ft);
sp_posc3_destroy(&ud.posc3);
sp_destroy(&sp);
return 0;
}
int t_tseg(sp_test *tst, sp_data *sp, const char *hash)
{
uint32_t n;
int fail = 0;
sp_srand(sp, 1234567);
UserData ud;
SPFLOAT osc = 0, tseg = 0;
SPFLOAT trig = (sp->pos == 0);
sp_tseg_create(&ud.tseg);
sp_osc_create(&ud.osc);
sp_ftbl_create(sp, &ud.ft, 2048);
sp_tseg_init(sp, ud.tseg, 0.0001);
ud.tseg->end = 1.0;
ud.tseg->type = 3.0;
ud.tseg->dur = 4.0;
sp_gen_sine(sp, ud.ft);
sp_osc_init(sp, ud.osc, ud.ft, 0);
for(n = 0; n < tst->size; n++) {
osc = 0;
tseg = 0;
trig = (sp->pos == 0);
sp_tseg_compute(sp, ud.tseg, &trig, &tseg);
ud.osc->freq = 100 + (tseg * 1000);
sp_osc_compute(sp, ud.osc, NULL, &osc);
sp_test_add_sample(tst, osc);
}
fail = sp_test_verify(tst, hash);
sp_tseg_destroy(&ud.tseg);
sp_ftbl_destroy(&ud.ft);
sp_osc_destroy(&ud.osc);
if(fail) return SP_NOT_OK;
else return SP_OK;
}
int main(){
sp_data *sp;
UserData ud;
sp_create(&sp);
int tempo = 120;
sp_rpt_create(&ud.rpt);
sp_maygate_create(&ud.mg);
sp_osc_create(&ud.osc);
sp_ftbl_create(sp, &ud.ft, 4096);
sp_metro_create(&ud.mt);
sp_tenv_create(&ud.te);
sp_maygate_init(sp, ud.mg);
ud.mg->prob = 0.5;
sp_gen_sine(sp, ud.ft);
sp_osc_init(sp, ud.osc, ud.ft, 0);
sp_metro_init(sp, ud.mt);
ud.mt->freq = tempo / 60.0;
sp_rpt_init(sp, ud.rpt, 1.0);
ud.rpt->bpm = tempo;
ud.rpt->div = 8;
ud.rpt->rep = 4;
sp_tenv_init(sp, ud.te);
ud.te->atk = 0.001;
ud.te->hold = 0.1;
ud.te->rel = 0.1;
sp_process(sp, &ud, compute);
sp_tenv_destroy(&ud.te);
sp_metro_destroy(&ud.mt);
sp_ftbl_destroy(&ud.ft);
sp_osc_destroy(&ud.osc);
sp_rpt_destroy(&ud.rpt);
sp_destroy(&sp);
return 0;
}
int sp_gen_rand(sp_data *sp, sp_ftbl *ft, const char *argstring)
{
sp_ftbl *args;
sp_ftbl_create(sp, &args, 1);
sp_gen_vals(sp, args, argstring);
int n, pos = 0, i, size = 0;
for(n = 0; n < args->size; n += 2) {
size = round(ft->size * args->tbl[n + 1]);
for(i = 0; i < size; i++) {
if(pos < ft->size) {
ft->tbl[pos] = args->tbl[n];
pos++;
}
}
}
if(pos <= ft->size) {
ft->size = pos;
}
sp_ftbl_destroy(&args);
return SP_OK;
}
int t_tenv2(sp_test *tst, sp_data *sp, const char *hash)
{
uint32_t n;
int fail = 0;
sp_srand(sp, 1234567);
UserData ud;
SPFLOAT osc = 0, tenv2 = 0, tick = 0;
sp_tenv2_create(&ud.tenv2);
sp_osc_create(&ud.osc);
sp_ftbl_create(sp, &ud.ft, 2048);
sp_tenv2_init(sp, ud.tenv2);
ud.tenv2->atk = 3;
ud.tenv2->rel = 1;
sp_gen_sine(sp, ud.ft);
sp_osc_init(sp, ud.osc, ud.ft, 0);
ud.osc->amp = 0.6;
for(n = 0; n < tst->size; n++) {
osc = 0, tenv2 = 0, tick = 0;
if(sp->pos == 0 || sp->pos == sp->sr * 1) tick = 1;
sp_osc_compute(sp, ud.osc, NULL, &osc);
sp_tenv2_compute(sp, ud.tenv2, &tick, &tenv2);
sp->out[0] = osc * tenv2;
sp_test_add_sample(tst, sp->out[0]);
}
fail = sp_test_verify(tst, hash);
sp_tenv2_destroy(&ud.tenv2);
sp_ftbl_destroy(&ud.ft);
sp_osc_destroy(&ud.osc);
if(fail) return SP_NOT_OK;
else return SP_OK;
}
int main() {
srand(1234567);
UserData ud;
sp_data *sp;
sp_create(&sp);
sp_thresh_create(&ud.thresh);
sp_osc_create(&ud.osc);
sp_osc_create(&ud.lfo);
sp_tenv_create(&ud.tenv);
sp_ftbl_create(sp, &ud.ft, 2048);
sp_thresh_init(sp, ud.thresh);
ud.thresh->mode = 1;
sp_gen_sine(sp, ud.ft);
sp_osc_init(sp, ud.osc, ud.ft, 0);
sp_osc_init(sp, ud.lfo, ud.ft, 0);
ud.lfo->freq = 3;
ud.lfo->amp = 1;
sp_tenv_init(sp, ud.tenv);
ud.tenv->atk = 0.01;
ud.tenv->hold = 0.01;
ud.tenv->rel = 0.01;
sp->len = 44100 * 5;
sp_process(sp, &ud, process);
sp_thresh_destroy(&ud.thresh);
sp_ftbl_destroy(&ud.ft);
sp_osc_destroy(&ud.osc);
sp_osc_destroy(&ud.lfo);
sp_tenv_destroy(&ud.tenv);
sp_destroy(&sp);
return 0;
}
static int sporth_huion(plumber_data *pd, sporth_stack *stack, void **ud)
{
huion_d *hd;
char *str;
switch(pd->mode) {
case PLUMBER_CREATE:
fprintf(stderr, "Creating our custom gain plugin!\n");
if(sporth_check_args(stack, "s") != SPORTH_OK) {
fprintf(stderr,"Incorrect arguments for huion\n");
stack->error++;
return PLUMBER_NOTOK;
}
/* malloc and assign address to user data */
str = sporth_stack_pop_string(stack);
hd = malloc(sizeof(huion_d));
*ud = hd;
sp_ftbl_create(pd->sp, &hd->data, P_MAX);
plumber_ftmap_add(pd, str, hd->data);
huion_start(hd);
break;
case PLUMBER_INIT:
str = sporth_stack_pop_string(stack);
break;
case PLUMBER_COMPUTE:
break;
case PLUMBER_DESTROY:
hd = *ud;
huion_stop(hd);
free(hd);
break;
default:
fprintf(stderr, "Huion: unknown mode %d\n", pd->mode);
break;
}
return PLUMBER_OK;
}
int main() {
srand(1234567);
UserData ud;
sp_data *sp;
sp_create(&sp);
sp_dmetro_create(&ud.dmetro);
sp_osc_create(&ud.osc);
sp_osc_create(&ud.lfo);
sp_ftbl_create(sp, &ud.ft, 2048);
sp_tenv_create(&ud.tenv);
sp_dmetro_init(sp, ud.dmetro);
ud.dmetro->time = 0.05;
sp_gen_sine(sp, ud.ft);
sp_osc_init(sp, ud.osc, ud.ft, 0);
sp_osc_init(sp, ud.lfo, ud.ft, 0);
ud.lfo->freq = 0.3;
ud.lfo->amp = 0.5;
sp_tenv_init(sp, ud.tenv);
ud.tenv->atk = 0.001;
ud.tenv->hold = 0.03;
ud.tenv->rel = 0.001;
sp->len = 44100 * 5;
sp_process(sp, &ud, process);
sp_dmetro_destroy(&ud.dmetro);
sp_ftbl_destroy(&ud.ft);
sp_osc_destroy(&ud.osc);
sp_osc_destroy(&ud.lfo);
sp_tenv_destroy(&ud.tenv);
sp_destroy(&sp);
return 0;
}
int t_line(sp_test *tst, sp_data *sp, const char *hash)
{
sp_srand(sp, 1234567);
uint32_t n;
int fail = 0;
SPFLOAT osc = 0, line = 0;
UserData ud;
sp_line_create(&ud.line);
sp_osc_create(&ud.osc);
sp_ftbl_create(sp, &ud.ft, 2048);
sp_line_init(sp, ud.line, 100, 3, 400);
sp_gen_sine(sp, ud.ft);
sp_osc_init(sp, ud.osc, ud.ft, 0);
sp->len = 44100 * 5;
for(n = 0; n < tst->size; n++) {
sp_line_compute(sp, ud.line, NULL, &line);
ud.osc->freq = line;
sp_osc_compute(sp, ud.osc, NULL, &osc);
sp->out[0] = osc;
sp_test_add_sample(tst, sp->out[0]);
}
fail = sp_test_verify(tst, hash);
sp_line_destroy(&ud.line);
sp_ftbl_destroy(&ud.ft);
sp_osc_destroy(&ud.osc);
if(fail) return SP_NOT_OK;
else return SP_OK;
}
int main() {
srand(1234567);
UserData ud;
sp_data *sp;
sp_create(&sp);
sp_delay_create(&ud.delay);
sp_osc_create(&ud.osc);
sp_ftbl_create(sp, &ud.ft, 2048);
sp_metro_create(&ud.met);
sp_tenv_create(&ud.tenv);
sp_delay_init(sp, ud.delay, 0.75 * 0.5);
ud.delay->feedback = 0.5;
sp_gen_sine(sp, ud.ft);
sp_osc_init(sp, ud.osc, ud.ft, 0);
ud.osc->amp = 0.5;
sp_metro_init(sp, ud.met);
ud.met->freq = 1;
sp_tenv_init(sp, ud.tenv);
ud.tenv->atk = 0.005;
ud.tenv->hold = 0.1;
ud.tenv->rel = 0.1;
sp->len = 44100 * 5;
sp_process(sp, &ud, process);
sp_delay_destroy(&ud.delay);
sp_ftbl_destroy(&ud.ft);
sp_osc_destroy(&ud.osc);
sp_metro_destroy(&ud.met);
sp_tenv_destroy(&ud.tenv);
sp_destroy(&sp);
return 0;
}
/* based off of GEN 19 */
int sp_gen_composite(sp_data *sp, sp_ftbl *ft, const char *argstring)
{
SPFLOAT phs, inc, amp, dc, tpdlen = 2 * M_PI/ (SPFLOAT) ft->size;
int i, n;
sp_ftbl *args;
sp_ftbl_create(sp, &args, 1);
sp_gen_vals(sp, args, argstring);
for(n = 0; n < args->size; n += 4) {
inc = args->tbl[n] * tpdlen;
amp = args->tbl[n + 1];
phs = args->tbl[n + 2] * tpd360;
dc = args->tbl[n + 3];
for (i = 0; i <ft->size ; i++) {
ft->tbl[i] += (SPFLOAT) (sin(phs) * amp + dc);
if ((phs += inc) >= 2 * M_PI) phs -= 2 * M_PI;
}
}
sp_ftbl_destroy(&args);
return SP_OK;
}
int main() {
srand(1234567);
UserData ud;
sp_data *sp;
sp_create(&sp);
sp_foo_create(&ud.foo);
sp_osc_create(&ud.osc);
sp_ftbl_create(sp, &ud.ft, 2048);
sp_foo_init(sp, ud.foo);
sp_gen_sine(sp, ud.ft);
sp_osc_init(sp, ud.osc, ud.ft, 0);
sp->len = 44100 * 5;
sp_process(sp, &ud, process);
sp_foo_destroy(&ud.foo);
sp_ftbl_destroy(&ud.ft);
sp_osc_destroy(&ud.osc);
sp_destroy(&sp);
return 0;
}
int sporth_gen_eval(sporth_stack *stack, void *ud)
{
plumber_data *pd = ud;
plumber_data my_pd;
uint32_t size;
sp_data *sp;
sp_ftbl *ft;
char *ftname;
char *str;
uint32_t n;
switch(pd->mode){
case PLUMBER_CREATE:
plumber_add_ugen(pd, SPORTH_GEN_EVAL, NULL);
if(sporth_check_args(stack, "sfs") != SPORTH_OK) {
plumber_print(pd, "Init: not enough arguments for gen_sine\n");
return PLUMBER_NOTOK;
}
str = sporth_stack_pop_string(stack);
size = (uint32_t) sporth_stack_pop_float(stack);
ftname = sporth_stack_pop_string(stack);
sp_ftbl_create(pd->sp, &ft, size);
plumber_ftmap_add(pd, ftname, ft);
#ifdef DEBUG_MODE
plumber_print(pd, "gen_sporth: compiling file %s to table of size %d\n",
filename, size);
#endif
plumber_register(&my_pd);
plumber_init(&my_pd);
sp_create(&sp);
sp->sr = pd->sp->sr;
sp_srand(sp, pd->seed);
my_pd.sp = sp;
my_pd.sp->len = size;
if(plumber_parse_string(&my_pd, str) == PLUMBER_OK) {
plumber_compute(&my_pd, PLUMBER_INIT);
for(n = 0; n < ft->size; n++) {
plumber_compute(&my_pd, PLUMBER_COMPUTE);
ft->tbl[n] = sporth_stack_pop_float(&my_pd.sporth.stack);
}
}
plumber_clean(&my_pd);
sp_destroy(&sp);
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:
break;
default:
printf("Error: Unknown mode!");
break;
}
return PLUMBER_OK;
}
void setUpTable(float *table, UInt32 size) {
ftbl_size = size;
sp_ftbl_create(sp, &ftbl, ftbl_size);
ftbl->tbl = table;
}
