descale stuff (resource)

from vapoursynth import core
import vapoursynth as vs
import kagefunc as kgf
import fvsfunc as fvf
import mvsfunc as mvf

w, h = 1280, 720
b, c = 1/3, 1/3

# Input clip
src8 = core.lsmas.LWLibavSource(r'C:\00000.m2ts')

# Normal luma downscale
res = src8.resize.Spline16(w, h, format=vs.GRAY16)

# Descale clips
srcy = src8.resize.Point(format=vs.GRAYS)
deb = srcy.descale.Debicubic(w, h, b, c)
reb = deb.resize.Bicubic(1920, 1080, filter_param_a=b, filter_param_b=c)
dif = srcy.std.MakeDiff(reb)
deb = fvf.Depth(deb, 16)

""" Mask error - change the Binarize threshold or amount of Maximum/Inflate calls
msk = dif.std.Expr('x abs')
msk = msk.std.Binarize(10/219)
msk = msk.fmtc.bitdepth(bits=8, fulld=1, dmode=2)
msk = msk.resize.Bilinear(w, h)
msk = msk.std.Binarize(4)
msk = kgf.iterate(msk, core.std.Maximum, 1)
msk = kgf.iterate(msk, core.std.Inflate, 2)
msk = msk.std.Expr('x 257 *', vs.GRAY16)
deb = deb.std.MaskedMerge(res, msk)
"""


""" Mask lines
msk = deb.std.Prewitt().std.Binarize(24 << 8)
if c >= 0.75:
    msk = msk.std.Maximum(coordinates=[0,1,0,1,1,0,1,0])
msk = msk.std.Convolution([1]*9)
deb = res.std.MaskedMerge(deb, msk)
"""


""" Runtime filtering - just change "conditionalfilter" to do whatever you want
err = dif.std.Crop(5,5,5,5)
err = err.rgsf.RemoveGrain(1)
err = err.std.Expr('x abs {e} <= 0 x 0 > x {e} - x {e} + ? ? 0.5 +'.format(e=1/219))
err = fvf.Depth(err, 8, range=1)
err = err.hist.Luma()
err = err.std.PlaneStats()

#mvf.ShowAverage(err).set_output() # the number shown is f.props.PlaneStatsAverage / 255

def conditionalfilter(n, f, thr=0.05/255):
    if f.props.PlaneStatsAverage < thr:
        return deb
    else:
        alpha = (f.props.PlaneStatsAverage - 0.05/255) * 510 + 0.2
        alpha = min(0.2, max(0.5, alpha) )
        return taa.TAAmbk(deb, aatype='Eedi3', alpha=alpha, mclip=msk)
deb = deb.std.FrameEval(conditionalfilter, prop_src=err)
"""

srcy = deb

# Merge chroma

""" Keep 4:2:0
srcuv = src8.fmtc.resample(w, h, planes=[1,3,3])
out = core.std.ShufflePlanes([srcy,srcuv], [0,1,2], vs.YUV)
"""

""" Convert to 4:4:4
def chroma_upscale(clip, w, h):
    nnedi3 = core.znedi3 if hasattr(core, 'znedi3') else core.nnedi3
    clip = nnedi3.nnedi3(clip.std.Transpose(), 1, 1, 0, 0, 3, 2)
    clip = nnedi3.nnedi3(clip.std.Transpose(), 1, 1, 0, 0, 3, 2)
    return clip.resize.Spline36(w, h, src_top=-0.5)
srcuv = src8.fmtc.bitdepth(bits=16, planes=[1,2])
srcu, srcv = kgf.split(srcuv)[1:]
srcu, srcv = [chroma_upscale(clip, w, h) for clip in (srcu, srcv)]
out = core.std.ShufflePlanes([srcy,srcu,srcv], [0]*3, vs.YUV)
"""