vapoursynth-mlrt-ort 15.16__tar.gz

vapoursynth_mlrt_ort-15.16/ApplyPatch.cmake

@@ -0,0 +1,22 @@
+function(add_patched_source OUT_VAR SRC_FILE)
+  find_package(Git REQUIRED)
+
+  cmake_path(RELATIVE_PATH SRC_FILE BASE_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/vs-mlrt" OUTPUT_VARIABLE REL_PATH)
+  set(BIN_FILE "${CMAKE_CURRENT_BINARY_DIR}/vs-mlrt/${REL_PATH}")
+  cmake_path(GET SRC_FILE FILENAME FILE_NAME)
+
+  list(GET ARGN 0 PATCH_FILE)
+  add_custom_command(
+    OUTPUT "${BIN_FILE}"
+    COMMAND ${CMAKE_COMMAND} -E copy "${SRC_FILE}" "${BIN_FILE}"
+    COMMAND
+      ${CMAKE_COMMAND} -E env "GIT_CEILING_DIRECTORIES=${CMAKE_CURRENT_BINARY_DIR}" ${GIT_EXECUTABLE} apply
+      "${PATCH_FILE}"
+    WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/vs-mlrt"
+    DEPENDS "${SRC_FILE}" "${PATCH_FILE}"
+    COMMENT "Copying and patching ${FILE_NAME}"
+    VERBATIM
+  )
+
+  set(${OUT_VAR} "${BIN_FILE}" PARENT_SCOPE)
+endfunction()

vapoursynth_mlrt_ort-15.16/CMakeLists.txt

@@ -0,0 +1,268 @@
+cmake_minimum_required(VERSION 3.22)
+project(VSORT_Package)
+
+# === Apply patches ===
+include("${CMAKE_CURRENT_SOURCE_DIR}/ApplyPatch.cmake")
+
+set(SRC_VSORT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/vs-mlrt")
+set(BIN_VSORT_DIR "${CMAKE_CURRENT_BINARY_DIR}/vs-mlrt")
+
+add_patched_source(
+  PATCHED_WIN32
+  "${SRC_VSORT_DIR}/vsort/win32.cpp"
+  "${CMAKE_CURRENT_SOURCE_DIR}/patches/more-cudnn-libs.patch"
+)
+
+# === C++ Standard & Options ===
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+# Options
+set(ENABLE_CUDA OFF CACHE BOOL "Enable CUDA backend")
+set(ENABLE_DML OFF CACHE BOOL "Enable DirectML backend")
+set(ENABLE_COREML OFF CACHE BOOL "Enable CoreML support")
+
+set(
+  VAPOURSYNTH_INCLUDE_DIRECTORY
+  "${CMAKE_CURRENT_SOURCE_DIR}/vapoursynth/include"
+  CACHE PATH
+  "Path to VapourSynth headers"
+)
+
+if(SKBUILD_PROJECT_VERSION)
+  set(VCS_TAG "v${SKBUILD_PROJECT_VERSION}" CACHE STRING "Version from scikit-build-core")
+  set(CMAKE_DISABLE_FIND_PACKAGE_Git ON)
+endif()
+
+# === Dependencies ===
+find_package(Protobuf REQUIRED CONFIG)
+find_package(ONNX REQUIRED)
+find_package(onnxruntime REQUIRED)
+
+if(ENABLE_CUDA)
+  find_package(CUDAToolkit REQUIRED)
+endif()
+
+# === Target Definition & Configuration ===
+add_library(
+  vsort
+  SHARED
+  vs-mlrt/vsort/vs_onnxruntime.cpp
+  vs-mlrt/vsort/win32.cpp
+  vs-mlrt/common/onnx_utils.cpp
+  vs-mlrt/common/convert_float_to_float16.cpp
+)
+
+set_target_properties(
+  vsort
+  PROPERTIES POSITION_INDEPENDENT_CODE ON CXX_EXTENSIONS OFF CXX_STANDARD 20 CXX_STANDARD_REQUIRED ON
+)
+
+if(UNIX)
+  if(APPLE)
+    set_target_properties(vsort PROPERTIES INSTALL_RPATH "@loader_path")
+  else()
+    set_target_properties(vsort PROPERTIES INSTALL_RPATH "$ORIGIN")
+  endif()
+endif()
+
+target_include_directories(
+  vsort
+  PRIVATE "${VAPOURSYNTH_INCLUDE_DIRECTORY}" "vs-mlrt/vsort" "vs-mlrt/common"
+  PUBLIC "${PROJECT_BINARY_DIR}"
+)
+
+if(ENABLE_CUDA)
+  target_compile_definitions(vsort PRIVATE ENABLE_CUDA)
+  target_include_directories(vsort PRIVATE ${CUDAToolkit_INCLUDE_DIRS})
+endif()
+
+if(ENABLE_DML)
+  target_compile_definitions(vsort PRIVATE ENABLE_DML)
+endif()
+
+if(ENABLE_COREML)
+  target_compile_definitions(vsort PRIVATE ENABLE_COREML=1)
+endif()
+
+configure_file(vs-mlrt/vsort/config.h.in config.h)
+
+# === Link Libraries Setup ===
+target_link_libraries(vsort PRIVATE ONNX::onnx onnxruntime::onnxruntime)
+
+if(MSVC)
+  target_link_options(vsort PRIVATE "/DELAYLOAD:onnxruntime.dll" "delayimp.lib")
+endif()
+
+if(ENABLE_CUDA)
+  target_link_libraries(vsort PRIVATE CUDA::cudart_static)
+endif()
+
+# === Packaging & Installation ===
+install(TARGETS vsort LIBRARY DESTINATION . RUNTIME DESTINATION .)
+
+# Helper runtime DLL/SO copying/installing logic
+if(WIN32)
+  # Copy ONNX Runtime
+  get_filename_component(_ROOT "${onnxruntime_DIR}/../../.." ABSOLUTE)
+  file(GLOB _DLLS "${_ROOT}/bin/*.dll")
+  # Copy CUDA providers DLL if CUDA is enabled
+  if(ENABLE_CUDA)
+    file(GLOB _LIB_DLLS "${_ROOT}/lib/*.dll")
+    list(APPEND _DLLS ${_LIB_DLLS})
+  endif()
+
+  if(_DLLS)
+    install(FILES ${_DLLS} DESTINATION "vsort")
+  else()
+    message(WARNING "Could not find ONNX Runtime DLLs")
+  endif()
+
+  if(ENABLE_DML)
+    if(NOT DML_DIR AND DEFINED ENV{DML_DIR})
+      set(DML_DIR "$ENV{DML_DIR}")
+    endif()
+
+    if(DML_DIR)
+      file(TO_CMAKE_PATH "${DML_DIR}" _DML_DIR)
+      find_file(_DML NAMES DirectML.dll PATHS "${_DML_DIR}/bin/x64-win" NO_DEFAULT_PATH)
+    endif()
+
+    if(_DML)
+      install(FILES "${_DML}" DESTINATION "vsort")
+    else()
+      message(WARNING "Could not find DirectML DLL. DML_DIR='${DML_DIR}'")
+    endif()
+  endif()
+
+  if(ENABLE_CUDA)
+    # Convert Windows paths to CMake paths (backslashes -> forward slashes) to avoid string parsing syntax errors
+    if(DEFINED ENV{CUDA_PATH})
+      file(TO_CMAKE_PATH "$ENV{CUDA_PATH}" _CUDA_PATH)
+    endif()
+    if(DEFINED ENV{CUDNN_PATH})
+      file(TO_CMAKE_PATH "$ENV{CUDNN_PATH}" _CUDNN_PATH)
+    endif()
+    if(DEFINED ENV{CUDNN_HOME})
+      file(TO_CMAKE_PATH "$ENV{CUDNN_HOME}" _CUDNN_HOME)
+    endif()
+
+    # Copy CUDA Toolkit DLLs
+    file(
+      GLOB _CUDA_DLLS
+      "${_CUDA_PATH}/bin/x64/cublas64_*.dll"
+      "${_CUDA_PATH}/bin/x64/cublasLt64_*.dll"
+      "${_CUDA_PATH}/bin/x64/cudart64_*.dll"
+      "${_CUDA_PATH}/bin/x64/cufft64_*.dll"
+      "${_CUDA_PATH}/bin/x64/cufftw64_*.dll"
+      "${_CUDA_PATH}/bin/x64/nvblas64_*.dll"
+      "${_CUDA_PATH}/extras/CUPTI/lib64/cupti64_*.dll"
+    )
+
+    # Copy cuDNN DLLs
+    file(
+      GLOB _CUDNN_DLLS
+      "${_CUDNN_PATH}/bin/*.dll"
+      "${_CUDNN_HOME}/bin/*.dll"
+      "${_CUDNN_PATH}/bin/x64/*.dll"
+      "${_CUDNN_HOME}/bin/x64/*.dll"
+    )
+
+    set(_ALL_CUDA_DLLS ${_CUDA_DLLS} ${_CUDNN_DLLS})
+    if(_ALL_CUDA_DLLS)
+      message(STATUS "Found CUDA and cuDNN DLLs to bundle: ${_ALL_CUDA_DLLS}")
+      install(FILES ${_ALL_CUDA_DLLS} DESTINATION "vsmlrt-cuda")
+    else()
+      message(
+        WARNING
+        "Could not find CUDA or cuDNN DLLs to bundle. CUDA_PATH='${_CUDA_PATH}', CUDNN_PATH='${_CUDNN_PATH}'"
+      )
+    endif()
+  endif()
+endif()
+
+if(UNIX AND NOT APPLE AND ENABLE_CUDA)
+  get_filename_component(_ROOT "${onnxruntime_DIR}/../../.." ABSOLUTE)
+  if(DEFINED ENV{CUDA_PATH})
+    file(TO_CMAKE_PATH "$ENV{CUDA_PATH}" _CUDA_PATH)
+  endif()
+  if(DEFINED ENV{CUDNN_PATH})
+    file(TO_CMAKE_PATH "$ENV{CUDNN_PATH}" _CUDNN_PATH)
+  endif()
+  if(DEFINED ENV{CUDNN_HOME})
+    file(TO_CMAKE_PATH "$ENV{CUDNN_HOME}" _CUDNN_HOME)
+  endif()
+
+  # Glob candidate libraries to bundle
+  file(
+    GLOB _LINUX_LIBS_PATHS
+    # cuDNN
+    "${_CUDNN_PATH}/lib/libcudnn*.so*"
+    "${_CUDNN_HOME}/lib/libcudnn*.so*"
+    "${_CUDNN_PATH}/lib64/libcudnn*.so*"
+    "${_CUDNN_HOME}/lib64/libcudnn*.so*"
+    # CUDA
+    "${_CUDA_PATH}/lib64/libcublas*.so*"
+    "${_CUDA_PATH}/lib64/libcudart*.so*"
+    "${_CUDA_PATH}/lib64/libcufft*.so*"
+    "${_CUDA_PATH}/lib64/libcurand*.so*"
+    "${_CUDA_PATH}/targets/*-linux/lib/libcublas*.so*"
+    "${_CUDA_PATH}/targets/*-linux/lib/libcudart*.so*"
+    "${_CUDA_PATH}/targets/*-linux/lib/libcufft*.so*"
+    "${_CUDA_PATH}/targets/*-linux/lib/libcurand*.so*"
+    "/usr/lib64/libcublas*.so*"
+    "/usr/lib64/libcudart*.so*"
+    "/usr/lib64/libcufft*.so*"
+    "/usr/lib64/libcurand*.so*"
+    # ONNX Runtime provider libraries
+    "${_ROOT}/lib/libonnxruntime*.so*"
+    "${_ROOT}/lib64/libonnxruntime*.so*"
+  )
+
+  if(_LINUX_LIBS_PATHS)
+    list(REMOVE_DUPLICATES _LINUX_LIBS_PATHS)
+    foreach(_LIB_PATH IN LISTS _LINUX_LIBS_PATHS)
+      get_filename_component(_LIB_NAME "${_LIB_PATH}" NAME)
+      get_filename_component(_REAL_PATH "${_LIB_PATH}" REALPATH)
+
+      # Check if the filename ends in ".so"
+      get_filename_component(_LIB_EXT "${_LIB_NAME}" EXT)
+      if("${_LIB_EXT}" STREQUAL ".so")
+        set(_ENDS_IN_SO ON)
+      else()
+        set(_ENDS_IN_SO OFF)
+      endif()
+
+      # Determine if we should bundle this library:
+      # - Symlinks (which represent the SONAME) that have a version suffix (e.g. libcublas.so.13)
+      # - Real files that are unversioned and end in .so (e.g. libonnxruntime_providers_cuda.so)
+      get_filename_component(_REAL_NAME "${_REAL_PATH}" NAME)
+      set(_SHOULD_BUNDLE OFF)
+      if(NOT "${_LIB_NAME}" STREQUAL "${_REAL_NAME}")
+        if(NOT _ENDS_IN_SO)
+          set(_SHOULD_BUNDLE ON)
+        endif()
+      else()
+        if(_ENDS_IN_SO)
+          set(_SHOULD_BUNDLE ON)
+        endif()
+      endif()
+
+      if(_SHOULD_BUNDLE)
+        message(STATUS "Bundling: ${_REAL_PATH} as ${_LIB_NAME}")
+        install(FILES "${_REAL_PATH}" RENAME "${_LIB_NAME}" DESTINATION .)
+      endif()
+    endforeach()
+  else()
+    message(WARNING "Could not find any Linux CUDA, cuDNN, or ORT libraries to bundle")
+  endif()
+endif()
+
+# Write VapourSynth Manifest
+if(WIN32)
+  file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/manifest.vs" "[VapourSynth Manifest V1]\nvsort\n")
+else()
+  file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/manifest.vs" "[VapourSynth Manifest V1]\nlibvsort\n")
+endif()
+install(FILES "${CMAKE_CURRENT_BINARY_DIR}/manifest.vs" DESTINATION .)

vapoursynth_mlrt_ort-15.16/PKG-INFO

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: vapoursynth-mlrt-ort
+Version: 15.16
+Summary: ONNX Runtime-based CPU/GPU inference plugin for VapourSynth
+Author: AmusementClub
+Maintainer-Email: =?utf-8?b?VmFyZMOr?= <ichunjo.le.terrible@gmail.com>
+License-Expression: GPL-3.0-or-later
+License-File: vs-mlrt/LICENSE
+Project-URL: Source Code, https://github.com/AmusementClub/vs-mlrt
+Project-URL: Bug Tracker, https://github.com/AmusementClub/vs-mlrt/issues
+Project-URL: Repository, https://github.com/Jaded-Encoding-Thaumaturgy/vs-wheels
+Requires-Python: >=3.12
+Requires-Dist: vapoursynth>=75
+Description-Content-Type: text/markdown
+
+# VapourSynth-MLRT-ORT
+
+This package contains the ONNX Runtime backend implementation of the [vs-mlrt](https://github.com/AmusementClub/vs-mlrt) plugin.
+
+## Installation
+
+To install the standard CPU/DirectML/CoreML package:
+
+```bash
+pip install vapoursynth-mlrt-ort
+```
+
+To install the CUDA-enabled package:
+
+```bash
+pip install vapoursynth-mlrt-ort-cuda --extra-index-url https://jaded-encoding-thaumaturgy.github.io/vs-wheels/simple
+```
+
+## Building from source
+
+### Requirements
+
+- **C++ Compiler**: C++20 compatible (e.g. MSVC 2019+, GCC, Clang)
+- **Dependencies**:
+  - `onnxruntime` (ONNX Runtime SDK)
+  - `ONNX`
+  - `Protobuf`
+- **Optional Backend Dependencies**:
+  - **DirectML** (Windows): Requires DirectML SDK. Define the `DML_DIR` environment/CMake variable to point to the SDK directory.
+  - **CUDA**: Requires `CUDAToolkit` and `cuDNN` SDKs. Ensure `CUDA_PATH`, `CUDNN_PATH` / `CUDNN_HOME` are set correctly.
+
+### Compilation
+
+By default, the package builds the CPU backend (with CoreML on macOS and optionally DirectML on Windows):
+
+```powershell
+uv build --package vapoursynth-mlrt-ort
+```
+
+To build the CUDA-enabled version, the package definition must first be updated using the helper script:
+
+```powershell
+# Update pyproject.toml package configuration to target CUDA
+uv run --script scripts/cuda_pyproject.py pyproject.toml
+
+# Compile the CUDA package
+uv build --package vapoursynth-mlrt-ort-cuda
+```
+
+---
+
+Detailed parameter information from the parent project follows.
+
+---
+# VapourSynth ONNX Runtime
+
+The vs-onnxruntime plugin provides optimized CPU & CUDA runtime for some popular AI filters.
+
+## Building and Installation
+
+To build, you will need [ONNX Runtime](https://www.onnxruntime.ai/), [protobuf](https://github.com/protocolbuffers/protobuf), [ONNX](https://github.com/onnx/onnx) and their dependencies.
+
+Please refer to [ONNX Runtime Docs](https://onnxruntime.ai/docs/install/) for installation notes.
+Or, you can use our prebuilt Windows binary releases from [AmusementClub](https://github.com/AmusementClub/onnxruntime/releases/latest/).
+
+Please refer to our [github actions workflow](../.github/workflows/windows-ort.yml) for sample building instructions.
+
+If you only use the CPU backend, then you just need to extract binary release into your `vapoursynth/plugins` directory.
+
+However, if you also use the CUDA backend, you will need to download some CUDA libraries as well, please see the release page for details. Those CUDA libraries also need to be extracted into VS `vapoursynth/plugins` directory. The plugin will try to load them from `vapoursynth/plugins/vsort/` directory or `vapoursynth/plugins/vsmlrt-cuda/` directory.
+
+## Usage
+
+Prototype: `core.ort.Model(clip[] clips, string network_path[, int[] overlap = None, int[] tilesize = None, string provider = "", int device_id = 0, int verbosity = 2, bint cudnn_benchmark = True, bint builtin = False, string builtindir="models", bint fp16 = False, bint path_is_serialization = False, bint use_cuda_graph = False])`
+
+Arguments:
+ - `clip[] clips`: the input clips, only 32-bit floating point RGB or GRAY clips are supported. For model specific input requirements, please consult our [wiki](https://github.com/AmusementClub/vs-mlrt/wiki).
+ - `string network_path`: the path to the network in ONNX format.
+ - `int[] overlap`: some networks (e.g. [CNN](https://en.wikipedia.org/wiki/Convolutional_neural_network)) support arbitrary input shape where other networks might only support fixed input shape and the input clip must be processed in tiles. The `overlap` argument specifies the overlapping (horizontal and vertical, or both, in pixels) between adjacent tiles to minimize boundary issues. Please refer to network specific docs on the recommended overlapping size.
+ - `int[] tilesize`: Even for CNN where arbitrary input sizes could be supported, sometimes the network does not work well for the entire range of input dimensions, and you have to limit the size of each tile. This parameter specify the tile size (horizontal and vertical, or both, including the overlapping). Please refer to network specific docs on the recommended tile size.
+ - `string provider`: Specifies the device to run the inference on.
+   - `"CPU"` or `""`: pure CPU backend
+   - `"CUDA"`: CUDA GPU backend, requires Nvidia Maxwell+ GPUs.
+   - `"DML"`: DirectML backend
+   - `"COREML"`: CoreML backend
+ - `int device_id`: select the GPU device for the CUDA backend.'
+ - `int verbosity`: specify the verbosity of logging, the default is warning.
+   - 0: fatal error only, `ORT_LOGGING_LEVEL_FATAL`
+   - 1: also errors, `ORT_LOGGING_LEVEL_ERROR`
+   - 2: also warnings, `ORT_LOGGING_LEVEL_WARNING`
+   - 3: also info, `ORT_LOGGING_LEVEL_INFO`
+   - 4: everything, `ORT_LOGGING_LEVEL_VERBOSE`
+ - `bint cudnn_benchmark`: whether to let cuDNN use benchmarking to search for the best convolution kernel to use. Default True. It might incur some startup latency.
+ - `bint builtin`: whether to load the model from the VS plugins directory, see also `builtindir`.
+ - `string builtindir`: the model directory under VS plugins directory for builtin models, default "models".
+ - `bint fp16`: whether to quantize model to fp16 for faster and memory efficient computation.
+ - `bint path_is_serialization`: whether the `network_path` argument specifies an onnx serialization of type `bytes`.
+ - `bint use_cuda_graph`: whether to use CUDA Graphs to improve performance and reduce CPU overhead in CUDA backend. Not all models are supported.
+ - `int ml_program`: select CoreML provider.
+   - 0: NeuralNetwork
+   - 1: MLProgram
+
+When `overlap` and `tilesize` are not specified, the filter will internally try to resize the network to fit the input clips. This might not always work (for example, the network might require the width to be divisible by 8), and the filter will error out in this case.
+
+The general rule is to either:
+1. left out `overlap`, `tilesize` at all and just process the input frame in one tile, or
+2. set all three so that the frame is processed in `tilesize[0]` x `tilesize[1]` tiles, and adjacent tiles will have an overlap of `overlap[0]` x `overlap[1]` pixels on each direction. The overlapped region will be throw out so that only internal output pixels are used.

vapoursynth_mlrt_ort-15.16/README.md

@@ -0,0 +1,54 @@
+# VapourSynth-MLRT-ORT
+
+This package contains the ONNX Runtime backend implementation of the [vs-mlrt](https://github.com/AmusementClub/vs-mlrt) plugin.
+
+## Installation
+
+To install the standard CPU/DirectML/CoreML package:
+
+```bash
+pip install vapoursynth-mlrt-ort
+```
+
+To install the CUDA-enabled package:
+
+```bash
+pip install vapoursynth-mlrt-ort-cuda --extra-index-url https://jaded-encoding-thaumaturgy.github.io/vs-wheels/simple
+```
+
+## Building from source
+
+### Requirements
+
+- **C++ Compiler**: C++20 compatible (e.g. MSVC 2019+, GCC, Clang)
+- **Dependencies**:
+  - `onnxruntime` (ONNX Runtime SDK)
+  - `ONNX`
+  - `Protobuf`
+- **Optional Backend Dependencies**:
+  - **DirectML** (Windows): Requires DirectML SDK. Define the `DML_DIR` environment/CMake variable to point to the SDK directory.
+  - **CUDA**: Requires `CUDAToolkit` and `cuDNN` SDKs. Ensure `CUDA_PATH`, `CUDNN_PATH` / `CUDNN_HOME` are set correctly.
+
+### Compilation
+
+By default, the package builds the CPU backend (with CoreML on macOS and optionally DirectML on Windows):
+
+```powershell
+uv build --package vapoursynth-mlrt-ort
+```
+
+To build the CUDA-enabled version, the package definition must first be updated using the helper script:
+
+```powershell
+# Update pyproject.toml package configuration to target CUDA
+uv run --script scripts/cuda_pyproject.py pyproject.toml
+
+# Compile the CUDA package
+uv build --package vapoursynth-mlrt-ort-cuda
+```
+
+---
+
+Detailed parameter information from the parent project follows.
+
+---

vapoursynth_mlrt_ort-15.16/patches/more-cudnn-libs.patch

@@ -0,0 +1,12 @@
+diff --git a/vsort/win32.cpp b/vsort/win32.cpp
+index 0c7026e..e827c9a 100644
+--- a/vsort/win32.cpp
++++ b/vsort/win32.cpp
+@@ -27,6 +27,7 @@ static std::vector<std::wstring> cudaDlls {
+     L"cudnn_graph64",
+     L"cudnn_engines_precompiled64", L"cudnn_heuristic64", L"cudnn_engines_runtime_compiled64",
+     L"cudnn_ops64", L"cudnn_cnn64", L"cudnn_adv64",
++    L"cudnn_engines_tensor_ir64", L"cudnn_ext64",
+     L"cudnn64",
+     L"cupti64",
+ };

vapoursynth_mlrt_ort-15.16/pyproject.toml

@@ -0,0 +1,77 @@
+[build-system]
+requires = [
+    "scikit-build-core>=0.12",
+    "setuptools-scm",
+    "ninja ; sys_platform != 'win32'",
+]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "vapoursynth-mlrt-ort"
+dynamic = ["version", "readme"]
+description = "ONNX Runtime-based CPU/GPU inference plugin for VapourSynth"
+license = "GPL-3.0-or-later"
+license-files = ["vs-mlrt/LICENSE"]
+requires-python = ">=3.12"
+authors = [{ name = "AmusementClub" }]
+maintainers = [{ name = "Vardë", email = "ichunjo.le.terrible@gmail.com" }]
+dependencies = ["vapoursynth>=75"]
+
+[project.urls]
+"Source Code" = "https://github.com/AmusementClub/vs-mlrt"
+"Bug Tracker" = "https://github.com/AmusementClub/vs-mlrt/issues"
+"Repository" = "https://github.com/Jaded-Encoding-Thaumaturgy/vs-wheels"
+
+[tool.setuptools_scm]
+root = "vs-mlrt"
+local_scheme = "no-local-version"
+tag_regex = '^v(?P<version>\d+.*)$'
+
+[tool.scikit-build]
+metadata.version.provider = "scikit_build_core.metadata.setuptools_scm"
+metadata.readme.provider = "scikit_build_core.metadata.fancy_pypi_readme"
+wheel.exclude = ["*.lib"]
+wheel.install-dir = "vapoursynth/plugins/ort"
+wheel.expand-macos-universal-tags = true
+wheel.py-api = "py3"
+cmake.source-dir = "."
+cmake.args = ["-G", "Ninja"]
+cmake.define.CMAKE_BUILD_TYPE = "Release"
+ninja.make-fallback = false
+ninja.version = ">=1.5"
+
+[[tool.scikit-build.overrides]]
+if.platform-system = "win32"
+inherit.cmake.define = "append"
+cmake.define.CMAKE_MSVC_RUNTIME_LIBRARY = "MultiThreaded"
+cmake.define.ENABLE_DML = "ON"
+
+[[tool.scikit-build.overrides]]
+if.platform-system = "linux"
+if.platform-machine = "x86_64"
+inherit.cmake.define = "append"
+cmake.define.CMAKE_CXX_FLAGS = "-Wall -ffast-math -march=x86-64-v3"
+
+[[tool.scikit-build.overrides]]
+if.platform-system = "linux"
+if.platform-machine = "aarch64"
+inherit.cmake.define = "append"
+cmake.define.CMAKE_CXX_FLAGS = "-Wall -ffast-math -march=armv8.2-a"
+
+[[tool.scikit-build.overrides]]
+if.platform-system = "darwin"
+if.platform-machine = "arm64"
+inherit.cmake.define = "append"
+cmake.define.CMAKE_CXX_FLAGS = "-Wall -ffast-math -mcpu=apple-m1"
+cmake.define.ENABLE_COREML = "ON"
+
+[[tool.scikit-build.overrides]]
+if.platform-system = "darwin"
+if.platform-machine = "x86_64"
+inherit.cmake.define = "append"
+cmake.define.CMAKE_CXX_FLAGS = "-Wall -ffast-math -march=x86-64-v3"
+cmake.define.ENABLE_COREML = "ON"
+
+[tool.hatch.metadata.hooks.fancy-pypi-readme]
+content-type = "text/markdown"
+fragments = [{ path = "README.md" }, { path = "vs-mlrt/vsort/README.md" }]

vapoursynth_mlrt_ort-15.16/scripts/cuda_pyproject.py

@@ -0,0 +1,29 @@
+# /// script
+# requires-python = ">=3.12"
+# dependencies = [
+#     "tomli-w>=1.2.0",
+# ]
+# ///
+
+import sys
+import tomllib
+from pathlib import Path
+
+import tomli_w
+
+
+def main(pyproject: Path) -> None:
+    data = tomllib.loads(pyproject.read_text(encoding="utf-8"))
+    data["project"]["name"] += "-cuda"
+    data["project"]["description"] += " with CUDA support"
+    data["tool"]["scikit-build"]["wheel"]["install-dir"] += "-cuda"
+
+    for override in data["tool"]["scikit-build"]["overrides"]:
+        if override["if"]["platform-system"] in ["win32", "linux"]:
+            override["cmake"]["define"]["ENABLE_CUDA"] = "ON"
+
+    pyproject.write_text(tomli_w.dumps(data), encoding="utf-8")
+
+
+if __name__ == "__main__":
+    main(Path(sys.argv[1]))

vapoursynth_mlrt_ort-15.16/vapoursynth/.codespellignore

@@ -0,0 +1,6 @@
+static bool funcToLut(int nin, int nout, void *vlut, VSFunction *func, const VSAPI *vsapi, std::string &errstr) {
+    for (int i = 0; i < nin; i++) {
+            std::string aLine = nstringToUtf8(argv[arg + 1]).c_str();
+            size_t equalsPos = aLine.find("=");
+                fprintf(stderr, "No value specified for argument: %s\n", aLine.c_str());
+            opts.scriptArgs[aLine.substr(0, equalsPos)] = aLine.substr(equalsPos + 1);

vapoursynth_mlrt_ort-15.16/vapoursynth/.github/workflows/codespell.yml

@@ -0,0 +1,15 @@
+name: codespell
+
+on: [push, pull_request]
+
+jobs:
+  codespell:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - uses: codespell-project/actions-codespell@master
+      with:
+        exclude_file: .codespellignore
+        skip: ./src/avfs/include,./src/avisynth/avisynth.h,./src/avisynth/interface.cpp,./src/core/ter-116n.h,./src/core/expr/jitasm.h

vapoursynth_mlrt_ort-15.16/vapoursynth/.github/workflows/linux.yml

@@ -0,0 +1,77 @@
+name: Linux
+
+on: [push, pull_request, workflow_dispatch]
+
+jobs:
+  build-gcc:
+    runs-on: ubuntu-latest
+
+    env:
+      CC: ${{ matrix.cc }}
+      CXX: ${{ matrix.cxx }}
+
+    strategy:
+      matrix:
+        include:
+          - cc: gcc-10
+            cxx: g++-10
+          - cc: gcc-11
+            cxx: g++-11
+      fail-fast: false
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Install GCC 11
+      if: ${{ matrix.cc == 'gcc-11' }}
+      run: |
+        sudo apt-get update
+        sudo apt-get install g++-11 -y
+
+    - name: Print compiler version
+      run: ${{ env.CC }} --version
+
+    - name: Install zimg
+      run: |
+        git clone https://github.com/sekrit-twc/zimg --branch v3.0 --depth 1
+        pushd zimg
+        ./autogen.sh
+        ./configure --prefix=/usr
+        make -j2
+        sudo make install -j2
+        popd
+        rm -rf zimg
+
+    - name: Setup Python
+      uses: actions/setup-python@v2
+      with:
+        # Version range or exact version of a Python version to use, using SemVer's version range syntax.
+        python-version: 3.9
+
+    - name: Install cython
+      run: |
+        python -m pip install --upgrade pip
+        pip install cython
+
+    - name: Set PKG_CONFIG_PATH
+      run: echo "PKG_CONFIG_PATH=$pythonLocation/lib/pkgconfig" >> $GITHUB_ENV
+
+    - name: configure
+      run: |
+        ./autogen.sh
+        ./configure --prefix=/usr
+
+    - name: make
+      run: make -j2
+
+    - name: make install
+      run: |
+        sudo make install -j2
+        python setup.py sdist -d sdist
+        mkdir empty
+        pushd empty
+        pip install vapoursynth --no-index --find-links ../sdist
+        popd
+
+    - name: Run test
+      run: python -m unittest discover -s test -p "*test.py"