vapoursynth-mvuscale 0.1.0__tar.gz

vapoursynth_mvuscale-0.1.0/CMakeLists.txt

@@ -0,0 +1,28 @@
+cmake_minimum_required(VERSION 3.18)
+project(mvuscale LANGUAGES CXX)
+
+# mvuscale — a native VapourSynth (API4) filter that scales mvutensils motion
+# vectors for the smdegrain_bis UHDhalf path (the manipmv.ScaleVect replacement).
+# It links no libpython and no libvapoursynth (VS resolves the API through the
+# plugin entry point), so the binary is Python-version-independent: one build
+# per (OS, arch) covers all Python 3.x.
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_VISIBILITY_PRESET hidden)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+add_library(mvuscale SHARED mvuscale.cpp)
+target_include_directories(mvuscale PRIVATE include)   # vendored VS API4 headers
+
+if(NOT MSVC)
+  target_compile_options(mvuscale PRIVATE -O3 -Wall)
+endif()
+
+# Install under <site-packages>/vapoursynth/plugins/mvuscale/ — the same payload
+# layout the PyPI VS-plugin wheels (manipmv, nlm_ispc, …) use, so a host that
+# relocates that tree into its own plugins dir finds the .so unchanged, and a
+# plain pip user gets it on sys.path for smdegrain_bis to load.
+install(TARGETS mvuscale
+        LIBRARY DESTINATION vapoursynth/plugins/mvuscale
+        RUNTIME DESTINATION vapoursynth/plugins/mvuscale)

vapoursynth_mvuscale-0.1.0/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: vapoursynth-mvuscale
+Version: 0.1.0
+Summary: Native VapourSynth (API4) filter that scales mvutensils motion vectors for smdegrain_bis UHDhalf
+Keywords: vapoursynth,mvutensils,motion-vectors,denoise,smdegrain
+Author: Florian Gamper
+License-Expression: GPL-3.0-or-later
+Classifier: Topic :: Multimedia :: Video
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Project-URL: Homepage, https://github.com/FlorianGamper/vs-smdegrain-bis
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# vapoursynth-mvuscale
+
+A tiny native **VapourSynth (API4)** filter that scales
+[mvutensils](https://github.com/myrsloik/mvutensils) motion vectors between
+resolutions — the `manipmv.ScaleVect` replacement used by the
+[`smdegrain-bis`](https://github.com/FlorianGamper/vs-smdegrain-bis) `UHDhalf` path, where
+motion is searched at half resolution and the vectors are multiplied back up to
+full resolution before `Degrain`.
+
+It registers `core.mvuscale.ScaleVect(clip, scale=<int>)`, operating on
+mvutensils' vector frame-props (geometry ×s, packed vectors ×s, SAD ×s²). It
+links no libpython and no libvapoursynth, so one build per platform serves every
+Python 3.x.
+
+## Install
+
+```bash
+pip install vapoursynth-mvuscale      # drops the plugin under vapoursynth/plugins/mvuscale/
+```
+
+`smdegrain-bis` loads it automatically when `UHDhalf=True`. A host that manages
+its own plugin directory can instead relocate the wheel payload (or the
+`native/build.sh` output) into that directory, where it autoloads.
+
+## Build from source
+
+```bash
+pip wheel native/ -w dist/            # scikit-build-core + CMake
+# or, just the .so:
+CXX=g++ bash native/build.sh          # -> tests/_plugins/mvuscale/libmvuscale.so
+```
+
+The VapourSynth API4 headers are vendored under `native/include/` (see its
+`NOTICE`), so no VapourSynth SDK is required to build.
+
+**Licence:** GPL-3.0-or-later.

vapoursynth_mvuscale-0.1.0/README.md

@@ -0,0 +1,36 @@
+# vapoursynth-mvuscale
+
+A tiny native **VapourSynth (API4)** filter that scales
+[mvutensils](https://github.com/myrsloik/mvutensils) motion vectors between
+resolutions — the `manipmv.ScaleVect` replacement used by the
+[`smdegrain-bis`](https://github.com/FlorianGamper/vs-smdegrain-bis) `UHDhalf` path, where
+motion is searched at half resolution and the vectors are multiplied back up to
+full resolution before `Degrain`.
+
+It registers `core.mvuscale.ScaleVect(clip, scale=<int>)`, operating on
+mvutensils' vector frame-props (geometry ×s, packed vectors ×s, SAD ×s²). It
+links no libpython and no libvapoursynth, so one build per platform serves every
+Python 3.x.
+
+## Install
+
+```bash
+pip install vapoursynth-mvuscale      # drops the plugin under vapoursynth/plugins/mvuscale/
+```
+
+`smdegrain-bis` loads it automatically when `UHDhalf=True`. A host that manages
+its own plugin directory can instead relocate the wheel payload (or the
+`native/build.sh` output) into that directory, where it autoloads.
+
+## Build from source
+
+```bash
+pip wheel native/ -w dist/            # scikit-build-core + CMake
+# or, just the .so:
+CXX=g++ bash native/build.sh          # -> tests/_plugins/mvuscale/libmvuscale.so
+```
+
+The VapourSynth API4 headers are vendored under `native/include/` (see its
+`NOTICE`), so no VapourSynth SDK is required to build.
+
+**Licence:** GPL-3.0-or-later.

vapoursynth_mvuscale-0.1.0/build.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+# Build the optional mvuscale native filter (fast UHDhalf vector scaler).
+# Portable x86-64 baseline (SSE2) — no AVX runtime requirement.
+#
+#   VS_INCLUDE=/path/to/vapoursynth/headers OUT=/dest/dir native/build.sh
+set -euo pipefail
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# VapourSynth API4 headers (VapourSynth4.h, VSHelper4.h) — vendored under
+# native/include/ so this builds with no VapourSynth SDK installed. Override
+# VS_INCLUDE to point at a system copy if you prefer.
+VS_INCLUDE="${VS_INCLUDE:-$HERE/include}"
+OUT="${OUT:-$HERE/../tests/_plugins/mvuscale}"
+CXX="${CXX:-g++}"
+mkdir -p "$OUT"
+set -x
+"$CXX" -std=c++17 -O3 -fPIC -shared -Wall -fvisibility=hidden \
+  -I"$VS_INCLUDE" "$HERE/mvuscale.cpp" -o "$OUT/libmvuscale.so"

vapoursynth_mvuscale-0.1.0/include/NOTICE

@@ -0,0 +1,13 @@
+VapourSynth API4 headers — vendored verbatim so the mvuscale native filter
+builds without a VapourSynth SDK installed (self-contained CI).
+
+Source: the `vapoursynth` distribution's `vapoursynth/include/` directory.
+Copyright (c) 2012-2026 Fredrik Mellbin.
+
+  VapourSynth4.h   LGPL-2.1-or-later
+  VSConstants4.h   LGPL-2.1-or-later
+  VSHelper4.h      WTFPL (Do What The Fuck You Want To Public License, v2)
+
+Both licences are compatible with this project's GPL-3.0-or-later, and merely
+#including these API headers to build a plugin is their intended use. They are
+not modified. To refresh, copy them from a current `vapoursynth` install.

vapoursynth_mvuscale-0.1.0/include/VSConstants4.h

@@ -0,0 +1,105 @@
+/*
+* Copyright (c) 2021 Fredrik Mellbin
+*
+* This file is part of VapourSynth.
+*
+* VapourSynth is free software; you can redistribute it and/or
+* modify it under the terms of the GNU Lesser General Public
+* License as published by the Free Software Foundation; either
+* version 2.1 of the License, or (at your option) any later version.
+*
+* VapourSynth is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public
+* License along with VapourSynth; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+
+#ifndef VSCONSTANTS4_H
+#define VSCONSTANTS4_H
+
+#if defined(VS_USE_LATEST_API) || defined(VS_USE_API_42)
+
+typedef enum VSRange {
+	VSC_RANGE_FULL = 1,
+	VSC_RANGE_LIMITED = 0
+} VSRange;
+
+#else
+
+typedef enum VSColorRange {
+	VSC_RANGE_FULL = 0,
+	VSC_RANGE_LIMITED = 1
+} VSColorRange;
+
+#endif
+
+typedef enum VSChromaLocation {
+	VSC_CHROMA_LEFT = 0,
+	VSC_CHROMA_CENTER = 1,
+	VSC_CHROMA_TOP_LEFT = 2,
+	VSC_CHROMA_TOP = 3,
+	VSC_CHROMA_BOTTOM_LEFT = 4,
+	VSC_CHROMA_BOTTOM = 5
+} VSChromaLocation;
+
+typedef enum VSFieldBased {
+	VSC_FIELD_PROGRESSIVE = 0,
+	VSC_FIELD_BOTTOM = 1,
+	VSC_FIELD_TOP = 2
+} VSFieldBased;
+
+typedef enum VSMatrixCoefficients {
+	VSC_MATRIX_RGB = 0,
+	VSC_MATRIX_BT709 = 1,
+	VSC_MATRIX_UNSPECIFIED = 2,
+	VSC_MATRIX_FCC = 4,
+	VSC_MATRIX_BT470_BG = 5,
+	VSC_MATRIX_ST170_M = 6,  /* Equivalent to 5. */
+	VSC_MATRIX_ST240_M = 7,
+	VSC_MATRIX_YCGCO = 8,
+	VSC_MATRIX_BT2020_NCL = 9,
+	VSC_MATRIX_BT2020_CL = 10,
+	VSC_MATRIX_CHROMATICITY_DERIVED_NCL = 12,
+	VSC_MATRIX_CHROMATICITY_DERIVED_CL = 13,
+	VSC_MATRIX_ICTCP = 14
+} VSMatrixCoefficients;
+
+typedef enum VSTransferCharacteristics {
+	VSC_TRANSFER_BT709 = 1,
+	VSC_TRANSFER_UNSPECIFIED = 2,
+	VSC_TRANSFER_BT470_M = 4,
+	VSC_TRANSFER_BT470_BG = 5,
+	VSC_TRANSFER_BT601 = 6,  /* Equivalent to 1. */
+	VSC_TRANSFER_ST240_M = 7,
+	VSC_TRANSFER_LINEAR = 8,
+	VSC_TRANSFER_LOG_100 = 9,
+	VSC_TRANSFER_LOG_316 = 10,
+	VSC_TRANSFER_IEC_61966_2_4 = 11,
+	VSC_TRANSFER_IEC_61966_2_1 = 13,
+	VSC_TRANSFER_BT2020_10 = 14, /* Equivalent to 1. */
+	VSC_TRANSFER_BT2020_12 = 15, /* Equivalent to 1. */
+	VSC_TRANSFER_ST2084 = 16,
+	VSC_TRANSFER_ST428 = 17,
+	VSC_TRANSFER_ARIB_B67 = 18
+} VSTransferCharacteristics;
+
+typedef enum VSColorPrimaries {
+	VSC_PRIMARIES_BT709 = 1,
+	VSC_PRIMARIES_UNSPECIFIED = 2,
+	VSC_PRIMARIES_BT470_M = 4,
+	VSC_PRIMARIES_BT470_BG = 5,
+	VSC_PRIMARIES_ST170_M = 6,
+	VSC_PRIMARIES_ST240_M = 7,  /* Equivalent to 6. */
+	VSC_PRIMARIES_FILM = 8,
+	VSC_PRIMARIES_BT2020 = 9,
+	VSC_PRIMARIES_ST428 = 10,
+	VSC_PRIMARIES_ST431_2 = 11,
+	VSC_PRIMARIES_ST432_1 = 12,
+	VSC_PRIMARIES_EBU3213_E = 22
+} VSColorPrimaries;
+
+#endif /* VSCONSTANTS4_H */

vapoursynth_mvuscale-0.1.0/include/VSHelper4.h

@@ -0,0 +1,217 @@
+/*****************************************************************************
+* Copyright (c) 2012-2020 Fredrik Mellbin
+* --- Legal stuff ---
+* This program is free software. It comes without any warranty, to
+* the extent permitted by applicable law. You can redistribute it
+* and/or modify it under the terms of the Do What The Fuck You Want
+* To Public License, Version 2, as published by Sam Hocevar. See
+* http://sam.zoy.org/wtfpl/COPYING for more details.
+*****************************************************************************/
+
+#ifndef VSHELPER4_H
+#define VSHELPER4_H
+
+#include <limits.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <math.h>
+#include <float.h>
+#ifdef _WIN32
+#include <malloc.h>
+#endif
+#include "VapourSynth4.h"
+
+#define VSH_STD_PLUGIN_ID "com.vapoursynth.std"
+#define VSH_RESIZE_PLUGIN_ID "com.vapoursynth.resize"
+#define VSH_TEXT_PLUGIN_ID "com.vapoursynth.text"
+
+#ifdef __cplusplus
+namespace vsh {
+#define VSH4_MANGLE_FUNCTION_NAME(name) name
+#define VSH4_BOOLEAN_TYPE bool
+#else
+#define VSH4_MANGLE_FUNCTION_NAME(name) vsh_##name
+#define VSH4_BOOLEAN_TYPE int
+#endif
+
+/* Visual Studio doesn't recognize inline in c mode */
+#if defined(_MSC_VER) && !defined(__cplusplus)
+#define inline _inline
+#endif
+
+/* A kinda portable definition of the C99 restrict keyword (or its unofficial C++ equivalent) */
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* Available in C99 */
+#define VS_RESTRICT restrict
+#elif defined(__cplusplus) || defined(_MSC_VER) /* Almost all relevant C++ compilers support it so just assume it works */
+#define VS_RESTRICT __restrict
+#else /* Not supported */
+#define VS_RESTRICT
+#endif
+
+#ifdef _WIN32
+#define VSH_ALIGNED_MALLOC(pptr, size, alignment) do { *(pptr) = _aligned_malloc((size), (alignment)); } while (0)
+#define VSH_ALIGNED_FREE(ptr) do { _aligned_free((ptr)); } while (0)
+#else
+#define VSH_ALIGNED_MALLOC(pptr, size, alignment) do { if(posix_memalign((void**)(pptr), (alignment), (size))) *((void**)pptr) = NULL; } while (0)
+#define VSH_ALIGNED_FREE(ptr) do { free((ptr)); } while (0)
+#endif
+
+#define VSMAX(a,b) ((a) > (b) ? (a) : (b))
+#define VSMIN(a,b) ((a) > (b) ? (b) : (a))
+
+#ifdef __cplusplus 
+/* A nicer templated malloc for all the C++ users out there */
+#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1900)
+template<typename T = void>
+#else
+template<typename T>
+#endif
+static inline T *vsh_aligned_malloc(size_t size, size_t alignment) {
+#ifdef _WIN32
+    return (T *)_aligned_malloc(size, alignment);
+#else
+    void *tmp = NULL;
+    if (posix_memalign(&tmp, alignment, size))
+        tmp = 0;
+    return (T *)tmp;
+#endif
+}
+
+static inline void vsh_aligned_free(void *ptr) {
+    VSH_ALIGNED_FREE(ptr);
+}
+#endif /* __cplusplus */
+
+/* convenience function for checking if the format never changes between frames */
+static inline VSH4_BOOLEAN_TYPE VSH4_MANGLE_FUNCTION_NAME(isConstantVideoFormat)(const VSVideoInfo *vi) {
+    return vi->height > 0 && vi->width > 0 && vi->format.colorFamily != cfUndefined;
+}
+
+/* convenience function to check if two clips have the same format (unknown/changeable will be considered the same too) */
+static inline VSH4_BOOLEAN_TYPE VSH4_MANGLE_FUNCTION_NAME(isSameVideoFormat)(const VSVideoFormat *v1, const VSVideoFormat *v2) {
+    return v1->colorFamily == v2->colorFamily && v1->sampleType == v2->sampleType && v1->bitsPerSample == v2->bitsPerSample && v1->subSamplingW == v2->subSamplingW && v1->subSamplingH == v2->subSamplingH;
+}
+
+/* convenience function to check if a clip has the same format as a format id */
+static inline VSH4_BOOLEAN_TYPE VSH4_MANGLE_FUNCTION_NAME(isSameVideoPresetFormat)(unsigned presetFormat, const VSVideoFormat *v, VSCore *core, const VSAPI *vsapi) {
+    return vsapi->queryVideoFormatID(v->colorFamily, v->sampleType, v->bitsPerSample, v->subSamplingW, v->subSamplingH, core) == presetFormat;
+}
+
+/* convenience function to check for if two clips have the same format (but not framerate) while also including width and height (unknown/changeable will be considered the same too) */
+static inline VSH4_BOOLEAN_TYPE VSH4_MANGLE_FUNCTION_NAME(isSameVideoInfo)(const VSVideoInfo *v1, const VSVideoInfo *v2) {
+    return v1->height == v2->height && v1->width == v2->width && VSH4_MANGLE_FUNCTION_NAME(isSameVideoFormat)(&v1->format, &v2->format);
+}
+
+/* convenience function to check for if two clips have the same format while also including samplerate (unknown/changeable will be considered the same too) */
+static inline VSH4_BOOLEAN_TYPE VSH4_MANGLE_FUNCTION_NAME(isSameAudioFormat)(const VSAudioFormat *a1, const VSAudioFormat *a2) {
+    return a1->bitsPerSample == a2->bitsPerSample && a1->sampleType == a2->sampleType && a1->channelLayout == a2->channelLayout;
+}
+
+/* convenience function to check for if two clips have the same format while also including samplerate (unknown/changeable will be considered the same too) */
+static inline VSH4_BOOLEAN_TYPE VSH4_MANGLE_FUNCTION_NAME(isSameAudioInfo)(const VSAudioInfo *a1, const VSAudioInfo *a2) {
+    return a1->sampleRate == a2->sampleRate && VSH4_MANGLE_FUNCTION_NAME(isSameAudioFormat)(&a1->format, &a2->format);
+}
+
+/* multiplies and divides a rational number, such as a frame duration, in place and reduces the result */
+static inline void VSH4_MANGLE_FUNCTION_NAME(muldivRational)(int64_t *num, int64_t *den, int64_t mul, int64_t div) {
+    /* do nothing if the rational number is invalid */
+    if (!*den)
+        return;
+
+    /* nobody wants to accidentally divide by zero */
+    assert(div);
+
+    int64_t a, b;
+    *num *= mul;
+    *den *= div;
+    a = *num;
+    b = *den;
+    while (b != 0) {
+        int64_t t = a;
+        a = b;
+        b = t % b;
+    }
+    if (a < 0)
+        a = -a;
+    *num /= a;
+    *den /= a;
+}
+
+/* reduces a rational number */
+static inline void VSH4_MANGLE_FUNCTION_NAME(reduceRational)(int64_t *num, int64_t *den) {
+    VSH4_MANGLE_FUNCTION_NAME(muldivRational)(num, den, 1, 1);
+}
+
+/* add two rational numbers and reduces the result */
+static inline void VSH4_MANGLE_FUNCTION_NAME(addRational)(int64_t *num, int64_t *den, int64_t addnum, int64_t addden) {
+    /* do nothing if the rational number is invalid */
+    if (!*den)
+        return;
+
+    /* nobody wants to accidentally add an invalid rational number */
+    assert(addden);
+
+    if (*den == addden) {
+        *num += addnum;
+    } else {
+        int64_t temp = addden;
+        addnum *= *den;
+        addden *= *den;
+        *num *= temp;
+        *den *= temp;
+
+        *num += addnum;
+
+        VSH4_MANGLE_FUNCTION_NAME(reduceRational)(num, den);
+    }
+}
+
+/* converts an int64 to int with saturation, useful to silence warnings when reading int properties among other things */
+static inline int VSH4_MANGLE_FUNCTION_NAME(int64ToIntS)(int64_t i) {
+    if (i > INT_MAX)
+        return INT_MAX;
+    else if (i < INT_MIN)
+        return INT_MIN;
+    else return (int)i;
+}
+
+/* converts a double to float with saturation, useful to silence warnings when reading float properties among other things */
+static inline float VSH4_MANGLE_FUNCTION_NAME(doubleToFloatS)(double d) {
+    return (float)d;
+}
+
+static inline void VSH4_MANGLE_FUNCTION_NAME(bitblt)(void *dstp, ptrdiff_t dst_stride, const void *srcp, ptrdiff_t src_stride, size_t row_size, size_t height) {
+    if (height) {
+        if (src_stride == dst_stride && src_stride == (ptrdiff_t)row_size) {
+            memcpy(dstp, srcp, row_size * height);
+        } else {
+            const uint8_t *srcp8 = (const uint8_t *)srcp;
+            uint8_t *dstp8 = (uint8_t *)dstp;
+            size_t i;
+            for (i = 0; i < height; i++) {
+                memcpy(dstp8, srcp8, row_size);
+                srcp8 += src_stride;
+                dstp8 += dst_stride;
+            }
+        }
+    }
+}
+
+/* check if the frame dimensions are valid for a given format */
+/* returns non-zero for valid width and height */
+static inline VSH4_BOOLEAN_TYPE VSH4_MANGLE_FUNCTION_NAME(areValidDimensions)(const VSVideoFormat *fi, int width, int height) {
+    return !(width % (1 << fi->subSamplingW) || height % (1 << fi->subSamplingH));
+}
+
+/* Visual Studio doesn't recognize inline in c mode */
+#if defined(_MSC_VER) && !defined(__cplusplus)
+#undef inline
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

vapoursynth_mvuscale-0.1.0/include/VapourSynth4.h

@@ -0,0 +1,534 @@
+/*
+* Copyright (c) 2012-2026 Fredrik Mellbin
+*
+* This file is part of VapourSynth.
+*
+* VapourSynth is free software; you can redistribute it and/or
+* modify it under the terms of the GNU Lesser General Public
+* License as published by the Free Software Foundation; either
+* version 2.1 of the License, or (at your option) any later version.
+*
+* VapourSynth is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public
+* License along with VapourSynth; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+
+#ifndef VAPOURSYNTH4_H
+#define VAPOURSYNTH4_H
+
+#include <stdint.h>
+#include <stddef.h>
+
+#define VS_MAKE_VERSION(major, minor) (((major) << 16) | (minor))
+#define VAPOURSYNTH_API_MAJOR 4
+#if defined(VS_USE_LATEST_API) || defined(VS_USE_API_42)
+#define VAPOURSYNTH_API_MINOR 2
+#elif defined(VS_USE_API_41)
+#define VAPOURSYNTH_API_MINOR 1
+#else
+#define VAPOURSYNTH_API_MINOR 0
+#endif
+#define VAPOURSYNTH_API_VERSION VS_MAKE_VERSION(VAPOURSYNTH_API_MAJOR, VAPOURSYNTH_API_MINOR)
+
+#define VS_AUDIO_FRAME_SAMPLES 3072
+
+/* Convenience for C++ users. */
+#ifdef __cplusplus
+#    define VS_EXTERN_C extern "C"
+#    if __cplusplus >= 201103L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201103L)
+#        define VS_NOEXCEPT noexcept
+#    else
+#        define VS_NOEXCEPT
+#    endif
+#else
+#    define VS_EXTERN_C
+#    define VS_NOEXCEPT
+#endif
+
+#if defined(_WIN32) && !defined(_WIN64)
+#    define VS_CC __stdcall
+#else
+#    define VS_CC
+#endif
+
+/* And now for some symbol hide-and-seek... */
+#if defined(_WIN32) /* Windows being special */
+#    define VS_EXTERNAL_API(ret) VS_EXTERN_C __declspec(dllexport) ret VS_CC
+#elif defined(__GNUC__) && __GNUC__ >= 4
+#    define VS_EXTERNAL_API(ret) VS_EXTERN_C __attribute__((visibility("default"))) ret VS_CC
+#else
+#    define VS_EXTERNAL_API(ret) VS_EXTERN_C ret VS_CC
+#endif
+
+#if !defined(VS_CORE_EXPORTS) && defined(_WIN32)
+#    define VS_API(ret) VS_EXTERN_C __declspec(dllimport) ret VS_CC
+#else
+#    define VS_API(ret) VS_EXTERNAL_API(ret)
+#endif
+
+typedef struct VSFrame VSFrame;
+typedef struct VSNode VSNode;
+typedef struct VSCore VSCore;
+typedef struct VSPlugin VSPlugin;
+typedef struct VSPluginFunction VSPluginFunction;
+typedef struct VSFunction VSFunction;
+typedef struct VSMap VSMap;
+typedef struct VSLogHandle VSLogHandle;
+typedef struct VSFrameContext VSFrameContext;
+typedef struct VSPLUGINAPI VSPLUGINAPI;
+typedef struct VSAPI VSAPI;
+
+typedef enum VSColorFamily {
+    cfUndefined = 0,
+    cfGray      = 1,
+    cfRGB       = 2,
+    cfYUV       = 3
+} VSColorFamily;
+
+typedef enum VSSampleType {
+    stInteger = 0,
+    stFloat = 1
+} VSSampleType;
+
+#define VS_MAKE_VIDEO_ID(colorFamily, sampleType, bitsPerSample, subSamplingW, subSamplingH) ((colorFamily << 28) | (sampleType << 24) | (bitsPerSample << 16) | (subSamplingW << 8) | (subSamplingH << 0))
+
+typedef enum VSPresetVideoFormat {
+    pfNone = 0,
+
+    pfGray8 = VS_MAKE_VIDEO_ID(cfGray, stInteger, 8, 0, 0),
+    pfGray9 = VS_MAKE_VIDEO_ID(cfGray, stInteger, 9, 0, 0),
+    pfGray10 = VS_MAKE_VIDEO_ID(cfGray, stInteger, 10, 0, 0),
+    pfGray12 = VS_MAKE_VIDEO_ID(cfGray, stInteger, 12, 0, 0),
+    pfGray14 = VS_MAKE_VIDEO_ID(cfGray, stInteger, 14, 0, 0),
+    pfGray16 = VS_MAKE_VIDEO_ID(cfGray, stInteger, 16, 0, 0),
+    pfGray32 = VS_MAKE_VIDEO_ID(cfGray, stInteger, 32, 0, 0),
+
+    pfGrayH = VS_MAKE_VIDEO_ID(cfGray, stFloat, 16, 0, 0),
+    pfGrayS = VS_MAKE_VIDEO_ID(cfGray, stFloat, 32, 0, 0),
+
+    pfYUV410P8 = VS_MAKE_VIDEO_ID(cfYUV, stInteger, 8, 2, 2),
+    pfYUV411P8 = VS_MAKE_VIDEO_ID(cfYUV, stInteger, 8, 2, 0),
+    pfYUV440P8 = VS_MAKE_VIDEO_ID(cfYUV, stInteger, 8, 0, 1),
+
+    pfYUV420P8 = VS_MAKE_VIDEO_ID(cfYUV, stInteger, 8, 1, 1),
+    pfYUV422P8 = VS_MAKE_VIDEO_ID(cfYUV, stInteger, 8, 1, 0),
+    pfYUV444P8 = VS_MAKE_VIDEO_ID(cfYUV, stInteger, 8, 0, 0),
+
+    pfYUV420P9 = VS_MAKE_VIDEO_ID(cfYUV, stInteger, 9, 1, 1),
+    pfYUV422P9 = VS_MAKE_VIDEO_ID(cfYUV, stInteger, 9, 1, 0),
+    pfYUV444P9 = VS_MAKE_VIDEO_ID(cfYUV, stInteger, 9, 0, 0),
+
+    pfYUV420P10 = VS_MAKE_VIDEO_ID(cfYUV, stInteger, 10, 1, 1),
+    pfYUV422P10 = VS_MAKE_VIDEO_ID(cfYUV, stInteger, 10, 1, 0),
+    pfYUV444P10 = VS_MAKE_VIDEO_ID(cfYUV, stInteger, 10, 0, 0),
+
+    pfYUV420P12 = VS_MAKE_VIDEO_ID(cfYUV, stInteger, 12, 1, 1),
+    pfYUV422P12 = VS_MAKE_VIDEO_ID(cfYUV, stInteger, 12, 1, 0),
+    pfYUV444P12 = VS_MAKE_VIDEO_ID(cfYUV, stInteger, 12, 0, 0),
+
+    pfYUV420P14 = VS_MAKE_VIDEO_ID(cfYUV, stInteger, 14, 1, 1),
+    pfYUV422P14 = VS_MAKE_VIDEO_ID(cfYUV, stInteger, 14, 1, 0),
+    pfYUV444P14 = VS_MAKE_VIDEO_ID(cfYUV, stInteger, 14, 0, 0),
+
+    pfYUV420P16 = VS_MAKE_VIDEO_ID(cfYUV, stInteger, 16, 1, 1),
+    pfYUV422P16 = VS_MAKE_VIDEO_ID(cfYUV, stInteger, 16, 1, 0),
+    pfYUV444P16 = VS_MAKE_VIDEO_ID(cfYUV, stInteger, 16, 0, 0),
+
+    pfYUV420PH = VS_MAKE_VIDEO_ID(cfYUV, stFloat, 16, 1, 1),
+    pfYUV420PS = VS_MAKE_VIDEO_ID(cfYUV, stFloat, 32, 1, 1),
+    pfYUV422PH = VS_MAKE_VIDEO_ID(cfYUV, stFloat, 16, 1, 0),
+    pfYUV422PS = VS_MAKE_VIDEO_ID(cfYUV, stFloat, 32, 1, 0),
+    pfYUV444PH = VS_MAKE_VIDEO_ID(cfYUV, stFloat, 16, 0, 0),
+    pfYUV444PS = VS_MAKE_VIDEO_ID(cfYUV, stFloat, 32, 0, 0),
+
+    pfRGB24 = VS_MAKE_VIDEO_ID(cfRGB, stInteger, 8, 0, 0),
+    pfRGB27 = VS_MAKE_VIDEO_ID(cfRGB, stInteger, 9, 0, 0),
+    pfRGB30 = VS_MAKE_VIDEO_ID(cfRGB, stInteger, 10, 0, 0),
+    pfRGB36 = VS_MAKE_VIDEO_ID(cfRGB, stInteger, 12, 0, 0),
+    pfRGB42 = VS_MAKE_VIDEO_ID(cfRGB, stInteger, 14, 0, 0),
+    pfRGB48 = VS_MAKE_VIDEO_ID(cfRGB, stInteger, 16, 0, 0),
+
+    pfRGBH = VS_MAKE_VIDEO_ID(cfRGB, stFloat, 16, 0, 0),
+    pfRGBS = VS_MAKE_VIDEO_ID(cfRGB, stFloat, 32, 0, 0),
+} VSPresetVideoFormat;
+
+#undef VS_MAKE_VIDEO_ID
+
+
+typedef enum VSFilterMode {
+    fmParallel = 0, /* completely parallel execution */
+    fmParallelRequests = 1, /* for filters that are single-threaded in nature but can request one or more frames they need in advance */
+    fmUnordered = 2, /* for filters that modify their internal state every request like source filters that read a file */
+    fmFrameState = 3 /* DO NOT USE UNLESS ABSOLUTELY NECESSARY, for compatibility with external code that can only keep the processing state of a single frame at a time */
+} VSFilterMode;
+
+typedef enum VSMediaType {
+    mtVideo = 1,
+    mtAudio = 2
+} VSMediaType;
+
+typedef struct VSVideoFormat {
+    int colorFamily; /* see VSColorFamily */
+    int sampleType; /* see VSSampleType */
+    int bitsPerSample; /* number of significant bits */
+    int bytesPerSample; /* actual storage is always in a power of 2 and the smallest possible that can fit the number of bits used per sample */
+
+    int subSamplingW; /* log2 subsampling factor, applied to second and third plane */
+    int subSamplingH; /* log2 subsampling factor, applied to second and third plane */
+
+    int numPlanes; /* implicit from colorFamily */
+} VSVideoFormat;
+
+typedef enum VSAudioChannels {
+    acFrontLeft           = 0,
+    acFrontRight          = 1,
+    acFrontCenter         = 2,
+    acLowFrequency        = 3,
+    acBackLeft            = 4,
+    acBackRight           = 5,
+    acFrontLeftOFCenter   = 6,
+    acFrontRightOFCenter  = 7,
+    acBackCenter          = 8,
+    acSideLeft            = 9,
+    acSideRight           = 10,
+    acTopCenter           = 11,
+    acTopFrontLeft        = 12,
+    acTopFrontCenter      = 13,
+    acTopFrontRight       = 14,
+    acTopBackLeft         = 15,
+    acTopBackCenter       = 16,
+    acTopBackRight        = 17,
+    acStereoLeft          = 29,
+    acStereoRight         = 30,
+    acWideLeft            = 31,
+    acWideRight           = 32,
+    acSurroundDirectLeft  = 33,
+    acSurroundDirectRight = 34,
+    acLowFrequency2       = 35
+} VSAudioChannels;
+
+typedef struct VSAudioFormat {
+    int sampleType;
+    int bitsPerSample;
+    int bytesPerSample; /* implicit from bitsPerSample */
+    int numChannels; /* implicit from channelLayout */
+    uint64_t channelLayout;
+} VSAudioFormat;
+
+typedef enum VSPropertyType {
+    ptUnset = 0,
+    ptInt = 1,
+    ptFloat = 2,
+    ptData = 3,
+    ptFunction = 4,
+    ptVideoNode = 5,
+    ptAudioNode = 6,
+    ptVideoFrame = 7,
+    ptAudioFrame = 8
+} VSPropertyType;
+
+typedef enum VSMapPropertyError {
+    peSuccess = 0,
+    peUnset   = 1, /* no key exists */
+    peType    = 2, /* key exists but not of a compatible type */
+    peIndex   = 4, /* index out of bounds */
+    peError   = 3  /* map has error state set */
+} VSMapPropertyError;
+
+typedef enum VSMapAppendMode {
+    maReplace = 0,
+    maAppend  = 1
+} VSMapAppendMode;
+
+typedef struct VSCoreInfo {
+    const char *versionString;
+    int core;
+    int api;
+    int numThreads;
+    int64_t maxFramebufferSize;
+    int64_t usedFramebufferSize;
+} VSCoreInfo;
+
+typedef struct VSCoreInfo2 {
+    const char *versionString;
+    int coreVersion;
+    int apiVersion;
+    int creationFlags;
+    int numThreads;
+    int64_t maxFramebufferSize;
+    int64_t usedFramebufferSize;
+} VSCoreInfo2;
+
+typedef struct VSVideoInfo {
+    VSVideoFormat format;
+    int64_t fpsNum;
+    int64_t fpsDen;
+    int width;
+    int height;
+    int numFrames;
+} VSVideoInfo;
+
+typedef struct VSAudioInfo {
+    VSAudioFormat format;
+    int sampleRate;
+    int64_t numSamples;
+    int numFrames; /* the total number of audio frames needed to hold numSamples, implicit from numSamples when calling createAudioFilter */
+} VSAudioInfo;
+
+typedef enum VSActivationReason {
+    arInitial = 0,
+    arAllFramesReady = 1,
+    arError = -1
+} VSActivationReason;
+
+typedef enum VSMessageType {
+    mtDebug = 0,
+    mtInformation = 1, 
+    mtWarning = 2,
+    mtCritical = 3,
+    mtFatal = 4 /* also terminates the process, should generally not be used by normal filters */
+} VSMessageType;
+
+typedef enum VSCoreCreationFlags {
+    ccfEnableGraphInspection = 1,
+    ccfDisableAutoLoading = 2,
+    ccfDisableLibraryUnloading = 4,
+    ccfEnableFrameRefDebug = 8
+} VSCoreCreationFlags;
+
+typedef enum VSPluginConfigFlags {
+    pcModifiable = 1
+} VSPluginConfigFlags;
+
+typedef enum VSDataTypeHint {
+    dtUnknown = -1,
+    dtBinary = 0,
+    dtUtf8 = 1
+} VSDataTypeHint;
+
+typedef enum VSRequestPattern {
+    rpGeneral = 0, /* General pattern */
+    rpNoFrameReuse = 1, /* When requesting all output frames from the filter no frame will be requested more than once from this input clip, never requests frames beyond the end of the clip */
+    rpStrictSpatial = 2 /* Always (and only) requests frame n from the input clip when generating output frame n, never requests frames beyond the end of the clip */
+#if VAPOURSYNTH_API_MINOR >= 1   
+    ,
+    rpFrameReuseLastOnly = 3 /* Added in API 4.1, This modes is basically identical rpNoFrameReuse except that it hints the last frame may be requested multiple times */
+#endif
+} VSRequestPattern;
+
+typedef enum VSCacheMode {
+    cmAuto = -1,
+    cmForceDisable = 0,
+    cmForceEnable = 1
+} VSCacheMode;
+
+/* Core entry point */
+typedef const VSAPI *(VS_CC *VSGetVapourSynthAPI)(int version);
+
+/* Plugin, function and filter related */
+typedef void (VS_CC *VSPublicFunction)(const VSMap *in, VSMap *out, void *userData, VSCore *core, const VSAPI *vsapi);
+typedef void (VS_CC *VSInitPlugin)(VSPlugin *plugin, const VSPLUGINAPI *vspapi);
+typedef void (VS_CC *VSFreeFunctionData)(void *userData);
+typedef const VSFrame *(VS_CC *VSFilterGetFrame)(int n, int activationReason, void *instanceData, void **frameData, VSFrameContext *frameCtx, VSCore *core, const VSAPI *vsapi);
+typedef void (VS_CC *VSFilterFree)(void *instanceData, VSCore *core, const VSAPI *vsapi);
+
+/* Other */
+typedef void (VS_CC *VSFrameDoneCallback)(void *userData, const VSFrame *f, int n, VSNode *node, const char *errorMsg);
+typedef void (VS_CC *VSLogHandler)(int msgType, const char *msg, void *userData);
+typedef void (VS_CC *VSLogHandlerFree)(void *userData);
+
+typedef struct VSPLUGINAPI {
+    int (VS_CC *getAPIVersion)(void) VS_NOEXCEPT; /* returns VAPOURSYNTH_API_VERSION of the library */
+    int (VS_CC *configPlugin)(const char *identifier, const char *pluginNamespace, const char *name, int pluginVersion, int apiVersion, int flags, VSPlugin *plugin) VS_NOEXCEPT; /* use the VS_MAKE_VERSION macro for pluginVersion */
+    int (VS_CC *registerFunction)(const char *name, const char *args, const char *returnType, VSPublicFunction argsFunc, void *functionData, VSPlugin *plugin) VS_NOEXCEPT; /* non-zero return value on success  */
+} VSPLUGINAPI;
+
+typedef struct VSFilterDependency {
+    VSNode *source;
+    int requestPattern; /* VSRequestPattern */
+} VSFilterDependency;
+
+struct VSAPI {
+    /* Audio and video filter related including nodes */
+    void (VS_CC *createVideoFilter)(VSMap *out, const char *name, const VSVideoInfo *vi, VSFilterGetFrame getFrame, VSFilterFree free, int filterMode, const VSFilterDependency *dependencies, int numDeps, void *instanceData, VSCore *core) VS_NOEXCEPT; /* output nodes are appended to the clip key in the out map */
+    VSNode *(VS_CC *createVideoFilter2)(const char *name, const VSVideoInfo *vi, VSFilterGetFrame getFrame, VSFilterFree free, int filterMode, const VSFilterDependency *dependencies, int numDeps, void *instanceData, VSCore *core) VS_NOEXCEPT; /* same as createVideoFilter but returns a pointer to the VSNode directly or NULL on failure */
+    void (VS_CC *createAudioFilter)(VSMap *out, const char *name, const VSAudioInfo *ai, VSFilterGetFrame getFrame, VSFilterFree free, int filterMode, const VSFilterDependency *dependencies, int numDeps, void *instanceData, VSCore *core) VS_NOEXCEPT; /* output nodes are appended to the clip key in the out map */
+    VSNode *(VS_CC *createAudioFilter2)(const char *name, const VSAudioInfo *ai, VSFilterGetFrame getFrame, VSFilterFree free, int filterMode, const VSFilterDependency *dependencies, int numDeps, void *instanceData, VSCore *core) VS_NOEXCEPT; /* same as createAudioFilter but returns a pointer to the VSNode directly or NULL on failure */
+    int (VS_CC *setLinearFilter)(VSNode *node) VS_NOEXCEPT; /* Use right after create*Filter*, sets the correct cache mode for using the cacheFrame API and returns the recommended upper number of additional frames to cache per request */
+    void (VS_CC *setCacheMode)(VSNode *node, int mode) VS_NOEXCEPT; /* VSCacheMode, changing the cache mode also resets all options to their default */
+    void (VS_CC *setCacheOptions)(VSNode *node, int fixedSize, int maxSize, int maxHistorySize) VS_NOEXCEPT; /* passing -1 means no change */
+
+    void (VS_CC *freeNode)(VSNode *node) VS_NOEXCEPT;
+    VSNode *(VS_CC *addNodeRef)(VSNode *node) VS_NOEXCEPT;
+    int (VS_CC *getNodeType)(VSNode *node) VS_NOEXCEPT; /* returns VSMediaType */
+    const VSVideoInfo *(VS_CC *getVideoInfo)(VSNode *node) VS_NOEXCEPT;
+    const VSAudioInfo *(VS_CC *getAudioInfo)(VSNode *node) VS_NOEXCEPT;
+
+    /* Frame related functions */
+    VSFrame *(VS_CC *newVideoFrame)(const VSVideoFormat *format, int width, int height, const VSFrame *propSrc, VSCore *core) VS_NOEXCEPT;
+    VSFrame *(VS_CC *newVideoFrame2)(const VSVideoFormat *format, int width, int height, const VSFrame **planeSrc, const int *planes, const VSFrame *propSrc, VSCore *core) VS_NOEXCEPT; /* same as newVideoFrame but allows the specified planes to be effectively copied from the source frames */
+    VSFrame *(VS_CC *newAudioFrame)(const VSAudioFormat *format, int numSamples, const VSFrame *propSrc, VSCore *core) VS_NOEXCEPT;
+    VSFrame *(VS_CC *newAudioFrame2)(const VSAudioFormat *format, int numSamples, const VSFrame **channelSrc, const int *channels, const VSFrame *propSrc, VSCore *core) VS_NOEXCEPT; /* same as newAudioFrame but allows the specified channels to be effectively copied from the source frames */
+    void (VS_CC *freeFrame)(const VSFrame *f) VS_NOEXCEPT;
+    const VSFrame *(VS_CC *addFrameRef)(const VSFrame *f) VS_NOEXCEPT;
+    VSFrame *(VS_CC *copyFrame)(const VSFrame *f, VSCore *core) VS_NOEXCEPT;
+    const VSMap *(VS_CC *getFramePropertiesRO)(const VSFrame *f) VS_NOEXCEPT;
+    VSMap *(VS_CC *getFramePropertiesRW)(VSFrame *f) VS_NOEXCEPT;
+
+    ptrdiff_t (VS_CC *getStride)(const VSFrame *f, int plane) VS_NOEXCEPT;
+    const uint8_t *(VS_CC *getReadPtr)(const VSFrame *f, int plane) VS_NOEXCEPT;
+    uint8_t *(VS_CC *getWritePtr)(VSFrame *f, int plane) VS_NOEXCEPT; /* calling this function invalidates previously gotten read pointers to the same frame */
+
+    const VSVideoFormat *(VS_CC *getVideoFrameFormat)(const VSFrame *f) VS_NOEXCEPT;
+    const VSAudioFormat *(VS_CC *getAudioFrameFormat)(const VSFrame *f) VS_NOEXCEPT;
+    int (VS_CC *getFrameType)(const VSFrame *f) VS_NOEXCEPT; /* returns VSMediaType */
+    int (VS_CC *getFrameWidth)(const VSFrame *f, int plane) VS_NOEXCEPT;
+    int (VS_CC *getFrameHeight)(const VSFrame *f, int plane) VS_NOEXCEPT;
+    int (VS_CC *getFrameLength)(const VSFrame *f) VS_NOEXCEPT; /* returns the number of samples for audio frames */
+
+    /* General format functions  */
+    int (VS_CC *getVideoFormatName)(const VSVideoFormat *format, char *buffer) VS_NOEXCEPT; /* up to 32 characters including terminating null may be written to the buffer, non-zero return value on success */
+    int (VS_CC *getAudioFormatName)(const VSAudioFormat *format, char *buffer) VS_NOEXCEPT; /* up to 32 characters including terminating null may be written to the buffer, non-zero return value on success */
+    int (VS_CC *queryVideoFormat)(VSVideoFormat *format, int colorFamily, int sampleType, int bitsPerSample, int subSamplingW, int subSamplingH, VSCore *core) VS_NOEXCEPT; /* non-zero return value on success */
+    int (VS_CC *queryAudioFormat)(VSAudioFormat *format, int sampleType, int bitsPerSample, uint64_t channelLayout, VSCore *core) VS_NOEXCEPT; /* non-zero return value on success */
+    uint32_t (VS_CC *queryVideoFormatID)(int colorFamily, int sampleType, int bitsPerSample, int subSamplingW, int subSamplingH, VSCore *core) VS_NOEXCEPT; /* returns 0 on failure */
+    int (VS_CC *getVideoFormatByID)(VSVideoFormat *format, uint32_t id, VSCore *core) VS_NOEXCEPT; /* non-zero return value on success */
+
+    /* Frame request and filter getframe functions */
+    const VSFrame *(VS_CC *getFrame)(int n, VSNode *node, char *errorMsg, int bufSize) VS_NOEXCEPT; /* only for external applications using the core as a library or for requesting frames in a filter constructor, do not use inside a filter's getframe function */
+    void (VS_CC *getFrameAsync)(int n, VSNode *node, VSFrameDoneCallback callback, void *userData) VS_NOEXCEPT; /* only for external applications using the core as a library or for requesting frames in a filter constructor, do not use inside a filter's getframe function */
+    const VSFrame *(VS_CC *getFrameFilter)(int n, VSNode *node, VSFrameContext *frameCtx) VS_NOEXCEPT; /* only use inside a filter's getframe function */
+    void (VS_CC *requestFrameFilter)(int n, VSNode *node, VSFrameContext *frameCtx) VS_NOEXCEPT; /* only use inside a filter's getframe function */
+    void (VS_CC *releaseFrameEarly)(VSNode *node, int n, VSFrameContext *frameCtx) VS_NOEXCEPT; /* only use inside a filter's getframe function, unless this function is called a requested frame is kept in memory until the end of processing the current frame */
+    void (VS_CC *cacheFrame)(const VSFrame *frame, int n, VSFrameContext *frameCtx) VS_NOEXCEPT; /* used to store intermediate frames in cache, useful for filters where random access is slow, must call setLinearFilter on the node before using or the result is undefined  */
+    void (VS_CC *setFilterError)(const char *errorMessage, VSFrameContext *frameCtx) VS_NOEXCEPT; /* used to signal errors in the filter getframe function */
+
+    /* External functions */
+    VSFunction *(VS_CC *createFunction)(VSPublicFunction func, void *userData, VSFreeFunctionData free, VSCore *core) VS_NOEXCEPT;
+    void (VS_CC *freeFunction)(VSFunction *f) VS_NOEXCEPT;
+    VSFunction *(VS_CC *addFunctionRef)(VSFunction *f) VS_NOEXCEPT;
+    void (VS_CC *callFunction)(VSFunction *func, const VSMap *in, VSMap *out) VS_NOEXCEPT;
+
+    /* Map and property access functions */
+    VSMap *(VS_CC *createMap)(void) VS_NOEXCEPT;
+    void (VS_CC *freeMap)(VSMap *map) VS_NOEXCEPT;
+    void (VS_CC *clearMap)(VSMap *map) VS_NOEXCEPT;
+    void (VS_CC *copyMap)(const VSMap *src, VSMap *dst) VS_NOEXCEPT; /* copies all values in src to dst, if a key already exists in dst it's replaced */
+
+    void (VS_CC *mapSetError)(VSMap *map, const char *errorMessage) VS_NOEXCEPT; /* used to signal errors outside filter getframe function */
+    const char *(VS_CC *mapGetError)(const VSMap *map) VS_NOEXCEPT; /* used to query errors, returns 0 if no error */
+
+    int (VS_CC *mapNumKeys)(const VSMap *map) VS_NOEXCEPT;
+    const char *(VS_CC *mapGetKey)(const VSMap *map, int index) VS_NOEXCEPT;
+    int (VS_CC *mapDeleteKey)(VSMap *map, const char *key) VS_NOEXCEPT;
+    int (VS_CC *mapNumElements)(const VSMap *map, const char *key) VS_NOEXCEPT; /* returns -1 if a key doesn't exist */
+    int (VS_CC *mapGetType)(const VSMap *map, const char *key) VS_NOEXCEPT; /* returns VSPropertyType */
+    int (VS_CC *mapSetEmpty)(VSMap *map, const char *key, int type) VS_NOEXCEPT;
+
+    int64_t (VS_CC *mapGetInt)(const VSMap *map, const char *key, int index, int *error) VS_NOEXCEPT;
+    int (VS_CC *mapGetIntSaturated)(const VSMap *map, const char *key, int index, int *error) VS_NOEXCEPT;
+    const int64_t *(VS_CC *mapGetIntArray)(const VSMap *map, const char *key, int *error) VS_NOEXCEPT;
+    int (VS_CC *mapSetInt)(VSMap *map, const char *key, int64_t i, int append) VS_NOEXCEPT;
+    int (VS_CC *mapSetIntArray)(VSMap *map, const char *key, const int64_t *i, int size) VS_NOEXCEPT;
+
+    double (VS_CC *mapGetFloat)(const VSMap *map, const char *key, int index, int *error) VS_NOEXCEPT;
+    float (VS_CC *mapGetFloatSaturated)(const VSMap *map, const char *key, int index, int *error) VS_NOEXCEPT;
+    const double *(VS_CC *mapGetFloatArray)(const VSMap *map, const char *key, int *error) VS_NOEXCEPT;
+    int (VS_CC *mapSetFloat)(VSMap *map, const char *key, double d, int append) VS_NOEXCEPT;
+    int (VS_CC *mapSetFloatArray)(VSMap *map, const char *key, const double *d, int size) VS_NOEXCEPT;
+
+    const char *(VS_CC *mapGetData)(const VSMap *map, const char *key, int index, int *error) VS_NOEXCEPT;
+    int (VS_CC *mapGetDataSize)(const VSMap *map, const char *key, int index, int *error) VS_NOEXCEPT;
+    int (VS_CC *mapGetDataTypeHint)(const VSMap *map, const char *key, int index, int *error) VS_NOEXCEPT; /* returns VSDataTypeHint */
+    int (VS_CC *mapSetData)(VSMap *map, const char *key, const char *data, int size, int type, int append) VS_NOEXCEPT;
+
+    VSNode *(VS_CC *mapGetNode)(const VSMap *map, const char *key, int index, int *error) VS_NOEXCEPT;
+    int (VS_CC *mapSetNode)(VSMap *map, const char *key, VSNode *node, int append) VS_NOEXCEPT; /* returns 0 on success */
+    int (VS_CC *mapConsumeNode)(VSMap *map, const char *key, VSNode *node, int append) VS_NOEXCEPT; /* always consumes the reference, even on error */
+
+    const VSFrame *(VS_CC *mapGetFrame)(const VSMap *map, const char *key, int index, int *error) VS_NOEXCEPT;
+    int (VS_CC *mapSetFrame)(VSMap *map, const char *key, const VSFrame *f, int append) VS_NOEXCEPT; /* returns 0 on success */
+    int (VS_CC *mapConsumeFrame)(VSMap *map, const char *key, const VSFrame *f, int append) VS_NOEXCEPT; /* always consumes the reference, even on error */
+
+    VSFunction *(VS_CC *mapGetFunction)(const VSMap *map, const char *key, int index, int *error) VS_NOEXCEPT;
+    int (VS_CC *mapSetFunction)(VSMap *map, const char *key, VSFunction *func, int append) VS_NOEXCEPT; /* returns 0 on success */
+    int (VS_CC *mapConsumeFunction)(VSMap *map, const char *key, VSFunction *func, int append) VS_NOEXCEPT; /* always consumes the reference, even on error */
+
+    /* Plugin and plugin function related */
+    int (VS_CC *registerFunction)(const char *name, const char *args, const char *returnType, VSPublicFunction argsFunc, void *functionData, VSPlugin *plugin) VS_NOEXCEPT; /* non-zero return value on success  */
+    VSPlugin *(VS_CC *getPluginByID)(const char *identifier, VSCore *core) VS_NOEXCEPT;
+    VSPlugin *(VS_CC *getPluginByNamespace)(const char *ns, VSCore *core) VS_NOEXCEPT;
+    VSPlugin *(VS_CC *getNextPlugin)(VSPlugin *plugin, VSCore *core) VS_NOEXCEPT; /* pass NULL to get the first plugin  */
+    const char *(VS_CC *getPluginName)(VSPlugin *plugin) VS_NOEXCEPT;
+    const char *(VS_CC *getPluginID)(VSPlugin *plugin) VS_NOEXCEPT;
+    const char *(VS_CC *getPluginNamespace)(VSPlugin *plugin) VS_NOEXCEPT;
+    VSPluginFunction *(VS_CC *getNextPluginFunction)(VSPluginFunction *func, VSPlugin *plugin) VS_NOEXCEPT; /* pass NULL to get the first plugin function  */
+    VSPluginFunction *(VS_CC *getPluginFunctionByName)(const char *name, VSPlugin *plugin) VS_NOEXCEPT;
+    const char *(VS_CC *getPluginFunctionName)(VSPluginFunction *func) VS_NOEXCEPT;
+    const char *(VS_CC *getPluginFunctionArguments)(VSPluginFunction *func) VS_NOEXCEPT; /* returns an argument format string */
+    const char *(VS_CC *getPluginFunctionReturnType)(VSPluginFunction *func) VS_NOEXCEPT; /* returns an argument format string */
+    const char *(VS_CC *getPluginPath)(const VSPlugin *plugin) VS_NOEXCEPT; /* the full path to the loaded library file containing the plugin entry point */
+    int (VS_CC *getPluginVersion)(const VSPlugin *plugin) VS_NOEXCEPT;
+    VSMap *(VS_CC *invoke)(VSPlugin *plugin, const char *name, const VSMap *args) VS_NOEXCEPT; /* user must free the returned VSMap */
+
+    /* Core and information */
+    VSCore *(VS_CC *createCore)(int flags) VS_NOEXCEPT; /* flags uses the VSCoreCreationFlags enum */
+    void (VS_CC *freeCore)(VSCore *core) VS_NOEXCEPT; /* only call this function after all node, frame and function references belonging to the core have been freed */
+    int64_t (VS_CC *setMaxCacheSize)(int64_t bytes, VSCore *core) VS_NOEXCEPT; /* the total cache size at which vapoursynth more aggressively tries to reclaim memory, it is not a hard limit */
+    int (VS_CC *setThreadCount)(int threads, VSCore *core) VS_NOEXCEPT; /* setting threads to 0 means automatic detection */
+    void (VS_CC *getCoreInfo)(VSCore *core, VSCoreInfo *info) VS_NOEXCEPT;
+    int (VS_CC *getAPIVersion)(void) VS_NOEXCEPT;
+
+    /* Message handler */
+    void (VS_CC *logMessage)(int msgType, const char *msg, VSCore *core) VS_NOEXCEPT;
+    VSLogHandle *(VS_CC *addLogHandler)(VSLogHandler handler, VSLogHandlerFree free, void *userData, VSCore *core) VS_NOEXCEPT; /* free and userData can be NULL, returns a handle that can be passed to removeLogHandler */
+    int (VS_CC *removeLogHandler)(VSLogHandle *handle, VSCore *core) VS_NOEXCEPT; /* returns non-zero if successfully removed */
+    
+    /* Added in API 4.1, mostly graph and node inspection, PLEASE DON'T USE INSIDE FILTERS */
+#if VAPOURSYNTH_API_MINOR >= 1
+    /* Additional cache management to free memory */
+    void (VS_CC *clearNodeCache)(VSNode *node) VS_NOEXCEPT; /* clears the cache of the specified node */
+    void (VS_CC *clearCoreCaches)(VSCore *core) VS_NOEXCEPT; /* clears all caches belonging to the specified core */
+
+    /* Basic node information */
+    const char *(VS_CC *getNodeName)(VSNode *node) VS_NOEXCEPT; /* the name passed to create*Filter */
+    int (VS_CC *getNodeFilterMode)(VSNode *node) VS_NOEXCEPT; /* returns VSFilterMode */
+    int (VS_CC *getNumNodeDependencies)(VSNode *node) VS_NOEXCEPT;
+    const VSFilterDependency *(VS_CC *getNodeDependency)(VSNode *node, int index) VS_NOEXCEPT;
+
+    /* Node timing functions */
+    int (VS_CC *getCoreNodeTiming)(VSCore *core) VS_NOEXCEPT; /* non-zero when filter timing is enabled */
+    void (VS_CC *setCoreNodeTiming)(VSCore *core, int enable) VS_NOEXCEPT; /* non-zero enables filter timing, note that disabling simply stops the counters from incrementing */
+    int64_t (VS_CC *getNodeProcessingTime)(VSNode *node, int reset) VS_NOEXCEPT; /* time spent processing frames in nanoseconds, reset sets the counter to 0 again */
+    int64_t (VS_CC *getFreedNodeProcessingTime)(VSCore *core, int reset) VS_NOEXCEPT; /* time spent processing frames in nanoseconds in all destroyed nodes, reset sets the counter to 0 again */
+
+    /* Added in API 4.2 */
+#if VAPOURSYNTH_API_MINOR >= 2
+    void (VS_CC *getCoreInfo2)(VSCore *core, VSCoreInfo2 *info) VS_NOEXCEPT;
+
+#if defined(VS_GRAPH_API)
+    /* !!! Experimental/expensive graph information, these function require both the major and minor version to match exactly when using them !!!
+     * 
+     * These functions only exist to retrieve internal details for debug purposes and graph visualization
+     * They will only only work properly when used on a core created with ccfEnableGraphInspection and are
+     * not safe to use concurrently with frame requests or other API functions. Because of this they are
+     * unsuitable for use in plugins and filters.
+     */
+
+    const char *(VS_CC *getNodeCreationFunctionName)(VSNode *node, int level) VS_NOEXCEPT; /* level=0 returns the name of the function that created the filter, specifying a higher level will retrieve the function above that invoked it or NULL if a non-existent level is requested */
+    const char *(VS_CC *getNodeCreationPluginID)(VSNode *node, int level) VS_NOEXCEPT; /* level=0 returns the name of the function that created the filter, specifying a higher level will retrieve the function above that invoked it or NULL if a non-existent level is requested */
+    const char *(VS_CC *getNodeCreationPluginNS)(VSNode *node, int level) VS_NOEXCEPT; /* level=0 returns the name of the function that created the filter, specifying a higher level will retrieve the function above that invoked it or NULL if a non-existent level is requested */
+    const VSMap *(VS_CC *getNodeCreationFunctionArguments)(VSNode *node, int level) VS_NOEXCEPT; /* level=0 returns a copy of the arguments passed to the function that created the filter, returns NULL if a non-existent level is requested */
+#endif
+#endif
+#endif
+};
+
+VS_API(const VSAPI *) getVapourSynthAPI(int version) VS_NOEXCEPT;
+
+#endif /* VAPOURSYNTH4_H */

vapoursynth_mvuscale-0.1.0/mvuscale.cpp

@@ -0,0 +1,149 @@
+// mvuscale — a native replacement for the pure-Python scale_vect() used by
+// smdegrain_bis' UHDhalf path (SMDEGRAIN_BIS_IMPROVEMENTS.md §5/§6).
+//
+// manipmv.ScaleVect cannot read mvutensils' vectors, and mvu ships no scaling
+// op, so the port scales the vectors in Python. That marshals ~96k int64 props
+// per frame through the GIL and is ~4x slower than the mvtools+manipmv UHDhalf
+// path. This filter does the same work in C++: it reads mvu's plain-int frame
+// props, scales geometry by s, packed vectors (low32=x, high32=y) by s, and
+// per-block SAD by s*s, releasing the GIL so frames process in parallel.
+//
+// The operation is memory-bound (array I/O + the unavoidable frame copy), so
+// it is deliberately scalar; -O3 auto-vectorises the trivial loops with the
+// x86-64 baseline (SSE2), keeping the .so portable (no AVX runtime requirement).
+//
+// Boundary frames carry geometry but no Vectors/SAD (§6.1); those are simply
+// left untouched.
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "VapourSynth4.h"
+#include "VSHelper4.h"
+
+namespace {
+
+struct ScaleVectData {
+    VSNode *node;
+    int scale;
+    std::string prefix;
+};
+
+// Geometry props that describe a resolution and therefore scale by `s`.
+const char *const kGeomSuffix[] = {
+    "BlkSizeX", "BlkSizeY", "OverlapX", "OverlapY",
+    "Width", "Height", "RealWidth", "RealHeight", "HPad", "VPad",
+};
+
+void scaleProps(VSMap *props, const ScaleVectData *d, const VSAPI *vsapi) {
+    const int64_t s = d->scale;
+    const int64_t s2 = s * s;
+    const std::string &pfx = d->prefix;
+
+    // Scalar geometry props: present on every frame, always scaled.
+    for (const char *suffix : kGeomSuffix) {
+        const std::string key = pfx + "Analysis" + suffix;
+        int err = 0;
+        int64_t v = vsapi->mapGetInt(props, key.c_str(), 0, &err);
+        if (!err)
+            vsapi->mapSetInt(props, key.c_str(), v * s, maReplace);
+    }
+
+    // Packed motion vectors: low 32 bits = x, high 32 bits = y (two's
+    // complement). Absent on sequence-boundary frames — skip if so.
+    const std::string vkey = pfx + "AnalysisVectors";
+    int verr = 0;
+    const int64_t *vec = vsapi->mapGetIntArray(props, vkey.c_str(), &verr);
+    if (verr || !vec)
+        return;
+    const int vcount = vsapi->mapNumElements(props, vkey.c_str());
+
+    // Copy the SAD array out before we overwrite any keys (mapSet* may
+    // reallocate the map's storage and invalidate `vec`/`sad`).
+    const std::string skey = pfx + "AnalysisSAD";
+    int serr = 0;
+    const int64_t *sad = vsapi->mapGetIntArray(props, skey.c_str(), &serr);
+    const int scount = (!serr && sad) ? vsapi->mapNumElements(props, skey.c_str()) : 0;
+
+    std::vector<int64_t> vout(vcount);
+    for (int i = 0; i < vcount; ++i) {
+        // Scaling a two's-complement value is a masked multiply: the low 32
+        // bits of (signed_half * s) are correct for either sign (multiplication
+        // is well-defined mod 2^32). Vectors are small, so no 32-bit overflow.
+        const uint64_t packed = static_cast<uint64_t>(vec[i]);
+        const int32_t x = static_cast<int32_t>(packed & 0xFFFFFFFFu);
+        const int32_t y = static_cast<int32_t>(packed >> 32);
+        const uint32_t nx = static_cast<uint32_t>(static_cast<int64_t>(x) * s);
+        const uint32_t ny = static_cast<uint32_t>(static_cast<int64_t>(y) * s);
+        vout[i] = static_cast<int64_t>(static_cast<uint64_t>(nx) |
+                                       (static_cast<uint64_t>(ny) << 32));
+    }
+
+    std::vector<int64_t> sout(scount);
+    for (int i = 0; i < scount; ++i)
+        sout[i] = sad[i] * s2;  // SAD scales with block area (s*s)
+
+    vsapi->mapSetIntArray(props, vkey.c_str(), vout.data(), vcount);
+    if (scount)
+        vsapi->mapSetIntArray(props, skey.c_str(), sout.data(), scount);
+}
+
+const VSFrame *VS_CC scaleVectGetFrame(int n, int activationReason, void *instanceData,
+        void **frameData, VSFrameContext *frameCtx, VSCore *core, const VSAPI *vsapi) {
+    ScaleVectData *d = static_cast<ScaleVectData *>(instanceData);
+    if (activationReason == arInitial) {
+        vsapi->requestFrameFilter(n, d->node, frameCtx);
+    } else if (activationReason == arAllFramesReady) {
+        const VSFrame *src = vsapi->getFrameFilter(n, d->node, frameCtx);
+        VSFrame *dst = vsapi->copyFrame(src, core);
+        vsapi->freeFrame(src);
+        scaleProps(vsapi->getFramePropertiesRW(dst), d, vsapi);
+        return dst;
+    }
+    return nullptr;
+}
+
+void VS_CC scaleVectFree(void *instanceData, VSCore *core, const VSAPI *vsapi) {
+    ScaleVectData *d = static_cast<ScaleVectData *>(instanceData);
+    vsapi->freeNode(d->node);
+    delete d;
+}
+
+void VS_CC scaleVectCreate(const VSMap *in, VSMap *out, void *userData,
+        VSCore *core, const VSAPI *vsapi) {
+    ScaleVectData d{};
+    d.node = vsapi->mapGetNode(in, "clip", 0, nullptr);
+
+    int err = 0;
+    d.scale = vsapi->mapGetIntSaturated(in, "scale", 0, &err);
+    if (err)
+        d.scale = 2;
+
+    const char *pfx = vsapi->mapGetData(in, "prefix", 0, &err);
+    d.prefix = err ? "MVUtensils" : pfx;
+
+    if (d.scale < 1) {
+        vsapi->mapSetError(out, "ScaleVect: scale must be >= 1");
+        vsapi->freeNode(d.node);
+        return;
+    }
+
+    const VSVideoInfo *vi = vsapi->getVideoInfo(d.node);
+    ScaleVectData *data = new ScaleVectData(std::move(d));
+    VSFilterDependency deps[] = {{data->node, rpStrictSpatial}};
+    vsapi->createVideoFilter(out, "ScaleVect", vi, scaleVectGetFrame, scaleVectFree,
+                             fmParallel, deps, 1, data, core);
+}
+
+}  // namespace
+
+VS_EXTERNAL_API(void) VapourSynthPluginInit2(VSPlugin *plugin, const VSPLUGINAPI *vspapi) {
+    vspapi->configPlugin("com.smdegrainbis.mvuscale", "mvuscale",
+                         "Scale mvutensils vector clips (manipmv.ScaleVect replacement)",
+                         VS_MAKE_VERSION(1, 0), VAPOURSYNTH_API_VERSION, 0, plugin);
+    vspapi->registerFunction("ScaleVect",
+                             "clip:vnode;scale:int:opt;prefix:data:opt;",
+                             "clip:vnode;",
+                             scaleVectCreate, nullptr, plugin);
+}

vapoursynth_mvuscale-0.1.0/pyproject.toml

@@ -0,0 +1,54 @@
+# vapoursynth-mvuscale — the compiled UHDhalf vector scaler for smdegrain_bis,
+# distributed as a per-platform wheel whose payload is a bare VS plugin under
+# vapoursynth/plugins/mvuscale/ (identical layout to vapoursynth-manipmv et al.).
+# This is a SEPARATE distribution from the pure-Python `smdegrain-bis` package.
+#
+# Build one wheel:   pip wheel native/ -w dist/
+# Build the matrix:  cibuildwheel native/     (see [tool.cibuildwheel] below)
+
+[build-system]
+requires = ["scikit-build-core>=0.10"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "vapoursynth-mvuscale"
+version = "0.1.0"
+description = "Native VapourSynth (API4) filter that scales mvutensils motion vectors for smdegrain_bis UHDhalf"
+readme = "README.md"
+requires-python = ">=3.8"
+license = "GPL-3.0-or-later"
+authors = [{ name = "Florian Gamper" }]
+keywords = ["vapoursynth", "mvutensils", "motion-vectors", "denoise", "smdegrain"]
+classifiers = [
+    "Topic :: Multimedia :: Video",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: MacOS",
+    "Operating System :: Microsoft :: Windows",
+]
+
+[project.urls]
+Homepage = "https://github.com/FlorianGamper/vs-smdegrain-bis"
+
+[tool.scikit-build]
+minimum-version = "0.10"
+# The payload has no CPython extension (no libpython link), so one wheel serves
+# all Python 3.x on a platform. py-api = "py3" tags it none-ABI accordingly.
+wheel.py-api = "py3"
+build-dir = "build/{wheel_tag}"
+
+[tool.cibuildwheel]
+# The .so is Python-version-independent, so build with a single interpreter per
+# platform rather than the full cpXX matrix.
+build = "cp312-*"
+skip = "*_i686 *-musllinux_i686"
+build-frontend = "build"
+# The .so links only libstdc++/gcc/c/m — all present in the 2_28 image, so
+# auditwheel repair is effectively a no-op (no bundled sidecar libs).
+manylinux-x86_64-image = "manylinux_2_28"
+manylinux-aarch64-image = "manylinux_2_28"
+
+# Build BOTH macOS arches on one (arm64) runner — clang cross-compiles the x86_64
+# .dylib via CMAKE_OSX_ARCHITECTURES, so we don't depend on the scarce/deprecated
+# Intel `macos-13` runner. (No tests in the wheel build, so cross-arch is fine.)
+[tool.cibuildwheel.macos]
+archs = ["x86_64", "arm64"]