aboutsummaryrefslogtreecommitdiff
path: root/tests
diff options
context:
space:
mode:
authorOnur Gündüz <ogunduz@gmail.com>2026-10-21 20:08:53 +0200
committerOnur Gündüz <ogunduz@gmail.com>2026-10-21 20:08:53 +0200
commita1e355b8ceb12ac66c9d82e7786df4c3c40be479 (patch)
tree9d69cf196ec00e85009e1037a3a314d703466ac3 /tests
downloadframesed-master.tar.gz
framesed-master.zip
Diffstat (limited to 'tests')
-rw-r--r--tests/test_classes.c124
-rw-r--r--tests/test_cli.py76
-rw-r--r--tests/test_framesed.c280
-rw-r--r--tests/test_policy.c140
4 files changed, 620 insertions, 0 deletions
diff --git a/tests/test_classes.c b/tests/test_classes.c
new file mode 100644
index 0000000..6dcf19f
--- /dev/null
+++ b/tests/test_classes.c
@@ -0,0 +1,124 @@
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "framesed.h"
+
+#define CHECK(condition) do { \
+ if (!(condition)) { \
+ fprintf(stderr, "%s:%d: %s\n", __FILE__, __LINE__, #condition); \
+ return 1; \
+ } \
+} while (0)
+
+static int check_result(const framesed_result *result, double duration) {
+ CHECK(result->planes && result->num_groups == FRAMESED_CLASS_COUNT);
+ CHECK(result->num_frames == (size_t)ceil(duration / FRAMESED_FRAME_STEP));
+ for (size_t i = 0; i < result->num_groups * result->num_frames; ++i)
+ CHECK(result->planes[i] >= 0.0f && result->planes[i] <= 1.0f);
+ int music = 0;
+ for (size_t i = 0; i < result->num_events; ++i) {
+ const framesed_event *event = &result->events[i];
+ CHECK(event->class_group >= 0 && event->class_group < FRAMESED_CLASS_COUNT);
+ CHECK(event->label == framesed_class_label((size_t)event->class_group));
+ CHECK(event->start >= 0.0 && event->end > event->start && event->end <= duration);
+ CHECK(event->score >= 0.50f && event->score <= 1.0f);
+ CHECK(i == 0 || result->events[i - 1].start <= event->start);
+ if (event->class_group == 253)
+ music = 1;
+ }
+ CHECK(music);
+ CHECK(result->num_tracks > 0 && result->track_step == 0.2);
+ for (size_t i = 0; i < result->num_tracks; ++i) {
+ const framesed_track *track = &result->tracks[i];
+ CHECK(track->class_group >= 0 && track->class_group < FRAMESED_CLASS_COUNT);
+ CHECK(track->label == framesed_class_label((size_t)track->class_group));
+ CHECK(track->count == (result->num_frames + 4) / 5);
+ CHECK(i == 0 || result->tracks[i - 1].class_group < track->class_group);
+ const float *row = result->planes + (size_t)track->class_group * result->num_frames;
+ for (size_t j = 0; j < track->count; ++j) {
+ float maximum = 0.0f;
+ for (size_t f = j * 5; f < (j + 1) * 5 && f < result->num_frames; ++f)
+ if (row[f] > maximum)
+ maximum = row[f];
+ CHECK(track->values[j] == maximum);
+ }
+ }
+ return 0;
+}
+
+int main(int argc, char **argv) {
+ const char *weights = argc > 1 ? argv[1] : "models/framesed_weights.bin";
+ /* A partial final frame/window exercises padding and duration clipping. */
+ const size_t count = 30u * FRAMESED_SAMPLE_RATE + 137;
+ const double duration = (double)count / FRAMESED_SAMPLE_RATE;
+ int16_t *samples = malloc(count * sizeof(*samples));
+ CHECK(samples);
+ for (size_t i = 0; i < count; ++i) {
+ const double t = (double)i / FRAMESED_SAMPLE_RATE;
+ double value = (sin(2 * M_PI * 261.6 * t) + sin(2 * M_PI * 329.6 * t) +
+ sin(2 * M_PI * 392.0 * t)) / 3;
+ value *= 0.65 + 0.35 * sin(2 * M_PI * 4.0 * t);
+ samples[i] = (int16_t)(value * 0.10 * 32767.0);
+ }
+ framesed_t *engine = framesed_create(weights);
+ CHECK(engine);
+ framesed_options options = {
+ .threads = 1, .track_step = 0.2, .keep_planes = 1, .all_classes = 1,
+ };
+ framesed_result one = {0};
+ CHECK(framesed_detect_s16(engine, samples, 10u * FRAMESED_SAMPLE_RATE, &options, &one) == 0);
+ CHECK(check_result(&one, 10.0) == 0);
+ framesed_logits logits = {0};
+ CHECK(framesed_infer_s16(engine, samples, 10u * FRAMESED_SAMPLE_RATE, &logits) == 0);
+ CHECK(one.num_frames == logits.frames);
+ for (size_t i = 0; i < FRAMESED_CLASS_COUNT * logits.frames; ++i) {
+ const float expected = 1.0f / (1.0f + expf(-logits.logits[i]));
+ CHECK(fabsf(one.planes[i] - expected) < 2e-7f);
+ }
+ framesed_logits_free(&logits);
+ framesed_result_free(&one);
+
+ CHECK(framesed_detect_s16(engine, samples, count, &options, &one) == 0);
+ CHECK(check_result(&one, duration) == 0);
+ options.threads = 4;
+ framesed_result many = {0};
+ CHECK(framesed_detect_s16(engine, samples, count, &options, &many) == 0);
+ CHECK(check_result(&many, duration) == 0);
+ CHECK(one.num_events == many.num_events && one.num_tracks == many.num_tracks);
+ CHECK(one.num_frames == many.num_frames && one.num_groups == many.num_groups);
+ CHECK(memcmp(one.planes, many.planes,
+ one.num_frames * one.num_groups * sizeof(float)) == 0);
+ for (size_t i = 0; i < one.num_events; ++i) {
+ const framesed_event *a = &one.events[i], *b = &many.events[i];
+ CHECK(a->class_group == b->class_group && a->label == b->label);
+ CHECK(a->start == b->start && a->end == b->end && a->score == b->score);
+ }
+ for (size_t i = 0; i < one.num_tracks; ++i) {
+ const framesed_track *a = &one.tracks[i], *b = &many.tracks[i];
+ CHECK(a->class_group == b->class_group && a->label == b->label && a->count == b->count);
+ CHECK(memcmp(a->values, b->values, a->count * sizeof(float)) == 0);
+ }
+ printf("framesed classes: 447 score planes match native logits; 1/4 workers agree "
+ "(%zu events, %zu tracks)\n", one.num_events, one.num_tracks);
+ framesed_result_free(&one);
+ framesed_result_free(&many);
+ options.keep_planes = 0;
+ options.track_step = 0;
+ CHECK(framesed_detect_s16(engine, samples, 10u * FRAMESED_SAMPLE_RATE, &options, &one) == 0);
+ CHECK(one.num_events > 0 && !one.planes && !one.tracks);
+ CHECK(one.num_groups == 0 && one.num_frames == 0 && one.num_tracks == 0);
+ framesed_result_free(&one);
+ options.keep_planes = 1;
+ CHECK(framesed_detect_s16(engine, samples, 17, &options, &one) == 0);
+ CHECK(one.num_groups == FRAMESED_CLASS_COUNT && one.num_frames == 1 && one.planes);
+ CHECK(one.num_events == 0);
+ framesed_result_free(&one);
+ CHECK(framesed_detect_s16(engine, NULL, 0, &options, &one) == 0);
+ CHECK(!one.planes && !one.events && !one.tracks);
+ framesed_result_free(&one);
+ framesed_destroy(engine);
+ free(samples);
+ return 0;
+}
diff --git a/tests/test_cli.py b/tests/test_cli.py
new file mode 100644
index 0000000..858f439
--- /dev/null
+++ b/tests/test_cli.py
@@ -0,0 +1,76 @@
+"""CLI vocabulary, caption/class output, and argument contracts."""
+
+import csv
+import math
+from pathlib import Path
+import struct
+import subprocess
+import sys
+import tempfile
+import wave
+
+
+WEIGHTS = sys.argv[1] if len(sys.argv) > 1 else "models/framesed_weights.bin"
+
+
+def run(*args, code=0):
+ result = subprocess.run(
+ ["build/framesed", *map(str, args)], capture_output=True, text=True
+ )
+ if result.returncode != code:
+ raise AssertionError(f"{args}: exit {result.returncode}\n{result.stderr}")
+ return result.stdout
+
+
+def main():
+ assert "--all-classes" in run("--help")
+ with Path("framesed/classes.csv").open(newline="", encoding="utf-8") as source:
+ rows = list(csv.DictReader(source))
+ expected = "".join(
+ f"{row['index']}\t{row['mid']}\t{row['display_name']}\n" for row in rows
+ )
+ assert len(rows) == 447
+ assert run("--list-classes") == expected
+ assert run("--all-classes", code=2) == ""
+ run("--threads", "0", code=2)
+ run("--track-step", "nan", code=2)
+ run("--unknown-option", code=2)
+
+ with tempfile.TemporaryDirectory(prefix="framesed-cli-") as directory:
+ path = Path(directory) / "music.wav"
+ samples = []
+ for i in range(10 * 16000):
+ t = i / 16000
+ value = sum(math.sin(2 * math.pi * f * t) for f in (261.6, 329.6, 392.0)) / 3
+ value *= 0.65 + 0.35 * math.sin(2 * math.pi * 4 * t)
+ samples.append(int(value * 0.10 * 32767))
+ with wave.open(str(path), "wb") as output:
+ output.setparams((1, 2, 16000, 0, "NONE", "not compressed"))
+ output.writeframes(struct.pack(f"<{len(samples)}h", *samples))
+ caption = run("--weights", WEIGHTS, path)
+ assert any(line.endswith(" 0 music") for line in caption.splitlines())
+ classes = run("--all-classes", "--track-step", "0.2", "--weights", WEIGHTS, path)
+ events = 0
+ tracks = 0
+ music = False
+ for line in classes.splitlines():
+ kind = line.split(" ", 1)[0]
+ if kind == "event":
+ _, start, end, score, index, label = line.split(" ", 5)
+ assert 0 <= float(start) < float(end) <= 10.0
+ events += 1
+ music |= int(index) == 253
+ else:
+ assert kind == "track"
+ _, time, score, index, label = line.split(" ", 4)
+ assert 0 <= float(time) < 10.0
+ tracks += 1
+ assert 0 <= float(score) <= 1
+ assert 0 <= int(index) < 447
+ assert label == rows[int(index)]["display_name"]
+ assert events and tracks and music
+ print("framesed CLI: 447 labels, caption/class detection, tracks, arguments passed")
+
+
+if __name__ == "__main__":
+ main()
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;
+}
diff --git a/tests/test_policy.c b/tests/test_policy.c
new file mode 100644
index 0000000..b8731bd
--- /dev/null
+++ b/tests/test_policy.c
@@ -0,0 +1,140 @@
+/* Synthetic scores isolate policy contracts from model recognition accuracy. */
+#include "../framesed/framesed.c"
+
+#define CHECK(condition) do { \
+ if (!(condition)) { \
+ fprintf(stderr, "%s:%d: %s\n", __FILE__, __LINE__, #condition); \
+ return 1; \
+ } \
+} while (0)
+
+static int test_metadata(void) {
+ CHECK(framesed_group_count() == 59);
+ CHECK(!strcmp(framesed_group_label(0), "music"));
+ CHECK(framesed_group_label(framesed_group_count()) == NULL);
+ CHECK(framesed_class_label(FRAMESED_CLASS_COUNT) == NULL);
+ CHECK(framesed_class_mid(SIZE_MAX) == NULL);
+ CHECK(!strcmp(framesed_class_label(0), "Accelerating, revving, vroom"));
+ CHECK(!strcmp(framesed_class_label(253), "Music"));
+ CHECK(!strcmp(framesed_class_mid(253), "/m/04rlf"));
+ CHECK(!strcmp(framesed_class_label(446), "Zipper (clothing)"));
+ for (size_t i = 0; i < FRAMESED_CLASS_COUNT; ++i) {
+ CHECK(framesed_class_label(i) && *framesed_class_label(i));
+ CHECK(framesed_class_mid(i) && *framesed_class_mid(i));
+ for (size_t j = 0; j < i; ++j) {
+ CHECK(strcmp(framesed_class_label(i), framesed_class_label(j)));
+ CHECK(strcmp(framesed_class_mid(i), framesed_class_mid(j)));
+ }
+ }
+ return 0;
+}
+
+static int test_probabilities(void) {
+ enum { FRAMES = 2 };
+ float logits[FRAMESED_CLASS_COUNT * FRAMES];
+ float scores[FRAMESED_CLASS_COUNT * FRAMES];
+ for (size_t i = 0; i < FRAMESED_CLASS_COUNT * FRAMES; ++i)
+ logits[i] = ((float)i - 447.0f) / 100.0f;
+ const framesed_logits input = {.logits = logits, .frames = FRAMES};
+ CHECK(group_probabilities(&input, scores, 1) == 0);
+ for (size_t i = 0; i < FRAMESED_CLASS_COUNT * FRAMES; ++i)
+ CHECK(scores[i] == sigmoid(logits[i]));
+ CHECK(group_probabilities(&input, scores, 0) == 0);
+ for (size_t group = 0; group < FRAMESED_GROUP_COUNT; ++group) {
+ const framesed_group_definition *d = &framesed_groups[group];
+ CHECK(d->class_count > 0);
+ CHECK((size_t)d->class_offset + d->class_count <=
+ sizeof(framesed_group_classes) / sizeof(framesed_group_classes[0]));
+ for (size_t frame = 0; frame < FRAMES; ++frame) {
+ float maximum = 0.0f;
+ for (size_t member = 0; member < d->class_count; ++member) {
+ const size_t index = framesed_group_classes[d->class_offset + member];
+ CHECK(index < FRAMESED_CLASS_COUNT);
+ const float p = sigmoid(logits[index * FRAMES + frame]);
+ if (p > maximum)
+ maximum = p;
+ }
+ CHECK(scores[group * FRAMES + frame] == maximum);
+ }
+ }
+ return 0;
+}
+
+static int test_all_classes(void) {
+ enum { FRAMES = 12 };
+ float scores[FRAMESED_CLASS_COUNT * FRAMES];
+ for (size_t i = 0; i < FRAMESED_CLASS_COUNT * FRAMES; ++i)
+ scores[i] = 0.75f;
+ framesed_result result = {0};
+ CHECK(extract_events(scores, FRAMES, 0.48, &result, 1) == 0);
+ CHECK(result.num_events == FRAMESED_CLASS_COUNT);
+ CHECK(build_tracks(scores, FRAMES, 0.2, &result, 1) == 0);
+ CHECK(result.num_tracks == FRAMESED_CLASS_COUNT);
+ for (size_t i = 0; i < FRAMESED_CLASS_COUNT; ++i) {
+ const framesed_event *event = &result.events[i];
+ CHECK(event->class_group == (int)i);
+ CHECK(event->label == framesed_class_label(i));
+ CHECK(event->start == 0.0 && event->end == 0.48 && event->score == 0.75f);
+ const framesed_track *track = &result.tracks[i];
+ CHECK(track->class_group == (int)i && track->label == framesed_class_label(i));
+ CHECK(track->count == 3);
+ for (size_t frame = 0; frame < track->count; ++frame)
+ CHECK(track->values[frame] == 0.75f);
+ }
+ framesed_result_free(&result);
+ return 0;
+}
+
+static int test_timing(void) {
+ enum { FRAMES = 30, CLASS = FRAMESED_CLASS_COUNT - 1 };
+ float scores[FRAMESED_CLASS_COUNT * FRAMES] = {0};
+ float *row = scores + CLASS * FRAMES;
+ row[1] = 0.75f;
+ for (size_t i = 2; i <= 8; ++i)
+ row[i] = 0.40f;
+ row[3] = 0.0f; /* A brief dropout must not split the event. */
+ for (size_t i = 20; i < 23; ++i)
+ row[i] = 0.9f; /* Below the minimum duration. */
+ for (size_t i = 0; i < FRAMES; ++i)
+ scores[10 * FRAMES + i] = 0.4f; /* Track without an event. */
+ framesed_result result = {0};
+ CHECK(extract_events(scores, FRAMES, 1.2, &result, 1) == 0);
+ CHECK(result.num_events == 1);
+ CHECK(result.events[0].class_group == CLASS);
+ CHECK(result.events[0].start == FRAMESED_FRAME_STEP);
+ CHECK(result.events[0].end == 9 * FRAMESED_FRAME_STEP);
+ CHECK(result.events[0].score == 0.75f);
+ CHECK(build_tracks(scores, FRAMES, 0.2, &result, 1) == 0);
+ CHECK(result.num_tracks == 2 && result.track_step == 0.2);
+ CHECK(result.tracks[0].class_group == 10 && result.tracks[1].class_group == CLASS);
+ CHECK(result.tracks[1].count == 6);
+ CHECK(result.tracks[1].values[0] == 0.75f);
+ CHECK(result.tracks[1].values[4] == 0.9f);
+ framesed_result_free(&result);
+ return 0;
+}
+
+static int test_caption_suppression(void) {
+ enum { FRAMES = 30 };
+ float scores[FRAMESED_GROUP_COUNT * FRAMES] = {0};
+ for (size_t i = 0; i < FRAMES; ++i) {
+ scores[1 * FRAMES + i] = 0.75f; /* applause */
+ scores[3 * FRAMES + i] = 0.75f; /* crowd */
+ scores[58 * FRAMES + i] = 0.75f; /* impact */
+ }
+ framesed_result result = {0};
+ CHECK(build_tracks(scores, FRAMES, 0.2, &result, 0) == 0);
+ CHECK(result.num_tracks == 3);
+ CHECK(extract_events(scores, FRAMES, 1.2, &result, 0) == 0);
+ CHECK(result.num_events == 1 && result.events[0].class_group == 1);
+ framesed_result_free(&result);
+ return 0;
+}
+
+int main(void) {
+ if (test_metadata() || test_probabilities() || test_all_classes() ||
+ test_timing() || test_caption_suppression())
+ return 1;
+ puts("framesed policy: metadata, 447 classes, timing, tracks, caption suppression passed");
+ return 0;
+}