aboutsummaryrefslogtreecommitdiff
path: root/tests/test_framesed.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--tests/test_framesed.c280
1 files changed, 280 insertions, 0 deletions
diff --git a/tests/test_framesed.c b/tests/test_framesed.c
new file mode 100644
index 0000000..5294a79
--- /dev/null
+++ b/tests/test_framesed.c
@@ -0,0 +1,280 @@
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "framesed.h"
+
+typedef struct {
+ char magic[12];
+ uint32_t version;
+ uint32_t samples;
+ uint32_t frames;
+ uint32_t classes;
+ uint32_t tracks;
+} reference_header;
+
+static int16_t *make_waveform(size_t count) {
+ int16_t *samples = malloc(count * sizeof(*samples));
+ if (!samples)
+ return NULL;
+ uint32_t state = 1;
+ for (size_t index = 0; index < count; ++index) {
+ state = state * 1664525u + 1013904223u;
+ const int noise = (int)((state >> 16) & 0xffffu) - 32768;
+ const int saw = (int)(index % 1600) - 800;
+ int value = noise / 8 + saw * 20;
+ if (value < -32768)
+ value = -32768;
+ if (value > 32767)
+ value = 32767;
+ samples[index] = (int16_t)value;
+ }
+ return samples;
+}
+
+/* A major triad under a 4 Hz tremolo, at the moderate level the model scores
+ * highest for music. This gives the event and score-track gates below
+ * something to detect without shipping a recording. */
+static int16_t *make_music_waveform(size_t count) {
+ int16_t *samples = malloc(count * sizeof(*samples));
+ if (!samples)
+ return NULL;
+ static const double partials[] = {261.6, 329.6, 392.0};
+ for (size_t index = 0; index < count; ++index) {
+ const double t = (double)index / FRAMESED_SAMPLE_RATE;
+ double value = 0.0;
+ for (size_t p = 0; p < sizeof partials / sizeof partials[0]; ++p)
+ value += sin(2.0 * M_PI * partials[p] * t);
+ value /= (double)(sizeof partials / sizeof partials[0]);
+ value *= 0.65 + 0.35 * sin(2.0 * M_PI * 4.0 * t);
+ samples[index] = (int16_t)(value * 0.10 * 32767.0);
+ }
+ return samples;
+}
+
+static void *read_file(const char *path, size_t *size) {
+ FILE *file = fopen(path, "rb");
+ if (!file)
+ return NULL;
+ if (fseek(file, 0, SEEK_END) != 0) {
+ fclose(file);
+ return NULL;
+ }
+ const long length = ftell(file);
+ if (length <= 0 || fseek(file, 0, SEEK_SET) != 0) {
+ fclose(file);
+ return NULL;
+ }
+ void *data = malloc((size_t)length);
+ if (!data || fread(data, 1, (size_t)length, file) != (size_t)length) {
+ free(data);
+ fclose(file);
+ return NULL;
+ }
+ fclose(file);
+ *size = (size_t)length;
+ return data;
+}
+
+int main(int argc, char **argv) {
+ const char *weights = argc > 1 ? argv[1] : "models/framesed_weights.bin";
+ const char *reference_path = argc > 2 ? argv[2] : "testdata/framesed_reference.bin";
+ size_t reference_size = 0;
+ unsigned char *reference = read_file(reference_path, &reference_size);
+ if (!reference || reference_size < sizeof(reference_header)) {
+ fprintf(stderr, "cannot read FRAMESED reference\n");
+ free(reference);
+ return 1;
+ }
+ const reference_header *header = (const reference_header *)reference;
+ if (memcmp(header->magic, "FRAMESEDR", 9) != 0 || header->version != 1 ||
+ header->classes != FRAMESED_CLASS_COUNT) {
+ fprintf(stderr, "invalid FRAMESED reference\n");
+ free(reference);
+ return 1;
+ }
+ const size_t expected_size =
+ sizeof(*header) + (size_t)header->tracks * sizeof(uint32_t) +
+ ((size_t)header->classes + (size_t)header->tracks * header->frames) * sizeof(float);
+ if (reference_size != expected_size) {
+ fprintf(stderr, "truncated FRAMESED reference\n");
+ free(reference);
+ return 1;
+ }
+
+ int16_t *samples = make_waveform(header->samples);
+ framesed_t *engine = framesed_create(weights);
+ framesed_logits result;
+ if (!samples || !engine || framesed_infer_s16(engine, samples, header->samples, &result) != 0) {
+ fprintf(stderr, "FRAMESED inference failed\n");
+ free(samples);
+ framesed_destroy(engine);
+ free(reference);
+ return 1;
+ }
+ if (result.frames != header->frames) {
+ fprintf(stderr, "FRAMESED frame count differs: %zu != %u\n", result.frames, header->frames);
+ framesed_logits_free(&result);
+ framesed_destroy(engine);
+ free(samples);
+ free(reference);
+ return 1;
+ }
+
+ const uint32_t *track_classes = (const uint32_t *)(reference + sizeof(*header));
+ const float *expected_global = (const float *)(track_classes + header->tracks);
+ const float *expected_tracks = expected_global + header->classes;
+ float max_global = 0.0f;
+ float max_track = 0.0f;
+ for (uint32_t class_index = 0; class_index < header->classes; ++class_index) {
+ const float *row = result.logits + (size_t)class_index * result.frames;
+ float sum = 0.0f;
+ for (size_t frame = 0; frame < result.frames; ++frame)
+ sum += row[frame];
+ const float error = fabsf(sum / result.frames - expected_global[class_index]);
+ if (error > max_global)
+ max_global = error;
+ }
+ for (uint32_t track = 0; track < header->tracks; ++track) {
+ const float *actual = result.logits + (size_t)track_classes[track] * result.frames;
+ const float *expected = expected_tracks + (size_t)track * result.frames;
+ for (size_t frame = 0; frame < result.frames; ++frame) {
+ const float error = fabsf(actual[frame] - expected[frame]);
+ if (error > max_track)
+ max_track = error;
+ }
+ }
+
+ printf("framesed parity: global %.6g, tracks %.6g (%s)\n", max_global, max_track, framesed_backend(engine));
+ int failed = max_global > 2e-3f || max_track > 4e-3f;
+ framesed_logits_free(&result);
+ framesed_result events = {0};
+ const framesed_options serial = {.threads = 1, .track_step = 0.2};
+ if (framesed_detect_s16(engine, samples, header->samples, &serial, &events) != 0) {
+ fprintf(stderr, "FRAMESED event detection failed\n");
+ failed = 1;
+ }
+ for (size_t i = 0; i < events.num_events; ++i) {
+ const framesed_event *event = &events.events[i];
+ if (!event->label || event->start < 0.0 || event->end <= event->start ||
+ event->end > (double)header->samples / FRAMESED_SAMPLE_RATE + 1e-9 || event->score < 0.0f ||
+ event->score > 1.0f || (i && events.events[i - 1].start > event->start)) {
+ fprintf(stderr, "invalid FRAMESED event result\n");
+ failed = 1;
+ break;
+ }
+ }
+ printf("framesed policy: %zu deterministic event%s\n", events.num_events,
+ events.num_events == 1 ? "" : "s");
+
+ /* Model windows write disjoint frame ranges chosen by window index, so the
+ * worker count must not reach the output. */
+ framesed_result threaded = {0};
+ const framesed_options parallel = {.threads = 4, .track_step = 0.2};
+ if (framesed_detect_s16(engine, samples, header->samples, &parallel, &threaded) != 0) {
+ fprintf(stderr, "threaded FRAMESED event detection failed\n");
+ failed = 1;
+ } else if (threaded.num_events != events.num_events) {
+ fprintf(stderr, "FRAMESED event count depends on the worker count: %zu vs %zu\n",
+ threaded.num_events, events.num_events);
+ failed = 1;
+ } else {
+ for (size_t i = 0; i < events.num_events; ++i) {
+ const framesed_event *one = &events.events[i];
+ const framesed_event *many = &threaded.events[i];
+ if (one->start != many->start || one->end != many->end || one->score != many->score ||
+ one->label != many->label) {
+ fprintf(stderr, "FRAMESED event %zu depends on the worker count\n", i);
+ failed = 1;
+ break;
+ }
+ }
+ }
+ printf("framesed threads: 1 and 4 workers agree exactly\n");
+
+ const double expected_step = 0.2;
+ const size_t expected_count =
+ (size_t)((double)header->samples / FRAMESED_SAMPLE_RATE / expected_step + 0.9999);
+ for (size_t i = 0; i < events.num_tracks; ++i) {
+ const framesed_track *track = &events.tracks[i];
+ if (track->count != expected_count || !track->label) {
+ fprintf(stderr, "score track %zu has %zu values, expected %zu\n", i, track->count,
+ expected_count);
+ failed = 1;
+ break;
+ }
+ for (size_t v = 0; v < track->count; ++v)
+ if (!(track->values[v] >= 0.0f && track->values[v] <= 1.0f)) {
+ fprintf(stderr, "score track %s leaves [0, 1]\n", track->label);
+ failed = 1;
+ break;
+ }
+ }
+ if (events.num_tracks && events.track_step != expected_step) {
+ fprintf(stderr, "score track step is %g, expected %g\n", events.track_step, expected_step);
+ failed = 1;
+ }
+ for (size_t i = 0; i < events.num_tracks; ++i) {
+ const framesed_track *one = &events.tracks[i];
+ const framesed_track *many = &threaded.tracks[i];
+ if (i >= threaded.num_tracks || one->count != many->count ||
+ memcmp(one->values, many->values, one->count * sizeof(float))) {
+ fprintf(stderr, "score track %zu depends on the worker count\n", i);
+ failed = 1;
+ break;
+ }
+ }
+ printf("framesed scores: %zu track%s of %zu values at %.2f s\n", events.num_tracks,
+ events.num_tracks == 1 ? "" : "s", events.num_tracks ? events.tracks[0].count : 0,
+ events.track_step);
+ framesed_result_free(&threaded);
+
+ /* A signal the model does recognise, so that events and score tracks are
+ * exercised rather than merely being empty and well formed. */
+ const framesed_options music_options = {.threads = 2, .track_step = 1.0, .keep_planes = 1};
+ const size_t music_samples = 30u * FRAMESED_SAMPLE_RATE;
+ int16_t *music = make_music_waveform(music_samples);
+ framesed_result music_result = {0};
+ if (!music || framesed_detect_s16(engine, music, music_samples, &music_options, &music_result) != 0) {
+ fprintf(stderr, "music FRAMESED detection failed\n");
+ failed = 1;
+ } else {
+ size_t music_events = 0;
+ double covered = 0.0;
+ for (size_t i = 0; i < music_result.num_events; ++i)
+ if (!strcmp(music_result.events[i].label, "music")) {
+ ++music_events;
+ covered += music_result.events[i].end - music_result.events[i].start;
+ }
+ const framesed_track *music_track = NULL;
+ for (size_t i = 0; i < music_result.num_tracks; ++i)
+ if (!strcmp(music_result.tracks[i].label, "music"))
+ music_track = &music_result.tracks[i];
+ float peak = 0.0f;
+ if (music_track)
+ for (size_t v = 0; v < music_track->count; ++v)
+ if (music_track->values[v] > peak)
+ peak = music_track->values[v];
+ if (!music_events || covered < 20.0 || !music_track || peak < 0.5f ||
+ music_result.track_step != 1.0 || music_track->count != 30) {
+ fprintf(stderr,
+ "music gate: %zu events over %.1f s, track %s peak %.3f, "
+ "step %g, %zu values\n",
+ music_events, covered, music_track ? "present" : "missing", (double)peak,
+ music_result.track_step, music_track ? music_track->count : 0);
+ failed = 1;
+ } else {
+ printf("framesed music: %zu event%s over %.1f s, track peak %.2f at 1.00 s\n", music_events,
+ music_events == 1 ? "" : "s", covered, (double)peak);
+ }
+ }
+ framesed_result_free(&music_result);
+ free(music);
+ framesed_result_free(&events);
+ framesed_destroy(engine);
+ free(samples);
+ free(reference);
+ return failed;
+}