add vcap/add_frame

this allows converting 50p to 60p or even 50i to 60p:
`uv -F double_framerate:nodelay,add_frame:e=5 -t testcard:fps=50i`

Another change is that from capture_filter dropped early return if
nullptr returned - this will preclude the above complex example because the
"flushing" nullptr would be consumed by double_framerate and additional
frames won't be read from add_frame

Author: MartinPulec

configure.ac

@@ -3639,6 +3639,7 @@ if test "$build_default" != no || test "$req_files" = all; then
         src/audio/filter/silence.o
         src/audio/filter/playback.o
         src/audio/filter/channel_remap.o
+        src/capture_filter/add_frame.o
         src/capture_filter/change_pixfmt.o
         src/capture_filter/color.o
         src/capture_filter/display.o

src/capture_filter.cpp

@@ -221,8 +221,6 @@ struct video_frame *capture_filter(struct capture_filter *state, struct video_fr
            ) {
                 struct capture_filter_instance *inst = (struct capture_filter_instance *) simple_linked_list_it_next(&it);
                 frame = inst->functions->filter(inst->state, frame);
-                if(!frame)
-                        return NULL;
         }
         return frame;
 }

src/capture_filter/add_frame.c

@@ -0,0 +1,173 @@
+// SPDX-License-Identifier: BSD-3-Clause
+// Copyright (c) 2026 CESNET, zájmové sdružení právických osob
+
+#include <assert.h> // for assert
+#include <stdint.h> // for uint32_t
+#include <stdlib.h> // for free, atoi, calloc
+#include <string.h> // for memcpy, strchr, strcmp, strdup, strtok_r
+#include <time.h>   // for nanosleep, timespec
+
+#include "capture_filter.h"  // for CAPTURE_FILTER_ABI_VERSION, capture_fil...
+#include "compat/c23.h"      // IWYU pragma: keep
+#include "debug.h"           // for LOG_LEVEL_ERROR, MSG
+#include "lib_common.h"      // for REGISTER_MODULE, library_class
+#include "tv.h"              // for time_ns_t, get_time_in_ns, SEC_TO_NS
+#include "types.h"           // for video_frame, video_frame_callbacks, tile
+#include "utils/color_out.h" // for color_printf, TBOLD
+#include "utils/macros.h"    // for to_fourcc, IS_KEY_PREFIX, IS_PREFIX
+#include "utils/text.h"      // for wrap_paragraph
+#include "video_frame.h"     // for vf_free, vf_alloc_desc, video_desc_from...
+struct module;
+
+#define MAGIC    to_fourcc('C', 'F', 'a', 'f')
+#define MOD_NAME "[cf/add_frame] "
+
+struct state_add_frame {
+        uint32_t            magic;
+        bool                nodelay;
+        int                 add_frame_cnt;
+        int                 curr_idx;
+        struct video_frame *cached;
+        time_ns_t           t0;
+};
+
+static void
+usage()
+{
+        char desc[] = "capture filter " TBOLD("add_frame")
+                      " adds extra frame per every amount of "
+                      "frames.\n\nTypical use case is to convert 50p to 60p.\n";
+        color_printf("%s\n", wrap_paragraph(desc));
+        color_printf("Usage:\n"
+                     "\t" TBOLD("-F add_frame:every=<num>[:nodelay]")
+                     "\n");
+        color_printf(
+            "\n(in the proposed 50p->60p case, the <num> will be 5)\n\n");
+}
+
+static void
+done(void *state)
+{
+        struct state_add_frame *s = state;
+        if (s->cached != nullptr) {
+                vf_free(s->cached);
+        }
+        free(s);
+}
+
+static bool
+parse_fmt(struct state_add_frame *s, char *fmt)
+{
+        char *tok   = nullptr;
+        char *state = nullptr;
+        while ((tok = strtok_r(fmt, ":", &state)) != nullptr) {
+                fmt = nullptr;
+                if (IS_KEY_PREFIX(tok, "every")) {
+                        s->add_frame_cnt = atoi(strchr(tok, '=') + 1);
+                } else if (IS_PREFIX(tok, "nodelay")) {
+                        s->nodelay = true;
+                } else {
+                        MSG(ERROR, "Unknown option: %s!\n", tok);
+                        return false;
+                }
+        }
+        if (s->add_frame_cnt <= 2) {
+                MSG(ERROR, "Number of frames missing or invalid (%d)!\n",
+                    s->add_frame_cnt);
+                return false;
+        }
+        return true;
+}
+
+static int
+init(struct module * /* parent */, const char *cfg, void **state)
+{
+        assert(cfg != nullptr);
+        if (strcmp(cfg, "help") == 0) {
+                usage();
+                return 1;
+        }
+        struct state_add_frame *s = calloc(1, sizeof *s);
+        s->magic                  = MAGIC;
+        char *ccfg                = strdup(cfg);
+        bool  ret                 = parse_fmt(s, ccfg);
+        free(ccfg);
+        if (!ret) {
+                done(s);
+                usage();
+                return -1;
+        }
+        *state = s;
+        return 0;
+}
+
+// from ./override_prop.c
+static void
+dispose_frame(struct video_frame *f)
+{
+        VIDEO_FRAME_DISPOSE((struct video_frame *) f->callbacks.dispose_udata);
+        vf_free(f);
+}
+
+static struct video_frame *
+filter(void *state, struct video_frame *in)
+{
+        struct state_add_frame *s = state;
+        if (in == nullptr) {
+                if (s->cached == nullptr) {
+                        return nullptr;
+                }
+                in        = s->cached;
+                s->cached = nullptr;
+        }
+
+        if (s->curr_idx == 0) {
+                if (s->cached != nullptr) {
+                        vf_free(s->cached);
+                }
+                s->cached                    = vf_get_copy(in);
+                s->cached->callbacks.dispose = vf_free;
+                s->curr_idx += 1;
+
+                // wrap with new header (fps adj)
+                struct video_frame *out =
+                    vf_alloc_desc(video_desc_from_frame(in));
+                out->fps = out->fps / s->add_frame_cnt * (s->add_frame_cnt + 1);
+                memcpy(out->tiles, in->tiles,
+                       in->tile_count * sizeof(struct tile));
+                s->t0 = get_time_in_ns();
+                return out;
+        }
+
+        // wrap with new header (fps adj)
+        double new_fps = in->fps / s->add_frame_cnt * (s->add_frame_cnt + 1);
+        struct video_frame *out = vf_alloc_desc(video_desc_from_frame(in));
+        out->fps                = new_fps;
+        memcpy(out->tiles, in->tiles, in->tile_count * sizeof(struct tile));
+
+        out->callbacks.dispose       = dispose_frame;
+        out->callbacks.dispose_udata = in;
+
+        if (!s->nodelay) {
+                time_ns_t now              = get_time_in_ns();
+                time_ns_t new_frame_budget = SEC_TO_NS(1) / new_fps;
+                time_ns_t sleep_ns =
+                    (s->t0 + (s->curr_idx * new_frame_budget)) - now;
+                if (sleep_ns > 0) {
+                        nanosleep(&(struct timespec){ .tv_nsec = sleep_ns },
+                                  nullptr);
+                }
+        }
+
+        s->curr_idx = (s->curr_idx + 1) % (s->add_frame_cnt + 1);
+        return out;
+}
+
+static const struct capture_filter_info capture_filter_blank = {
+        .init   = init,
+        .done   = done,
+        .filter = filter,
+};
+
+REGISTER_MODULE(add_frame, &capture_filter_blank, LIBRARY_CLASS_CAPTURE_FILTER,
+                CAPTURE_FILTER_ABI_VERSION);