#include #include #include #include #include #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; }