typed-ffmpeg-compatible 3.3__py3-none-any.whl → 3.4__py3-none-any.whl

typed_ffmpeg/sources.py

@@ -1,4 +1,5 @@
 # NOTE: this file is auto-generated, do not modify
+
 from typing import Any, Literal
 
 from .common.schema import FFMpegFilterDef
@@ -8,6 +9,7 @@ from .schema import Auto, Default
 from .streams.audio import AudioStream
 from .streams.video import VideoStream
 from .types import (
+    Binary,
     Boolean,
     Color,
     Dictionary,
@@ -24,6 +26,7 @@ from .types import (
     String,
     Video_rate,
 )
+from .utils.frozendict import merge
 
 
 def abuffer(
@@ -33,7 +36,7 @@ def abuffer(
     sample_fmt: Sample_fmt = Default("none"),
     channel_layout: String = Default(None),
     channels: Int = Default(0),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> AudioStream:
     """
 
@@ -55,14 +58,16 @@ def abuffer(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="abuffer", typings_input=(), typings_output=("audio",)),
-        **{
-            "time_base": time_base,
-            "sample_rate": sample_rate,
-            "sample_fmt": sample_fmt,
-            "channel_layout": channel_layout,
-            "channels": channels,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "time_base": time_base,
+                "sample_rate": sample_rate,
+                "sample_fmt": sample_fmt,
+                "channel_layout": channel_layout,
+                "channels": channels,
+            },
+            extra_options,
+        ),
     )
     return filter_node.audio(0)
 
@@ -74,7 +79,7 @@ def aevalsrc(
     sample_rate: String = Default("44100"),
     duration: Duration = Default(-1e-06),
     channel_layout: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> AudioStream:
     """
 
@@ -96,14 +101,16 @@ def aevalsrc(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="aevalsrc", typings_input=(), typings_output=("audio",)),
-        **{
-            "exprs": exprs,
-            "nb_samples": nb_samples,
-            "sample_rate": sample_rate,
-            "duration": duration,
-            "channel_layout": channel_layout,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "exprs": exprs,
+                "nb_samples": nb_samples,
+                "sample_rate": sample_rate,
+                "duration": duration,
+                "channel_layout": channel_layout,
+            },
+            extra_options,
+        ),
     )
     return filter_node.audio(0)
 
@@ -115,7 +122,7 @@ def afdelaysrc(
     nb_samples: Int = Default(1024),
     taps: Int = Default(0),
     channel_layout: String = Default("stereo"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> AudioStream:
     """
 
@@ -137,14 +144,92 @@ def afdelaysrc(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="afdelaysrc", typings_input=(), typings_output=("audio",)),
-        **{
-            "delay": delay,
-            "sample_rate": sample_rate,
-            "nb_samples": nb_samples,
-            "taps": taps,
-            "channel_layout": channel_layout,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "delay": delay,
+                "sample_rate": sample_rate,
+                "nb_samples": nb_samples,
+                "taps": taps,
+                "channel_layout": channel_layout,
+            },
+            extra_options,
+        ),
+    )
+    return filter_node.audio(0)
+
+
+def afireqsrc(
+    *,
+    preset: Int
+    | Literal[
+        "custom",
+        "flat",
+        "acoustic",
+        "bass",
+        "beats",
+        "classic",
+        "clear",
+        "deep",
+        "dubstep",
+        "electronic",
+        "hardstyle",
+        "hop",
+        "jazz",
+        "metal",
+        "movie",
+        "pop",
+        "b",
+        "rock",
+        "vocal",
+    ]
+    | Default = Default("flat"),
+    gains: String = Default("0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0"),
+    bands: String = Default(
+        "25 40 63 100 160 250 400 630 1000 1600 2500 4000 6300 10000 16000 24000"
+    ),
+    taps: Int = Default(4096),
+    sample_rate: Int = Default(44100),
+    nb_samples: Int = Default(1024),
+    interp: Int | Literal["linear", "cubic"] | Default = Default("linear"),
+    phase: Int | Literal["linear", "min"] | Default = Default("min"),
+    extra_options: dict[str, Any] | None = None,
+) -> AudioStream:
+    """
+
+    Generate a FIR equalizer coefficients audio stream.
+
+    Args:
+        preset: set equalizer preset (from -1 to 17) (default flat)
+        gains: set gain values per band (default "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0")
+        bands: set central frequency values per band (default "25 40 63 100 160 250 400 630 1000 1600 2500 4000 6300 10000 16000 24000")
+        taps: set number of taps (from 16 to 65535) (default 4096)
+        sample_rate: set sample rate (from 1 to INT_MAX) (default 44100)
+        nb_samples: set the number of samples per requested frame (from 1 to INT_MAX) (default 1024)
+        interp: set the interpolation (from 0 to 1) (default linear)
+        phase: set the phase (from 0 to 1) (default min)
+
+    Returns:
+        default: the audio stream
+
+    References:
+        [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#afireqsrc)
+
+    """
+    filter_node = filter_node_factory(
+        FFMpegFilterDef(name="afireqsrc", typings_input=(), typings_output=("audio",)),
+        **merge(
+            {
+                "preset": preset,
+                "gains": gains,
+                "bands": bands,
+                "taps": taps,
+                "sample_rate": sample_rate,
+                "nb_samples": nb_samples,
+                "interp": interp,
+                "phase": phase,
+            },
+            extra_options,
+        ),
     )
     return filter_node.audio(0)
 
@@ -205,7 +290,7 @@ def afirsrc(
         "kaiser",
     ]
     | Default = Default("blackman"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> AudioStream:
     """
 
@@ -229,16 +314,18 @@ def afirsrc(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="afirsrc", typings_input=(), typings_output=("audio",)),
-        **{
-            "taps": taps,
-            "frequency": frequency,
-            "magnitude": magnitude,
-            "phase": phase,
-            "sample_rate": sample_rate,
-            "nb_samples": nb_samples,
-            "win_func": win_func,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "taps": taps,
+                "frequency": frequency,
+                "magnitude": magnitude,
+                "phase": phase,
+                "sample_rate": sample_rate,
+                "nb_samples": nb_samples,
+                "win_func": win_func,
+            },
+            extra_options,
+        ),
     )
     return filter_node.audio(0)
 
@@ -249,7 +336,7 @@ def ainterleave(
     duration: Int | Literal["longest", "shortest", "first"] | Default = Default(
         "longest"
     ),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> AudioStream:
     """
 
@@ -273,11 +360,13 @@ def ainterleave(
             typings_output=("audio",),
         ),
         *streams,
-        **{
-            "nb_inputs": nb_inputs,
-            "duration": duration,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "nb_inputs": nb_inputs,
+                "duration": duration,
+            },
+            extra_options,
+        ),
     )
     return filter_node.audio(0)
 
@@ -287,7 +376,7 @@ def allrgb(
     rate: Video_rate = Default("25"),
     duration: Duration = Default(-1e-06),
     sar: Rational = Default("1/1"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -307,12 +396,14 @@ def allrgb(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="allrgb", typings_input=(), typings_output=("video",)),
-        **{
-            "rate": rate,
-            "duration": duration,
-            "sar": sar,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "rate": rate,
+                "duration": duration,
+                "sar": sar,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -322,7 +413,7 @@ def allyuv(
     rate: Video_rate = Default("25"),
     duration: Duration = Default(-1e-06),
     sar: Rational = Default("1/1"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -342,12 +433,14 @@ def allyuv(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="allyuv", typings_input=(), typings_output=("video",)),
-        **{
-            "rate": rate,
-            "duration": duration,
-            "sar": sar,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "rate": rate,
+                "duration": duration,
+                "sar": sar,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -355,7 +448,7 @@ def allyuv(
 def amerge(
     *streams: AudioStream,
     inputs: Int = Auto("len(streams)"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> AudioStream:
     """
 
@@ -378,10 +471,12 @@ def amerge(
             typings_output=("audio",),
         ),
         *streams,
-        **{
-            "inputs": inputs,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "inputs": inputs,
+            },
+            extra_options,
+        ),
     )
     return filter_node.audio(0)
 
@@ -395,7 +490,7 @@ def amix(
     dropout_transition: Float = Default(2.0),
     weights: String = Default("1 1"),
     normalize: Boolean = Default(True),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> AudioStream:
     """
 
@@ -422,14 +517,16 @@ def amix(
             typings_output=("audio",),
         ),
         *streams,
-        **{
-            "inputs": inputs,
-            "duration": duration,
-            "dropout_transition": dropout_transition,
-            "weights": weights,
-            "normalize": normalize,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "inputs": inputs,
+                "duration": duration,
+                "dropout_transition": dropout_transition,
+                "weights": weights,
+                "normalize": normalize,
+            },
+            extra_options,
+        ),
     )
     return filter_node.audio(0)
 
@@ -445,7 +542,7 @@ def amovie(
     discontinuity: Duration = Default(0.0),
     dec_threads: Int = Default(0),
     format_opts: Dictionary = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> FilterNode:
     """
 
@@ -476,18 +573,20 @@ def amovie(
             typings_input="[StreamType.audio] * len(streams.split('+'))",
             typings_output="[StreamType.audio] * len(streams.split('+'))",
         ),
-        **{
-            "filename": filename,
-            "format_name": format_name,
-            "stream_index": stream_index,
-            "seek_point": seek_point,
-            "streams": streams,
-            "loop": loop,
-            "discontinuity": discontinuity,
-            "dec_threads": dec_threads,
-            "format_opts": format_opts,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "filename": filename,
+                "format_name": format_name,
+                "stream_index": stream_index,
+                "seek_point": seek_point,
+                "streams": streams,
+                "loop": loop,
+                "discontinuity": discontinuity,
+                "dec_threads": dec_threads,
+                "format_opts": format_opts,
+            },
+            extra_options,
+        ),
     )
 
     return filter_node
@@ -503,7 +602,8 @@ def anoisesrc(
     | Default = Default("white"),
     seed: Int64 = Default(-1),
     nb_samples: Int = Default(1024),
-    extra_options: dict[str, Any] = None,
+    density: Double = Default(0.05),
+    extra_options: dict[str, Any] | None = None,
 ) -> AudioStream:
     """
 
@@ -516,6 +616,7 @@ def anoisesrc(
         color: set noise color (from 0 to 5) (default white)
         seed: set random seed (from -1 to UINT32_MAX) (default -1)
         nb_samples: set the number of samples per requested frame (from 1 to INT_MAX) (default 1024)
+        density: set density (from 0 to 1) (default 0.05)
 
     Returns:
         default: the audio stream
@@ -526,15 +627,18 @@ def anoisesrc(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="anoisesrc", typings_input=(), typings_output=("audio",)),
-        **{
-            "sample_rate": sample_rate,
-            "amplitude": amplitude,
-            "duration": duration,
-            "color": color,
-            "seed": seed,
-            "nb_samples": nb_samples,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "sample_rate": sample_rate,
+                "amplitude": amplitude,
+                "duration": duration,
+                "color": color,
+                "seed": seed,
+                "nb_samples": nb_samples,
+                "density": density,
+            },
+            extra_options,
+        ),
     )
     return filter_node.audio(0)
 
@@ -545,7 +649,7 @@ def anullsrc(
     sample_rate: String = Default("44100"),
     nb_samples: Int = Default(1024),
     duration: Duration = Default(-1e-06),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> AudioStream:
     """
 
@@ -566,13 +670,15 @@ def anullsrc(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="anullsrc", typings_input=(), typings_output=("audio",)),
-        **{
-            "channel_layout": channel_layout,
-            "sample_rate": sample_rate,
-            "nb_samples": nb_samples,
-            "duration": duration,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "channel_layout": channel_layout,
+                "sample_rate": sample_rate,
+                "nb_samples": nb_samples,
+                "duration": duration,
+            },
+            extra_options,
+        ),
     )
     return filter_node.audio(0)
 
@@ -581,7 +687,7 @@ def astreamselect(
     *streams: AudioStream,
     inputs: Int = Auto("len(streams)"),
     map: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> FilterNode:
     """
 
@@ -606,11 +712,13 @@ def astreamselect(
             typings_output="[StreamType.audio] * len(re.findall(r'\\d+', str(map)))",
         ),
         *streams,
-        **{
-            "inputs": inputs,
-            "map": map,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "inputs": inputs,
+                "map": map,
+            },
+            extra_options,
+        ),
     )
 
     return filter_node
@@ -629,7 +737,7 @@ def avsynctest(
     fg: Color = Default("white"),
     bg: Color = Default("black"),
     ag: Color = Default("gray"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> tuple[
     AudioStream,
     VideoStream,
@@ -663,20 +771,22 @@ def avsynctest(
         FFMpegFilterDef(
             name="avsynctest", typings_input=(), typings_output=("audio", "video")
         ),
-        **{
-            "size": size,
-            "framerate": framerate,
-            "samplerate": samplerate,
-            "amplitude": amplitude,
-            "period": period,
-            "delay": delay,
-            "cycle": cycle,
-            "duration": duration,
-            "fg": fg,
-            "bg": bg,
-            "ag": ag,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "size": size,
+                "framerate": framerate,
+                "samplerate": samplerate,
+                "amplitude": amplitude,
+                "period": period,
+                "delay": delay,
+                "cycle": cycle,
+                "duration": duration,
+                "fg": fg,
+                "bg": bg,
+                "ag": ag,
+            },
+            extra_options,
+        ),
     )
     return (
         filter_node.audio(0),
@@ -698,7 +808,7 @@ def bm3d(
     ref: Boolean = Default(False),
     planes: Int = Default(7),
     enable: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -732,21 +842,23 @@ def bm3d(
             typings_output=("video",),
         ),
         *streams,
-        **{
-            "sigma": sigma,
-            "block": block,
-            "bstep": bstep,
-            "group": group,
-            "range": range,
-            "mstep": mstep,
-            "thmse": thmse,
-            "hdthr": hdthr,
-            "estim": estim,
-            "ref": ref,
-            "planes": planes,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "sigma": sigma,
+                "block": block,
+                "bstep": bstep,
+                "group": group,
+                "range": range,
+                "mstep": mstep,
+                "thmse": thmse,
+                "hdthr": hdthr,
+                "estim": estim,
+                "ref": ref,
+                "planes": planes,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -759,7 +871,7 @@ def buffer(
     pix_fmt: Pix_fmt = Default("none"),
     sar: Rational = Default("0/1"),
     time_base: Rational = Default("0/1"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -782,15 +894,17 @@ def buffer(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="buffer", typings_input=(), typings_output=("video",)),
-        **{
-            "width": width,
-            "video_size": video_size,
-            "height": height,
-            "pix_fmt": pix_fmt,
-            "sar": sar,
-            "time_base": time_base,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "width": width,
+                "video_size": video_size,
+                "height": height,
+                "pix_fmt": pix_fmt,
+                "sar": sar,
+                "time_base": time_base,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -808,7 +922,7 @@ def cellauto(
     start_full: Boolean = Default(False),
     full: Boolean = Default(True),
     stitch: Boolean = Default(True),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -836,20 +950,22 @@ def cellauto(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="cellauto", typings_input=(), typings_output=("video",)),
-        **{
-            "filename": filename,
-            "pattern": pattern,
-            "rate": rate,
-            "size": size,
-            "rule": rule,
-            "random_fill_ratio": random_fill_ratio,
-            "random_seed": random_seed,
-            "scroll": scroll,
-            "start_full": start_full,
-            "full": full,
-            "stitch": stitch,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "filename": filename,
+                "pattern": pattern,
+                "rate": rate,
+                "size": size,
+                "rule": rule,
+                "random_fill_ratio": random_fill_ratio,
+                "random_seed": random_seed,
+                "scroll": scroll,
+                "start_full": start_full,
+                "full": full,
+                "stitch": stitch,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -861,7 +977,7 @@ def color(
     rate: Video_rate = Default("25"),
     duration: Duration = Default(-1e-06),
     sar: Rational = Default("1/1"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -883,14 +999,69 @@ def color(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="color", typings_input=(), typings_output=("video",)),
-        **{
-            "color": color,
-            "size": size,
-            "rate": rate,
-            "duration": duration,
-            "sar": sar,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "color": color,
+                "size": size,
+                "rate": rate,
+                "duration": duration,
+                "sar": sar,
+            },
+            extra_options,
+        ),
+    )
+    return filter_node.video(0)
+
+
+def color_vulkan(
+    *,
+    color: Color = Default("black"),
+    size: Image_size = Default("1920x1080"),
+    rate: Video_rate = Default("60"),
+    duration: Duration = Default(-1e-06),
+    sar: Rational = Default("1/1"),
+    format: String = Default(None),
+    out_range: Int
+    | Literal["full", "limited", "jpeg", "mpeg", "tv", "pc"]
+    | Default = Default(0),
+    extra_options: dict[str, Any] | None = None,
+) -> VideoStream:
+    """
+
+    Generate a constant color (Vulkan)
+
+    Args:
+        color: set color (default "black")
+        size: set video size (default "1920x1080")
+        rate: set video rate (default "60")
+        duration: set video duration (default -0.000001)
+        sar: set video sample aspect ratio (from 0 to INT_MAX) (default 1/1)
+        format: Output video format (software format of hardware frames)
+        out_range: Output colour range (from 0 to 2) (default 0) (from 0 to 2) (default 0)
+
+    Returns:
+        default: the video stream
+
+    References:
+        [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#color_005fvulkan)
+
+    """
+    filter_node = filter_node_factory(
+        FFMpegFilterDef(
+            name="color_vulkan", typings_input=(), typings_output=("video",)
+        ),
+        **merge(
+            {
+                "color": color,
+                "size": size,
+                "rate": rate,
+                "duration": duration,
+                "sar": sar,
+                "format": format,
+                "out_range": out_range,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -902,7 +1073,7 @@ def colorchart(
     sar: Rational = Default("1/1"),
     patch_size: Image_size = Default("64x64"),
     preset: Int | Literal["reference", "skintones"] | Default = Default("reference"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -924,14 +1095,16 @@ def colorchart(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="colorchart", typings_input=(), typings_output=("video",)),
-        **{
-            "rate": rate,
-            "duration": duration,
-            "sar": sar,
-            "patch_size": patch_size,
-            "preset": preset,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "rate": rate,
+                "duration": duration,
+                "sar": sar,
+                "patch_size": patch_size,
+                "preset": preset,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -943,7 +1116,7 @@ def colorspectrum(
     duration: Duration = Default(-1e-06),
     sar: Rational = Default("1/1"),
     type: Int | Literal["black", "white", "all"] | Default = Default("black"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -967,14 +1140,16 @@ def colorspectrum(
         FFMpegFilterDef(
             name="colorspectrum", typings_input=(), typings_output=("video",)
         ),
-        **{
-            "size": size,
-            "rate": rate,
-            "duration": duration,
-            "sar": sar,
-            "type": type,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "size": size,
+                "rate": rate,
+                "duration": duration,
+                "sar": sar,
+                "type": type,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -985,7 +1160,7 @@ def concat(
     v: Int = Default(1),
     a: Int = Default(0),
     unsafe: Boolean = Default(False),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> FilterNode:
     """
 
@@ -1012,13 +1187,15 @@ def concat(
             typings_output="[StreamType.video]*int(v) + [StreamType.audio]*int(a)",
         ),
         *streams,
-        **{
-            "n": n,
-            "v": v,
-            "a": a,
-            "unsafe": unsafe,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "n": n,
+                "v": v,
+                "a": a,
+                "unsafe": unsafe,
+            },
+            extra_options,
+        ),
     )
 
     return filter_node
@@ -1034,7 +1211,7 @@ def decimate(
     ppsrc: Boolean = Default(False),
     chroma: Boolean = Default(True),
     mixed: Boolean = Default(False),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -1064,17 +1241,19 @@ def decimate(
             typings_output=("video",),
         ),
         *streams,
-        **{
-            "cycle": cycle,
-            "dupthresh": dupthresh,
-            "scthresh": scthresh,
-            "blockx": blockx,
-            "blocky": blocky,
-            "ppsrc": ppsrc,
-            "chroma": chroma,
-            "mixed": mixed,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "cycle": cycle,
+                "dupthresh": dupthresh,
+                "scthresh": scthresh,
+                "blockx": blockx,
+                "blocky": blocky,
+                "ppsrc": ppsrc,
+                "chroma": chroma,
+                "mixed": mixed,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -1097,7 +1276,7 @@ def fieldmatch(
     blockx: Int = Default(16),
     blocky: Int = Default(16),
     combpel: Int = Default(80),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -1133,34 +1312,79 @@ def fieldmatch(
             typings_output=("video",),
         ),
         *streams,
-        **{
-            "order": order,
-            "mode": mode,
-            "ppsrc": ppsrc,
-            "field": field,
-            "mchroma": mchroma,
-            "y0": y0,
-            "scthresh": scthresh,
-            "combmatch": combmatch,
-            "combdbg": combdbg,
-            "cthresh": cthresh,
-            "chroma": chroma,
-            "blockx": blockx,
-            "blocky": blocky,
-            "combpel": combpel,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "order": order,
+                "mode": mode,
+                "ppsrc": ppsrc,
+                "field": field,
+                "mchroma": mchroma,
+                "y0": y0,
+                "scthresh": scthresh,
+                "combmatch": combmatch,
+                "combdbg": combdbg,
+                "cthresh": cthresh,
+                "chroma": chroma,
+                "blockx": blockx,
+                "blocky": blocky,
+                "combpel": combpel,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
 
+def flite(
+    *,
+    list_voices: Boolean = Default(False),
+    nb_samples: Int = Default(512),
+    text: String = Default(None),
+    textfile: String = Default(None),
+    v: String = Default("kal"),
+    extra_options: dict[str, Any] | None = None,
+) -> AudioStream:
+    """
+
+    Synthesize voice from text using libflite.
+
+    Args:
+        list_voices: list voices and exit (default false)
+        nb_samples: set number of samples per frame (from 0 to INT_MAX) (default 512)
+        text: set text to speak
+        textfile: set filename of the text to speak
+        v: set voice (default "kal")
+
+    Returns:
+        default: the audio stream
+
+    References:
+        [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#flite)
+
+    """
+    filter_node = filter_node_factory(
+        FFMpegFilterDef(name="flite", typings_input=(), typings_output=("audio",)),
+        **merge(
+            {
+                "list_voices": list_voices,
+                "nb_samples": nb_samples,
+                "text": text,
+                "textfile": textfile,
+                "v": v,
+            },
+            extra_options,
+        ),
+    )
+    return filter_node.audio(0)
+
+
 def frei0r_src(
     *,
     size: Image_size = Default("320x240"),
     framerate: Video_rate = Default("25"),
     filter_name: String = Default(None),
     filter_params: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -1181,13 +1405,15 @@ def frei0r_src(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="frei0r_src", typings_input=(), typings_output=("video",)),
-        **{
-            "size": size,
-            "framerate": framerate,
-            "filter_name": filter_name,
-            "filter_params": filter_params,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "size": size,
+                "framerate": framerate,
+                "filter_name": filter_name,
+                "filter_params": filter_params,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -1215,7 +1441,7 @@ def gradients(
     type: Int | Literal["linear", "radial", "circular", "spiral"] | Default = Default(
         "linear"
     ),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -1251,28 +1477,30 @@ def gradients(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="gradients", typings_input=(), typings_output=("video",)),
-        **{
-            "size": size,
-            "rate": rate,
-            "c0": c0,
-            "c1": c1,
-            "c2": c2,
-            "c3": c3,
-            "c4": c4,
-            "c5": c5,
-            "c6": c6,
-            "c7": c7,
-            "x0": x0,
-            "y0": y0,
-            "x1": x1,
-            "y1": y1,
-            "nb_colors": nb_colors,
-            "seed": seed,
-            "duration": duration,
-            "speed": speed,
-            "type": type,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "size": size,
+                "rate": rate,
+                "c0": c0,
+                "c1": c1,
+                "c2": c2,
+                "c3": c3,
+                "c4": c4,
+                "c5": c5,
+                "c6": c6,
+                "c7": c7,
+                "x0": x0,
+                "y0": y0,
+                "x1": x1,
+                "y1": y1,
+                "nb_colors": nb_colors,
+                "seed": seed,
+                "duration": duration,
+                "speed": speed,
+                "type": type,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -1286,7 +1514,7 @@ def guided(
     guidance: Int | Literal["off", "on"] | Default = Default("off"),
     planes: Int = Default(1),
     enable: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -1315,16 +1543,18 @@ def guided(
             typings_output=("video",),
         ),
         *streams,
-        **{
-            "radius": radius,
-            "eps": eps,
-            "mode": mode,
-            "sub": sub,
-            "guidance": guidance,
-            "planes": planes,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "radius": radius,
+                "eps": eps,
+                "mode": mode,
+                "sub": sub,
+                "guidance": guidance,
+                "planes": planes,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -1335,7 +1565,7 @@ def haldclutsrc(
     rate: Video_rate = Default("25"),
     duration: Duration = Default(-1e-06),
     sar: Rational = Default("1/1"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -1358,13 +1588,15 @@ def haldclutsrc(
         FFMpegFilterDef(
             name="haldclutsrc", typings_input=(), typings_output=("video",)
         ),
-        **{
-            "level": level,
-            "rate": rate,
-            "duration": duration,
-            "sar": sar,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "level": level,
+                "rate": rate,
+                "duration": duration,
+                "sar": sar,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -1377,7 +1609,7 @@ def headphone(
     type: Int | Literal["time", "freq"] | Default = Default("freq"),
     size: Int = Default(1024),
     hrir: Int | Literal["stereo", "multich"] | Default = Default("stereo"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> AudioStream:
     """
 
@@ -1405,15 +1637,17 @@ def headphone(
             typings_output=("audio",),
         ),
         *streams,
-        **{
-            "map": map,
-            "gain": gain,
-            "lfe": lfe,
-            "type": type,
-            "size": size,
-            "hrir": hrir,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "map": map,
+                "gain": gain,
+                "lfe": lfe,
+                "type": type,
+                "size": size,
+                "hrir": hrir,
+            },
+            extra_options,
+        ),
     )
     return filter_node.audio(0)
 
@@ -1471,7 +1705,7 @@ def hilbert(
         "kaiser",
     ]
     | Default = Default("blackman"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> AudioStream:
     """
 
@@ -1492,13 +1726,15 @@ def hilbert(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="hilbert", typings_input=(), typings_output=("audio",)),
-        **{
-            "sample_rate": sample_rate,
-            "taps": taps,
-            "nb_samples": nb_samples,
-            "win_func": win_func,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "sample_rate": sample_rate,
+                "taps": taps,
+                "nb_samples": nb_samples,
+                "win_func": win_func,
+            },
+            extra_options,
+        ),
     )
     return filter_node.audio(0)
 
@@ -1507,7 +1743,7 @@ def hstack(
     *streams: VideoStream,
     inputs: Int = Auto("len(streams)"),
     shortest: Boolean = Default(False),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -1531,11 +1767,55 @@ def hstack(
             typings_output=("video",),
         ),
         *streams,
-        **{
-            "inputs": inputs,
-            "shortest": shortest,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "inputs": inputs,
+                "shortest": shortest,
+            },
+            extra_options,
+        ),
+    )
+    return filter_node.video(0)
+
+
+def hstack_vaapi(
+    *streams: VideoStream,
+    inputs: Int = Default(2),
+    shortest: Boolean = Default(False),
+    height: Int = Default(0),
+    extra_options: dict[str, Any] | None = None,
+) -> VideoStream:
+    """
+
+    "VA-API" hstack
+
+    Args:
+        inputs: Set number of inputs (from 2 to 65535) (default 2)
+        shortest: Force termination when the shortest input terminates (default false)
+        height: Set output height (0 to use the height of input 0) (from 0 to 65535) (default 0)
+
+    Returns:
+        default: the video stream
+
+    References:
+        [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#hstack_005fvaapi)
+
+    """
+    filter_node = filter_node_factory(
+        FFMpegFilterDef(
+            name="hstack_vaapi",
+            typings_input="[StreamType.video] * int(inputs)",
+            typings_output=("video",),
+        ),
+        *streams,
+        **merge(
+            {
+                "inputs": inputs,
+                "shortest": shortest,
+                "height": height,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -1546,7 +1826,7 @@ def interleave(
     duration: Int | Literal["longest", "shortest", "first"] | Default = Default(
         "longest"
     ),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -1570,11 +1850,13 @@ def interleave(
             typings_output=("video",),
         ),
         *streams,
-        **{
-            "nb_inputs": nb_inputs,
-            "duration": duration,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "nb_inputs": nb_inputs,
+                "duration": duration,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -1584,7 +1866,7 @@ def join(
     inputs: Int = Auto("len(streams)"),
     channel_layout: String = Default("stereo"),
     map: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> AudioStream:
     """
 
@@ -1609,16 +1891,425 @@ def join(
             typings_output=("audio",),
         ),
         *streams,
-        **{
-            "inputs": inputs,
-            "channel_layout": channel_layout,
-            "map": map,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "inputs": inputs,
+                "channel_layout": channel_layout,
+                "map": map,
+            },
+            extra_options,
+        ),
+    )
+    return filter_node.audio(0)
+
+
+def ladspa(
+    *streams: AudioStream,
+    file: String = Default(None),
+    plugin: String = Default(None),
+    controls: String = Default(None),
+    sample_rate: Int = Default(44100),
+    nb_samples: Int = Default(1024),
+    duration: Duration = Default(-1e-06),
+    latency: Boolean = Default(False),
+    extra_options: dict[str, Any] | None = None,
+) -> AudioStream:
+    """
+
+    Apply LADSPA effect.
+
+    Args:
+        file: set library name or full path
+        plugin: set plugin name
+        controls: set plugin options
+        sample_rate: set sample rate (from 1 to INT_MAX) (default 44100)
+        nb_samples: set the number of samples per requested frame (from 1 to INT_MAX) (default 1024)
+        duration: set audio duration (default -0.000001)
+        latency: enable latency compensation (default false)
+
+    Returns:
+        default: the audio stream
+
+    References:
+        [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#ladspa)
+
+    """
+    filter_node = filter_node_factory(
+        FFMpegFilterDef(
+            name="ladspa", typings_input="[StreamType.audio]", typings_output=("audio",)
+        ),
+        *streams,
+        **merge(
+            {
+                "file": file,
+                "plugin": plugin,
+                "controls": controls,
+                "sample_rate": sample_rate,
+                "nb_samples": nb_samples,
+                "duration": duration,
+                "latency": latency,
+            },
+            extra_options,
+        ),
     )
     return filter_node.audio(0)
 
 
+def libplacebo(
+    *streams: VideoStream,
+    inputs: Int = Auto("len(streams)"),
+    w: String = Default("iw"),
+    h: String = Default("ih"),
+    fps: String = Default("none"),
+    crop_x: String = Default("(iw-cw"),
+    crop_y: String = Default("(ih-ch"),
+    crop_w: String = Default("iw"),
+    crop_h: String = Default("ih"),
+    pos_x: String = Default("(ow-pw"),
+    pos_y: String = Default("(oh-ph"),
+    pos_w: String = Default("ow"),
+    pos_h: String = Default("oh"),
+    format: String = Default(None),
+    force_original_aspect_ratio: Int
+    | Literal["disable", "decrease", "increase"]
+    | Default = Default("disable"),
+    force_divisible_by: Int = Default(1),
+    normalize_sar: Boolean = Default(False),
+    pad_crop_ratio: Float = Default(0.0),
+    fillcolor: String = Default("black"),
+    corner_rounding: Float = Default(0.0),
+    extra_opts: Dictionary = Default(None),
+    colorspace: Int
+    | Literal[
+        "auto",
+        "gbr",
+        "bt709",
+        "unknown",
+        "bt470bg",
+        "smpte170m",
+        "smpte240m",
+        "ycgco",
+        "bt2020nc",
+        "bt2020c",
+        "ictcp",
+    ]
+    | Default = Default("auto"),
+    range: Int
+    | Literal[
+        "auto", "unspecified", "unknown", "limited", "tv", "mpeg", "full", "pc", "jpeg"
+    ]
+    | Default = Default("auto"),
+    color_primaries: Int
+    | Literal[
+        "auto",
+        "bt709",
+        "unknown",
+        "bt470m",
+        "bt470bg",
+        "smpte170m",
+        "smpte240m",
+        "film",
+        "bt2020",
+        "smpte428",
+        "smpte431",
+        "smpte432",
+        "p22",
+        "ebu3213",
+    ]
+    | Default = Default("auto"),
+    color_trc: Int
+    | Literal[
+        "auto",
+        "bt709",
+        "unknown",
+        "bt470m",
+        "bt470bg",
+        "smpte170m",
+        "smpte240m",
+        "linear",
+        "4",
+        "bt1361e",
+        "1",
+        "10",
+        "12",
+        "smpte2084",
+        "b67",
+    ]
+    | Default = Default("auto"),
+    upscaler: String = Default("spline36"),
+    downscaler: String = Default("mitchell"),
+    frame_mixer: String = Default("none"),
+    lut_entries: Int = Default(0),
+    antiringing: Float = Default(0.0),
+    sigmoid: Boolean = Default(True),
+    apply_filmgrain: Boolean = Default(True),
+    apply_dolbyvision: Boolean = Default(True),
+    deband: Boolean = Default(False),
+    deband_iterations: Int = Default(1),
+    deband_threshold: Float = Default(4.0),
+    deband_radius: Float = Default(16.0),
+    deband_grain: Float = Default(6.0),
+    brightness: Float = Default(0.0),
+    contrast: Float = Default(1.0),
+    saturation: Float = Default(1.0),
+    hue: Float = Default(0.0),
+    gamma: Float = Default(1.0),
+    peak_detect: Boolean = Default(True),
+    smoothing_period: Float = Default(100.0),
+    minimum_peak: Float = Default(1.0),
+    scene_threshold_low: Float = Default(5.5),
+    scene_threshold_high: Float = Default(10.0),
+    percentile: Float = Default(99.995),
+    gamut_mode: Int
+    | Literal[
+        "clip",
+        "perceptual",
+        "relative",
+        "saturation",
+        "absolute",
+        "desaturate",
+        "darken",
+        "warn",
+        "linear",
+    ]
+    | Default = Default("perceptual"),
+    tonemapping: Int
+    | Literal[
+        "auto",
+        "clip",
+        "40",
+        "10",
+        "2390",
+        "2446a",
+        "spline",
+        "reinhard",
+        "mobius",
+        "hable",
+        "gamma",
+        "linear",
+    ]
+    | Default = Default("auto"),
+    tonemapping_param: Float = Default(0.0),
+    inverse_tonemapping: Boolean = Default(False),
+    tonemapping_lut_size: Int = Default(256),
+    contrast_recovery: Float = Default(0.3),
+    contrast_smoothness: Float = Default(3.5),
+    desaturation_strength: Float = Default(-1.0),
+    desaturation_exponent: Float = Default(-1.0),
+    gamut_warning: Boolean = Default(False),
+    gamut_clipping: Boolean = Default(False),
+    intent: Int
+    | Literal["perceptual", "relative", "absolute", "saturation"]
+    | Default = Default("perceptual"),
+    tonemapping_mode: Int
+    | Literal["auto", "rgb", "max", "hybrid", "luma"]
+    | Default = Default("auto"),
+    tonemapping_crosstalk: Float = Default(0.04),
+    overshoot: Float = Default(0.05),
+    hybrid_mix: Float = Default(0.2),
+    dithering: Int
+    | Literal["none", "blue", "ordered", "ordered_fixed", "white"]
+    | Default = Default("blue"),
+    dither_lut_size: Int = Default(6),
+    dither_temporal: Boolean = Default(False),
+    cones: Flags | Literal["l", "m", "s"] | Default = Default("0"),
+    cone_strength: Float = Default(0.0),
+    custom_shader_path: String = Default(None),
+    custom_shader_bin: Binary = Default(None),
+    skip_aa: Boolean = Default(False),
+    polar_cutoff: Float = Default(0.0),
+    disable_linear: Boolean = Default(False),
+    disable_builtin: Boolean = Default(False),
+    force_icc_lut: Boolean = Default(False),
+    force_dither: Boolean = Default(False),
+    disable_fbos: Boolean = Default(False),
+    extra_options: dict[str, Any] | None = None,
+) -> VideoStream:
+    """
+
+    Apply various GPU filters from libplacebo
+
+    Args:
+        inputs: Number of inputs (from 1 to INT_MAX) (default 1)
+        w: Output video frame width (default "iw")
+        h: Output video frame height (default "ih")
+        fps: Output video frame rate (default "none")
+        crop_x: Input video crop x (default "(iw-cw)/2")
+        crop_y: Input video crop y (default "(ih-ch)/2")
+        crop_w: Input video crop w (default "iw")
+        crop_h: Input video crop h (default "ih")
+        pos_x: Output video placement x (default "(ow-pw)/2")
+        pos_y: Output video placement y (default "(oh-ph)/2")
+        pos_w: Output video placement w (default "ow")
+        pos_h: Output video placement h (default "oh")
+        format: Output video format
+        force_original_aspect_ratio: decrease or increase w/h if necessary to keep the original AR (from 0 to 2) (default disable)
+        force_divisible_by: enforce that the output resolution is divisible by a defined integer when force_original_aspect_ratio is used (from 1 to 256) (default 1)
+        normalize_sar: force SAR normalization to 1:1 by adjusting pos_x/y/w/h (default false)
+        pad_crop_ratio: ratio between padding and cropping when normalizing SAR (0=pad, 1=crop) (from 0 to 1) (default 0)
+        fillcolor: Background fill color (default "black")
+        corner_rounding: Corner rounding radius (from 0 to 1) (default 0)
+        extra_opts: Pass extra libplacebo-specific options using a :-separated list of key=value pairs
+        colorspace: select colorspace (from -1 to 14) (default auto)
+        range: select color range (from -1 to 2) (default auto)
+        color_primaries: select color primaries (from -1 to 22) (default auto)
+        color_trc: select color transfer (from -1 to 18) (default auto)
+        upscaler: Upscaler function (default "spline36")
+        downscaler: Downscaler function (default "mitchell")
+        frame_mixer: Frame mixing function (default "none")
+        lut_entries: Number of scaler LUT entries (from 0 to 256) (default 0)
+        antiringing: Antiringing strength (for non-EWA filters) (from 0 to 1) (default 0)
+        sigmoid: Enable sigmoid upscaling (default true)
+        apply_filmgrain: Apply film grain metadata (default true)
+        apply_dolbyvision: Apply Dolby Vision metadata (default true)
+        deband: Enable debanding (default false)
+        deband_iterations: Deband iterations (from 0 to 16) (default 1)
+        deband_threshold: Deband threshold (from 0 to 1024) (default 4)
+        deband_radius: Deband radius (from 0 to 1024) (default 16)
+        deband_grain: Deband grain (from 0 to 1024) (default 6)
+        brightness: Brightness boost (from -1 to 1) (default 0)
+        contrast: Contrast gain (from 0 to 16) (default 1)
+        saturation: Saturation gain (from 0 to 16) (default 1)
+        hue: Hue shift (from -3.14159 to 3.14159) (default 0)
+        gamma: Gamma adjustment (from 0 to 16) (default 1)
+        peak_detect: Enable dynamic peak detection for HDR tone-mapping (default true)
+        smoothing_period: Peak detection smoothing period (from 0 to 1000) (default 100)
+        minimum_peak: Peak detection minimum peak (from 0 to 100) (default 1)
+        scene_threshold_low: Scene change low threshold (from -1 to 100) (default 5.5)
+        scene_threshold_high: Scene change high threshold (from -1 to 100) (default 10)
+        percentile: Peak detection percentile (from 0 to 100) (default 99.995)
+        gamut_mode: Gamut-mapping mode (from 0 to 8) (default perceptual)
+        tonemapping: Tone-mapping algorithm (from 0 to 11) (default auto)
+        tonemapping_param: Tunable parameter for some tone-mapping functions (from 0 to 100) (default 0)
+        inverse_tonemapping: Inverse tone mapping (range expansion) (default false)
+        tonemapping_lut_size: Tone-mapping LUT size (from 2 to 1024) (default 256)
+        contrast_recovery: HDR contrast recovery strength (from 0 to 3) (default 0.3)
+        contrast_smoothness: HDR contrast recovery smoothness (from 1 to 32) (default 3.5)
+        desaturation_strength: Desaturation strength (from -1 to 1) (default -1)
+        desaturation_exponent: Desaturation exponent (from -1 to 10) (default -1)
+        gamut_warning: Highlight out-of-gamut colors (default false)
+        gamut_clipping: Enable desaturating colorimetric gamut clipping (default false)
+        intent: Rendering intent (from 0 to 3) (default perceptual)
+        tonemapping_mode: Tone-mapping mode (from 0 to 4) (default auto)
+        tonemapping_crosstalk: Crosstalk factor for tone-mapping (from 0 to 0.3) (default 0.04)
+        overshoot: Tone-mapping overshoot margin (from 0 to 1) (default 0.05)
+        hybrid_mix: Tone-mapping hybrid LMS mixing coefficient (from 0 to 1) (default 0.2)
+        dithering: Dither method to use (from -1 to 3) (default blue)
+        dither_lut_size: Dithering LUT size (from 1 to 8) (default 6)
+        dither_temporal: Enable temporal dithering (default false)
+        cones: Colorblindness adaptation model (default 0)
+        cone_strength: Colorblindness adaptation strength (from 0 to 10) (default 0)
+        custom_shader_path: Path to custom user shader (mpv .hook format)
+        custom_shader_bin: Custom user shader as binary (mpv .hook format)
+        skip_aa: Skip anti-aliasing (default false)
+        polar_cutoff: Polar LUT cutoff (from 0 to 1) (default 0)
+        disable_linear: Disable linear scaling (default false)
+        disable_builtin: Disable built-in scalers (default false)
+        force_icc_lut: Deprecated, does nothing (default false)
+        force_dither: Force dithering (default false)
+        disable_fbos: Force-disable FBOs (default false)
+
+    Returns:
+        default: the video stream
+
+    References:
+        [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#libplacebo)
+
+    """
+    filter_node = filter_node_factory(
+        FFMpegFilterDef(
+            name="libplacebo",
+            typings_input="[StreamType.video] * int(inputs)",
+            typings_output=("video",),
+        ),
+        *streams,
+        **merge(
+            {
+                "inputs": inputs,
+                "w": w,
+                "h": h,
+                "fps": fps,
+                "crop_x": crop_x,
+                "crop_y": crop_y,
+                "crop_w": crop_w,
+                "crop_h": crop_h,
+                "pos_x": pos_x,
+                "pos_y": pos_y,
+                "pos_w": pos_w,
+                "pos_h": pos_h,
+                "format": format,
+                "force_original_aspect_ratio": force_original_aspect_ratio,
+                "force_divisible_by": force_divisible_by,
+                "normalize_sar": normalize_sar,
+                "pad_crop_ratio": pad_crop_ratio,
+                "fillcolor": fillcolor,
+                "corner_rounding": corner_rounding,
+                "extra_opts": extra_opts,
+                "colorspace": colorspace,
+                "range": range,
+                "color_primaries": color_primaries,
+                "color_trc": color_trc,
+                "upscaler": upscaler,
+                "downscaler": downscaler,
+                "frame_mixer": frame_mixer,
+                "lut_entries": lut_entries,
+                "antiringing": antiringing,
+                "sigmoid": sigmoid,
+                "apply_filmgrain": apply_filmgrain,
+                "apply_dolbyvision": apply_dolbyvision,
+                "deband": deband,
+                "deband_iterations": deband_iterations,
+                "deband_threshold": deband_threshold,
+                "deband_radius": deband_radius,
+                "deband_grain": deband_grain,
+                "brightness": brightness,
+                "contrast": contrast,
+                "saturation": saturation,
+                "hue": hue,
+                "gamma": gamma,
+                "peak_detect": peak_detect,
+                "smoothing_period": smoothing_period,
+                "minimum_peak": minimum_peak,
+                "scene_threshold_low": scene_threshold_low,
+                "scene_threshold_high": scene_threshold_high,
+                "percentile": percentile,
+                "gamut_mode": gamut_mode,
+                "tonemapping": tonemapping,
+                "tonemapping_param": tonemapping_param,
+                "inverse_tonemapping": inverse_tonemapping,
+                "tonemapping_lut_size": tonemapping_lut_size,
+                "contrast_recovery": contrast_recovery,
+                "contrast_smoothness": contrast_smoothness,
+                "desaturation_strength": desaturation_strength,
+                "desaturation_exponent": desaturation_exponent,
+                "gamut_warning": gamut_warning,
+                "gamut_clipping": gamut_clipping,
+                "intent": intent,
+                "tonemapping_mode": tonemapping_mode,
+                "tonemapping_crosstalk": tonemapping_crosstalk,
+                "overshoot": overshoot,
+                "hybrid_mix": hybrid_mix,
+                "dithering": dithering,
+                "dither_lut_size": dither_lut_size,
+                "dither_temporal": dither_temporal,
+                "cones": cones,
+                "cone-strength": cone_strength,
+                "custom_shader_path": custom_shader_path,
+                "custom_shader_bin": custom_shader_bin,
+                "skip_aa": skip_aa,
+                "polar_cutoff": polar_cutoff,
+                "disable_linear": disable_linear,
+                "disable_builtin": disable_builtin,
+                "force_icc_lut": force_icc_lut,
+                "force_dither": force_dither,
+                "disable_fbos": disable_fbos,
+            },
+            extra_options,
+        ),
+    )
+    return filter_node.video(0)
+
+
 def life(
     *,
     filename: String = Default(None),
@@ -1632,7 +2323,7 @@ def life(
     life_color: Color = Default("white"),
     death_color: Color = Default("black"),
     mold_color: Color = Default("black"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -1660,20 +2351,22 @@ def life(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="life", typings_input=(), typings_output=("video",)),
-        **{
-            "filename": filename,
-            "size": size,
-            "rate": rate,
-            "rule": rule,
-            "random_fill_ratio": random_fill_ratio,
-            "random_seed": random_seed,
-            "stitch": stitch,
-            "mold": mold,
-            "life_color": life_color,
-            "death_color": death_color,
-            "mold_color": mold_color,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "filename": filename,
+                "size": size,
+                "rate": rate,
+                "rule": rule,
+                "random_fill_ratio": random_fill_ratio,
+                "random_seed": random_seed,
+                "stitch": stitch,
+                "mold": mold,
+                "life_color": life_color,
+                "death_color": death_color,
+                "mold_color": mold_color,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -1685,7 +2378,7 @@ def limitdiff(
     reference: Boolean = Default(False),
     planes: Int = Default(15),
     enable: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -1712,18 +2405,66 @@ def limitdiff(
             typings_output=("video",),
         ),
         *streams,
-        **{
-            "threshold": threshold,
-            "elasticity": elasticity,
-            "reference": reference,
-            "planes": planes,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "threshold": threshold,
+                "elasticity": elasticity,
+                "reference": reference,
+                "planes": planes,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
 
+def lv2(
+    *streams: AudioStream,
+    plugin: String = Default(None),
+    controls: String = Default(None),
+    sample_rate: Int = Default(44100),
+    nb_samples: Int = Default(1024),
+    duration: Duration = Default(-1e-06),
+    extra_options: dict[str, Any] | None = None,
+) -> AudioStream:
+    """
+
+    Apply LV2 effect.
+
+    Args:
+        plugin: set plugin uri
+        controls: set plugin options
+        sample_rate: set sample rate (from 1 to INT_MAX) (default 44100)
+        nb_samples: set the number of samples per requested frame (from 1 to INT_MAX) (default 1024)
+        duration: set audio duration (default -0.000001)
+
+    Returns:
+        default: the audio stream
+
+    References:
+        [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#lv2)
+
+    """
+    filter_node = filter_node_factory(
+        FFMpegFilterDef(
+            name="lv2", typings_input="[StreamType.audio]", typings_output=("audio",)
+        ),
+        *streams,
+        **merge(
+            {
+                "plugin": plugin,
+                "controls": controls,
+                "sample_rate": sample_rate,
+                "nb_samples": nb_samples,
+                "duration": duration,
+            },
+            extra_options,
+        ),
+    )
+    return filter_node.audio(0)
+
+
 def mandelbrot(
     *,
     size: Image_size = Default("640x480"),
@@ -1744,7 +2485,7 @@ def mandelbrot(
     inner: Int
     | Literal["black", "period", "convergence", "mincol"]
     | Default = Default("mincol"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -1775,23 +2516,25 @@ def mandelbrot(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="mandelbrot", typings_input=(), typings_output=("video",)),
-        **{
-            "size": size,
-            "rate": rate,
-            "maxiter": maxiter,
-            "start_x": start_x,
-            "start_y": start_y,
-            "start_scale": start_scale,
-            "end_scale": end_scale,
-            "end_pts": end_pts,
-            "bailout": bailout,
-            "morphxf": morphxf,
-            "morphyf": morphyf,
-            "morphamp": morphamp,
-            "outer": outer,
-            "inner": inner,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "size": size,
+                "rate": rate,
+                "maxiter": maxiter,
+                "start_x": start_x,
+                "start_y": start_y,
+                "start_scale": start_scale,
+                "end_scale": end_scale,
+                "end_pts": end_pts,
+                "bailout": bailout,
+                "morphxf": morphxf,
+                "morphyf": morphyf,
+                "morphamp": morphamp,
+                "outer": outer,
+                "inner": inner,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -1808,7 +2551,7 @@ def mergeplanes(
     map2p: Int = Default(0),
     map3s: Int = Default(0),
     map3p: Int = Default(0),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -1840,19 +2583,21 @@ def mergeplanes(
             typings_output=("video",),
         ),
         *streams,
-        **{
-            "mapping": mapping,
-            "format": format,
-            "map0s": map0s,
-            "map0p": map0p,
-            "map1s": map1s,
-            "map1p": map1p,
-            "map2s": map2s,
-            "map2p": map2p,
-            "map3s": map3s,
-            "map3p": map3p,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "mapping": mapping,
+                "format": format,
+                "map0s": map0s,
+                "map0p": map0p,
+                "map1s": map1s,
+                "map1p": map1p,
+                "map2s": map2s,
+                "map2p": map2p,
+                "map3s": map3s,
+                "map3p": map3p,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -1867,7 +2612,7 @@ def mix(
         "longest"
     ),
     enable: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -1895,15 +2640,17 @@ def mix(
             typings_output=("video",),
         ),
         *streams,
-        **{
-            "inputs": inputs,
-            "weights": weights,
-            "scale": scale,
-            "planes": planes,
-            "duration": duration,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "inputs": inputs,
+                "weights": weights,
+                "scale": scale,
+                "planes": planes,
+                "duration": duration,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -1919,7 +2666,7 @@ def movie(
     discontinuity: Duration = Default(0.0),
     dec_threads: Int = Default(0),
     format_opts: Dictionary = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> FilterNode:
     """
 
@@ -1950,18 +2697,20 @@ def movie(
             typings_input="[StreamType.video] * len(streams.split('+'))",
             typings_output="[StreamType.video] * len(streams.split('+'))",
         ),
-        **{
-            "filename": filename,
-            "format_name": format_name,
-            "stream_index": stream_index,
-            "seek_point": seek_point,
-            "streams": streams,
-            "loop": loop,
-            "discontinuity": discontinuity,
-            "dec_threads": dec_threads,
-            "format_opts": format_opts,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "filename": filename,
+                "format_name": format_name,
+                "stream_index": stream_index,
+                "seek_point": seek_point,
+                "streams": streams,
+                "loop": loop,
+                "discontinuity": discontinuity,
+                "dec_threads": dec_threads,
+                "format_opts": format_opts,
+            },
+            extra_options,
+        ),
     )
 
     return filter_node
@@ -1987,7 +2736,7 @@ def mptestsrc(
     ]
     | Default = Default("all"),
     max_frames: Int64 = Default(30),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -2008,13 +2757,15 @@ def mptestsrc(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="mptestsrc", typings_input=(), typings_output=("video",)),
-        **{
-            "rate": rate,
-            "duration": duration,
-            "test": test,
-            "max_frames": max_frames,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "rate": rate,
+                "duration": duration,
+                "test": test,
+                "max_frames": max_frames,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2025,7 +2776,7 @@ def nullsrc(
     rate: Video_rate = Default("25"),
     duration: Duration = Default(-1e-06),
     sar: Rational = Default("1/1"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -2046,13 +2797,58 @@ def nullsrc(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="nullsrc", typings_input=(), typings_output=("video",)),
-        **{
-            "size": size,
-            "rate": rate,
-            "duration": duration,
-            "sar": sar,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "size": size,
+                "rate": rate,
+                "duration": duration,
+                "sar": sar,
+            },
+            extra_options,
+        ),
+    )
+    return filter_node.video(0)
+
+
+def openclsrc(
+    *,
+    source: String = Default(None),
+    kernel: String = Default(None),
+    size: Image_size = Default(None),
+    format: Pix_fmt = Default("none"),
+    rate: Video_rate = Default("25"),
+    extra_options: dict[str, Any] | None = None,
+) -> VideoStream:
+    """
+
+    Generate video using an OpenCL program
+
+    Args:
+        source: OpenCL program source file
+        kernel: Kernel name in program
+        size: Video size
+        format: Video format (default none)
+        rate: Video frame rate (default "25")
+
+    Returns:
+        default: the video stream
+
+    References:
+        [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#openclsrc)
+
+    """
+    filter_node = filter_node_factory(
+        FFMpegFilterDef(name="openclsrc", typings_input=(), typings_output=("video",)),
+        **merge(
+            {
+                "source": source,
+                "kernel": kernel,
+                "size": size,
+                "format": format,
+                "rate": rate,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2063,7 +2859,7 @@ def pal100bars(
     rate: Video_rate = Default("25"),
     duration: Duration = Default(-1e-06),
     sar: Rational = Default("1/1"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -2084,13 +2880,15 @@ def pal100bars(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="pal100bars", typings_input=(), typings_output=("video",)),
-        **{
-            "size": size,
-            "rate": rate,
-            "duration": duration,
-            "sar": sar,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "size": size,
+                "rate": rate,
+                "duration": duration,
+                "sar": sar,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2101,7 +2899,7 @@ def pal75bars(
     rate: Video_rate = Default("25"),
     duration: Duration = Default(-1e-06),
     sar: Rational = Default("1/1"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -2122,13 +2920,15 @@ def pal75bars(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="pal75bars", typings_input=(), typings_output=("video",)),
-        **{
-            "size": size,
-            "rate": rate,
-            "duration": duration,
-            "sar": sar,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "size": size,
+                "rate": rate,
+                "duration": duration,
+                "sar": sar,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2138,7 +2938,7 @@ def premultiply(
     planes: Int = Default(15),
     inplace: Boolean = Default(False),
     enable: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -2163,12 +2963,71 @@ def premultiply(
             typings_output=("video",),
         ),
         *streams,
-        **{
-            "planes": planes,
-            "inplace": inplace,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "planes": planes,
+                "inplace": inplace,
+                "enable": enable,
+            },
+            extra_options,
+        ),
+    )
+    return filter_node.video(0)
+
+
+def program_opencl(
+    *streams: VideoStream,
+    source: String = Default(None),
+    kernel: String = Default(None),
+    inputs: Int = Default(1),
+    size: Image_size = Default(None),
+    eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default("repeat"),
+    shortest: Boolean = Default(False),
+    repeatlast: Boolean = Default(True),
+    ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default("default"),
+    extra_options: dict[str, Any] | None = None,
+) -> VideoStream:
+    """
+
+    Filter video using an OpenCL program
+
+    Args:
+        source: OpenCL program source file
+        kernel: Kernel name in program
+        inputs: Number of inputs (from 1 to INT_MAX) (default 1)
+        size: Video size
+        eof_action: Action to take when encountering EOF from secondary input (from 0 to 2) (default repeat)
+        shortest: force termination when the shortest input terminates (default false)
+        repeatlast: extend last frame of secondary streams beyond EOF (default true)
+        ts_sync_mode: How strictly to sync streams based on secondary input timestamps (from 0 to 1) (default default)
+
+    Returns:
+        default: the video stream
+
+    References:
+        [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#program_005fopencl)
+
+    """
+    filter_node = filter_node_factory(
+        FFMpegFilterDef(
+            name="program_opencl",
+            typings_input="[StreamType.video] * int(inputs)",
+            typings_output=("video",),
+        ),
+        *streams,
+        **merge(
+            {
+                "source": source,
+                "kernel": kernel,
+                "inputs": inputs,
+                "size": size,
+                "eof_action": eof_action,
+                "shortest": shortest,
+                "repeatlast": repeatlast,
+                "ts_sync_mode": ts_sync_mode,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2180,7 +3039,7 @@ def rgbtestsrc(
     duration: Duration = Default(-1e-06),
     sar: Rational = Default("1/1"),
     complement: Boolean = Default(False),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -2202,14 +3061,16 @@ def rgbtestsrc(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="rgbtestsrc", typings_input=(), typings_output=("video",)),
-        **{
-            "size": size,
-            "rate": rate,
-            "duration": duration,
-            "sar": sar,
-            "complement": complement,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "size": size,
+                "rate": rate,
+                "duration": duration,
+                "sar": sar,
+                "complement": complement,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2221,7 +3082,7 @@ def sierpinski(
     seed: Int64 = Default(-1),
     jump: Int = Default(100),
     type: Int | Literal["carpet", "triangle"] | Default = Default("carpet"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -2243,14 +3104,16 @@ def sierpinski(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="sierpinski", typings_input=(), typings_output=("video",)),
-        **{
-            "size": size,
-            "rate": rate,
-            "seed": seed,
-            "jump": jump,
-            "type": type,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "size": size,
+                "rate": rate,
+                "seed": seed,
+                "jump": jump,
+                "type": type,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2266,7 +3129,7 @@ def signature(
     th_xh: Int = Default(116),
     th_di: Int = Default(0),
     th_it: Double = Default(0.5),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -2297,18 +3160,20 @@ def signature(
             typings_output=("video",),
         ),
         *streams,
-        **{
-            "detectmode": detectmode,
-            "nb_inputs": nb_inputs,
-            "filename": filename,
-            "format": format,
-            "th_d": th_d,
-            "th_dc": th_dc,
-            "th_xh": th_xh,
-            "th_di": th_di,
-            "th_it": th_it,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "detectmode": detectmode,
+                "nb_inputs": nb_inputs,
+                "filename": filename,
+                "format": format,
+                "th_d": th_d,
+                "th_dc": th_dc,
+                "th_xh": th_xh,
+                "th_di": th_di,
+                "th_it": th_it,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2325,7 +3190,7 @@ def sinc(
     round: Boolean = Default(False),
     hptaps: Int = Default(0),
     lptaps: Int = Default(0),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> AudioStream:
     """
 
@@ -2352,19 +3217,21 @@ def sinc(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="sinc", typings_input=(), typings_output=("audio",)),
-        **{
-            "sample_rate": sample_rate,
-            "nb_samples": nb_samples,
-            "hp": hp,
-            "lp": lp,
-            "phase": phase,
-            "beta": beta,
-            "att": att,
-            "round": round,
-            "hptaps": hptaps,
-            "lptaps": lptaps,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "sample_rate": sample_rate,
+                "nb_samples": nb_samples,
+                "hp": hp,
+                "lp": lp,
+                "phase": phase,
+                "beta": beta,
+                "att": att,
+                "round": round,
+                "hptaps": hptaps,
+                "lptaps": lptaps,
+            },
+            extra_options,
+        ),
     )
     return filter_node.audio(0)
 
@@ -2376,7 +3243,7 @@ def sine(
     sample_rate: Int = Default(44100),
     duration: Duration = Default(0.0),
     samples_per_frame: String = Default("1024"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> AudioStream:
     """
 
@@ -2398,14 +3265,16 @@ def sine(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="sine", typings_input=(), typings_output=("audio",)),
-        **{
-            "frequency": frequency,
-            "beep_factor": beep_factor,
-            "sample_rate": sample_rate,
-            "duration": duration,
-            "samples_per_frame": samples_per_frame,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "frequency": frequency,
+                "beep_factor": beep_factor,
+                "sample_rate": sample_rate,
+                "duration": duration,
+                "samples_per_frame": samples_per_frame,
+            },
+            extra_options,
+        ),
     )
     return filter_node.audio(0)
 
@@ -2416,7 +3285,7 @@ def smptebars(
     rate: Video_rate = Default("25"),
     duration: Duration = Default(-1e-06),
     sar: Rational = Default("1/1"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -2437,13 +3306,15 @@ def smptebars(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="smptebars", typings_input=(), typings_output=("video",)),
-        **{
-            "size": size,
-            "rate": rate,
-            "duration": duration,
-            "sar": sar,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "size": size,
+                "rate": rate,
+                "duration": duration,
+                "sar": sar,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2454,7 +3325,7 @@ def smptehdbars(
     rate: Video_rate = Default("25"),
     duration: Duration = Default(-1e-06),
     sar: Rational = Default("1/1"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -2477,13 +3348,15 @@ def smptehdbars(
         FFMpegFilterDef(
             name="smptehdbars", typings_input=(), typings_output=("video",)
         ),
-        **{
-            "size": size,
-            "rate": rate,
-            "duration": duration,
-            "sar": sar,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "size": size,
+                "rate": rate,
+                "duration": duration,
+                "sar": sar,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2492,7 +3365,7 @@ def streamselect(
     *streams: VideoStream,
     inputs: Int = Auto("len(streams)"),
     map: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> FilterNode:
     """
 
@@ -2517,11 +3390,13 @@ def streamselect(
             typings_output="[StreamType.video] * len(re.findall(r'\\d+', str(map)))",
         ),
         *streams,
-        **{
-            "inputs": inputs,
-            "map": map,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "inputs": inputs,
+                "map": map,
+            },
+            extra_options,
+        ),
     )
 
     return filter_node
@@ -2534,7 +3409,7 @@ def testsrc(
     duration: Duration = Default(-1e-06),
     sar: Rational = Default("1/1"),
     decimals: Int = Default(0),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -2556,14 +3431,16 @@ def testsrc(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="testsrc", typings_input=(), typings_output=("video",)),
-        **{
-            "size": size,
-            "rate": rate,
-            "duration": duration,
-            "sar": sar,
-            "decimals": decimals,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "size": size,
+                "rate": rate,
+                "duration": duration,
+                "sar": sar,
+                "decimals": decimals,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2575,7 +3452,7 @@ def testsrc2(
     duration: Duration = Default(-1e-06),
     sar: Rational = Default("1/1"),
     alpha: Int = Default(255),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -2597,14 +3474,16 @@ def testsrc2(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="testsrc2", typings_input=(), typings_output=("video",)),
-        **{
-            "size": size,
-            "rate": rate,
-            "duration": duration,
-            "sar": sar,
-            "alpha": alpha,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "size": size,
+                "rate": rate,
+                "duration": duration,
+                "sar": sar,
+                "alpha": alpha,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2614,7 +3493,7 @@ def unpremultiply(
     planes: Int = Default(15),
     inplace: Boolean = Default(False),
     enable: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -2639,12 +3518,14 @@ def unpremultiply(
             typings_output=("video",),
         ),
         *streams,
-        **{
-            "planes": planes,
-            "inplace": inplace,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "planes": planes,
+                "inplace": inplace,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2653,7 +3534,7 @@ def vstack(
     *streams: VideoStream,
     inputs: Int = Auto("len(streams)"),
     shortest: Boolean = Default(False),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -2677,11 +3558,55 @@ def vstack(
             typings_output=("video",),
         ),
         *streams,
-        **{
-            "inputs": inputs,
-            "shortest": shortest,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "inputs": inputs,
+                "shortest": shortest,
+            },
+            extra_options,
+        ),
+    )
+    return filter_node.video(0)
+
+
+def vstack_vaapi(
+    *streams: VideoStream,
+    inputs: Int = Default(2),
+    shortest: Boolean = Default(False),
+    width: Int = Default(0),
+    extra_options: dict[str, Any] | None = None,
+) -> VideoStream:
+    """
+
+    "VA-API" vstack
+
+    Args:
+        inputs: Set number of inputs (from 2 to 65535) (default 2)
+        shortest: Force termination when the shortest input terminates (default false)
+        width: Set output width (0 to use the width of input 0) (from 0 to 65535) (default 0)
+
+    Returns:
+        default: the video stream
+
+    References:
+        [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#vstack_005fvaapi)
+
+    """
+    filter_node = filter_node_factory(
+        FFMpegFilterDef(
+            name="vstack_vaapi",
+            typings_input="[StreamType.video] * int(inputs)",
+            typings_output=("video",),
+        ),
+        *streams,
+        **merge(
+            {
+                "inputs": inputs,
+                "shortest": shortest,
+                "width": width,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2696,7 +3621,7 @@ def xmedian(
     repeatlast: Boolean = Default(True),
     ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default("default"),
     enable: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -2726,17 +3651,19 @@ def xmedian(
             typings_output=("video",),
         ),
         *streams,
-        **{
-            "inputs": inputs,
-            "planes": planes,
-            "percentile": percentile,
-            "eof_action": eof_action,
-            "shortest": shortest,
-            "repeatlast": repeatlast,
-            "ts_sync_mode": ts_sync_mode,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "inputs": inputs,
+                "planes": planes,
+                "percentile": percentile,
+                "eof_action": eof_action,
+                "shortest": shortest,
+                "repeatlast": repeatlast,
+                "ts_sync_mode": ts_sync_mode,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2748,7 +3675,7 @@ def xstack(
     grid: Image_size = Default(None),
     shortest: Boolean = Default(False),
     fill: String = Default("none"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -2775,14 +3702,67 @@ def xstack(
             typings_output=("video",),
         ),
         *streams,
-        **{
-            "inputs": inputs,
-            "layout": layout,
-            "grid": grid,
-            "shortest": shortest,
-            "fill": fill,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "inputs": inputs,
+                "layout": layout,
+                "grid": grid,
+                "shortest": shortest,
+                "fill": fill,
+            },
+            extra_options,
+        ),
+    )
+    return filter_node.video(0)
+
+
+def xstack_vaapi(
+    *streams: VideoStream,
+    inputs: Int = Default(2),
+    shortest: Boolean = Default(False),
+    layout: String = Default(None),
+    grid: Image_size = Default(None),
+    grid_tile_size: Image_size = Default(None),
+    fill: String = Default("none"),
+    extra_options: dict[str, Any] | None = None,
+) -> VideoStream:
+    """
+
+    "VA-API" xstack
+
+    Args:
+        inputs: Set number of inputs (from 2 to 65535) (default 2)
+        shortest: Force termination when the shortest input terminates (default false)
+        layout: Set custom layout
+        grid: set fixed size grid layout
+        grid_tile_size: set tile size in grid layout
+        fill: Set the color for unused pixels (default "none")
+
+    Returns:
+        default: the video stream
+
+    References:
+        [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#xstack_005fvaapi)
+
+    """
+    filter_node = filter_node_factory(
+        FFMpegFilterDef(
+            name="xstack_vaapi",
+            typings_input="[StreamType.video] * int(inputs)",
+            typings_output=("video",),
+        ),
+        *streams,
+        **merge(
+            {
+                "inputs": inputs,
+                "shortest": shortest,
+                "layout": layout,
+                "grid": grid,
+                "grid_tile_size": grid_tile_size,
+                "fill": fill,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2793,7 +3773,7 @@ def yuvtestsrc(
     rate: Video_rate = Default("25"),
     duration: Duration = Default(-1e-06),
     sar: Rational = Default("1/1"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -2814,12 +3794,102 @@ def yuvtestsrc(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(name="yuvtestsrc", typings_input=(), typings_output=("video",)),
-        **{
-            "size": size,
-            "rate": rate,
-            "duration": duration,
-            "sar": sar,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "size": size,
+                "rate": rate,
+                "duration": duration,
+                "sar": sar,
+            },
+            extra_options,
+        ),
+    )
+    return filter_node.video(0)
+
+
+def zoneplate(
+    *,
+    size: Image_size = Default("320x240"),
+    rate: Video_rate = Default("25"),
+    duration: Duration = Default(-1e-06),
+    sar: Rational = Default("1/1"),
+    precision: Int = Default(10),
+    xo: Int = Default(0),
+    yo: Int = Default(0),
+    to: Int = Default(0),
+    k0: Int = Default(0),
+    kx: Int = Default(0),
+    ky: Int = Default(0),
+    kt: Int = Default(0),
+    kxt: Int = Default(0),
+    kyt: Int = Default(0),
+    kxy: Int = Default(0),
+    kx2: Int = Default(0),
+    ky2: Int = Default(0),
+    kt2: Int = Default(0),
+    ku: Int = Default(0),
+    kv: Int = Default(0),
+    extra_options: dict[str, Any] | None = None,
+) -> VideoStream:
+    """
+
+    Generate zone-plate.
+
+    Args:
+        size: set video size (default "320x240")
+        rate: set video rate (default "25")
+        duration: set video duration (default -0.000001)
+        sar: set video sample aspect ratio (from 0 to INT_MAX) (default 1/1)
+        precision: set LUT precision (from 4 to 16) (default 10)
+        xo: set X-axis offset (from INT_MIN to INT_MAX) (default 0)
+        yo: set Y-axis offset (from INT_MIN to INT_MAX) (default 0)
+        to: set T-axis offset (from INT_MIN to INT_MAX) (default 0)
+        k0: set 0-order phase (from INT_MIN to INT_MAX) (default 0)
+        kx: set 1-order X-axis phase (from INT_MIN to INT_MAX) (default 0)
+        ky: set 1-order Y-axis phase (from INT_MIN to INT_MAX) (default 0)
+        kt: set 1-order T-axis phase (from INT_MIN to INT_MAX) (default 0)
+        kxt: set X-axis*T-axis product phase (from INT_MIN to INT_MAX) (default 0)
+        kyt: set Y-axis*T-axis product phase (from INT_MIN to INT_MAX) (default 0)
+        kxy: set X-axis*Y-axis product phase (from INT_MIN to INT_MAX) (default 0)
+        kx2: set 2-order X-axis phase (from INT_MIN to INT_MAX) (default 0)
+        ky2: set 2-order Y-axis phase (from INT_MIN to INT_MAX) (default 0)
+        kt2: set 2-order T-axis phase (from INT_MIN to INT_MAX) (default 0)
+        ku: set 0-order U-color phase (from INT_MIN to INT_MAX) (default 0)
+        kv: set 0-order V-color phase (from INT_MIN to INT_MAX) (default 0)
+
+    Returns:
+        default: the video stream
+
+    References:
+        [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#zoneplate)
+
+    """
+    filter_node = filter_node_factory(
+        FFMpegFilterDef(name="zoneplate", typings_input=(), typings_output=("video",)),
+        **merge(
+            {
+                "size": size,
+                "rate": rate,
+                "duration": duration,
+                "sar": sar,
+                "precision": precision,
+                "xo": xo,
+                "yo": yo,
+                "to": to,
+                "k0": k0,
+                "kx": kx,
+                "ky": ky,
+                "kt": kt,
+                "kxt": kxt,
+                "kyt": kyt,
+                "kxy": kxy,
+                "kx2": kx2,
+                "ky2": ky2,
+                "kt2": kt2,
+                "ku": ku,
+                "kv": kv,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)