Replacement for Oyster?

[asarian]

I am trying to use Oyster, but keep getting all sort of errors:

import vapoursynth as vs
import havsfunc as haf
import Oyster

core = vs.core
core.max_cache_size = 65535

vid = core.lsmas.LibavSMASHSource(r"f:\veai\test.mov")
vid = core.fmtc.bitdepth(vid, bits = 32 )
vid = core.fmtc.resample(vid, css = "444" )

ref_s = Oyster.Basic(vid, short_time=True)
vid = Oyster.Deringing(vid, ref_s, block_step=2)

vid = core.resize.Spline64(vid, matrix = 1, format = vs.YUV420P10)
vid = core.cas.CAS (vid, 0.9)
vid = core.neo_f3kdb.Deband (vid, preset="veryhigh", dither_algo=2)

vid.set_output ()


2024-11-06 19:49:45.871
Python exception: No attribute with the name SetFieldBased exists. Did you mistype a plugin namespace?

Traceback (most recent call last):
File "src\cython\vapoursynth.pyx", line 2832, in vapoursynth._vpy_evaluate
File "src\cython\vapoursynth.pyx", line 2833, in vapoursynth._vpy_evaluate
File "", line 12, in
File "C:\Users\user\AppData\Roaming\Python\Python39\site-packages\Oyster.py", line 267, in Basic
src = core.SetFieldBased(src, 0)
File "src\cython\vapoursynth.pyx", line 2385, in vapoursynth._CoreProxy.__getattr__
File "src\cython\vapoursynth.pyx", line 2228, in vapoursynth.Core.__getattr__
AttributeError: No attribute with the name SetFieldBased exists. Did you mistype a plugin namespace?


Is there a way to fix this? Or use a working alternative to Oyster? Thanks.

[Selur]

Is there a way to fix this?
Changed line 14 from
self.core = vs.get_core()
to
self.core = vs.core
(in Oyster.py)
and it works fine (and as expected terribly slow) here.

core.max_cache_size = 65535
Out of curiosity, how much RAM does your system have that you can spare 64GB for caching?

Cu Selur

Ps.: Not sure whether it's worth it, but one could adjust the code to use:

nnedi3cl or znedi3 instead of normal nnedi3.
neo_dfttest instead of dfttest.

[asarian]

Changed line 14 from
self.core = vs.get_core()
to
self.core = vs.core
(in Oyster.py)
and it works fine (and as expected terribly slow) here.


Out of curiosity, how much RAM does your system have that you can spare 64GB for caching?

Cu Selur


Thanks. I had already changed to 'vs.core'. :) That solved the immediate error; but the 'AttributeError: No attribute with the name SetFieldBased exists. Did you mistype a plugin namespace?' error remains, so I just figured it's broken beyond my capabilities to fix.

P.S. I have 64G memory, but memory usage never actually seems to exceed around 2/3rd of what I have.

[Selur]

Change:

import vapoursynth as vs
import havsfunc as haf
import Oyster

core = vs.core
core.max_cache_size = 65535


to

import vapoursynth as vs
core = vs.core
core.max_cache_size = 65535

import havsfunc as haf
import Oyster

[_Al_]

Looks like oyster script ties mvtools and other core attributes to a particular script instance.

[asarian]

Change:

import vapoursynth as vs
import havsfunc as haf
import Oyster

core = vs.core
core.max_cache_size = 65535


to

import vapoursynth as vs
core = vs.core
core.max_cache_size = 65535

import havsfunc as haf
import Oyster


I tried that; sadly, got the exact same AttributeError: No attribute with the name SetFieldBased exists. Did you mistype a plugin namespace? error. So, now it looks like this:

import vapoursynth as vs
core = vs.core
core.max_cache_size = 65535

import havsfunc as haf
import Oyster as Oy
import math
import mvmulti

vid = core.lsmas.LibavSMASHSource(r"f:\veai\test.mov")

vid = core.fmtc.bitdepth(vid, bits = 32 )
vid = core.fmtc.resample(vid, css = "444" )

ref_s = Oy.Basic(vid, short_time=True)
vid = Oy.Deringing(vid, ref_s, block_step=2)

[Selur]

I used:
# Imports
import vapoursynth as vs
# getting Vapoursynth core
import sys
import os
core = vs.core
# Import scripts folder
scriptPath = 'F:/Hybrid/64bit/vsscripts'
sys.path.insert(0, os.path.abspath(scriptPath))
# loading plugins
core.std.LoadPlugin(path="F:/Hybrid/64bit/vsfilters/SourceFilter/LSmashSource/LSMASHSource.dll")
# Import scripts
import validate
# Source: 'G:\TestClips&Co\files\test.avi'
# Current color space: YUV420P8, bit depth: 8, resolution: 640x352, frame rate: 25fps, scanorder: progressive, yuv luminance scale: limited, matrix: 470bg, format: MPEG-4 Visual
# Loading G:\TestClips&Co\files\test.avi using LWLibavSource
clip = core.lsmas.LWLibavSource(source="G:/TestClips&Co/files/test.avi", format="YUV420P8", stream_index=0, cache=0, prefer_hw=0)
frame = clip.get_frame(0)
# setting color matrix to 470bg.
clip = core.std.SetFrameProps(clip, _Matrix=vs.MATRIX_BT470_BG)
# setting color transfer (vs.TRANSFER_BT601), if it is not set.
if validate.transferIsInvalid(clip):
clip = core.std.SetFrameProps(clip=clip, _Transfer=vs.TRANSFER_BT601)
# setting color primaries info (to vs.PRIMARIES_BT470_BG), if it is not set.
if validate.primariesIsInvalid(clip):
clip = core.std.SetFrameProps(clip=clip, _Primaries=vs.PRIMARIES_BT470_BG)
# setting color range to TV (limited) range.
clip = core.std.SetFrameProps(clip=clip, _ColorRange=vs.RANGE_LIMITED)
# making sure frame rate is set to 25fps
clip = core.std.AssumeFPS(clip=clip, fpsnum=25, fpsden=1)
# making sure the detected scan type is set (detected: progressive)
clip = core.std.SetFrameProps(clip=clip, _FieldBased=vs.FIELD_PROGRESSIVE) # progressive


# Loading Support Files
import ctypes
Dllref = ctypes.windll.LoadLibrary("F:/Hybrid/64bit/vsfilters/Support/libfftw3f-3.dll")
Dllref = ctypes.windll.LoadLibrary("F:/Hybrid/64bit/vsfilters/Support/libfftw3-3.dll")
core.std.LoadPlugin(path="F:/Hybrid/64bit/vsfilters/DenoiseFilter/DFTTest/DFTTest.dll")
core.std.LoadPlugin(path="F:/Hybrid/64bit/vsfilters/DenoiseFilter/KNLMeansCL/KNLMeansCL.dll")
core.std.LoadPlugin(path="F:/Hybrid/64bit/vsfilters/ResizeFilter/nnedi3/libnnedi3.dll")
core.std.LoadPlugin(path="F:/Hybrid/64bit/vsfilters/DenoiseFilter/BM3D/BM3D.dll")
core.std.LoadPlugin(path="F:/Hybrid/64bit/vsfilters/Support/libmvtools_sf_em64t.dll")
core.std.LoadPlugin(path="F:/Hybrid/64bit/vsfilters/Support/fmtconv.dll")
import Oyster

#vid = core.fmtc.bitdepth(clip, bits = 32 )
#vid = core.fmtc.resample(vid, css = "444" )
vid = core.resize.Bicubic(clip=clip, format=vs.RGBS, matrix_in_s="470bg", range_s="limited")

ref_s = Oyster.Basic(vid, short_time=True)
clip = Oyster.Deringing(vid, ref_s, block_step=2)

# output
clip.set_output()
with: https://pastebin.com/DwhtghH1
and it worked fine.

Anything uncommon with your Vapoursynth setup?

[asarian]

I used:


#vid = core.fmtc.bitdepth(clip, bits = 32 )
#vid = core.fmtc.resample(vid, css = "444" )
vid = core.resize.Bicubic(clip=clip, format=vs.RGBS, matrix_in_s="470bg", range_s="limited")

ref_s = Oyster.Basic(vid, short_time=True)
clip = Oyster.Deringing(vid, ref_s, block_step=2)

# output
clip.set_output()
with: https://pastebin.com/DwhtghH1
and it worked fine.

Anything uncommon with your Vapoursynth setup?

Actually, in my latest code, I had used sections from your exact code. :):goodpost:

I don't get it, though. SetFieldBased should be part of 'core.std', like:

clip = core.std.SetFieldBased(clip, 0)

So, why on earth would VapourSynth tell me "No attribute with the name SetFieldBased exists"?


EDIT: I smell a rat! In Oyster, I see this

core = vs.core
src = core.SetFieldBased(src, 0)

Maybe that should indeed now be core.std.SetFieldBased?

[Selur]

I reuploaded the Oyster.py: https://pastebin.com/faN0jg4a

self.core = vs.core # <-
self.MSuper = self.core.mvsf.Super
self.MAnalyze = self.core.mvsf.Analyze
self.MRecalculate = self.core.mvsf.Recalculate
self.MDegrain = self.core.mvsf.Degrain
self.RGB2OPP = self.core.bm3d.RGB2OPP
self.OPP2RGB = self.core.bm3d.OPP2RGB
self.BMBasic = self.core.bm3d.VBasic
self.BMFinal = self.core.bm3d.VFinal
self.Aggregate = self.core.bm3d.VAggregate
self.DFTTest = self.core.dfttest.DFTTest
self.KNLMeansCL = self.core.knlm.KNLMeansCL
self.NNEDI = self.core.nnedi3.nnedi3
self.Resample = self.core.fmtc.resample
self.Expr = self.core.std.Expr
self.MakeDiff = self.core.std.MakeDiff
self.MergeDiff = self.core.std.MergeDiff
self.Crop = self.core.std.CropRel
self.CropAbs = self.core.std.CropAbs
self.Transpose = self.core.std.Transpose
self.BlankClip = self.core.std.BlankClip
self.AddBorders = self.core.std.AddBorders
self.StackHorizontal = self.core.std.StackHorizontal
self.StackVertical = self.core.std.StackVertical
self.MaskedMerge = self.core.std.MaskedMerge
self.ShufflePlanes = self.core.std.ShufflePlanes
self.SetFieldBased = self.core.std.SetFieldBased # <-

the last line is the important one.

[asarian]

I reuploaded the Oyster.py: https://pastebin.com/faN0jg4a

self.core = vs.core # <-
self.MSuper = self.core.mvsf.Super
self.MAnalyze = self.core.mvsf.Analyze
self.MRecalculate = self.core.mvsf.Recalculate
self.MDegrain = self.core.mvsf.Degrain
self.RGB2OPP = self.core.bm3d.RGB2OPP
self.OPP2RGB = self.core.bm3d.OPP2RGB
self.BMBasic = self.core.bm3d.VBasic
self.BMFinal = self.core.bm3d.VFinal
self.Aggregate = self.core.bm3d.VAggregate
self.DFTTest = self.core.dfttest.DFTTest
self.KNLMeansCL = self.core.knlm.KNLMeansCL
self.NNEDI = self.core.nnedi3.nnedi3
self.Resample = self.core.fmtc.resample
self.Expr = self.core.std.Expr
self.MakeDiff = self.core.std.MakeDiff
self.MergeDiff = self.core.std.MergeDiff
self.Crop = self.core.std.CropRel
self.CropAbs = self.core.std.CropAbs
self.Transpose = self.core.std.Transpose
self.BlankClip = self.core.std.BlankClip
self.AddBorders = self.core.std.AddBorders
self.StackHorizontal = self.core.std.StackHorizontal
self.StackVertical = self.core.std.StackVertical
self.MaskedMerge = self.core.std.MaskedMerge
self.ShufflePlanes = self.core.std.ShufflePlanes
self.SetFieldBased = self.core.std.SetFieldBased # <-

the last line is the important one.

Haha! You're 10x faster than I am. :) I was painstakingly trying to fix all of them, but I was only at 3.

Anyway, you've been a great help! Thank you.

[Cary Knoop]

If CUDA is enabled we could use core.bm3dcuda.BM3Dv2 to speed up things.

[Selur]

What directly comes to mind to instead of

'core.std.Expr', one could use 'llvmexpr.Expr'
'core.nnedi3.nnedi3', one could use 'core.znedi3.nnedi3'
'core.knlm.KNLMeansCL', one could use 'core.nlm_cuda.NLMeans'
'core.dfttest.DFTTest', one could use 'core.dfttest2_nvrtc.DFTTest' or 'core.dfttest2_cuda.DFTTest'

see: https://github.com/Selur/VapoursynthScriptsInHybrid/blob/master/Oyster.py

About 'core.bm3dcuda.BM3Dv2': from what I see inside Oyster, there is no BM3D call, so at least a simple replacement won't work.

Cu Selur

[Cary Knoop]

About 'core.bm3dcuda.BM3Dv2': from what I see inside Oyster, there is no BM3D call, so at least a simple replacement won't work.

Cu Selur
There are, they just got a different name:

self.RGB2OPP = self.core.bm3d.RGB2OPP
self.OPP2RGB = self.core.bm3d.OPP2RGB
self.BMBasic = self.core.bm3d.VBasic
self.BMFinal = self.core.bm3d.VFinal
self.Aggregate = self.core.bm3d.VAggregate

[Selur]

Using:
# Imports
import vapoursynth as vs
# getting Vapoursynth core
import ctypes
import sys
import os
core = vs.core
# Limit frame cache to 48473MB
core.max_cache_size = 48473
# Import scripts folder
scriptPath = 'F:/Hybrid/64bit/vsscripts'
sys.path.insert(0, os.path.abspath(scriptPath))
# Loading Support Files
Dllref = ctypes.windll.LoadLibrary("F:/Hybrid/64bit/vsfilters/Support/libfftw3f-3.dll")

# Load BM3D plugins
core.std.LoadPlugin(path="F:/Hybrid/64bit/vsfilters/DenoiseFilter/BM3D/BM3D.dll")
core.std.LoadPlugin(path="F:/Hybrid/64bit/vsfilters/DenoiseFilter/BM3D/bm3dcuda.dll")
core.std.LoadPlugin(path="F:/Hybrid/64bit/vsfilters/DenoiseFilter/BM3D/bm3dcuda_rtc.dll")

# Function to list available functions in a plugin namespace
def list_plugin_functions(plugin_name):
if hasattr(core, plugin_name):
plugin = getattr(core, plugin_name)
funcs = [f for f in dir(plugin) if not f.startswith("_")]
print(f"Functions in {plugin_name}: {funcs}")
else:
print(f"No plugin namespace named {plugin_name}")

# List BM3D namespaces
for plugin_name in ['bm3d', 'bm3dcuda', 'bm3dcuda_rtc']:
list_plugin_functions(plugin_name)

I see:

Functions in bm3d: ['Basic', 'Final', 'OPP2RGB', 'RGB2OPP', 'VAggregate', 'VBasic', 'VFinal']
Functions in bm3dcuda: ['BM3D', 'BM3Dv2', 'VAggregate']
Functions in bm3dcuda_rtc: ['BM3D', 'BM3Dv2', 'VAggregate']

so I don't think a simple replacement is possible, but if you know a way let me know. (To me, it looks like the Oyster class would need more adjustments to support bm3dcuda or bm3dcuda_rtc.)

Cu Selur

[Selur]

I think I got it:
class get_core:
def __init__(self):
self.core = vs.core

# --- motion estimation ---
self.MSuper = self.core.mvsf.Super
self.MAnalyze = self.core.mvsf.Analyze
self.MRecalculate = self.core.mvsf.Recalculate
self.MDegrain = self.core.mvsf.Degrain

# --- BM3D / BM3DCUDA selection ---
if hasattr(self.core, 'bm3dcuda_rtc'):
bm3d_core = self.core.bm3dcuda_rtc
# BM3DCUDA uses a single 'BM3D' entry, no separate RGB2OPP/OPP2RGB
self.BMBasic = lambda **kwargs: bm3d_core.BM3D(**kwargs, radius=0)
self.BMFinal = lambda **kwargs: bm3d_core.BM3D(**kwargs, radius=0)
self.Aggregate = bm3d_core.VAggregate
self.RGB2OPP = lambda clip, _: clip
self.OPP2RGB = lambda clip, _: clip

elif hasattr(self.core, 'bm3dcuda'):
bm3d_core = self.core.bm3dcuda
self.BMBasic = lambda **kwargs: bm3d_core.BM3D(**kwargs, radius=0)
self.BMFinal = lambda **kwargs: bm3d_core.BM3D(**kwargs)
self.Aggregate = bm3d_core.VAggregate
self.RGB2OPP = lambda clip, _: clip
self.OPP2RGB = lambda clip, _: clip

if hasattr(self.core, 'bm3d'):
bm3d_core = self.core.bm3d
# Standard BM3D has Basic, Final, VBasic, VFinal, RGB2OPP, OPP2RGB
self.BMBasic = bm3d_core.Basic
self.BMFinal = bm3d_core.Final
self.Aggregate = bm3d_core.VAggregate
self.RGB2OPP = bm3d_core.RGB2OPP
self.OPP2RGB = bm3d_core.OPP2RG
updated the script on github, but
using bm3dcuda_rtc, I get:
Output 429 frames in 41.51 seconds (10.33 fps)
using bm3dcuda, I get:
Output 429 frames in 41.75 seconds (10.27 fps)
using bm3d, I get:
Output 429 frames in 41.28 seconds (10.39 fps)
there is basically not gain from using bm3dcuda or bm3dcuda_rtc, the difference is too small to judge.
Maybe using higher resolution clips, than my 640x352 test clip will show some speed gains when using the gpu.
Nope, using 4k, no difference in speed whether I use bm3dcuda or bm3dcuda_rtc or the cpu. GPU is hardly utilized at all.
At least on my setup these changes didn't seem to help at all.

Cu Selur

[Cary Knoop]

That's rather disappointing, thanks for testing.

[Selur]

You might want to try on your system, as I'm not sure how this will change depending on the gpu&cpu combination one uses. (using a Ryzen 7950x and a Geforce RTX 4080 here)

[Selur]

Main problem is the motion estimation.
Filtername Filter mode Time (%) Time (s)
Degrain parallel 132.79 92.36
Analyze parallel 117.95 82.04
Analyze parallel 112.54 78.28
Analyze parallel 111.98 77.89
Analyze parallel 106.60 74.14
Analyze parallel 106.50 74.07
Analyze parallel 106.22 73.88
Analyze parallel 103.04 71.67
Analyze parallel 101.68 70.72
Analyze parallel 92.73 64.50
Analyze parallel 87.65 60.96
Analyze parallel 80.92 56.29
Analyze parallel 71.89 50.00
Recalculate parallel 53.23 37.02
Recalculate parallel 52.85 36.76
Recalculate parallel 49.89 34.70
Recalculate parallel 43.86 30.51
Recalculate parallel 42.96 29.88
Recalculate parallel 42.66 29.67
Recalculate parallel 41.13 28.61
Recalculate parallel 40.47 28.15
Recalculate parallel 40.35 28.06
Recalculate parallel 40.18 27.94
Recalculate parallel 39.88 27.74
Recalculate parallel 38.35 26.67
so unless we get faster MAnalyze or MRecalculate or use faster values for motion estimation stuff, you won't get this faster.

[Cary Knoop]

I tried to run Oyster and got stuck here:

vapoursynth.Error: DFTTest: Function does not take argument(s) named sbsize, slocation, smode, sosize, tbsize, tosize, tmode

Dfttest related dll's in pugins folder:
----------------------------------------
DFTTest.dll
dfttest2_cpu.dll
dfttest2_cuda.dll
dfttest2_nvrtc.dll

also have
libfttw3-3.dll
libfttw3f-3.dll

Ryzen 7950x with 128GB and RTX 3090

[Selur]

I see the problem, dfttest2.py is also needed and then should be called instead of the library directly for parameter compatibility.
=> no, something is strange.

[Selur]

Neither DFTTest nor bm3dcuda* can be used since they lack parameters the originals have. So some functions would work and others would not.
i.e. for dfttest2 even with dfttest.py smode=0 isn't supported.
=> so unless one decides to change Oyster, you can't use them

[Cary Knoop]

Without dfttest2 it works. However you mention about 10 fps with similar hardware I get perhaps one frame every 20 seconds, any idea what could be the problem?

My plugins:
[.] [..] AddGrain.dll addnoise.dll
akarin.dll BestAudioSource.dll bestsource.dll Bilateral.dll
BilateralGPU.dll BilateralGPU_RTC.dll BM3D.dll BM3DCPU-znver2.dll
BM3DCUDA.dll bm3dcuda_rtc.dll Bwdif.dll CAS.dll
chromanr.dll chromanrcuda.dll CTMF.dll d2vsource.dll
DCTFilter.dll Deblock.dll DFTTest.dll dfttest2_cpu.dllX
dfttest2_cuda.dllX dfttest2_nvrtc.dllX dpid.dll EEDI2.dll
EEDI3.dll EEDI3m.dll ffms2.dll fft3dfilter.dll
fmtconv.dll KNLMeansCL.dll libawarpsharp2.dll libdescale.dll
libfftw3-3.dll libfftw3f-3.dll libfluxsmooth.dll libftf_em64t_avx_fma.dll
libhistogram.dll libhqdn3d.dll libmedian.dll libmsmoosh.dll
libmvtools.dll libmvtools_sf_em64t.dllX libnnedi3.dll libresize2.dll
libsangnom.dll libtivtc.dll LSMASHSource.dll manipmv.dll
MiscFilters.dll [models] mvtools.dll neo-dfttest.dll
neo-f3kdb.dll neo-fft3d.dll neo-tmedian.dll neo-vague-denoiser.dll
NNEDI3CL.dll nnedi3_weights.bin ReadMpls.dll realsrnv.dll
RemoveGrainVS.dll Retinex.dll RGSF_x64.dll SubText.dll
TCanny.dll TDeintMod.dll tonemap.dll TTempSmooth.dll
vcm.dll VIVTC.dll VSFilterMod.dll [vsmlrt-cuda]
vsnlm_cuda.dll vszip.dll vsznedi3.dll wnnm.dll
Yadifmod.dll zbilateral.dll zsmooth.dll

(the dllX versions are just disabled libs).

[Selur]

the 10fps was just with:
y = Oyster.Basic(src=y, super=None, radius=6, pel=4, sad=2000.0, short_time=False)
other stuff is here ~0.2fps. (on a Ryzen 7 7950X with 64GB RAM and a SD source)

[Cary Knoop]

the 10fps was just with:
y = Oyster.Basic(src=y, super=None, radius=6, pel=4, sad=2000.0, short_time=False)
other stuff is here ~0.2fps. (on a Ryzen 7 7950X with 64GB RAM and a SD source)
Given that high quality open source GPU MC is not actively developed I suppose we have to wait a few more years before this can be realistically deployed.

For personal use could svpflow be deployed as a faster alternative to mvtools?

[Selur]

I doubt it, since degrain is missing and svpflow was rather restricted in options iirc., too groggy today to really think about it. :)
=> no svpflow doesn't seem to work either: a. only supports some functionality b. requires YUV420P8 or YUV420P16

I give up trying to optimize this.

[Cary Knoop]

I tried to make a Poor Man's Oyster using as much as CUDA as possible (only works with CUDA and the required functions).

https://github.com/caryknoop/pmoyster

Currently in Alpha stage.

[Selur]

Interesting, how does it compare in speed to normal Oyster?

[Cary Knoop]

For a deinterlaced PAL source using Super, Basic and Deringing on pel=4:

Level 4 = 7.0 fps
Level 3 = 6.7 fps
Level 2 = 3.4 fps
Level 1 = 1.7 fps
Level 0 = 0.4 fps

On Ryzen 7950x using RTX 3090

Level 0 and 1 are likely overkill.

[Selur]

nice :)

[yuygfgg]

mvsf is unusably slow. Is it possible to convert to 16bit and use regular mvtools? That might make things even faster.

[Selur]

Normally, single precision mvtools should be faster than normal mvtools. Why do you expect it to be faster with normal mvtools?
(Yes, using 16bit mvtools should be possible.)

[Cary Knoop]

Removed the chroma save/restore, implemented V2 BMD interface, set defaults based on footage type.

Simple example using default parameters based on footage (can always override with parameters)


level = 2 # recommended starting point
fmt= "video" # "video, "film", "balanced", "auto"
corr = "medium" # "low", "medium", "good"

super = PMOyster.Super(clip, pel=2)
ref = PMOyster.Basic(clip, super=super, format=fmt, correction=corr)

clip = PMOyster.Deringing(clip, ref, format=sf, correction=corr, level=level)
#clip = PMOyster.Destaircase(clip, ref, format=sf, correction=corr, level=level)
#clip = PMOyster.Deblocking(clip, ref, format=sf, correction=corr, level=level)

[yuygfgg]

Normally, single precision mvtools should be faster than normal mvtools. Why do you expect it to be faster with normal mvtools?
(Yes, using 16bit mvtools should be possible.)
I didn't test myself but I saw this PR: https://github.com/Jaded-Encoding-Thaumaturgy/vs-jetpack/pull/188

which says "float plugin is unusably slow and full of bugs...".

And mvsf doesn't have simd while normal mvtools contains optimizations from x264.

[Selur]

regarding using mvtools:
try https://pastebin.com/uiBrKWSM

tested it with:
import PMOyster2

# Convert original clip to 32-bit float YUV444
clip = core.resize.Bicubic(clip, format=vs.YUV444P16, matrix_in_s="470bg", range_in_s="limited")

level = 2 # recommended starting point
fmt= "video" # "video, "film", "balanced", "auto"
corr = "medium" # "low", "medium", "good"

super = PMOyster2.Super(clip, pel=2)
ref = PMOyster2.Basic(clip, super=super, format=fmt, correction=corr)
clip = PMOyster2.Deringing(clip, ref, format=fmt, correction=corr, level=level)