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

typed_ffmpeg/filters.py

@@ -1,4 +1,6 @@
 # NOTE: this file is auto-generated, do not modify
+
+
 from typing import Any, Literal
 
 from .common.schema import FFMpegFilterDef
@@ -8,8 +10,10 @@ from .schema import Auto, Default
 from .streams.audio import AudioStream
 from .streams.video import VideoStream
 from .types import (
+    Binary,
     Boolean,
     Color,
+    Dictionary,
     Double,
     Duration,
     Flags,
@@ -20,6 +24,7 @@ from .types import (
     Pix_fmt,
     String,
 )
+from .utils.frozendict import merge
 
 
 def acrossfade(
@@ -85,7 +90,7 @@ def acrossfade(
         "hsin2",
     ]
     | Default = Default("tri"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> AudioStream:
     """
 
@@ -113,14 +118,16 @@ def acrossfade(
         ),
         _crossfade0,
         _crossfade1,
-        **{
-            "nb_samples": nb_samples,
-            "duration": duration,
-            "overlap": overlap,
-            "curve1": curve1,
-            "curve2": curve2,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "nb_samples": nb_samples,
+                "duration": duration,
+                "overlap": overlap,
+                "curve1": curve1,
+                "curve2": curve2,
+            },
+            extra_options,
+        ),
     )
     return filter_node.audio(0)
 
@@ -131,7 +138,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:
     """
 
@@ -155,11 +162,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)
 
@@ -173,7 +182,7 @@ def alphamerge(
     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:
     """
 
@@ -201,14 +210,16 @@ def alphamerge(
         ),
         _main,
         _alpha,
-        **{
-            "eof_action": eof_action,
-            "shortest": shortest,
-            "repeatlast": repeatlast,
-            "ts_sync_mode": ts_sync_mode,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "eof_action": eof_action,
+                "shortest": shortest,
+                "repeatlast": repeatlast,
+                "ts_sync_mode": ts_sync_mode,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -216,7 +227,7 @@ def alphamerge(
 def amerge(
     *streams: AudioStream,
     inputs: Int = Auto("len(streams)"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> AudioStream:
     """
 
@@ -239,10 +250,12 @@ def amerge(
             typings_output=("audio",),
         ),
         *streams,
-        **{
-            "inputs": inputs,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "inputs": inputs,
+            },
+            extra_options,
+        ),
     )
     return filter_node.audio(0)
 
@@ -256,7 +269,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:
     """
 
@@ -283,14 +296,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)
 
@@ -298,7 +313,7 @@ def amix(
 def amultiply(
     _multiply0: AudioStream,
     _multiply1: AudioStream,
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> AudioStream:
     """
 
@@ -319,7 +334,7 @@ def amultiply(
         ),
         _multiply0,
         _multiply1,
-        **{} | (extra_options or {}),
+        **merge({}, extra_options),
     )
     return filter_node.audio(0)
 
@@ -334,7 +349,7 @@ def anlmf(
     leakage: Float = Default(0.0),
     out_mode: Int | Literal["i", "d", "o", "n", "e"] | Default = Default("o"),
     enable: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> AudioStream:
     """
 
@@ -361,15 +376,17 @@ def anlmf(
         ),
         _input,
         _desired,
-        **{
-            "order": order,
-            "mu": mu,
-            "eps": eps,
-            "leakage": leakage,
-            "out_mode": out_mode,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "order": order,
+                "mu": mu,
+                "eps": eps,
+                "leakage": leakage,
+                "out_mode": out_mode,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.audio(0)
 
@@ -384,7 +401,7 @@ def anlms(
     leakage: Float = Default(0.0),
     out_mode: Int | Literal["i", "d", "o", "n", "e"] | Default = Default("o"),
     enable: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> AudioStream:
     """
 
@@ -411,15 +428,17 @@ def anlms(
         ),
         _input,
         _desired,
-        **{
-            "order": order,
-            "mu": mu,
-            "eps": eps,
-            "leakage": leakage,
-            "out_mode": out_mode,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "order": order,
+                "mu": mu,
+                "eps": eps,
+                "leakage": leakage,
+                "out_mode": out_mode,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.audio(0)
 
@@ -429,7 +448,7 @@ def apsnr(
     _input1: AudioStream,
     *,
     enable: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> AudioStream:
     """
 
@@ -451,10 +470,12 @@ def apsnr(
         ),
         _input0,
         _input1,
-        **{
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.audio(0)
 
@@ -468,7 +489,7 @@ def arls(
     delta: Float = Default(2.0),
     out_mode: Int | Literal["i", "d", "o", "n", "e"] | Default = Default("o"),
     enable: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> AudioStream:
     """
 
@@ -494,14 +515,16 @@ def arls(
         ),
         _input,
         _desired,
-        **{
-            "order": order,
-            "lambda": _lambda,
-            "delta": delta,
-            "out_mode": out_mode,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "order": order,
+                "lambda": _lambda,
+                "delta": delta,
+                "out_mode": out_mode,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.audio(0)
 
@@ -511,7 +534,7 @@ def asdr(
     _input1: AudioStream,
     *,
     enable: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> AudioStream:
     """
 
@@ -533,10 +556,12 @@ def asdr(
         ),
         _input0,
         _input1,
-        **{
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.audio(0)
 
@@ -546,7 +571,7 @@ def asisdr(
     _input1: AudioStream,
     *,
     enable: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> AudioStream:
     """
 
@@ -568,10 +593,12 @@ def asisdr(
         ),
         _input0,
         _input1,
-        **{
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.audio(0)
 
@@ -580,7 +607,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:
     """
 
@@ -605,11 +632,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
@@ -621,7 +650,7 @@ def axcorrelate(
     *,
     size: Int = Default(256),
     algo: Int | Literal["slow", "fast", "best"] | Default = Default("best"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> AudioStream:
     """
 
@@ -646,11 +675,13 @@ def axcorrelate(
         ),
         _axcorrelate0,
         _axcorrelate1,
-        **{
-            "size": size,
-            "algo": algo,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "size": size,
+                "algo": algo,
+            },
+            extra_options,
+        ),
     )
     return filter_node.audio(0)
 
@@ -904,7 +935,7 @@ def blend(
     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:
     """
 
@@ -945,29 +976,97 @@ def blend(
         ),
         _top,
         _bottom,
-        **{
-            "c0_mode": c0_mode,
-            "c1_mode": c1_mode,
-            "c2_mode": c2_mode,
-            "c3_mode": c3_mode,
-            "all_mode": all_mode,
-            "c0_expr": c0_expr,
-            "c1_expr": c1_expr,
-            "c2_expr": c2_expr,
-            "c3_expr": c3_expr,
-            "all_expr": all_expr,
-            "c0_opacity": c0_opacity,
-            "c1_opacity": c1_opacity,
-            "c2_opacity": c2_opacity,
-            "c3_opacity": c3_opacity,
-            "all_opacity": all_opacity,
-            "eof_action": eof_action,
-            "shortest": shortest,
-            "repeatlast": repeatlast,
-            "ts_sync_mode": ts_sync_mode,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "c0_mode": c0_mode,
+                "c1_mode": c1_mode,
+                "c2_mode": c2_mode,
+                "c3_mode": c3_mode,
+                "all_mode": all_mode,
+                "c0_expr": c0_expr,
+                "c1_expr": c1_expr,
+                "c2_expr": c2_expr,
+                "c3_expr": c3_expr,
+                "all_expr": all_expr,
+                "c0_opacity": c0_opacity,
+                "c1_opacity": c1_opacity,
+                "c2_opacity": c2_opacity,
+                "c3_opacity": c3_opacity,
+                "all_opacity": all_opacity,
+                "eof_action": eof_action,
+                "shortest": shortest,
+                "repeatlast": repeatlast,
+                "ts_sync_mode": ts_sync_mode,
+                "enable": enable,
+            },
+            extra_options,
+        ),
+    )
+    return filter_node.video(0)
+
+
+def blend_vulkan(
+    _top: VideoStream,
+    _bottom: VideoStream,
+    *,
+    c0_mode: Int | Literal["normal", "multiply"] | Default = Default("normal"),
+    c1_mode: Int | Literal["normal", "multiply"] | Default = Default("normal"),
+    c2_mode: Int | Literal["normal", "multiply"] | Default = Default("normal"),
+    c3_mode: Int | Literal["normal", "multiply"] | Default = Default("normal"),
+    all_mode: Int | Literal["normal", "multiply"] | Default = Default(-1),
+    c0_opacity: Double = Default(1.0),
+    c1_opacity: Double = Default(1.0),
+    c2_opacity: Double = Default(1.0),
+    c3_opacity: Double = Default(1.0),
+    all_opacity: Double = Default(1.0),
+    extra_options: dict[str, Any] | None = None,
+) -> VideoStream:
+    """
+
+    Blend two video frames in Vulkan
+
+    Args:
+        c0_mode: set component #0 blend mode (from 0 to 39) (default normal)
+        c1_mode: set component #1 blend mode (from 0 to 39) (default normal)
+        c2_mode: set component #2 blend mode (from 0 to 39) (default normal)
+        c3_mode: set component #3 blend mode (from 0 to 39) (default normal)
+        all_mode: set blend mode for all components (from -1 to 39) (default -1)
+        c0_opacity: set color component #0 opacity (from 0 to 1) (default 1)
+        c1_opacity: set color component #1 opacity (from 0 to 1) (default 1)
+        c2_opacity: set color component #2 opacity (from 0 to 1) (default 1)
+        c3_opacity: set color component #3 opacity (from 0 to 1) (default 1)
+        all_opacity: set opacity for all color components (from 0 to 1) (default 1)
+
+    Returns:
+        default: the video stream
+
+    References:
+        [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#blend_005fvulkan)
+
+    """
+    filter_node = filter_node_factory(
+        FFMpegFilterDef(
+            name="blend_vulkan",
+            typings_input=("video", "video"),
+            typings_output=("video",),
+        ),
+        _top,
+        _bottom,
+        **merge(
+            {
+                "c0_mode": c0_mode,
+                "c1_mode": c1_mode,
+                "c2_mode": c2_mode,
+                "c3_mode": c3_mode,
+                "all_mode": all_mode,
+                "c0_opacity": c0_opacity,
+                "c1_opacity": c1_opacity,
+                "c2_opacity": c2_opacity,
+                "c3_opacity": c3_opacity,
+                "all_opacity": all_opacity,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -986,7 +1085,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:
     """
 
@@ -1020,21 +1119,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)
 
@@ -1049,7 +1150,7 @@ def colormap(
     type: Int | Literal["relative", "absolute"] | Default = Default("absolute"),
     kernel: Int | Literal["euclidean", "weuclidean"] | Default = Default("euclidean"),
     enable: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -1078,14 +1179,16 @@ def colormap(
         _default,
         _source,
         _target,
-        **{
-            "patch_size": patch_size,
-            "nb_patches": nb_patches,
-            "type": type,
-            "kernel": kernel,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "patch_size": patch_size,
+                "nb_patches": nb_patches,
+                "type": type,
+                "kernel": kernel,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -1096,7 +1199,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:
     """
 
@@ -1123,13 +1226,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
@@ -1147,7 +1252,7 @@ def convolve(
     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:
     """
 
@@ -1176,17 +1281,19 @@ def convolve(
         ),
         _main,
         _impulse,
-        **{
-            "planes": planes,
-            "impulse": impulse,
-            "noise": noise,
-            "eof_action": eof_action,
-            "shortest": shortest,
-            "repeatlast": repeatlast,
-            "ts_sync_mode": ts_sync_mode,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "planes": planes,
+                "impulse": impulse,
+                "noise": noise,
+                "eof_action": eof_action,
+                "shortest": shortest,
+                "repeatlast": repeatlast,
+                "ts_sync_mode": ts_sync_mode,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -1200,7 +1307,7 @@ def corr(
     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:
     """
 
@@ -1226,14 +1333,16 @@ def corr(
         ),
         _main,
         _reference,
-        **{
-            "eof_action": eof_action,
-            "shortest": shortest,
-            "repeatlast": repeatlast,
-            "ts_sync_mode": ts_sync_mode,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "eof_action": eof_action,
+                "shortest": shortest,
+                "repeatlast": repeatlast,
+                "ts_sync_mode": ts_sync_mode,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -1248,7 +1357,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:
     """
 
@@ -1278,17 +1387,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)
 
@@ -1305,7 +1416,7 @@ def deconvolve(
     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:
     """
 
@@ -1336,17 +1447,19 @@ def deconvolve(
         ),
         _main,
         _impulse,
-        **{
-            "planes": planes,
-            "impulse": impulse,
-            "noise": noise,
-            "eof_action": eof_action,
-            "shortest": shortest,
-            "repeatlast": repeatlast,
-            "ts_sync_mode": ts_sync_mode,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "planes": planes,
+                "impulse": impulse,
+                "noise": noise,
+                "eof_action": eof_action,
+                "shortest": shortest,
+                "repeatlast": repeatlast,
+                "ts_sync_mode": ts_sync_mode,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -1360,7 +1473,7 @@ def displace(
         "smear"
     ),
     enable: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -1386,11 +1499,13 @@ def displace(
         _source,
         _xmap,
         _ymap,
-        **{
-            "edge": edge,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "edge": edge,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -1401,7 +1516,7 @@ def feedback(
     *,
     x: Int = Default(0),
     w: Int = Default(0),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> tuple[
     VideoStream,
     VideoStream,
@@ -1430,11 +1545,13 @@ def feedback(
         ),
         _default,
         _feedin,
-        **{
-            "x": x,
-            "w": w,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "x": x,
+                "w": w,
+            },
+            extra_options,
+        ),
     )
     return (
         filter_node.video(0),
@@ -1460,7 +1577,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:
     """
 
@@ -1496,23 +1613,25 @@ 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)
 
@@ -1524,7 +1643,7 @@ def framepack(
     format: Int
     | Literal["sbs", "tab", "frameseq", "lines", "columns"]
     | Default = Default("sbs"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -1548,10 +1667,12 @@ def framepack(
         ),
         _left,
         _right,
-        **{
-            "format": format,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "format": format,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -1563,7 +1684,7 @@ def freezeframes(
     first: Int64 = Default(0),
     last: Int64 = Default(0),
     replace: Int64 = Default(0),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -1589,12 +1710,14 @@ def freezeframes(
         ),
         _source,
         _replace,
-        **{
-            "first": first,
-            "last": last,
-            "replace": replace,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "first": first,
+                "last": last,
+                "replace": replace,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -1608,7 +1731,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:
     """
 
@@ -1637,16 +1760,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)
 
@@ -1664,7 +1789,7 @@ def haldclut(
     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:
     """
 
@@ -1692,16 +1817,18 @@ def haldclut(
         ),
         _main,
         _clut,
-        **{
-            "clut": clut,
-            "interp": interp,
-            "eof_action": eof_action,
-            "shortest": shortest,
-            "repeatlast": repeatlast,
-            "ts_sync_mode": ts_sync_mode,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "clut": clut,
+                "interp": interp,
+                "eof_action": eof_action,
+                "shortest": shortest,
+                "repeatlast": repeatlast,
+                "ts_sync_mode": ts_sync_mode,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -1714,7 +1841,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:
     """
 
@@ -1742,15 +1869,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)
 
@@ -1759,7 +1888,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:
     """
 
@@ -1783,11 +1912,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)
 
@@ -1803,7 +1976,7 @@ def hysteresis(
     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:
     """
 
@@ -1833,16 +2006,18 @@ def hysteresis(
         ),
         _base,
         _alt,
-        **{
-            "planes": planes,
-            "threshold": threshold,
-            "eof_action": eof_action,
-            "shortest": shortest,
-            "repeatlast": repeatlast,
-            "ts_sync_mode": ts_sync_mode,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "planes": planes,
+                "threshold": threshold,
+                "eof_action": eof_action,
+                "shortest": shortest,
+                "repeatlast": repeatlast,
+                "ts_sync_mode": ts_sync_mode,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -1856,7 +2031,7 @@ def identity(
     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:
     """
 
@@ -1882,14 +2057,16 @@ def identity(
         ),
         _main,
         _reference,
-        **{
-            "eof_action": eof_action,
-            "shortest": shortest,
-            "repeatlast": repeatlast,
-            "ts_sync_mode": ts_sync_mode,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "eof_action": eof_action,
+                "shortest": shortest,
+                "repeatlast": repeatlast,
+                "ts_sync_mode": ts_sync_mode,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -1900,7 +2077,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:
     """
 
@@ -1924,11 +2101,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)
 
@@ -1938,7 +2117,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:
     """
 
@@ -1963,77 +2142,421 @@ 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 libvmaf(
-    _main: VideoStream,
-    _reference: VideoStream,
-    *,
-    log_path: String = Default(None),
-    log_fmt: String = Default("xml"),
-    pool: String = Default(None),
-    n_threads: Int = Default(0),
-    n_subsample: Int = Default(1),
-    model: String = Default("version=vmaf_v0.6.1"),
-    feature: String = 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,
+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:
     """
 
-    Calculate the VMAF between two video streams.
+    Apply various GPU filters from libplacebo
 
     Args:
-        log_path: Set the file path to be used to write log.
-        log_fmt: Set the format of the log (csv, json, xml, or sub). (default "xml")
-        pool: Set the pool method to be used for computing vmaf.
-        n_threads: Set number of threads to be used when computing vmaf. (from 0 to UINT32_MAX) (default 0)
-        n_subsample: Set interval for frame subsampling used when computing vmaf. (from 1 to UINT32_MAX) (default 1)
-        model: Set the model to be used for computing vmaf. (default "version=vmaf_v0.6.1")
-        feature: Set the feature to be used for computing vmaf.
-        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)
+        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#libvmaf)
+        [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#libplacebo)
 
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(
-            name="libvmaf", typings_input=("video", "video"), typings_output=("video",)
+            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,
         ),
-        _main,
-        _reference,
-        **{
-            "log_path": log_path,
-            "log_fmt": log_fmt,
-            "pool": pool,
-            "n_threads": n_threads,
-            "n_subsample": n_subsample,
-            "model": model,
-            "feature": feature,
-            "eof_action": eof_action,
-            "shortest": shortest,
-            "repeatlast": repeatlast,
-            "ts_sync_mode": ts_sync_mode,
-        }
-        | (extra_options or {}),
     )
     return filter_node.video(0)
 
@@ -2045,7 +2568,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:
     """
 
@@ -2072,14 +2595,16 @@ 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)
 
@@ -2098,7 +2623,7 @@ def lut2(
     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:
     """
 
@@ -2129,23 +2654,71 @@ def lut2(
         ),
         _srcx,
         _srcy,
-        **{
-            "c0": c0,
-            "c1": c1,
-            "c2": c2,
-            "c3": c3,
-            "d": d,
-            "eof_action": eof_action,
-            "shortest": shortest,
-            "repeatlast": repeatlast,
-            "ts_sync_mode": ts_sync_mode,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "c0": c0,
+                "c1": c1,
+                "c2": c2,
+                "c3": c3,
+                "d": d,
+                "eof_action": eof_action,
+                "shortest": shortest,
+                "repeatlast": repeatlast,
+                "ts_sync_mode": ts_sync_mode,
+                "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 maskedclamp(
     _base: VideoStream,
     _dark: VideoStream,
@@ -2155,7 +2728,7 @@ def maskedclamp(
     overshoot: Int = Default(0),
     planes: Int = Default(15),
     enable: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -2183,13 +2756,15 @@ def maskedclamp(
         _base,
         _dark,
         _bright,
-        **{
-            "undershoot": undershoot,
-            "overshoot": overshoot,
-            "planes": planes,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "undershoot": undershoot,
+                "overshoot": overshoot,
+                "planes": planes,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2201,7 +2776,7 @@ def maskedmax(
     *,
     planes: Int = Default(15),
     enable: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -2227,11 +2802,13 @@ def maskedmax(
         _source,
         _filter1,
         _filter2,
-        **{
-            "planes": planes,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "planes": planes,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2243,7 +2820,7 @@ def maskedmerge(
     *,
     planes: Int = Default(15),
     enable: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -2269,11 +2846,13 @@ def maskedmerge(
         _base,
         _overlay,
         _mask,
-        **{
-            "planes": planes,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "planes": planes,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2285,7 +2864,7 @@ def maskedmin(
     *,
     planes: Int = Default(15),
     enable: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -2311,11 +2890,13 @@ def maskedmin(
         _source,
         _filter1,
         _filter2,
-        **{
-            "planes": planes,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "planes": planes,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2328,7 +2909,7 @@ def maskedthreshold(
     planes: Int = Default(15),
     mode: Int | Literal["abs", "diff"] | Default = Default("abs"),
     enable: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -2355,13 +2936,15 @@ def maskedthreshold(
         ),
         _source,
         _reference,
-        **{
-            "threshold": threshold,
-            "planes": planes,
-            "mode": mode,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "threshold": threshold,
+                "planes": planes,
+                "mode": mode,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2378,7 +2961,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:
     """
 
@@ -2410,19 +2993,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)
 
@@ -2433,7 +3018,7 @@ def midequalizer(
     *,
     planes: Int = Default(15),
     enable: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -2458,11 +3043,13 @@ def midequalizer(
         ),
         _in0,
         _in1,
-        **{
-            "planes": planes,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "planes": planes,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2477,7 +3064,7 @@ def mix(
         "longest"
     ),
     enable: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -2505,15 +3092,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)
 
@@ -2532,7 +3121,7 @@ def morpho(
     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:
     """
 
@@ -2561,17 +3150,19 @@ def morpho(
         ),
         _default,
         _structure,
-        **{
-            "mode": mode,
-            "planes": planes,
-            "structure": structure,
-            "eof_action": eof_action,
-            "shortest": shortest,
-            "repeatlast": repeatlast,
-            "ts_sync_mode": ts_sync_mode,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "mode": mode,
+                "planes": planes,
+                "structure": structure,
+                "eof_action": eof_action,
+                "shortest": shortest,
+                "repeatlast": repeatlast,
+                "ts_sync_mode": ts_sync_mode,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2585,7 +3176,7 @@ def msad(
     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:
     """
 
@@ -2611,14 +3202,16 @@ def msad(
         ),
         _main,
         _reference,
-        **{
-            "eof_action": eof_action,
-            "shortest": shortest,
-            "repeatlast": repeatlast,
-            "ts_sync_mode": ts_sync_mode,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "eof_action": eof_action,
+                "shortest": shortest,
+                "repeatlast": repeatlast,
+                "ts_sync_mode": ts_sync_mode,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2631,7 +3224,7 @@ def multiply(
     offset: Float = Default(0.5),
     planes: Flags = Default("F"),
     enable: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -2656,13 +3249,15 @@ def multiply(
         ),
         _source,
         _factor,
-        **{
-            "scale": scale,
-            "offset": offset,
-            "planes": planes,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "scale": scale,
+                "offset": offset,
+                "planes": planes,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2695,7 +3290,7 @@ def overlay(
     alpha: Int | Literal["straight", "premultiplied"] | Default = Default("straight"),
     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,19 +3321,170 @@ def overlay(
         ),
         _main,
         _overlay,
-        **{
-            "x": x,
-            "y": y,
-            "eof_action": eof_action,
-            "eval": eval,
-            "shortest": shortest,
-            "format": format,
-            "repeatlast": repeatlast,
-            "alpha": alpha,
-            "ts_sync_mode": ts_sync_mode,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "x": x,
+                "y": y,
+                "eof_action": eof_action,
+                "eval": eval,
+                "shortest": shortest,
+                "format": format,
+                "repeatlast": repeatlast,
+                "alpha": alpha,
+                "ts_sync_mode": ts_sync_mode,
+                "enable": enable,
+            },
+            extra_options,
+        ),
+    )
+    return filter_node.video(0)
+
+
+def overlay_opencl(
+    _main: VideoStream,
+    _overlay: VideoStream,
+    *,
+    x: Int = Default(0),
+    y: Int = Default(0),
+    extra_options: dict[str, Any] | None = None,
+) -> VideoStream:
+    """
+
+    Overlay one video on top of another
+
+    Args:
+        x: Overlay x position (from 0 to INT_MAX) (default 0)
+        y: Overlay y position (from 0 to INT_MAX) (default 0)
+
+    Returns:
+        default: the video stream
+
+    References:
+        [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#overlay_005fopencl)
+
+    """
+    filter_node = filter_node_factory(
+        FFMpegFilterDef(
+            name="overlay_opencl",
+            typings_input=("video", "video"),
+            typings_output=("video",),
+        ),
+        _main,
+        _overlay,
+        **merge(
+            {
+                "x": x,
+                "y": y,
+            },
+            extra_options,
+        ),
+    )
+    return filter_node.video(0)
+
+
+def overlay_vaapi(
+    _main: VideoStream,
+    _overlay: VideoStream,
+    *,
+    x: String = Default("0"),
+    y: String = Default("0"),
+    w: String = Default("overlay_iw"),
+    h: String = Default("overlay_ih*w/overlay_iw"),
+    alpha: Float = Default(1.0),
+    eof_action: Int
+    | Literal["repeat", "endall", "pass", "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:
+    """
+
+    Overlay one video on top of another
+
+    Args:
+        x: Overlay x position (default "0")
+        y: Overlay y position (default "0")
+        w: Overlay width (default "overlay_iw")
+        h: Overlay height (default "overlay_ih*w/overlay_iw")
+        alpha: Overlay global alpha (from 0 to 1) (default 1)
+        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: repeat overlay of the last overlay frame (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#overlay_005fvaapi)
+
+    """
+    filter_node = filter_node_factory(
+        FFMpegFilterDef(
+            name="overlay_vaapi",
+            typings_input=("video", "video"),
+            typings_output=("video",),
+        ),
+        _main,
+        _overlay,
+        **merge(
+            {
+                "x": x,
+                "y": y,
+                "w": w,
+                "h": h,
+                "alpha": alpha,
+                "eof_action": eof_action,
+                "shortest": shortest,
+                "repeatlast": repeatlast,
+                "ts_sync_mode": ts_sync_mode,
+            },
+            extra_options,
+        ),
+    )
+    return filter_node.video(0)
+
+
+def overlay_vulkan(
+    _main: VideoStream,
+    _overlay: VideoStream,
+    *,
+    x: Int = Default(0),
+    y: Int = Default(0),
+    extra_options: dict[str, Any] | None = None,
+) -> VideoStream:
+    """
+
+    Overlay a source on top of another
+
+    Args:
+        x: Set horizontal offset (from 0 to INT_MAX) (default 0)
+        y: Set vertical offset (from 0 to INT_MAX) (default 0)
+
+    Returns:
+        default: the video stream
+
+    References:
+        [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#overlay_005fvulkan)
+
+    """
+    filter_node = filter_node_factory(
+        FFMpegFilterDef(
+            name="overlay_vulkan",
+            typings_input=("video", "video"),
+            typings_output=("video",),
+        ),
+        _main,
+        _overlay,
+        **merge(
+            {
+                "x": x,
+                "y": y,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2764,7 +3510,7 @@ def paletteuse(
     new: Boolean = Default(False),
     alpha_threshold: Int = Default(128),
     debug_kdtree: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -2793,15 +3539,17 @@ def paletteuse(
         ),
         _default,
         _palette,
-        **{
-            "dither": dither,
-            "bayer_scale": bayer_scale,
-            "diff_mode": diff_mode,
-            "new": new,
-            "alpha_threshold": alpha_threshold,
-            "debug_kdtree": debug_kdtree,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "dither": dither,
+                "bayer_scale": bayer_scale,
+                "diff_mode": diff_mode,
+                "new": new,
+                "alpha_threshold": alpha_threshold,
+                "debug_kdtree": debug_kdtree,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2811,7 +3559,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:
     """
 
@@ -2836,12 +3584,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)
 
@@ -2858,7 +3665,7 @@ def psnr(
     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:
     """
 
@@ -2887,17 +3694,19 @@ def psnr(
         ),
         _main,
         _reference,
-        **{
-            "stats_file": stats_file,
-            "stats_version": stats_version,
-            "output_max": output_max,
-            "eof_action": eof_action,
-            "shortest": shortest,
-            "repeatlast": repeatlast,
-            "ts_sync_mode": ts_sync_mode,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "stats_file": stats_file,
+                "stats_version": stats_version,
+                "output_max": output_max,
+                "eof_action": eof_action,
+                "shortest": shortest,
+                "repeatlast": repeatlast,
+                "ts_sync_mode": ts_sync_mode,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2909,7 +3718,7 @@ def remap(
     *,
     format: Int | Literal["color", "gray"] | Default = Default("color"),
     fill: Color = Default("black"),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -2935,11 +3744,57 @@ def remap(
         _source,
         _xmap,
         _ymap,
-        **{
-            "format": format,
-            "fill": fill,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "format": format,
+                "fill": fill,
+            },
+            extra_options,
+        ),
+    )
+    return filter_node.video(0)
+
+
+def remap_opencl(
+    _source: VideoStream,
+    _xmap: VideoStream,
+    _ymap: VideoStream,
+    *,
+    interp: Int | Literal["near", "linear"] | Default = Default("linear"),
+    fill: Color = Default("black"),
+    extra_options: dict[str, Any] | None = None,
+) -> VideoStream:
+    """
+
+    Remap pixels using OpenCL.
+
+    Args:
+        interp: set interpolation method (from 0 to 1) (default linear)
+        fill: set the color of the unmapped pixels (default "black")
+
+    Returns:
+        default: the video stream
+
+    References:
+        [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#remap_005fopencl)
+
+    """
+    filter_node = filter_node_factory(
+        FFMpegFilterDef(
+            name="remap_opencl",
+            typings_input=("video", "video", "video"),
+            typings_output=("video",),
+        ),
+        _source,
+        _xmap,
+        _ymap,
+        **merge(
+            {
+                "interp": interp,
+                "fill": fill,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -2960,7 +3815,7 @@ def sidechaincompress(
     detection: Int | Literal["peak", "rms"] | Default = Default("rms"),
     level_sc: Double = Default(1.0),
     mix: Double = Default(1.0),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> AudioStream:
     """
 
@@ -2995,21 +3850,23 @@ def sidechaincompress(
         ),
         _main,
         _sidechain,
-        **{
-            "level_in": level_in,
-            "mode": mode,
-            "threshold": threshold,
-            "ratio": ratio,
-            "attack": attack,
-            "release": release,
-            "makeup": makeup,
-            "knee": knee,
-            "link": link,
-            "detection": detection,
-            "level_sc": level_sc,
-            "mix": mix,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "level_in": level_in,
+                "mode": mode,
+                "threshold": threshold,
+                "ratio": ratio,
+                "attack": attack,
+                "release": release,
+                "makeup": makeup,
+                "knee": knee,
+                "link": link,
+                "detection": detection,
+                "level_sc": level_sc,
+                "mix": mix,
+            },
+            extra_options,
+        ),
     )
     return filter_node.audio(0)
 
@@ -3031,7 +3888,7 @@ def sidechaingate(
     link: Int | Literal["average", "maximum"] | Default = Default("average"),
     level_sc: Double = Default(1.0),
     enable: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> AudioStream:
     """
 
@@ -3067,22 +3924,24 @@ def sidechaingate(
         ),
         _main,
         _sidechain,
-        **{
-            "level_in": level_in,
-            "mode": mode,
-            "range": range,
-            "threshold": threshold,
-            "ratio": ratio,
-            "attack": attack,
-            "release": release,
-            "makeup": makeup,
-            "knee": knee,
-            "detection": detection,
-            "link": link,
-            "level_sc": level_sc,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "level_in": level_in,
+                "mode": mode,
+                "range": range,
+                "threshold": threshold,
+                "ratio": ratio,
+                "attack": attack,
+                "release": release,
+                "makeup": makeup,
+                "knee": knee,
+                "detection": detection,
+                "link": link,
+                "level_sc": level_sc,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.audio(0)
 
@@ -3098,7 +3957,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:
     """
 
@@ -3129,18 +3988,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)
 
@@ -3185,7 +4046,7 @@ def spectrumsynth(
     orientation: Int | Literal["vertical", "horizontal"] | Default = Default(
         "vertical"
     ),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> AudioStream:
     """
 
@@ -3215,16 +4076,18 @@ def spectrumsynth(
         ),
         _magnitude,
         _phase,
-        **{
-            "sample_rate": sample_rate,
-            "channels": channels,
-            "scale": scale,
-            "slide": slide,
-            "win_func": win_func,
-            "overlap": overlap,
-            "orientation": orientation,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "sample_rate": sample_rate,
+                "channels": channels,
+                "scale": scale,
+                "slide": slide,
+                "win_func": win_func,
+                "overlap": overlap,
+                "orientation": orientation,
+            },
+            extra_options,
+        ),
     )
     return filter_node.audio(0)
 
@@ -3239,7 +4102,7 @@ def ssim(
     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:
     """
 
@@ -3266,15 +4129,17 @@ def ssim(
         ),
         _main,
         _reference,
-        **{
-            "stats_file": stats_file,
-            "eof_action": eof_action,
-            "shortest": shortest,
-            "repeatlast": repeatlast,
-            "ts_sync_mode": ts_sync_mode,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "stats_file": stats_file,
+                "eof_action": eof_action,
+                "shortest": shortest,
+                "repeatlast": repeatlast,
+                "ts_sync_mode": ts_sync_mode,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -3283,7 +4148,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:
     """
 
@@ -3308,11 +4173,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
@@ -3326,7 +4193,7 @@ def threshold(
     *,
     planes: Int = Default(15),
     enable: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -3353,11 +4220,13 @@ def threshold(
         _threshold,
         _min,
         _max,
-        **{
-            "planes": planes,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "planes": planes,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -3367,7 +4236,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:
     """
 
@@ -3392,12 +4261,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)
 
@@ -3414,7 +4285,7 @@ def varblur(
     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:
     """
 
@@ -3443,17 +4314,19 @@ def varblur(
         ),
         _default,
         _radius,
-        **{
-            "min_r": min_r,
-            "max_r": max_r,
-            "planes": planes,
-            "eof_action": eof_action,
-            "shortest": shortest,
-            "repeatlast": repeatlast,
-            "ts_sync_mode": ts_sync_mode,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "min_r": min_r,
+                "max_r": max_r,
+                "planes": planes,
+                "eof_action": eof_action,
+                "shortest": shortest,
+                "repeatlast": repeatlast,
+                "ts_sync_mode": ts_sync_mode,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -3467,7 +4340,7 @@ def vif(
     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:
     """
 
@@ -3493,14 +4366,16 @@ def vif(
         ),
         _main,
         _reference,
-        **{
-            "eof_action": eof_action,
-            "shortest": shortest,
-            "repeatlast": repeatlast,
-            "ts_sync_mode": ts_sync_mode,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "eof_action": eof_action,
+                "shortest": shortest,
+                "repeatlast": repeatlast,
+                "ts_sync_mode": ts_sync_mode,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -3509,7 +4384,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:
     """
 
@@ -3533,11 +4408,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)
 
@@ -3553,7 +4472,7 @@ def xcorrelate(
     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:
     """
 
@@ -3583,16 +4502,18 @@ def xcorrelate(
         ),
         _primary,
         _secondary,
-        **{
-            "planes": planes,
-            "secondary": secondary,
-            "eof_action": eof_action,
-            "shortest": shortest,
-            "repeatlast": repeatlast,
-            "ts_sync_mode": ts_sync_mode,
-            "enable": enable,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "planes": planes,
+                "secondary": secondary,
+                "eof_action": eof_action,
+                "shortest": shortest,
+                "repeatlast": repeatlast,
+                "ts_sync_mode": ts_sync_mode,
+                "enable": enable,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -3667,7 +4588,7 @@ def xfade(
     duration: Duration = Default(1.0),
     offset: Duration = Default(0.0),
     expr: String = Default(None),
-    extra_options: dict[str, Any] = None,
+    extra_options: dict[str, Any] | None = None,
 ) -> VideoStream:
     """
 
@@ -3692,13 +4613,79 @@ def xfade(
         ),
         _main,
         _xfade,
-        **{
-            "transition": transition,
-            "duration": duration,
-            "offset": offset,
-            "expr": expr,
-        }
-        | (extra_options or {}),
+        **merge(
+            {
+                "transition": transition,
+                "duration": duration,
+                "offset": offset,
+                "expr": expr,
+            },
+            extra_options,
+        ),
+    )
+    return filter_node.video(0)
+
+
+def xfade_opencl(
+    _main: VideoStream,
+    _xfade: VideoStream,
+    *,
+    transition: Int
+    | Literal[
+        "custom",
+        "fade",
+        "wipeleft",
+        "wiperight",
+        "wipeup",
+        "wipedown",
+        "slideleft",
+        "slideright",
+        "slideup",
+        "slidedown",
+    ]
+    | Default = Default("fade"),
+    source: String = Default(None),
+    kernel: String = Default(None),
+    duration: Duration = Default(1.0),
+    offset: Duration = Default(0.0),
+    extra_options: dict[str, Any] | None = None,
+) -> VideoStream:
+    """
+
+    Cross fade one video with another video.
+
+    Args:
+        transition: set cross fade transition (from 0 to 9) (default fade)
+        source: set OpenCL program source file for custom transition
+        kernel: set kernel name in program file for custom transition
+        duration: set cross fade duration (default 1)
+        offset: set cross fade start relative to first input stream (default 0)
+
+    Returns:
+        default: the video stream
+
+    References:
+        [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#xfade_005fopencl)
+
+    """
+    filter_node = filter_node_factory(
+        FFMpegFilterDef(
+            name="xfade_opencl",
+            typings_input=("video", "video"),
+            typings_output=("video",),
+        ),
+        _main,
+        _xfade,
+        **merge(
+            {
+                "transition": transition,
+                "source": source,
+                "kernel": kernel,
+                "duration": duration,
+                "offset": offset,
+            },
+            extra_options,
+        ),
     )
     return filter_node.video(0)
 
@@ -3713,7 +4700,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:
     """
 
@@ -3743,17 +4730,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)
 
@@ -3765,7 +4754,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:
     """
 
@@ -3792,13 +4781,66 @@ 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)