Mdegrain with SVPflow problem

[DTL]

"get more motion blur added in moving parts"

In theory the thSAD is scaled internally to at the changing of block size. So the disadvantages of 16x16 block should be mostly on the angled luma/chroma transients. But large flat enough areas should be identical with 8x8 block. Have you adjust the thSAD value for the best ratio of blur vs degraining ?

For some 'drafting' work the 'PredictorType=4' mode may be used. It is sort of 'checked/refined pel=0.5 (or 0.25?)/ interpolated (predicted) pel = 1' and simply outputs prediction of level 1 without any search at largest and slowest level 0. So it close to use full-HD sized MAnalyse with UHD-1 (4K) sized source for MDegrain. The speed is in theory about 4 times faster. But unfortunately speed of MDegrain itself also not very great yet and with infinitely fast MAnalyse it become main limiting. I hope its stable enough example available at build - https://drive.google.com/file/d/1kMcDG7v5lb3HM2PFMFwrGs2H8JBx3Pl1/view .
Using optPredictorType=4 require re-adjusting thSAD to about 1.5 times lower because SAD from level 1 (half HV sized) typically lower in compare with level 0.

[hello_hello]

anton_foy,
Something else you might want to try...
Expanding a limited range source to full range for MAnalyse seems to be common in functions these days. I've been meaning to add it for a while but never got round to it. It might compensate for reducing the bitdepth though. I don't know, but I added some new arguments to FastDegrain and MDegrainNL for MAnalyse bitdepth and range, and while I was at it I added Degrain4/5/6 to FastDegrain, in case you want to encode even slower. :)

# ===============================================================================
# ===============================================================================
# MDegrainNL (MDegrainN Light) 2021-12-09
# ===============================================================================
# ===============================================================================

function MDegrainNL(clip Source, \
int "TR", int "thSAD", int "thSAD2", int "BLKSize", int "Overlap", int "Pel", bool "Precise", \
bool "TrueM", bool "GlobalM", bool "Exp", bool "SBits", int "BitD", int "lambda", int "pnew", bool "MT", bool "LSB") {

TR = default(TR, 1) # Temporal radius
thSAD = default(thSAD, 150) # Denoising strength
BLKSize = default(BLKSize, 16) # Block size
Overlap = default(Overlap, BLKSize/2) # Block overlap
Pel = default(Pel, 2) # MVAnalyse pel (1, 2, 4)
Precise = default(Precise, false) # Recalculate
TrueM = default(TrueM, false) # Enable/disable truemotion
GlobalM = default(GlobalM, true) # Enable/disable global motion
Exp = default(Exp, true) # Limited->Full range expansion for MAnalyse search
SBits = default(SBits, false) # Use source bitdepth for MAnalyse search
BitD = default(BitD, 8) # Bit depth for MAnalyse search (max = source bits)
MT = default(MT, false) # Internal multithreading
LSB = default(LSB, false) # Stacked 16-bit

# Uncommenting the two lines below results in the same MVTools2 settings as QTGMC when truemotion=false
# lambda = default(lambda, (TrueM ? 1000 : 100 ) * BLKSize * BLKSize / 64)
# pnew = default(pnew, TrueM ? 50 : 25)

# -------------------------------------------------------------------------------

AvsVerStrLC = LCase(VersionString())
IsAvsPlus = (FindStr(AvsVerStrLC, "avisynth+") > 0)
IsAvsNeo = (FindStr(AvsVerStrLC, "avisynth neo") > 0)
AvsStrNum = IsAvsPlus || IsAvsNeo ? FindStr(AvsVerStrLC, "(r") + 2 : 0
AvsBuildNum = (AvsStrNum > 2) ? int(value(MidStr(AvsVerStrLC, AvsStrNum))) : 0
IsAvsHBD = (AvsBuildNum > 2294)

# -------------------------------------------------------------------------------

Super = MSuper(Source, pel=Pel, mt=MT)

Search = Exp ? Super.ColorYUV(levels="TV->PC") : Super
Search = IsAvsHBD && !SBits && (BitD < BitsPerComponent(Source)) ? Search.ConvertBits(BitD) : Search

MultiVec1 = MAnalyse(Search, multi=true, delta=TR, blksize=BLKSize, overlap=Overlap, \
truemotion=TrueM, global=GlobalM, lambda=lambda, pnew=pnew, mt=MT)

MultiVec2 = !Precise ? MultiVec1 : \
MRecalculate(Search, MultiVec1, tr=TR, blksize=BLKSize/2, overlap=Overlap/2, \
thSAD=thSAD2, truemotion=TrueM, lambda=lambda, pnew=pnew)

MDegrainN(Source, Super, MultiVec2, TR, thSAD=thSAD, thSAD2=thSAD2, mt=MT, lsb=LSB) }

# ===============================================================================
# ===============================================================================

# ===============================================================================
# ===============================================================================
# FastDegrain 2021-12-09
# ===============================================================================
# ===============================================================================
#
# FastDegrain by Sagekilla
# Easy to use alias for MDegrain 1, 2, or 3
# Features optional sharpening if you should desire
# Required plugins: LSFMod (to enable sharpening) & MVTools2.dll
#
# Changes by Hello_Hello
# Updated the required plugins list
# Added missing "thSAD" argument for MDegrain1, MDegrain2 & MDegrain3
# Added "TrueM" argument and made truemotion=false the default
# Added "GlobalM" argument and made global=true the default
# Added "MT" argument
# Added "Precise" argument
# Added "Exp" argument
# Added "SBits" argument
# Added "BitD" argument
# LimitedSharpenFaster variable "oshot" corrected to "OShoot"
# Replaced LimitedSharpenFaster with LSFMod
# Added "SFirst" argument and moved the sharpening to after the degraining by default
# Changed the default for "Sharp" from 160 to 75
#
# -------------------------------------------------------------------------------
#
# Degrain: MVDegrain 1, 2, or 3. Each is increasingly stronger and slower.
# thSAD: Affects degraining: Low values reduce degraining, high values raise it.
# BLKSize: MVAnalsye blksize. See MVTools documentation for details.
# Overlap: MVAnalyse overlap. Must be even & <= BLKSize/2. Higher values are better & slower.
# Pel: MVAnalyse subpixel accuracy. Higher values give better MVs and lowers speed.
# Precise: Recalculate. It's quite a bit slower.
# Limit: Limits max MVDegrain change. Decrease if you experience artifacts.
# TrueM: Enables truemotion.
# GlobalM: Disables global motion.
# Exp: Limited->Full range expansion for MAnalyse search. Set false for full range source. Default true.
# SBits: For bit depths > 8, use the same bit depth for MAnalyse search as the source. Default false.
# BitD: Bit depth for MAnalyse search when SBits=false. Max = source bits. Default 8.
# MT: Enables internal multithreading.
# Sharp: Enables LSFMod sharpening.
# Str: LSFMod's sharpening strength. Increase for more sharpening.
# SS: Supersampling for LSFMod, values over 1 decrease edge aliasing.
# Sft: Dampens LSFMod sharpening (it weakens the sharpening)
# OShoot: Sharpening limit, increase it too much and it causes haloing.
# SFirst: SFirst=true sharpens before denoising. The default is false.
#
# ===============================================================================
# ===============================================================================

function FastDegrain(clip Source, \
int "Degrain", int "BLKSize", int "thSAD", int "Overlap", int "Pel", bool "Precise", int "Limit", \
bool "TrueM", bool "GlobalM", bool "Exp", bool "SBits", int "BitD", bool "MT", int "lambda", int "pnew", \
bool "Sharp", int "Str", int "SS", int "Sft", int "OShoot", bool "SFirst") {

# -------------------------------------------------------------------------------

Degrain = default(Degrain, 2) # Degraining method (1 - 3)
thSAD = default(thSAD, 400) # MVDegrain thSAD
BLKSize = default(BLKSize, 8) # MAnalyse block size (4, 8, 16)
Overlap = default(Overlap, BLKSize/2) # MVAnalyse block overlap
Pel = default(Pel, 1) # MVAnalyse pel (1, 2, 4)
Precise = default(Precise, false) # Recalculate
Limit = default(Limit, 255) # MVDegrain limit (0 - 255)
TrueM = default(TrueM, false) # Enable/disable truemotion
GlobalM = default(GlobalM, true) # Enable/disable global motion
Exp = default(Exp, true) # Limited->Full range expansion for MAnalyse search
SBits = default(SBits, false) # Use source bitdepth for MAnalyse search
BitD = default(BitD, 8) # Bit depth for MAnalyse search (max = source bits)
MT = default(MT, false) # Internal multithreading (through avstp.dll)
Sharp = default(Sharp, false) # Toggles LSFMod
Str = default(Str, 75) # LSFMod strength
SS = default(SS, 1.5) # LSFMod supersampling
Sft = default(Sft, 30) # LSFMod soft
OShoot = default(OShoot, 1) # LSFMod overshoot
SFirst = default(SFirst, false) # Enable sharpening before denoising

# Uncommenting the two lines below results in the same MVTools2 settings as QTGMC when truemotion=false
# lambda = default(lambda, (TrueM ? 1000 : 100 ) * BLKSize * BLKSize / 64)
# pnew = default(pnew, TrueM ? 50 : 25)

# -------------------------------------------------------------------------------

AvsVerStrLC = LCase(VersionString())
IsAvsPlus = (FindStr(AvsVerStrLC, "avisynth+") > 0)
IsAvsNeo = (FindStr(AvsVerStrLC, "avisynth neo") > 0)
AvsStrNum = IsAvsPlus || IsAvsNeo ? FindStr(AvsVerStrLC, "(r") + 2 : 0
AvsBuildNum = (AvsStrNum > 2) ? int(value(MidStr(AvsVerStrLC, AvsStrNum))) : 0
IsAvsHBD = (AvsBuildNum > 2294)

# -------------------------------------------------------------------------------

Input = !Sharp || !SFirst ? Source : \
Source.LSFMod(strength=Str, ss_x=SS, ss_y=SS, soft=Sft, overshoot=OShoot)

Super = Input.MSuper(pel=Pel, mt=MT)
Search = Exp ? Super.ColorYUV(levels="TV->PC") : Super
Search = IsAvsHBD && !SBits && (BitD < BitsPerComponent(Source)) ? Search.ConvertBits(BitD) : Search

bvec1 = (Degrain >= 1) ? MAnalyse(Search, isb=true, delta=1, blksize=BLKSize, overlap=Overlap, \
truemotion=TrueM, global=GlobalM, lambda=lambda, pnew=pnew, mt=MT) : nop()
bvec2 = (Degrain >= 2) ? MAnalyse(Search, isb=true, delta=2, blksize=BLKSize, overlap=Overlap, \
truemotion=TrueM, global=GlobalM, lambda=lambda, pnew=pnew, mt=MT) : nop()
bvec3 = (Degrain >= 3) ? MAnalyse(Search, isb=true, delta=3, blksize=BLKSize, overlap=Overlap, \
truemotion=TrueM, global=GlobalM, lambda=lambda, pnew=pnew, mt=MT) : nop()
bvec4 = (Degrain >= 4) ? MAnalyse(Search, isb=true, delta=4, blksize=BLKSize, overlap=Overlap, \
truemotion=TrueM, global=GlobalM, lambda=lambda, pnew=pnew, mt=MT) : nop()
bvec5 = (Degrain >= 5) ? MAnalyse(Search, isb=true, delta=5, blksize=BLKSize, overlap=Overlap, \
truemotion=TrueM, global=GlobalM, lambda=lambda, pnew=pnew, mt=MT) : nop()
bvec6 = (Degrain >= 6) ? MAnalyse(Search, isb=true, delta=6, blksize=BLKSize, overlap=Overlap, \
truemotion=TrueM, global=GlobalM, lambda=lambda, pnew=pnew, mt=MT) : nop()

fvec1 = (Degrain >= 1) ? MAnalyse(Search, isb=false, delta=1, blksize=BLKSize, overlap=Overlap, \
truemotion=TrueM, global=GlobalM, lambda=lambda, pnew=pnew, mt=MT) : nop()
fvec2 = (Degrain >= 2) ? MAnalyse(Search, isb=false, delta=2, blksize=BLKSize, overlap=Overlap, \
truemotion=TrueM, lambda=lambda, pnew=pnew, global=GlobalM, mt=MT) : nop()
fvec3 = (Degrain >= 3) ? MAnalyse(Search, isb=false, delta=3, blksize=BLKSize, overlap=Overlap, \
truemotion=TrueM, global=GlobalM, lambda=lambda, pnew=pnew, mt=MT) : nop()
fvec4 = (Degrain >= 4) ? MAnalyse(Search, isb=false, delta=4, blksize=BLKSize, overlap=Overlap, \
truemotion=TrueM, global=GlobalM, lambda=lambda, pnew=pnew, mt=MT) : nop()
fvec5 = (Degrain >= 5) ? MAnalyse(Search, isb=false, delta=5, blksize=BLKSize, overlap=Overlap, \
truemotion=TrueM, lambda=lambda, pnew=pnew, global=GlobalM, mt=MT) : nop()
fvec6 = (Degrain >= 6) ? MAnalyse(Search, isb=false, delta=6, blksize=BLKSize, overlap=Overlap, \
truemotion=TrueM, global=GlobalM, lambda=lambda, pnew=pnew, mt=MT) : nop()

# -------------------------------------------------------------------------------

Precise ? Eval("""

bvec1 = (Degrain >= 1) ? MRecalculate(Search, bvec1, blksize=BLKSize/2, overlap=Overlap/2, \
thSAD=thSAD/2, truemotion=TrueM, lambda=lambda, pnew=pnew) : nop()
bvec2 = (Degrain >= 2) ? MRecalculate(Search, bvec2, blksize=BLKSize/2, overlap=Overlap/2, \
thSAD=thSAD/2, truemotion=TrueM, lambda=lambda, pnew=pnew) : nop()
bvec3 = (Degrain >= 3) ? MRecalculate(Search, bvec3, blksize=BLKSize/2, overlap=Overlap/2, \
thSAD=thSAD/2, truemotion=TrueM, lambda=lambda, pnew=pnew) : nop()
bvec4 = (Degrain >= 4) ? MRecalculate(Search, bvec4, blksize=BLKSize/2, overlap=Overlap/2, \
thSAD=thSAD/2, truemotion=TrueM, lambda=lambda, pnew=pnew) : nop()
bvec5 = (Degrain >= 5) ? MRecalculate(Search, bvec5, blksize=BLKSize/2, overlap=Overlap/2, \
thSAD=thSAD/2, truemotion=TrueM, lambda=lambda, pnew=pnew) : nop()
bvec6 = (Degrain >= 6) ? MRecalculate(Search, bvec6, blksize=BLKSize/2, overlap=Overlap/2, \
thSAD=thSAD/2, truemotion=TrueM, lambda=lambda, pnew=pnew) : nop()

fvec1 = (Degrain >= 1) ? MRecalculate(Search, fvec1, blksize=BLKSize/2, overlap=Overlap/2, \
thSAD=thSAD/2, truemotion=TrueM, lambda=lambda, pnew=pnew) : nop()
fvec2 = (Degrain >= 2) ? MRecalculate(Search, fvec2, blksize=BLKSize/2, overlap=Overlap/2, \
thSAD=thSAD/2, truemotion=TrueM, lambda=lambda, pnew=pnew) : nop()
fvec3 = (Degrain >= 3) ? MRecalculate(Search, fvec3, blksize=BLKSize/2, overlap=Overlap/2, \
thSAD=thSAD/2, truemotion=TrueM, lambda=lambda, pnew=pnew) : nop()
fvec4 = (Degrain >= 4) ? MRecalculate(Search, fvec4, blksize=BLKSize/2, overlap=Overlap/2, \
thSAD=thSAD/2, truemotion=TrueM, lambda=lambda, pnew=pnew) : nop()
fvec5 = (Degrain >= 5) ? MRecalculate(Search, fvec5, blksize=BLKSize/2, overlap=Overlap/2, \
thSAD=thSAD/2, truemotion=TrueM, lambda=lambda, pnew=pnew) : nop()
fvec6 = (Degrain >= 6) ? MRecalculate(Search, fvec6, blksize=BLKSize/2, overlap=Overlap/2, \
thSAD=thSAD/2, truemotion=TrueM, lambda=lambda, pnew=pnew) : nop()

""") : nop()

# -------------------------------------------------------------------------------

Output = \
(Degrain < 1) ? Input : \
(Degrain == 1) ? \
MDegrain1(Input, Super, bvec1, fvec1, \
thSAD=thSAD, limit=Limit) : \
(Degrain == 2) ? \
MDegrain2(Input, Super, bvec1, fvec1, bvec2, fvec2, \
thSAD=thSAD, limit=Limit) : \
(Degrain == 3) ? \
MDegrain3(Input, Super, bvec1, fvec1, bvec2, fvec2, bvec3, fvec3, \
thSAD=thSAD, limit=Limit) : \
(Degrain == 4) ? \
MDegrain4(Input, Super, bvec1, fvec1, bvec2, fvec2, bvec3, fvec3, bvec4, fvec4, \
thSAD=thSAD, limit=Limit) : \
(Degrain == 5) ? \
MDegrain5(Input, Super, bvec1, fvec1, bvec2, fvec2, bvec3, fvec3, bvec4, fvec4, bvec5, fvec5, \
thSAD=thSAD, limit=Limit) : \
(Degrain >= 6) ? \
MDegrain6(Input, Super, bvec1, fvec1, bvec2, fvec2, bvec3, fvec3, bvec4, fvec4, bvec5, fvec5, bvec6, fvec6, \
thSAD=thSAD, limit=Limit) : nop()

Output = \
!Sharp || SFirst ? Output : Output.LSFMod(strength=Str, ss_x=SS, ss_y=SS, soft=Sft, overshoot=OShoot)

return Output }

# ===============================================================================
# ===============================================================================
# FastDegrainSharp
# ===============================================================================
# ===============================================================================

function FastDegrainSharp(clip Source, \
int "Degrain", int "BLKSize", int "thSAD", int "Overlap", int "Pel", bool "Precise", int "Limit", \
bool "TrueM", bool "GlobalM", bool "Exp", bool "SBits", int "BitD", bool "MT", int "lambda", int "pnew", \
bool "Sharp", int "Str", int "SS", int "Sft", int "OShoot", bool "SFirst") {

Sharp = default(Sharp, true)

FastDegrain(Source, Degrain, BLKSize, thSAD, Overlap, Pel, Precise, Limit, \
TrueM, GlobalM, Exp, SBits, BitD, lambda, pnew, MT, Sharp, Str, SS, Sft, OShoot, SFirst) }

# ===============================================================================
# ===============================================================================

[anton_foy]

"get more motion blur added in moving parts"

In theory the thSAD is scaled internally to at the changing of block size. So the disadvantages of 16x16 block should be mostly on the angled luma/chroma transients. But large flat enough areas should be identical with 8x8 block. Have you adjust the thSAD value for the best ratio of blur vs degraining ?

For some 'drafting' work the 'PredictorType=4' mode may be used. It is sort of 'checked/refined pel=0.5 (or 0.25?)/ interpolated (predicted) pel = 1' and simply outputs prediction of level 1 without any search at largest and slowest level 0. So it close to use full-HD sized MAnalyse with UHD-1 (4K) sized source for MDegrain. The speed is in theory about 4 times faster. But unfortunately speed of MDegrain itself also not very great yet and with infinitely fast MAnalyse it become main limiting. I hope its stable enough example available at build - https://drive.google.com/file/d/1kMcDG7v5lb3HM2PFMFwrGs2H8JBx3Pl1/view .
Using optPredictorType=4 require re-adjusting thSAD to about 1.5 times lower because SAD from level 1 (half HV sized) typically lower in compare with level 0.

Thank you! Very interesting. But where can I find any documentation on how to use optPredictorType=4? Is it used in MAnalyse?

anton_foy,
Something else you might want to try...
Expanding a limited range source to full range for MAnalyse seems to be common in functions these days. I've been meaning to add it for a while but never got round to it. It might compensate for reducing the bitdepth though. I don't know, but I added some new arguments to FastDegrain and MDegrainNL for MAnalyse bitdepth and range, and while I was at it I added Degrain4/5/6 to FastDegrain, in case you want to encode even slower.

Thank you! That is great, I tried both scripts, FastDegrain works great Fastdegrain(degrain=3,bitd=8,globalm=false,thsad=300) speed = 0.029x so pretty fast! Although it is very different in appearence to my old FastDegrain script because it is softer overall. The MDegrainNL is not working at all sadly I get allocated memory error.

[DTL]

Is it used in MAnalyse?"

Yes. Archive have compiled version SO1_PT4 with hardcoded PredictorType=4 option for users without ability to edit complicated scripts. So you can simply load this dll. It also have some simple optimizations for CPUs up to SSE4.1.

[anton_foy]

Is it used in MAnalyse?"

Yes. Archive have compiled version SO1_PT4 with hardcoded PredictorType=4 option for users without ability to edit complicated scripts. So you can simply load this dll. It also have some simple optimizations for CPUs up to SSE4.1.

Yes it works! I get the impression it keeps a little more details but speed is 0.0375x with this script:
# FastDegrain - MOD #

function FastDegrain( clip src, int "degrain", int "blksize", int "overlap", int "pel",
\ int "thSAD", int "limit", bool "MT")
{
degrain = default( degrain, 2 ) # Degraining method (1 - 3)
blksize = default( blksize, 8 ) # MAnalyse block size (4, 8, 16)
overlap = default( overlap, blksize/2 ) # MVAnalyse block overlap (even, ov<=blksize/2)
pel = default( pel, 1 ) # MVAnalyse pel (1, 2, 4)
thSAD = default( thSAD, 400 ) # MVDegrain thSAD
limit = default( limit, 255 ) # MVDegrain limit (0 - 255)
MT = default( MT, false) # Internal multithreading (through avstp.dll)

# Create our Super clip for MV search. Then, search for motion vectors.
super8 = src.convertbits(8).ex_KNLMeansCL(D=1, A=2, h=6, s=2, device_type="gpu").MSuper(pel=pel)
super = src.MSuper(pel=pel)
bvec3 = (degrain>=3) ? super8.MAnalyse(isb=true, delta=3, blksize=blksize, overlap=overlap, mt=MT, PredictorType=4) : NOP()
bvec2 = (degrain>=2) ? super8.MAnalyse(isb=true, delta=2, blksize=blksize, overlap=overlap, mt=MT, PredictorType=4) : NOP()
bvec1 = (degrain>=1) ? super8.MAnalyse(isb=true, delta=1, blksize=blksize, overlap=overlap, mt=MT, PredictorType=4) : NOP()
fvec1 = (degrain>=1) ? super8.MAnalyse(isb=false, delta=1, blksize=blksize, overlap=overlap, mt=MT, PredictorType=4) : NOP()
fvec2 = (degrain>=2) ? super8.MAnalyse(isb=false, delta=2, blksize=blksize, overlap=overlap, mt=MT, PredictorType=4) : NOP()
fvec3 = (degrain>=3) ? super8.MAnalyse(isb=false, delta=3, blksize=blksize, overlap=overlap, mt=MT, PredictorType=4) : NOP()

# Degraining the video using MVDegrain. Nothing special here.
src = (degrain==1) ? src.MDegrain1(super, bvec1, fvec1, thSAD=thSAD, limit=limit) : src
src = (degrain==2) ? src.MDegrain2(super, bvec1, fvec1, bvec2, fvec2, thSAD=thSAD, limit=limit) : src
src = (degrain>=3) ? src.MDegrain3(super, bvec1, fvec1, bvec2, fvec2, bvec3, fvec3, thSAD=thSAD, limit=limit) : src

return src
}

With this script its 0.0378x. So very close speedwise:

# FastDegrain - MOD #

function FastDegrain( clip src, int "degrain", int "blksize", int "overlap", int "pel",
\ int "thSAD", int "limit", bool "MT")
{
degrain = default( degrain, 2 ) # Degraining method (1 - 3)
blksize = default( blksize, 8 ) # MAnalyse block size (4, 8, 16)
overlap = default( overlap, blksize/2 ) # MVAnalyse block overlap (even, ov<=blksize/2)
pel = default( pel, 1 ) # MVAnalyse pel (1, 2, 4)
thSAD = default( thSAD, 400 ) # MVDegrain thSAD
limit = default( limit, 255 ) # MVDegrain limit (0 - 255)
MT = default( MT, false) # Internal multithreading (through avstp.dll)

# Create our Super clip for MV search. Then, search for motion vectors.
super8 = src.convertbits(8).ex_KNLMeansCL(D=1, A=2, h=6, s=2, device_type="gpu").MSuper(pel=pel)
super = src.MSuper(pel=pel)
bvec3 = (degrain>=3) ? super8.MAnalyse(isb=true, delta=3, blksize=blksize, overlap=overlap, mt=MT) : NOP()
bvec2 = (degrain>=2) ? super8.MAnalyse(isb=true, delta=2, blksize=blksize, overlap=overlap, mt=MT) : NOP()
bvec1 = (degrain>=1) ? super8.MAnalyse(isb=true, delta=1, blksize=blksize, overlap=overlap, mt=MT) : NOP()
fvec1 = (degrain>=1) ? super8.MAnalyse(isb=false, delta=1, blksize=blksize, overlap=overlap, mt=MT) : NOP()
fvec2 = (degrain>=2) ? super8.MAnalyse(isb=false, delta=2, blksize=blksize, overlap=overlap, mt=MT) : NOP()
fvec3 = (degrain>=3) ? super8.MAnalyse(isb=false, delta=3, blksize=blksize, overlap=overlap, mt=MT) : NOP()

# Degraining the video using MVDegrain. Nothing special here.
src = (degrain==1) ? src.MDegrain1(super, bvec1, fvec1, thSAD=thSAD, limit=limit) : src
src = (degrain==2) ? src.MDegrain2(super, bvec1, fvec1, bvec2, fvec2, thSAD=thSAD, limit=limit) : src
src = (degrain>=3) ? src.MDegrain3(super, bvec1, fvec1, bvec2, fvec2, bvec3, fvec3, thSAD=thSAD, limit=limit) : src

return src
}

EDIT: THSAD=200 makes it freeze every time for me.
For a speed check, using my script commenting out everything but convertbits(16), Levels, ConverttoYUV444() and convertbits(10) has a speed of 0.0562x

[hello_hello]

Fastdegrain(degrain=3,bitd=8,globalm=false,thsad=300) speed = 0.029x so pretty fast! Although it is very different in appearence to my old FastDegrain script because it is softer overall.

It's probably related to a truemotion setting (truemotion and global motion are enabled by default). And maybe the reduction in bitdepth or expansion of levels for MAnalyse. You'd need to change them one at a time to find out what's causing it to look softer. There's no reason why the scripts should run at different speeds if the settings are identical.

I downloaded your original script from post # 26. The only changes I made were to add the missing thSAD arguments and the MT argument so I could enable/disable MT easily, and I changed the name to FDegrain so I could put it in the auto-loading folder and run both versions, then I did a comparison with the version I posted yesterday. When the settings are the same they're exactly the same.

A = FastDegrain(degrain=3, TrueM=true, thsad=300, Sbits=true, Exp=false)
B = FDegrain(degrain=3, thsad=300)
ShowDiff(A, B, Amp=true)

https://i.postimg.cc/F7qzfWQz/same.jpg (https://postimg.cc/F7qzfWQz)

As a side note, enabling internal multithreading definitely changes the output, although when it's enabled for both versions the result is still the same.

A = FastDegrain(degrain=3, TrueM=true, thsad=300, Sbits=true, Exp=false, MT=true)
B = FDegrain(degrain=3, thsad=300, MT=false)
ShowDiff(A, B, Amp=true)

https://i.postimg.cc/TLR38Bn7/mt-true.jpg (https://postimg.cc/TLR38Bn7)

I ran a couple of test encodes with Exp=true. Expanding the levels for MAnalyse obviously makes a difference. I think it does retain a tad more detail during motion but it probably removes a little less noise during motion too.
The bitrate of the encode was a little lower than with Exp=false for both tests, so I think I'll keep using Exp=true.

A = FastDegrain(degrain=3, TrueM=true, thsad=300, Sbits=true, Exp=true, MT=false)
B = FDegrain(degrain=3, thsad=300, MT=false)
ShowDiff(A, B, Amp=true)

https://i.postimg.cc/Cn5M5DPb/exp.jpg (https://postimg.cc/Cn5M5DPb)

The MDegrainNL is not working at all sadly I get allocated memory error.

I'm not sure what the deal is with MDegrainNL. It's working here. Maybe it relates to the version of MVTools2 you're testing.

function ShowDiff(clip Clip1, clip Clip2, val "Amp", val "Comp", val "Show") {

Amp = defined(Amp) && IsInt(Amp) ? ((Amp == 0) ? false : true) : default(Amp, false)
Show = defined(Show) && IsInt(Show) ? ((Show == 0) ? false : true) : default(Show, false)
Comp = defined(Comp) && IsInt(Comp) ? ((Comp == 0) ? false : true) : default(Comp, false)

assert((IsInt(Amp) || IsBool(Amp)) && (IsInt(Comp) || IsBool(Comp)) && (IsInt(Show) || IsBool(Show)), \
" ShowDiff " + chr(10) + """ "Amp", "Comp" & "Show", can only be integer or bool. """ + chr(10) + \
" For Integer: Zero specifies false, and any other integer specifies true. " + chr(10) + \
" For Bool: They be true or false. " + chr(10))

C1 = Clip1.levels(96, 1.0, 160, 96, 160).GreyScale()
C2 = Subtract(Clip1, Clip2)
C3 = !Amp ? C2 : C2.levels(124, 1.0, 131, 0, 255)
C4 = !Show ? C3 : Merge(C1, C3)
C5 = !Comp ? C4 : Compare(Clip1, Clip2, show_graph=true)

return C5 }

function FDegrain( clip src, int "degrain", int "blksize", int "overlap", int "pel",
\ int "thSAD", int "limit", bool "MT")
{
degrain = default( degrain, 2 ) # Degraining method (1 - 3)
blksize = default( blksize, 8 ) # MAnalyse block size (4, 8, 16)
overlap = default( overlap, blksize/2 ) # MVAnalyse block overlap (even, ov<=blksize/2)
pel = default( pel, 1 ) # MVAnalyse pel (1, 2, 4)
thSAD = default( thSAD, 400 ) # MVDegrain thSAD
limit = default( limit, 255 ) # MVDegrain limit (0 - 255)
MT = default( MT, false ) # Internal multithreading (through avstp.dll)

# Create our Super clip for MV search. Then, search for motion vectors.
super = src.MSuper(pel=pel, mt=MT)
bvec3 = (degrain>=3) ? super.MAnalyse(isb=true, delta=3, blksize=blksize, overlap=overlap, mt=MT) : NOP()
bvec2 = (degrain>=2) ? super.MAnalyse(isb=true, delta=2, blksize=blksize, overlap=overlap, mt=MT) : NOP()
bvec1 = (degrain>=1) ? super.MAnalyse(isb=true, delta=1, blksize=blksize, overlap=overlap, mt=MT) : NOP()
fvec1 = (degrain>=1) ? super.MAnalyse(isb=false, delta=1, blksize=blksize, overlap=overlap, mt=MT) : NOP()
fvec2 = (degrain>=2) ? super.MAnalyse(isb=false, delta=2, blksize=blksize, overlap=overlap, mt=MT) : NOP()
fvec3 = (degrain>=3) ? super.MAnalyse(isb=false, delta=3, blksize=blksize, overlap=overlap, mt=MT) : NOP()

# Degraining the video using MVDegrain. Nothing special here.
src = (degrain==1) ? src.MDegrain1(super, bvec1, fvec1, thSAD=thSAD, limit=limit, mt=MT) : src
src = (degrain==2) ? src.MDegrain2(super, bvec1, fvec1, bvec2, fvec2, thSAD=thSAD, limit=limit, mt=MT) : src
src = (degrain>=3) ? src.MDegrain3(super, bvec1, fvec1, bvec2, fvec2, bvec3, fvec3, thSAD=thSAD, limit=limit, mt=MT) : src

return src
}

[DTL]

THSAD=200 makes it freeze"

Something very strange happens. Adjusting thSAD should not cause any visible change in speed or freeze. Also typical adjustments steps may be 50..25 or less to finetune of noise removing vs detail preservation.

The speed still very low - may you do not run avs+ mt with Prefetch() at the end of script ? May your system is too low on RAM to process UHD and system running in swapping pages to slow HDD ?

[Boulder]

With UHD resolutions, MVTools functions and Prefetch, you may need to increase the maximum cache size from the default to avoid any performance hits.

[anton_foy]

THSAD=200 makes it freeze"

Something very strange happens. Adjusting thSAD should not cause any visible change in speed or freeze. Also typical adjustments steps may be 50..25 or less to finetune of noise removing vs detail preservation.

The speed still very low - may you do not run avs+ mt with Prefetch() at the end of script ? May your system is too low on RAM to process UHD and system running in swapping pages to slow HDD ?

Yes it is strange even without any filters (except levels) it is running at 0.06x.
My RAM is 32gb ddr3 or do you refer to VRAM?

[anton_foy]

With UHD resolutions, MVTools functions and Prefetch, you may need to increase the maximum cache size from the default to avoid any performance hits.

Oh thanks but how do I do that? I will in the coming days recieve a better cpu aswell but I also think something else is the bottleneck.

[StainlessS]

Oh thanks but how do I do that?
http://avisynth.nl/index.php/Internal_functions#SetMemoryMax

[anton_foy]

http://avisynth.nl/index.php/Internal_functions#SetMemoryMax

Oops! Thanks! I should read up alot more I was not aware of the "setcachemode" parameter. I will try to laborate with "setmemorymax" and so on.

[Boulder]

I use cache mode 1 and max cache size 20480 (overkill just to be sure). My MVTools-included scripts use around 10GB of memory when encoding.

[anton_foy]

I use cache mode 1 and max cache size 20480 (overkill just to be sure). My MVTools-included scripts use around 10GB of memory when encoding.

Thank you! Do you use mvtools with or without "mt=true"?

[DTL]

"with or without "mt=true"?"

To disable internal mt you need to set mt=false in both MAnalyse and MDegrain or remove avstp.dll from any search path. It may be present in plugins folder or system or somewhere else.

[Boulder]

Always without any plugin-related multithreading, so I've remove avstp.dll from all folders to prevent it.

[anton_foy]

Always without any plugin-related multithreading, so I've remove avstp.dll from all folders to prevent it.

Removed avstp.dll but I found the bigger bottleneck my hdd. Replaced my external usb 3.0 hdd to an internal ssd and now I get about 5 fps with fastdegrain(degrain=3) and 3-4 fps with basiq(preset="high") when boosting prefetch(16)! Probably no good at 16 for longer clips I only tested with 20 frames long clip yet.

Edit: fastdegrain_svp(degrain=3, gpu=true) is still a bit slower (~3fps) than fastdegrain.

[Boulder]

It could be useful to set the number of threads to the amount you have and then limit the number of prefetched frames. I use Prefetch(threads=24, frames=12) on my 3900X.

[anton_foy]

It could be useful to set the number of threads to the amount you have and then limit the number of prefetched frames. I use Prefetch(threads=24, frames=12) on my 3900X.

Great thanks I will do this!