vapoursynth-dotkill 3.0__tar.gz

vapoursynth_dotkill-3.0/.github/workflows/build.yml

@@ -0,0 +1,99 @@
+name: Build
+
+on: [push, pull_request, workflow_dispatch]
+
+jobs:
+  build-non-windows-wheel:
+    strategy:
+      matrix:
+        include:
+        - arch: linux_x86_64
+          runs-on: ubuntu-latest
+        - arch: linux_aarch64
+          runs-on: ubuntu-24.04-arm
+        - arch: macosx_x86_64
+          runs-on: macos-26-intel
+        - arch: macosx_arm64
+          runs-on: macos-26
+      fail-fast: false
+
+    runs-on: ${{ matrix.runs-on }}
+
+    steps:
+    - uses: actions/checkout@v6
+
+    - uses: pypa/cibuildwheel@v3.4.0
+      env:
+        CIBW_BUILD: cp314-*
+        CIBW_BUILD_FRONTEND: uv
+      with:
+        output-dir: dist
+        extras: uv
+
+    - name: Fix tag
+      run: |
+        cd dist
+        for whl in *.whl; do
+          pipx run wheel tags --remove --python-tag py3 --abi-tag none $whl
+        done
+
+    - uses: actions/upload-artifact@v7
+      with:
+        name: descratch-${{ matrix.arch }}
+        path: dist
+
+  build-windows-wheel:
+    runs-on: windows-latest
+
+    defaults:
+      run:
+        shell: msys2 {0}
+
+    steps:
+    - uses: actions/checkout@v6
+
+    - uses: msys2/setup-msys2@v2
+      with:
+        msystem: UCRT64
+        update: true
+        install: >-
+          mingw-w64-ucrt-x86_64-git
+          mingw-w64-ucrt-x86_64-ninja
+          mingw-w64-ucrt-x86_64-toolchain
+          mingw-w64-ucrt-x86_64-uv
+
+    - name: Build
+      run: |
+        uv build -Csetup-args="-Dcpp_link_args=-static"
+
+    - name: Fix tag
+      run: |
+        cd dist
+        for whl in *.whl; do
+          uvx wheel tags --remove --python-tag py3 --abi-tag none $whl
+        done
+
+    - uses: actions/upload-artifact@v7
+      with:
+        name: descratch-sdist
+        path: dist/*.tar.gz
+
+    - uses: actions/upload-artifact@v7
+      with:
+        name: descratch-win_amd64
+        path: dist/*.whl
+
+  publish:
+    permissions:
+      id-token: write
+    needs: [build-non-windows-wheel, build-windows-wheel]
+    if: ${{ startsWith(github.ref, 'refs/tags/') }}
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/download-artifact@v8
+      with:
+        path: dist
+        merge-multiple: true
+
+    - uses: pypa/gh-action-pypi-publish@release/v1

vapoursynth_dotkill-3.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Fredrik Mellbin
+
+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.

vapoursynth_dotkill-3.0/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: vapoursynth-dotkill
+Version: 3.0
+Summary: Rainbow and dotcrawl removal filter for VapourSynth
+Keywords: video,rainbows,dotcrawl
+Author-Email: Fredrik Mellbin <fredrik.mellbin@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Plugins
+Classifier: Natural Language :: English
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: C++
+Classifier: Topic :: Multimedia :: Video
+Project-URL: Repository, https://github.com/myrsloik/DotKill.git
+Project-URL: Issues, https://github.com/myrsloik/DotKill/issues
+Requires-Python: >=3.12
+Requires-Dist: VapourSynth
+Description-Content-Type: text/markdown
+
+DotKill
+=======
+
+Spatio-temporal dotcrawl and rainbow remover for VapourSynth
+
+Functions
+=========
+
+DotKillS
+--------
+
+dotkill.DotKillS(clip clip[, int iterations=1])
+
+A purely spatial dotcrawl remover that can be safely used on most material after field matching.
+
+iterations: The number of times to apply the internal filter. Usally a number between 1 and 4 will have the best results and using too high values may cause artifacting.
+
+usematch: If true then matching hints from VFM are used when processing. This may or may not have a positive effect.
+
+DotKillZ
+--------
+
+dotkill.DotKillZ(clip clip[, int order=0, int offset=0])
+
+A pseudo-spatial dotcrawl and rainbow remover. It only works on NTSC content with rainbows added after 3:2 pulldown. This is true most of the time for anime.
+
+Note that due to its nature only every other final frame will have dotcrawl and rainbows removed. Typically never artifacts if all requirements are met.
+
+order: Field order. Usually 0, note that 1 hasn't been tested due to a lack of test material.
+
+offset: The cycle offset for the pulldown pattern. A number between 0 and 4. Can only be determined by trial and error.
+
+DotKillT
+--------
+
+dotkill.DotKillT(clip clip[, int order=0, int offset=0, int dupthresh=64, int tratio=3, bint show=False])
+
+A full spatioi-temporal dotcrawl and rainbow remover. It only works on NTSC content with rainbows added after 3:2 pulldown. This is true most of the time for anime.
+
+May produce extreme artifacting if dupthresh is set too high.
+
+order: Field order. Usually 0, note that 1 hasn't been tested due to a lack of test material.
+
+offset: The cycle offset for the pulldown pattern. A number between 0 and 4. Can only be determined by trial and error.
+
+dupthresh: The threshold for determining if a block has changed between fields. Depending on the source material 32-128 are usually reasonable values. A value of 0 makes the function identical to DotKillZ.
+
+tratio: If more than 1/tratio blocks have changed between fields then temporal filtering won't be considered in that direction. Higher values can make high motion sections less likely to artifact.
+
+show: Shows which blocks have been determined to contain no change between fields and therefore will be blended to reduce artifacts. White square means that it will blend with the next frame and black square the previous. 
+
+Usage
+=====
+
+clip = core.dotkill.DotKillT(clip, offset=1, dupthresh=64)
+
+clip = core.vivtc.VFM(clip)
+
+clip = core.dotkill.DotKillS(clip, iterations=4)
+
+clip = core.vivtc.VDecimate(clip)
+

vapoursynth_dotkill-3.0/README.md

@@ -0,0 +1,62 @@
+DotKill
+=======
+
+Spatio-temporal dotcrawl and rainbow remover for VapourSynth
+
+Functions
+=========
+
+DotKillS
+--------
+
+dotkill.DotKillS(clip clip[, int iterations=1])
+
+A purely spatial dotcrawl remover that can be safely used on most material after field matching.
+
+iterations: The number of times to apply the internal filter. Usally a number between 1 and 4 will have the best results and using too high values may cause artifacting.
+
+usematch: If true then matching hints from VFM are used when processing. This may or may not have a positive effect.
+
+DotKillZ
+--------
+
+dotkill.DotKillZ(clip clip[, int order=0, int offset=0])
+
+A pseudo-spatial dotcrawl and rainbow remover. It only works on NTSC content with rainbows added after 3:2 pulldown. This is true most of the time for anime.
+
+Note that due to its nature only every other final frame will have dotcrawl and rainbows removed. Typically never artifacts if all requirements are met.
+
+order: Field order. Usually 0, note that 1 hasn't been tested due to a lack of test material.
+
+offset: The cycle offset for the pulldown pattern. A number between 0 and 4. Can only be determined by trial and error.
+
+DotKillT
+--------
+
+dotkill.DotKillT(clip clip[, int order=0, int offset=0, int dupthresh=64, int tratio=3, bint show=False])
+
+A full spatioi-temporal dotcrawl and rainbow remover. It only works on NTSC content with rainbows added after 3:2 pulldown. This is true most of the time for anime.
+
+May produce extreme artifacting if dupthresh is set too high.
+
+order: Field order. Usually 0, note that 1 hasn't been tested due to a lack of test material.
+
+offset: The cycle offset for the pulldown pattern. A number between 0 and 4. Can only be determined by trial and error.
+
+dupthresh: The threshold for determining if a block has changed between fields. Depending on the source material 32-128 are usually reasonable values. A value of 0 makes the function identical to DotKillZ.
+
+tratio: If more than 1/tratio blocks have changed between fields then temporal filtering won't be considered in that direction. Higher values can make high motion sections less likely to artifact.
+
+show: Shows which blocks have been determined to contain no change between fields and therefore will be blended to reduce artifacts. White square means that it will blend with the next frame and black square the previous. 
+
+Usage
+=====
+
+clip = core.dotkill.DotKillT(clip, offset=1, dupthresh=64)
+
+clip = core.vivtc.VFM(clip)
+
+clip = core.dotkill.DotKillS(clip, iterations=4)
+
+clip = core.vivtc.VDecimate(clip)
+

vapoursynth_dotkill-3.0/meson.build

@@ -0,0 +1,27 @@
+project('DotKill', 'cpp',
+    default_options: ['buildtype=release', 'warning_level=2', 'b_lto=true', 'b_ndebug=if-release', 'cpp_std=c++17'],
+    license: 'MIT',
+    license_files: 'LICENSE',
+    meson_version: '>=1.2.3',
+    version: '3.0',
+)
+
+incdir = include_directories(
+    run_command(
+        find_program('python', 'python3'),
+        '-c',
+        'import vapoursynth as vs; print(vs.get_include())',
+        check: true,
+    ).stdout().strip(),
+)
+
+py = import('python').find_installation(pure: false)
+
+shared_module('dotkill',
+    files('src/dotkill1.cpp'),
+    gnu_symbol_visibility: 'hidden',
+    include_directories: incdir,
+    install: true,
+    install_dir: py.get_install_dir() / 'vapoursynth/plugins',
+    name_prefix: '',
+)

vapoursynth_dotkill-3.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["meson-python", "VapourSynth>=74"]
+build-backend = "mesonpy"
+
+[project]
+name = "vapoursynth-dotkill"
+description = "Rainbow and dotcrawl removal filter for VapourSynth"
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    {name = "Fredrik Mellbin", email = "fredrik.mellbin@gmail.com"},    
+]
+keywords = ["video", "rainbows", "dotcrawl"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: Plugins",
+    "Natural Language :: English",
+    "Operating System :: MacOS",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX",
+    "Operating System :: Unix",
+    "Programming Language :: C++",
+    "Topic :: Multimedia :: Video",
+]
+dependencies = ["VapourSynth"]
+dynamic = ["version"]
+
+[project.urls]
+Repository = "https://github.com/myrsloik/DotKill.git"
+Issues = "https://github.com/myrsloik/DotKill/issues"
+
+[tool.meson-python.wheel]
+exclude = ["*/*.dll.a", "*/*.lib"]

vapoursynth_dotkill-3.0/src/dotkill1.cpp

@@ -0,0 +1,706 @@
+#include "VapourSynth4.h"
+#include "VSHelper4.h"
+#include <algorithm>
+#include <memory>
+#include <cstdlib>
+#include <vector>
+
+////////////////////////////////////////
+// DotKillS
+
+typedef struct {
+    VSNode *node;
+    const VSVideoInfo *vi;
+    int iterations;
+} DotKillSData;
+
+static void convHoriz(const uint8_t *src, ptrdiff_t srcStride, int16_t *dst, int width, int height) {
+    while (--height) {
+        dst[0] = 0;
+        dst[1] = 0;
+
+        for (int x = 2; x < width - 3; x++) {
+            int16_t temp = -(src[x - 2] + src[x - 1]) + 2 * (src[x] + src[x + 1]) - (src[x + 2] + src[x + 3]);
+            temp += -(src[x - 2 + srcStride] + src[x - 1 + srcStride]) + 2 * (src[x + srcStride] + src[x + 1 + srcStride]) - (src[x + 2 + srcStride] + src[x + 3 + srcStride]);
+            dst[x] = temp;
+        }
+
+        dst[width - 3] = 0;
+        dst[width - 2] = 0;
+        dst[width - 1] = 0;
+
+        src += srcStride;
+        dst += width;
+    }
+    memset(dst, 0, sizeof(int16_t) * width);
+}
+
+static void convVert(const uint8_t *src, ptrdiff_t srcStride, int16_t *dst, int width, int height) {
+    height -= 5;
+
+    memset(dst, 0, sizeof(int16_t) * width * 2);
+    src += 2 * srcStride;
+    dst += 2 * width;
+
+    while (height--) {
+        for (int x = 0; x < width - 1; x++) {
+            dst[x] = -(src[x - 2 * srcStride] + src[x - 2 * srcStride + 1] + (src[x - 1 * srcStride] + src[x - 1 * srcStride + 1]))
+                + 2 * (src[x] + src[x + 1] + (src[x + 1 * srcStride] + src[x + 1 * srcStride + 1]))
+                - (src[x + 2 * srcStride] + src[x + 2 * srcStride + 1] + (src[x + 3 * srcStride] + src[x + 3 * srcStride + 1]));
+        }
+
+        dst[width - 1] = 0;
+
+        src += srcStride;
+        dst += width;
+    }
+
+    memset(dst, 0, sizeof(int16_t) * width * 3);
+}
+
+static void applyMask(const int16_t *maskPtr, uint8_t *dst, ptrdiff_t dstStride, int width, int height, uint8_t *ppMask) {
+    maskPtr += width;
+    ppMask += width;
+    dst += dstStride;
+
+    int16_t sortArray[8];
+
+    for (int y = 1; y < height - 1; y++) {
+        for (int x = 1; x < width - 2; x++) {
+            sortArray[0] = maskPtr[x - width - 1];
+            sortArray[1] = maskPtr[x - width];
+            sortArray[2] = maskPtr[x - width + 1];
+            sortArray[3] = maskPtr[x - 1];
+            sortArray[4] = maskPtr[x + 1];
+            sortArray[5] = maskPtr[x + width - 1];
+            sortArray[6] = maskPtr[x + width];
+            sortArray[7] = maskPtr[x + width + 1];
+
+            std::sort(sortArray, sortArray + 8);
+
+            int16_t upper = sortArray[7];
+            int16_t lower = sortArray[0];
+
+            int16_t t = maskPtr[x] - std::clamp(maskPtr[x], lower, upper);
+            
+            if (t >= 0)
+                t = (t + 4) / 8;
+            else
+                t = (t - 4) / 8;
+
+            if (std::abs(t) > 1) {
+                ppMask[x] = 255;
+
+                dst[x] = static_cast<uint8_t>(std::clamp(dst[x] - t, 16, 235));
+                dst[x + 1] = static_cast<uint8_t>(std::clamp(dst[x + 1] - t, 16, 235));
+                dst[x + dstStride] = static_cast<uint8_t>(std::clamp(dst[x + dstStride] - t, 16, 235));
+                dst[x + 1 + dstStride] = static_cast<uint8_t>(std::clamp(dst[x + 1 + dstStride] - t, 16, 235));
+            }
+        }
+
+        maskPtr += width;
+        ppMask += width;
+        dst += dstStride;
+    }
+}
+
+static const VSFrame *VS_CC dotKillSGetFrame(int n, int activationReason, void *instanceData, void **frameData, VSFrameContext *frameCtx, VSCore *core, const VSAPI *vsapi) {
+    DotKillSData *d = reinterpret_cast<DotKillSData*>(instanceData);
+
+    if (activationReason == arInitial) {
+        vsapi->requestFrameFilter(n, d->node, frameCtx);
+    } else if (activationReason == arAllFramesReady) {
+        const VSFrame *inframe = vsapi->getFrameFilter(n, d->node, frameCtx);
+        VSFrame *outframe = vsapi->copyFrame(inframe, core);
+
+        int width = d->vi->width;
+        int height = d->vi->height;
+        ptrdiff_t dstStride = vsapi->getStride(outframe, 0);
+        uint8_t *dstPtr = vsapi->getWritePtr(outframe, 0);
+
+        int16_t *tempMask = new int16_t[width * height];
+        uint8_t *ppMask = new uint8_t[width * height]();
+
+        for (int i = 0; i < d->iterations; i++) {
+            convVert(dstPtr, dstStride, tempMask, width, height);
+            applyMask(tempMask, dstPtr, dstStride, width, height, ppMask);
+
+            convHoriz(dstPtr, dstStride, tempMask, width, height);
+            applyMask(tempMask, dstPtr, dstStride, width, height, ppMask);
+
+        }
+
+        delete[] tempMask;
+        delete[] ppMask;
+
+        return outframe;
+    }
+
+    return nullptr;
+}
+
+static void VS_CC dotKillSFree(void *instanceData, VSCore *core, const VSAPI *vsapi) {
+    DotKillSData *d = reinterpret_cast<DotKillSData*>(instanceData);
+    vsapi->freeNode(d->node);
+    delete d;
+}
+
+static void VS_CC dotKillSCreate(const VSMap *in, VSMap *out, void *userData, VSCore *core, const VSAPI *vsapi) {
+    std::unique_ptr<DotKillSData> d(new DotKillSData());
+
+    int err;
+    d->node = vsapi->mapGetNode(in, "clip", 0, nullptr);
+    d->vi = vsapi->getVideoInfo(d->node);
+    d->iterations = vsapi->mapGetIntSaturated(in, "iterations", 0, &err);
+    if (d->iterations < 1)
+        d->iterations = 1;
+    if ((!vsh::isSameVideoPresetFormat(pfYUV420P8, &d->vi->format, core, vsapi) && !vsh::isSameVideoPresetFormat(pfGray8, &d->vi->format, core, vsapi)) || !vsh::isConstantVideoFormat(d->vi)) {
+        vsapi->mapSetError(out, "DotKillS: only constant dimension YUV420P8 and GRAY8 supported");
+        vsapi->freeNode(d->node);
+        return;
+    }
+
+    VSFilterDependency deps[] = { {d->node, rpStrictSpatial} };
+    vsapi->createVideoFilter(out, "DotKillS", d->vi, dotKillSGetFrame, dotKillSFree, fmParallel, deps, 1, d.get(), core);
+    d.release();
+}
+
+/////////////////////////////////////////////////////////////////////
+// DotKillZ
+
+
+static void applyFieldBlend(const VSFrame *srcc, const VSFrame *srcn, VSFrame *outframe, int order, VSCore *core, const VSAPI *vsapi) {
+    const VSVideoFormat *fi = vsapi->getVideoFrameFormat(srcc);
+    for (int plane = 0; plane < fi->numPlanes; plane++) {
+        int width = vsapi->getFrameWidth(srcc, plane);
+        int height = vsapi->getFrameHeight(srcc, plane);
+
+        ptrdiff_t stride = vsapi->getStride(outframe, plane);
+        uint8_t *dstp = vsapi->getWritePtr(outframe, plane);
+        const uint8_t *srccp = vsapi->getReadPtr(srcc, plane);
+        const uint8_t *srcnp = vsapi->getReadPtr(srcn, plane);
+
+        if (order) {
+            srccp += stride;
+            srcnp += stride;
+            dstp += stride;
+        }
+
+        for (int h = order; h < height; h += 2) {
+            for (int w = 0; w < width; w++)
+                dstp[w] = (srccp[w] + srcnp[w] + 1) / 2;
+
+            srccp += 2 * stride;
+            srcnp += 2 * stride;
+            dstp += 2 * stride;
+        }
+    }
+}
+
+static void applyDotcrawInverse(const VSFrame *srcc, const VSFrame *srcn, VSFrame *outframe, int order, VSCore *core, const VSAPI *vsapi) {
+    const VSVideoFormat *fi = vsapi->getVideoFrameFormat(srcc);
+    for (int plane = 0; plane < fi->numPlanes; plane++) {
+        int width = vsapi->getFrameWidth(srcc, plane);
+        int height = vsapi->getFrameHeight(srcc, plane);
+
+        ptrdiff_t stride = vsapi->getStride(outframe, plane);
+        uint8_t *dstp = vsapi->getWritePtr(outframe, plane);
+        const uint8_t *srccp = vsapi->getReadPtr(srcc, plane);
+        const uint8_t *srcnp = vsapi->getReadPtr(srcn, plane);
+
+        if (order) {
+            srccp += stride;
+            srcnp += stride;
+            dstp += stride;
+        }
+
+        for (int h = order; h < height; h += 2) {
+            for (int w = 0; w < width; w++) {
+                dstp[w] = (srccp[w] + srcnp[w] + 1) / 2;
+
+                if (h > 1) {
+                    uint8_t l0val = dstp[w - 2 * stride];
+                    uint8_t l2val = dstp[w];
+                    int l0diff = dstp[w - 2 * stride] - srccp[w - 2 * stride];
+                    int l2diff = dstp[w] - srccp[w];
+                    if (plane == 0)
+                        dstp[w - stride] = std::clamp(srccp[w - stride] + (order ? l0diff : l2diff), 16, 235);
+                    else
+                        dstp[w - stride] = (l0val + l2val + 1) / 2; // simply use some kind of interpolation and discard one field?
+                }
+            }
+
+            srccp += 2 * stride;
+            srcnp += 2 * stride;
+            dstp += 2 * stride;
+        }
+    }
+}
+
+typedef struct {
+    VSNode *node;
+    const VSVideoInfo *vi;
+    int order;
+    int offset;
+} DotKillZData;
+
+static const VSFrame *VS_CC dotKillZGetFrame(int n, int activationReason, void *instanceData, void **frameData, VSFrameContext *frameCtx, VSCore *core, const VSAPI *vsapi) {
+    DotKillZData *d = reinterpret_cast<DotKillZData*>(instanceData);
+
+    if (activationReason == arInitial) {
+        vsapi->requestFrameFilter(std::max(n - 1, 0), d->node, frameCtx);
+        vsapi->requestFrameFilter(n, d->node, frameCtx);
+        vsapi->requestFrameFilter(n + 1, d->node, frameCtx);
+    } else if (activationReason == arAllFramesReady) {
+        const VSFrame *srcp = vsapi->getFrameFilter(std::max(n - 1, 0), d->node, frameCtx);
+        const VSFrame *srcc = vsapi->getFrameFilter(n, d->node, frameCtx);
+        const VSFrame *srcn = vsapi->getFrameFilter(n + 1, d->node, frameCtx);
+
+        /*
+            FIELD OFFSETS
+            -1  0  1  2  3
+            A1 B1 B1 C1 D1
+            A2 B2 C2 D2 D2
+        */
+
+        VSFrame *outframe = vsapi->copyFrame(srcc, core);
+        if ((n + d->offset) % 5 == 0) {
+            // current and next field are duplicates, complement field is from the same frame so do dotcrawl inverse on that as well
+            applyDotcrawInverse(srcc, srcn, outframe, d->order, core, vsapi);
+        } else if ((n + d->offset) % 5 == 1) {
+            // current and previous field are duplicates so blend them together
+            applyFieldBlend(srcc, srcp, outframe, d->order, core, vsapi);
+        } else if ((n + d->offset) % 5 == 2) {
+            // current and next complement field are duplicates so blend them together
+            applyFieldBlend(srcc, srcn, outframe, !d->order, core, vsapi);
+        } else if ((n + d->offset) % 5 == 3) {
+            // current and previous field are duplicates, complement field is from the same frame so do dotcrawl inverse on that as well
+            applyDotcrawInverse(srcc, srcp, outframe, !d->order, core, vsapi);
+        }
+
+        vsapi->freeFrame(srcp);
+        vsapi->freeFrame(srcc);
+        vsapi->freeFrame(srcn);
+
+        return outframe;
+    }
+
+    return nullptr;
+}
+
+static void VS_CC dotKillZFree(void *instanceData, VSCore *core, const VSAPI *vsapi) {
+    DotKillZData *d = reinterpret_cast<DotKillZData*>(instanceData);
+    vsapi->freeNode(d->node);
+    delete d;
+}
+
+static void VS_CC dotKillZCreate(const VSMap *in, VSMap *out, void *userData, VSCore *core, const VSAPI *vsapi) {
+    std::unique_ptr<DotKillZData> d(new DotKillZData());
+
+    int err;
+    d->node = vsapi->mapGetNode(in, "clip", 0, nullptr);
+    d->vi = vsapi->getVideoInfo(d->node);
+    d->offset = vsapi->mapGetIntSaturated(in, "offset", 0, &err);
+    d->order = !!vsapi->mapGetInt(in, "order", 0, &err);
+
+    if (!vsh::isSameVideoPresetFormat(pfYUV420P8, &d->vi->format, core, vsapi) || !vsh::isConstantVideoFormat(d->vi)) {
+        vsapi->mapSetError(out, "DotKillZ: only constant dimension YUV420P8 supported");
+        vsapi->freeNode(d->node);
+        return;
+    }
+
+    VSFilterDependency deps[] = { {d->node, rpGeneral} };
+    vsapi->createVideoFilter(out, "DotKillZ", d->vi, dotKillZGetFrame, dotKillZFree, fmParallelRequests, deps, 1, d.get(), core);
+    d.release();
+}
+
+/////////////////////////////////////////////////////////////////////
+// DotKillT
+
+constexpr int blockx = 16;
+constexpr int blocky = 8;
+
+static void calcDiffMetric(const VSFrame *f1, const VSFrame *f2, int64_t *bdiffs, int nxblocks, int nyblocks,int field, const VSAPI *vsapi) {
+    for (int plane = 0; plane < 3; plane++) {
+        ptrdiff_t stride = vsapi->getStride(f1, plane);
+        const uint8_t *f1p = vsapi->getReadPtr(f1, plane);
+        const uint8_t *f2p = vsapi->getReadPtr(f2, plane);
+        const VSVideoFormat *fi = vsapi->getVideoFrameFormat(f1);
+
+        if (field) {
+            f1p += stride;
+            f2p += stride;
+        }
+
+        int width = vsapi->getFrameWidth(f1, plane);
+        int height = vsapi->getFrameHeight(f1, plane);
+        int hblockx = blockx / 2;
+        int hblocky = blocky / 2;
+        // adjust for subsampling
+        if (plane > 0) {
+            hblockx /= 1 << fi->subSamplingW;
+            hblocky /= 1 << fi->subSamplingH;
+        }
+
+        for (int y = 0; y < height / 2; y++) {
+            int ydest = y / hblocky;
+            int xdest = 0;
+
+            for (int x = 0; x < width; x += hblockx) {
+                int acc = 0;
+                int m = VSMIN(width, x + hblockx);
+                for (int xl = x; xl < m; xl++) {
+                    int tmp = f1p[xl] - f2p[xl];
+                    acc += tmp * tmp;
+                }
+                bdiffs[ydest * nxblocks + xdest] += acc;
+                xdest++;
+            }
+
+            f1p += stride * 2;
+            f2p += stride * 2;
+        }
+    }
+}
+
+static int64_t getMaxDiff(int i, int j, const int64_t *bdiffs1, int nxblocks, int nyblocks) {
+    int64_t tmp1 = bdiffs1[i * nxblocks + j] + bdiffs1[i * nxblocks + j + 1] + bdiffs1[(i + 1) * nxblocks + j] + bdiffs1[(i + 1) * nxblocks + j + 1];
+    int64_t tmp2 = bdiffs1[i * nxblocks + j] + bdiffs1[i * nxblocks + j - 1] + bdiffs1[(i + 1) * nxblocks + j] + bdiffs1[(i + 1) * nxblocks + j - 1];
+    int64_t tmp3 = bdiffs1[i * nxblocks + j] + bdiffs1[i * nxblocks - j + 1] + bdiffs1[(i - 1) * nxblocks + j] + bdiffs1[(i - 1) * nxblocks + j + 1];
+    int64_t tmp4 = bdiffs1[i * nxblocks + j] + bdiffs1[i * nxblocks - j - 1] + bdiffs1[(i - 1) * nxblocks + j] + bdiffs1[(i - 1) * nxblocks + j - 1];
+    return std::max({ tmp1, tmp2, tmp3, tmp4 });
+}
+
+static void diffMetricToMask(uint8_t *mask, const int64_t *bdiffs1, const int64_t *bdiffs2, int nxblocks, int nyblocks, int dupthresh, int tratio, const VSAPI *vsapi) {
+    int totdiff1 = 0;
+    int totdiff2 = 0;
+
+    for (int i = 1; i < nyblocks - 1; i++) {
+        for (int j = 1; j < nxblocks - 1; j++) {
+            int64_t diff1 = getMaxDiff(i, j, bdiffs1, nxblocks, nyblocks);
+            int64_t diff2 = getMaxDiff(i, j, bdiffs2, nxblocks, nyblocks);
+
+            if (diff1 >= dupthresh)
+                totdiff1++;
+            if (diff2 >= dupthresh)
+                totdiff2++;
+        }
+    }
+
+    // skip temporal processing if more than 1/tratio blocks have changed
+    bool skip1 = (totdiff1 * tratio > (nxblocks - 2) * (nyblocks - 2));
+    bool skip2 = (totdiff2 * tratio > (nxblocks - 2) * (nyblocks - 2));
+
+    for (int i = 1; i < nyblocks - 1; i++) {
+        for (int j = 1; j < nxblocks - 1; j++) {
+            int64_t diff1 = getMaxDiff(i, j, bdiffs1, nxblocks, nyblocks);
+            int64_t diff2 = getMaxDiff(i, j, bdiffs2, nxblocks, nyblocks);
+
+            if (!skip1 && diff1 <= diff2 && diff1 < dupthresh)
+                mask[nxblocks * i + j] = 1;
+            else if (!skip2 && diff2 < diff1 && diff2 < dupthresh)
+                mask[nxblocks * i + j] = 2;
+            else
+                mask[nxblocks * i + j] = 0;
+        }
+
+        // extend mask left and right
+        mask[nxblocks * i] = mask[nxblocks * i + 1];
+        mask[nxblocks * i + (nxblocks - 1)] = mask[nxblocks * i + (nxblocks - 2)];
+    }
+
+    // extend mask to top and bottom
+    memcpy(mask, mask + nxblocks, nxblocks);
+    memcpy(mask + nxblocks * (nyblocks - 1), mask + nxblocks * (nyblocks - 2), nxblocks);
+}
+
+static void applyTemporalMask(VSFrame *dst, const VSFrame *f0, const VSFrame *f1, const VSFrame *f2, uint8_t *mask, int nxblocks, int nyblocks, int field, bool show, const VSAPI *vsapi) {
+    for (int plane = 0; plane < 3; plane++) {
+        ptrdiff_t stride = vsapi->getStride(f1, plane);
+        const uint8_t *f0p = vsapi->getReadPtr(f0, plane);
+        const uint8_t *f1p = vsapi->getReadPtr(f1, plane);
+        const uint8_t *f2p = vsapi->getReadPtr(f2, plane);
+        uint8_t *dstp = vsapi->getWritePtr(dst, plane);
+        const VSVideoFormat *fi = vsapi->getVideoFrameFormat(f1);
+
+        if (field) {
+            f0p += stride;
+            f1p += stride;
+            f2p += stride;
+            dstp += stride;
+        }
+
+        int width = vsapi->getFrameWidth(f1, plane);
+        int height = vsapi->getFrameHeight(f1, plane);
+        int hblockx = blockx / 2;
+        int hblocky = blocky / 2;
+
+        if (plane > 0) {
+            hblockx /= 1 << fi->subSamplingW;
+            hblocky /= 1 << fi->subSamplingH;
+        }
+
+        for (int y = 0; y < height / 2; y++) {
+            int ydest = y / hblocky;
+            int xdest = 0;
+
+            for (int x = 0; x < width; x += hblockx) {
+                int m = VSMIN(width, x + hblockx);
+
+                for (int xl = x; xl < m; xl++) {
+                    if (mask[ydest * nxblocks + xdest] == 1)
+                        dstp[xl] = ((f1p[xl] + f0p[xl] + 1) / 2);
+                    else if (mask[ydest * nxblocks + xdest] == 2)
+                        dstp[xl] = ((f2p[xl] + f0p[xl] + 1) / 2);
+                    else
+                        dstp[xl] = dstp[xl];
+                }
+                xdest++;
+            }
+
+            f0p += stride * 2;
+            f1p += stride * 2;
+            f2p += stride * 2;
+            dstp += stride * 2;
+        }
+    }
+
+    // Horrible square drawing code
+    if (show) {
+        ptrdiff_t stride = vsapi->getStride(dst, 0);
+        uint8_t *dstp = vsapi->getWritePtr(dst, 0);
+
+        int width = vsapi->getFrameWidth(dst, 0);
+        int height = vsapi->getFrameHeight(dst, 0);
+        int hblockx = blockx / 2;
+
+        for (int y = 0; y < height; y++) {
+            int ydest = y / blocky;
+            int xdest = 0;
+
+            for (int x = 0; x < width; x += hblockx) {
+                int m = std::min(width, x + hblockx);
+
+                if (y % blocky == 0) {
+                    for (int xl = x; xl < m; xl++) {
+                        if (mask[ydest * nxblocks + xdest] == 1) {
+                            dstp[xl] = 0;
+                        } else if (mask[ydest * nxblocks + xdest] == 2) {
+                            dstp[xl] = 255;
+                        }
+                    }
+                } else if (y % blocky == blocky - 1) {
+                    for (int xl = x; xl < m; xl++) {
+                        if (mask[ydest * nxblocks + xdest] == 1) {
+                            dstp[xl] = 0;
+                        } else if (mask[ydest * nxblocks + xdest] == 2) {
+                            dstp[xl] = 255;
+                        }
+                    }
+                }
+
+                if (mask[ydest * nxblocks + xdest] == 1) {
+                    dstp[x] = 0;
+                    dstp[m - 1] = 0;
+                } else if (mask[ydest * nxblocks + xdest] == 2) {
+                    dstp[x] = 255;
+                    dstp[m - 1] = 255;
+                }
+
+                xdest++;
+            }
+
+            dstp += stride;
+        }
+    }
+}
+
+typedef struct {
+    VSNode *node;
+    const VSVideoInfo *vi;
+    int order;
+    int offset;
+    int dupthresh;
+    int tratio;
+    bool show;
+} DotKillTData;
+
+static const VSFrame *VS_CC dotKillTGetFrame(int n, int activationReason, void *instanceData, void **frameData, VSFrameContext *frameCtx, VSCore *core, const VSAPI *vsapi) {
+    DotKillTData *d = reinterpret_cast<DotKillTData*>(instanceData);
+
+    int nxblocks = (d->vi->width + blockx / 2 - 1) / (blockx / 2);
+    int nyblocks = (d->vi->height + blocky / 2 - 1) / (blocky / 2);
+
+    if (activationReason == arInitial) {
+        vsapi->requestFrameFilter(std::max(n - 2, 0), d->node, frameCtx);
+        vsapi->requestFrameFilter(std::max(n - 1, 0), d->node, frameCtx);
+        vsapi->requestFrameFilter(n, d->node, frameCtx);
+        vsapi->requestFrameFilter(n + 1, d->node, frameCtx);
+        vsapi->requestFrameFilter(n + 2, d->node, frameCtx);
+    } else if (activationReason == arAllFramesReady) {
+        const VSFrame *srcpp = vsapi->getFrameFilter(std::max(n - 2, 0), d->node, frameCtx);
+        const VSFrame *srcp = vsapi->getFrameFilter(std::max(n - 1, 0), d->node, frameCtx);
+        const VSFrame *srcc = vsapi->getFrameFilter(n, d->node, frameCtx);
+        const VSFrame *srcn = vsapi->getFrameFilter(n + 1, d->node, frameCtx);
+        const VSFrame *srcnn = vsapi->getFrameFilter(n + 2, d->node, frameCtx);
+
+        // first two fields are duplicates, meaning that offset 0, 1 and 5, 6 are used in the various calculations
+        // fields 2, 3 and 4 needs to have determined how many blocks are consecutively static
+        // note that comparisons are only run on a single since we can in most comparisons can eliminate
+        // the dotcrawl from the equation
+
+        // 0-1 2 3 4 5-6
+
+        // the complementary field can likewise be used for movement detection
+
+        /*
+            FIELD OFFSETS
+             +  -  +  -  +  -
+            -1  0  1  2  3  4
+            A1 B1 B1 C1 D1 E1
+            A2 B2 C2 D2 D2 E2
+        */
+
+        VSFrame *outframe = vsapi->copyFrame(srcc, core);
+
+        vsapi->mapSetInt(vsapi->getFramePropertiesRW(outframe), "DotKillTOffset", (n + d->offset) % 5, maReplace);
+
+        if ((n + d->offset) % 5 == 0) {
+            // 1
+            applyDotcrawInverse(srcc, srcn, outframe, d->order, core, vsapi);
+
+            // 2
+            std::vector<int64_t> maskprev1(nxblocks * nyblocks);
+            std::vector<int64_t> masknext1(nxblocks * nyblocks);
+            std::vector<uint8_t> mask(nxblocks * nyblocks);
+            calcDiffMetric(srcp, srcn, maskprev1.data(), nxblocks, nyblocks, d->order, vsapi);
+            calcDiffMetric(srcc, srcnn, masknext1.data(), nxblocks, nyblocks, d->order, vsapi);
+
+            diffMetricToMask(mask.data(), maskprev1.data(), masknext1.data(), nxblocks, nyblocks, d->dupthresh, d->tratio, vsapi);
+
+            applyTemporalMask(outframe, srcc, srcp, srcn, mask.data(), nxblocks, nyblocks, !d->order, d->show, vsapi);
+        } else if ((n + d->offset) % 5 == 1) {
+            // 1
+            applyFieldBlend(srcc, srcp, outframe, d->order, core, vsapi);
+
+            // 2
+            std::vector<int64_t> maskprev1(nxblocks * nyblocks);
+            std::vector<int64_t> masknext1(nxblocks * nyblocks);
+            std::vector<uint8_t> mask(nxblocks * nyblocks);
+            calcDiffMetric(srcp, srcn, maskprev1.data(), nxblocks, nyblocks, d->order, vsapi);
+            calcDiffMetric(srcc, srcnn, masknext1.data(), nxblocks, nyblocks, !d->order, vsapi);
+
+            diffMetricToMask(mask.data(), maskprev1.data(), masknext1.data(), nxblocks, nyblocks, d->dupthresh, d->tratio, vsapi);
+
+            applyTemporalMask(outframe, srcc, srcp, srcn, mask.data(), nxblocks, nyblocks, !d->order, d->show, vsapi);
+        } else if ((n + d->offset) % 5 == 2) {
+            // 1
+            std::vector<int64_t> maskprev1(nxblocks * nyblocks);
+            std::vector<int64_t> masknext1(nxblocks * nyblocks);
+            std::vector<uint8_t> mask(nxblocks * nyblocks);
+            calcDiffMetric(srcc, srcpp, maskprev1.data(), nxblocks, nyblocks, d->order, vsapi);
+            calcDiffMetric(srcp, srcn, masknext1.data(), nxblocks, nyblocks, !d->order, vsapi);
+
+            diffMetricToMask(mask.data(), maskprev1.data(), masknext1.data(), nxblocks, nyblocks, d->dupthresh, d->tratio, vsapi);
+
+            applyTemporalMask(outframe, srcc, srcp, srcn, mask.data(), nxblocks, nyblocks, d->order, d->show, vsapi);
+
+            // 2
+            applyFieldBlend(srcc, srcn, outframe, !d->order, core, vsapi);
+        } else if ((n + d->offset) % 5 == 3) {
+            // 2
+            applyDotcrawInverse(srcc, srcp, outframe, !d->order, core, vsapi);
+
+            // 1
+            std::vector<int64_t> maskprev1(nxblocks * nyblocks);
+            std::vector<int64_t> masknext1(nxblocks * nyblocks);
+            std::vector<uint8_t> mask(nxblocks * nyblocks);
+            calcDiffMetric(srcc, srcpp, maskprev1.data(), nxblocks, nyblocks, !d->order, vsapi);
+            calcDiffMetric(srcp, srcn, masknext1.data(), nxblocks, nyblocks, !d->order, vsapi);
+
+            diffMetricToMask(mask.data(), maskprev1.data(), masknext1.data(), nxblocks, nyblocks, d->dupthresh, d->tratio, vsapi);
+
+            applyTemporalMask(outframe, srcc, srcp, srcn, mask.data(), nxblocks, nyblocks, d->order, d->show, vsapi);
+        } else if ((n + d->offset) % 5 == 4) {
+            // 1
+            {
+                std::vector<int64_t> maskprev1(nxblocks * nyblocks);
+                std::vector<int64_t> masknext1(nxblocks * nyblocks);
+                std::vector<uint8_t> mask(nxblocks * nyblocks);
+                calcDiffMetric(srcc, srcpp, maskprev1.data(), nxblocks, nyblocks, !d->order, vsapi);
+                calcDiffMetric(srcc, srcnn, masknext1.data(), nxblocks, nyblocks, d->order, vsapi);
+
+                diffMetricToMask(mask.data(), maskprev1.data(), masknext1.data(), nxblocks, nyblocks, d->dupthresh, d->tratio, vsapi);
+
+                applyTemporalMask(outframe, srcc, srcp, srcn, mask.data(), nxblocks, nyblocks, d->order, d->show, vsapi);
+            }
+
+            // 2
+            {
+                std::vector<int64_t> maskprev1(nxblocks * nyblocks);
+                std::vector<int64_t> masknext1(nxblocks * nyblocks);
+                std::vector<uint8_t> mask(nxblocks * nyblocks);
+                calcDiffMetric(srcpp, srcc, maskprev1.data(), nxblocks, nyblocks, !d->order, vsapi);
+                calcDiffMetric(srcc, srcnn, masknext1.data(), nxblocks, nyblocks, d->order, vsapi);
+
+                diffMetricToMask(mask.data(), maskprev1.data(), masknext1.data(), nxblocks, nyblocks, d->dupthresh, d->tratio, vsapi);
+
+                applyTemporalMask(outframe, srcc, srcp, srcn, mask.data(), nxblocks, nyblocks, !d->order, d->show, vsapi);
+            }
+        }
+
+        vsapi->freeFrame(srcpp);
+        vsapi->freeFrame(srcp);
+        vsapi->freeFrame(srcc);
+        vsapi->freeFrame(srcn);
+        vsapi->freeFrame(srcnn);
+
+        return outframe;
+    }
+
+    return nullptr;
+}
+
+static void VS_CC dotKillTFree(void *instanceData, VSCore *core, const VSAPI *vsapi) {
+    DotKillTData *d = reinterpret_cast<DotKillTData*>(instanceData);
+    vsapi->freeNode(d->node);
+    delete d;
+}
+
+static void VS_CC dotKillTCreate(const VSMap *in, VSMap *out, void *userData, VSCore *core, const VSAPI *vsapi) {
+    std::unique_ptr<DotKillTData> d(new DotKillTData());
+
+    int err;
+    d->node = vsapi->mapGetNode(in, "clip", 0, nullptr);
+    d->vi = vsapi->getVideoInfo(d->node);
+    d->offset = vsapi->mapGetIntSaturated(in, "offset", 0, &err);
+    d->order = !!vsapi->mapGetInt(in, "order", 0, &err);
+    d->dupthresh = vsapi->mapGetIntSaturated(in, "dupthresh", 0, &err);
+    if (err || d->dupthresh < 0)
+        d->dupthresh = 64;
+    d->dupthresh *= d->dupthresh;
+    d->tratio = vsapi->mapGetIntSaturated(in, "tratio", 0, &err);
+    if (err || d->tratio < 1)
+        d->tratio = 3;
+    d->show = !!vsapi->mapGetInt(in, "show", 0, &err);
+
+    if (!vsh::isSameVideoPresetFormat(pfYUV420P8, &d->vi->format, core, vsapi) || !vsh::isConstantVideoFormat(d->vi)) {
+        vsapi->mapSetError(out, "DotKillT: only constant dimension YUV420P8 supported");
+        vsapi->freeNode(d->node);
+        return;
+    }
+
+    VSFilterDependency deps[] = { {d->node, rpGeneral} };
+    vsapi->createVideoFilter(out, "DotKillT", d->vi, dotKillTGetFrame, dotKillTFree, fmParallelRequests, deps, 1, d.get(), core);
+    d.release();
+}
+
+//////////////////////////////////////////
+// Init
+
+VS_EXTERNAL_API(void) VapourSynthPluginInit2(VSPlugin *plugin, const VSPLUGINAPI *vspapi) {
+    vspapi->configPlugin("com.vapoursynth.dotkill", "dotkill", "VapourSynth DotKill", VS_MAKE_VERSION(4, 0), VAPOURSYNTH_API_VERSION, 0, plugin);
+    vspapi->registerFunction("DotKillS", "clip:vnode;iterations:int:opt;", "clip:vnode", dotKillSCreate, 0, plugin);
+    vspapi->registerFunction("DotKillZ", "clip:vnode;order:int:opt;offset:int:opt;", "clip:vnode", dotKillZCreate, 0, plugin);
+    vspapi->registerFunction("DotKillT", "clip:vnode;order:int:opt;offset:int:opt;dupthresh:int:opt;tratio:int:opt;show:int:opt;", "clip:vnode", dotKillTCreate, 0, plugin);
+}