diff options
| author | Onur Gündüz <ogunduz@gmail.com> | 2026-10-21 20:08:53 +0200 |
|---|---|---|
| committer | Onur Gündüz <ogunduz@gmail.com> | 2026-10-21 20:08:53 +0200 |
| commit | a1e355b8ceb12ac66c9d82e7786df4c3c40be479 (patch) | |
| tree | 9d69cf196ec00e85009e1037a3a314d703466ac3 /tests/test_framesed.c | |
| download | framesed-a1e355b8ceb12ac66c9d82e7786df4c3c40be479.tar.gz framesed-a1e355b8ceb12ac66c9d82e7786df4c3c40be479.zip | |
Diffstat (limited to 'tests/test_framesed.c')
| -rw-r--r-- | tests/test_framesed.c | 280 |
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, ¶llel, &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; +} |
