sointu/tests/test_render_samples_api.c
Veikko Sariola e0a793ea6d Reorganize the project folder structure and how go packages are organized.
Sointu.asm / lib stuff lives at the root folder. There is a folder called "go4k", which is where
all go stuff lives. Following the ideas from https://medium.com/@benbjohnson/standard-package-layout-7cdbc8391fc1
the go4k folder is the "domain-model" of the go side, and should have no dependencies.
It contains Unit, Instrument, Synth interface etc. Putting go4k under a sub-folder is actually
in the spirit of Ben, as go4k adds dependency to the go language.

Bridge ties the domain-model to the sointulib through cgo. It returns C.Synth, but
makes sure the C.Synth implements the Synth interface, so others are able to use the
Synth no matter how it actually is done. MockSynth and WebProxy synth are good
prospects for other implementations of Synth.

It is a bit fuzzy where methods like "Play" that have no dependencies other than domain
model structs should go. They probably should live in the go4k package as well.

The file-organization on the Go-side is not at all finalized. But how packages are broken
into files is mostly a documentation issue; it does not affect the users of the packages at
all.

BTW: The name go4k was chosen because Ben advocated naming the subpackages
according to the dependency they introduce AND because the prototype of 4klang was
called go4k (there are still some defines in the 4klang source revealing this). go4k thus
honors our roots but is also not so bad name: it's the main package of a 4k synth tracker,
written in go.
2020-10-31 22:05:47 +02:00

130 lines
3.9 KiB
C

#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <sointu.h>
#define BPM 100
#define SAMPLE_RATE 44100
#define TOTAL_ROWS 16
#define SAMPLES_PER_ROW SAMPLE_RATE * 4 * 60 / (BPM * 16)
const int su_max_samples = SAMPLES_PER_ROW * TOTAL_ROWS;
int main(int argc, char* argv[]) {
Synth* synth;
float* buffer;
const unsigned char commands[] = { su_envelope_id, // MONO
su_envelope_id, // MONO
su_out_id + 1, // STEREO
su_advance_id };// MONO
const unsigned char values[] = { 64, 64, 64, 80, 128, // envelope 1
95, 64, 64, 80, 128, // envelope 2
128 };
int errcode;
int time;
int samples;
int totalrendered;
int retval;
// initialize Synth
synth = (Synth*)malloc(sizeof(Synth));
memcpy(synth->Commands, commands, sizeof(commands));
memcpy(synth->Values, values, sizeof(values));
synth->NumVoices = 1;
synth->Polyphony = 0;
synth->RandSeed = 1;
// initialize Buffer
buffer = (float*)malloc(2 * sizeof(float) * su_max_samples);
// triger first voice
synth->SynthWrk.Voices[0].Note = 64;
totalrendered = 0;
// First check that when we render using su_render with 0 time
// we get nothing done
samples = su_max_samples;
time = 0;
errcode = su_render(synth, buffer, &samples, &time);
if (errcode != 0)
{
printf("su_render returned error");
goto fail;
}
if (samples > 0)
{
printf("su_render rendered samples, despite it should not");
goto fail;
}
if (time > 0)
{
printf("su_render advanced time, despite it should not");
goto fail;
}
// Then check that when we render using su_render with 0 samples,
// we get nothing done
samples = 0;
time = INT32_MAX;
errcode = su_render(synth, buffer, &samples, &time);
if (errcode != 0)
{
printf("su_render returned error");
goto fail;
}
if (samples > 0)
{
printf("su_render rendered samples, despite it should not");
goto fail;
}
if (time > 0)
{
printf("su_render advanced time, despite it should not");
goto fail;
}
// Then check that each time we call render, only SAMPLES_PER_ROW
// number of samples are rendered
for (int i = 0; i < 16; i++) {
// Simulate "small buffers" i.e. render a buffer with 1 sample
// check that buffer full
samples = 1;
time = INT32_MAX;
su_render(synth, &buffer[totalrendered*2], &samples, &time);
totalrendered += samples;
if (samples != 1)
{
printf("su_render should have return 1, as it should have believed buffer is full");
goto fail;
}
if (time != 1)
{
printf("su_render should have advanced the time also by one");
goto fail;
}
samples = SAMPLES_PER_ROW - 1;
time = INT32_MAX;
su_render(synth, &buffer[totalrendered * 2], &samples, &time);
totalrendered += samples;
if (samples != SAMPLES_PER_ROW - 1)
{
printf("su_render should have return SAMPLES_PER_ROW - 1, as it should have believed buffer is full");
goto fail;
}
if (time != SAMPLES_PER_ROW - 1)
{
printf("su_render should have advanced the time also by SAMPLES_PER_ROW - 1");
goto fail;
}
if (i == 8)
synth->SynthWrk.Voices[0].Release++;
}
if (totalrendered != su_max_samples)
{
printf("su_render should have rendered a total of su_max_samples");
goto fail;
}
retval = 0;
finish:
free(synth);
free(buffer);
return retval;
fail:
retval = 1;
goto finish;
}