vsfgs 0.5.0__tar.gz

vsfgs-0.5.0/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

vsfgs-0.5.0/.github/workflows/build-wheels.yml

@@ -0,0 +1,99 @@
+name: Build and Publish Wheels
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+  release:
+    types:
+      - published
+
+jobs:
+  build_wheels:
+    name: Build wheels on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            arch: x86_64
+          - os: ubuntu-24.04-arm
+            arch: aarch64
+          - os: windows-latest
+            arch: AMD64
+          - os: macos-latest
+            arch: "x86_64 arm64"
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Build wheels
+        uses: pypa/cibuildwheel@v4.1.0
+        env:
+          CIBW_ARCHS: ${{ matrix.arch }}
+          CIBW_BEFORE_ALL_LINUX: "if command -v apk; then apk add nasm; elif command -v dnf; then dnf install -y nasm; elif command -v yum; then yum install -y nasm; else apt-get update && apt-get install -y nasm; fi"
+          CIBW_BEFORE_ALL_WINDOWS: "choco install nasm"
+          CIBW_BEFORE_ALL_MACOS: "export HOMEBREW_NO_AUTO_UPDATE=1; export HOMEBREW_NO_REQUIRE_TAP_TRUST=1; brew install nasm"
+          CIBW_SKIP: "cp39-* cp310-* cp311-* cp312-* *t-*"
+          CIBW_TEST_COMMAND: "python -c \"import vsfgs\""
+          CIBW_TEST_SKIP: "*-*linux_{aarch64,ppc64le,s390x} *-win_arm64 *-macosx_arm64"
+
+      - name: Upload wheels as artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: cibw-wheels-${{ matrix.os }}-${{ matrix.arch }}
+          path: ./wheelhouse/*.whl
+
+  build_sdist:
+    name: Build source distribution
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Set up Python 3.13
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.13'
+
+      - name: Install nasm (needed by meson setup for dav1d)
+        run: sudo apt-get update && sudo apt-get install -y nasm
+
+      - name: Install build tool
+        run: python -m pip install build
+
+      - name: Build sdist
+        run: python -m build --sdist
+
+      - name: Upload sdist as artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: cibw-sdist
+          path: dist/*.tar.gz
+
+  publish_pypi:
+    name: Publish to PyPI
+    needs: [build_wheels, build_sdist]
+    if: github.event_name == 'release' && github.event.action == 'published'
+    runs-on: ubuntu-latest
+    
+    permissions:
+      id-token: write
+      contents: read
+
+    steps:
+      - name: Download artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: cibw-*
+          path: dist
+          merge-multiple: true
+
+      - name: Publish package to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist

vsfgs-0.5.0/.gitignore

@@ -0,0 +1,47 @@
+__pycache__/
+*.py[cod]
+*$py.class
+
+*.so
+*.pyd
+*.dll
+*.lib
+*.exp
+*.obj
+*.o
+*.a
+
+build/
+dist/
+.mesonpy-*/
+*.egg-info/
+.eggs/
+*.egg
+
+.venv/
+venv/
+ENV/
+env/
+
+.vscode/
+.idea/
+*.swp
+*.swo
+.vs/
+
+.DS_Store
+
+test.vpy
+dynamic_fgs_test.txt
+bench_tmp.vpy
+bench_results.json
+bench_runner.py
+
+subprojects/*/build*/
+.ninja_*
+build.bat
+/.vsjet
+/typings
+test.vpy
+test.vpy
+heavy_fgs.txt

vsfgs-0.5.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 vs-fgs contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vsfgs-0.5.0/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.1
+Name: vsfgs
+Version: 0.5.0
+Summary: A VapourSynth plugin for applying Film Grain Synthesis (FGS) using the dav1d engine.
+Keywords: vapoursynth,film-grain,fgs,dav1d,video-processing,afgs1,av1,simd
+Author: PingWer74
+License: MIT
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Multimedia :: Video :: Non-Linear Editor
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Assembly
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Plugins
+Project-URL: Repository, https://github.com/PingWer/vs-fgs
+Project-URL: Issues, https://github.com/PingWer/vs-fgs/issues
+Requires-Python: >=3.13
+Requires-Dist: vapoursynth>=74
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Description-Content-Type: text/markdown
+
+# vs-fgs
+
+A VapourSynth plugin for applying Film Grain Synthesis (FGS) using the [dav1d](https://code.videolan.org/videolan/dav1d) engine.
+
+Since `dav1d` is widely regarded as the best and fastest AV1 decoder available, its FGS engine is fully spec-compliant with **AFGS1** (AOMedia Film Grain Synthesis 1), guaranteeing highly accurate, performant, and standardized grain generation.
+
+`vsfgs` parses standard FGS text files and applies film grain to the input clip natively in **8-bit, 10-bit, or 12-bit YUV**. It also handles automatic dithering if the input bit depth is higher.
+
+## Installation
+```bash
+pip install vsfgs
+```
+
+## Usage
+
+```python
+import vapoursynth as vs
+import vsfgs
+
+core = vs.core
+
+# 1. Load your video
+clip = core.lsmas.LWLibavSource("source.mkv")
+
+# 2. Apply Film Grain
+# - ignore_chroma: If True, grain is only applied to Luma (Chroma is copied).
+# - static: If True, uses the seed from the FGS table for all frames (if dynamic FGS, per event). If False, rotates the seed for each frame.
+# - simd: Hardware SIMD architecture ('auto', 'avx512', 'avx2', 'sse41', 'sse3', 'sse2', or 'none'/'c' for plain C). Defaults to 'auto'.
+clip = vsfgs.apply_fgs(clip, "grain_table.txt", ignore_chroma=False, static=False, simd="auto")
+
+clip.set_output()
+```
+
+### Frame Properties
+
+For each processed frame, `vsfgs` outputs the exact seed integer used during synthesis into the VapourSynth frame properties map: **`FGS_Seed`**
+
+
+## Advanced Customization
+
+`vsfgs` allows for extreme and advanced customization of the film grain pattern. The logic for synthesizing grain relies on a detailed parameter table.
+For an advanced visual editor to fine-tune these parameters and for more details on the grain configuration, please refer to the **FGSEditor** wiki:
+[https://github.com/PingWer/FGSEditor](https://github.com/PingWer/FGSEditor)
+
+## Performance & Compatibility
+
+`vsfgs` uses `dav1d`'s hand-written Assembly instructions (AVX-512, AVX2, SSE3 ...), resulting in extremely high throughput with almost zero overhead.
+
+**Platform Support:**
+
+| OS | Architecture | Supported | Tested |
+| :--- | :--- | :---: | :---: |
+| **Windows** | x86_64, ARM64 | ✅ | ✅ |
+| **Linux** | x86_64, aarch64 | ✅ | ❌ |
+| **macOS** | x86_64, Apple Silicon | ✅ | ❌ |
+
+**Benchmark Comparison** *(2,000 frames of real 1080p source via `BestSource`)*:
+Tests measure clean frame throughput and processor scaling across native chroma sub-samplings, comparing `vsfgs` against `Grainer.GAUSS` (from `vsdeband`). It also demonstrates the speedup of `dav1d`'s hardware SIMD Assembly optimizations over unvectorized reference C code (`simd='none'`).
+
+| Format | Baseline (BestSource + 16b) | `vsfgs` (SIMD: Auto / AVX-512) | `vsfgs` (SIMD: None / Plain C) | `Grainer.GAUSS` (`vsdeband`) |
+| --- | --- | --- | --- | --- |
+| **YUV420P16** | ~1128 FPS | **~557 FPS** | ~514 FPS | ~347 FPS |
+| **YUV422P16** | ~866 FPS | **~434 FPS** | ~425 FPS | ~322 FPS |
+| **YUV444P16** | ~649 FPS | **~305 FPS** | ~299 FPS | ~279 FPS |
+
+## Building from Source
+
+To compile the plugin manually, you must have a working C++ toolchain and Meson setup. The plugin depends on `dav1d`, which will be built automatically as a Meson subproject.
+
+### Prerequisites
+
+- **Python 3.13+** (or newer)
+- **C++ Compiler**: GCC/Clang (Linux/macOS) or MSVC (Windows)
+- **Meson & Ninja**: Build system (`pip install meson ninja`)
+- **nasm**: Highly recommended for x86/x64 systems to enable `dav1d` assembly optimizations (drastically improves grain synthesis performance).
+  - *Windows*: `choco install nasm`
+  - *Linux*: `sudo apt-get install nasm` or `sudo dnf install nasm`
+  - *macOS*: `brew install nasm`
+
+### Build Steps
+
+1. Clone the repository recursively to fetch the `dav1d` submodule:
+   ```bash
+   git clone --recursive https://github.com/PingWer/vs-fgs.git
+   cd vs-fgs
+   ```
+
+2. Build and install the plugin directly into your active Python environment:
+   ```bash
+   pip install .
+   ```
+
+### Standalone Build (Without Python Installation)
+
+If you only want to compile the VapourSynth plugin binary (DLL/SO/DYLIB) without installing it via pip, you can use Meson directly:
+
+```bash
+meson setup build --buildtype=release
+meson compile -C build
+```
+## License
+
+This project is licensed under the **MIT License**.

vsfgs-0.5.0/README.md

@@ -0,0 +1,103 @@
+# vs-fgs
+
+A VapourSynth plugin for applying Film Grain Synthesis (FGS) using the [dav1d](https://code.videolan.org/videolan/dav1d) engine.
+
+Since `dav1d` is widely regarded as the best and fastest AV1 decoder available, its FGS engine is fully spec-compliant with **AFGS1** (AOMedia Film Grain Synthesis 1), guaranteeing highly accurate, performant, and standardized grain generation.
+
+`vsfgs` parses standard FGS text files and applies film grain to the input clip natively in **8-bit, 10-bit, or 12-bit YUV**. It also handles automatic dithering if the input bit depth is higher.
+
+## Installation
+```bash
+pip install vsfgs
+```
+
+## Usage
+
+```python
+import vapoursynth as vs
+import vsfgs
+
+core = vs.core
+
+# 1. Load your video
+clip = core.lsmas.LWLibavSource("source.mkv")
+
+# 2. Apply Film Grain
+# - ignore_chroma: If True, grain is only applied to Luma (Chroma is copied).
+# - static: If True, uses the seed from the FGS table for all frames (if dynamic FGS, per event). If False, rotates the seed for each frame.
+# - simd: Hardware SIMD architecture ('auto', 'avx512', 'avx2', 'sse41', 'sse3', 'sse2', or 'none'/'c' for plain C). Defaults to 'auto'.
+clip = vsfgs.apply_fgs(clip, "grain_table.txt", ignore_chroma=False, static=False, simd="auto")
+
+clip.set_output()
+```
+
+### Frame Properties
+
+For each processed frame, `vsfgs` outputs the exact seed integer used during synthesis into the VapourSynth frame properties map: **`FGS_Seed`**
+
+
+## Advanced Customization
+
+`vsfgs` allows for extreme and advanced customization of the film grain pattern. The logic for synthesizing grain relies on a detailed parameter table.
+For an advanced visual editor to fine-tune these parameters and for more details on the grain configuration, please refer to the **FGSEditor** wiki:
+[https://github.com/PingWer/FGSEditor](https://github.com/PingWer/FGSEditor)
+
+## Performance & Compatibility
+
+`vsfgs` uses `dav1d`'s hand-written Assembly instructions (AVX-512, AVX2, SSE3 ...), resulting in extremely high throughput with almost zero overhead.
+
+**Platform Support:**
+
+| OS | Architecture | Supported | Tested |
+| :--- | :--- | :---: | :---: |
+| **Windows** | x86_64, ARM64 | ✅ | ✅ |
+| **Linux** | x86_64, aarch64 | ✅ | ❌ |
+| **macOS** | x86_64, Apple Silicon | ✅ | ❌ |
+
+**Benchmark Comparison** *(2,000 frames of real 1080p source via `BestSource`)*:
+Tests measure clean frame throughput and processor scaling across native chroma sub-samplings, comparing `vsfgs` against `Grainer.GAUSS` (from `vsdeband`). It also demonstrates the speedup of `dav1d`'s hardware SIMD Assembly optimizations over unvectorized reference C code (`simd='none'`).
+
+| Format | Baseline (BestSource + 16b) | `vsfgs` (SIMD: Auto / AVX-512) | `vsfgs` (SIMD: None / Plain C) | `Grainer.GAUSS` (`vsdeband`) |
+| --- | --- | --- | --- | --- |
+| **YUV420P16** | ~1128 FPS | **~557 FPS** | ~514 FPS | ~347 FPS |
+| **YUV422P16** | ~866 FPS | **~434 FPS** | ~425 FPS | ~322 FPS |
+| **YUV444P16** | ~649 FPS | **~305 FPS** | ~299 FPS | ~279 FPS |
+
+## Building from Source
+
+To compile the plugin manually, you must have a working C++ toolchain and Meson setup. The plugin depends on `dav1d`, which will be built automatically as a Meson subproject.
+
+### Prerequisites
+
+- **Python 3.13+** (or newer)
+- **C++ Compiler**: GCC/Clang (Linux/macOS) or MSVC (Windows)
+- **Meson & Ninja**: Build system (`pip install meson ninja`)
+- **nasm**: Highly recommended for x86/x64 systems to enable `dav1d` assembly optimizations (drastically improves grain synthesis performance).
+  - *Windows*: `choco install nasm`
+  - *Linux*: `sudo apt-get install nasm` or `sudo dnf install nasm`
+  - *macOS*: `brew install nasm`
+
+### Build Steps
+
+1. Clone the repository recursively to fetch the `dav1d` submodule:
+   ```bash
+   git clone --recursive https://github.com/PingWer/vs-fgs.git
+   cd vs-fgs
+   ```
+
+2. Build and install the plugin directly into your active Python environment:
+   ```bash
+   pip install .
+   ```
+
+### Standalone Build (Without Python Installation)
+
+If you only want to compile the VapourSynth plugin binary (DLL/SO/DYLIB) without installing it via pip, you can use Meson directly:
+
+```bash
+meson setup build --buildtype=release
+meson compile -C build
+```
+## License
+
+This project is licensed under the **MIT License**.

vsfgs-0.5.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