def main(self: Filtering) -> vs.VideoNode: # noqa
"""Vapoursynth filtering"""
src = WEB.clip_cut
src = src.std.AssumeFPS(src)
src = depth(src, 16)
out = src
denoise = hvf.SMDegrain(out, tr=1, thSAD=100, thSADC=100)
out = denoise
dering = hvf.EdgeCleaner(out, 15, smode=1, hot=True)
dering = gf.MaskedDHA(dering, darkstr=0.05, brightstr=0.75)
out = dering
aaa = vdf.scale.nnedi3_upscale(get_y(out), pscrn=1, correct_shift=False)
aaa = aaa.resize.Bicubic(1920, 1080, src_left=0.5, src_top=0.5, filter_param_a=-0.5, filter_param_b=0.25)
out = vdf.misc.merge_chroma(aaa, out)
cwarp = xvs.WarpFixChromaBlend(out, 64, depth=4)
out = cwarp
detail_mask = lvf.mask.detail_mask(out, brz_a=2250, brz_b=1200)
deband = vdf.deband.dumb3kdb(out, 16, threshold=33, grain=[24, 0])
deband = core.std.MaskedMerge(deband, out, detail_mask)
out = deband
return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2], [0, 1, 2])[:100]
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
src = depth(src, 16)
out = src
ref = hvf.SMDegrain(out, thSAD=300)
denoise = mvf.BM3D(out, [1.5, 1.25], radius1=1, ref=ref)
out = denoise
crop = core.std.Crop(out, left=12)
crop = awf.bbmod(crop, left=2, thresh=20 << 8)
resize = core.resize.Bicubic(crop, 1920)
out = lvf.rfs(out, resize, [(78, 89)])
y = get_y(out)
lineart = gf.EdgeDetect(y, 'scharr').morpho.Dilate(2, 2).std.Inflate()
fkrescale = fake_rescale(
y, 882, 0, 1,
deringer=lambda x: gf.MaskedDHA(x, rx=1.85, ry=1.85, darkstr=0.25, brightstr=1.0, maskpull=100, maskpush=200),
antialiser=lambda c: lvf.sraa(c, 2, 13, downscaler=core.resize.Bicubic)
)
merged = core.std.MaskedMerge(y, fkrescale, lineart)
out = vdf.merge_chroma(merged, out)
dering = hvf.EdgeCleaner(out, 17, smode=1, hot=True)
out = dering
out = lvf.rfs(
out, denoise,
[(0, 11), (38, 77), (115, 133), (316, 395), (441, 460), (606, 779), (825, 844), (990, 1127)]
)
detail_mask = lvf.mask.detail_mask(out, brz_a=2250, brz_b=1000)
deband = vdf.dumb3kdb(out, 15, threshold=17, grain=(24, 0))
deband = core.std.MaskedMerge(deband, out, detail_mask)
out = deband
grain = adptvgrnMod(out, 0.3, static=True, grain_chroma=False, hi=[128, 240], seed=333)
out = grain
decz = vdf.decsiz(out, min_in=128 << 8, max_in=200 << 8)
out = decz
return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2], [0, 1, 2])
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Main VapourSynth filterchain"""
import havsfunc as haf
import lvsfunc as lvf
import vardefunc as vdf
from ccd import ccd
from vsutil import depth
src = JP_BD.clip_cut
cloc = core.resize.Bicubic(src, chromaloc_in=2, chromaloc=0)
src = depth(cloc, 16)
halo_mask = lvf.mask.halo_mask(src, rad=1, brz=0.85, thmi=0.35, thma=0.95)
halo_mask = halo_mask.std.Maximum().std.Inflate()
bidehalo = lvf.dehalo.bidehalo(src,
sigmaR=8 / 255,
sigmaS=2.0,
sigmaS_final=1.5)
dehalo_den = core.dfttest.DFTTest(bidehalo, sigma=8.0)
dehalo_clean = haf.EdgeCleaner(dehalo_den, strength=8, smode=1, hot=True)
dehalo = core.std.MaskedMerge(src, dehalo_clean, halo_mask)
# Certain cuts have a strong camera effect that amplifies haloing, and is likely intentional
dehalo = lvf.rfs(dehalo, src, [(773, 786), (867, 886)])
denoise = core.dfttest.DFTTest(dehalo, sigma=1.75)
cdenoise = ccd(denoise, threshold=4, matrix='709')
decs = vdf.noise.decsiz(cdenoise,
sigmaS=8.0,
min_in=208 << 8,
max_in=232 << 8)
baa = lvf.aa.based_aa(decs, str(shader_file))
sraa = lvf.sraa(decs, rfactor=1.45)
clmp = lvf.aa.clamp_aa(decs, baa, sraa, strength=1.45)
darken = haf.FastLineDarkenMOD(clmp, strength=12)
# Debanding and graining
deband = flt.masked_f3kdb(darken, rad=18, thr=[24, 20])
grain = vdf.noise.Graigasm(thrs=[x << 8 for x in (32, 80, 128, 176)],
strengths=[(0.20, 0.0), (0.15, 0.0),
(0.10, 0.0), (0.0, 0.0)],
sizes=(1.20, 1.15, 1.10, 1),
sharps=(70, 60, 50, 50),
grainers=[
vdf.noise.AddGrain(seed=69420,
constant=True),
vdf.noise.AddGrain(seed=69420,
constant=True),
vdf.noise.AddGrain(seed=69420,
constant=True)
]).graining(deband)
return grain
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_clip
src = depth(src, 16)
cleanedge = hvf.EdgeCleaner(src, 15, rmode=1, smode=1, hot=True)
out = cleanedge
deband_mask = lvf.denoise.detail_mask(out, brz_a=2250,
brz_b=1500).std.Median()
deband = dbs.f3kpf(out, 17, 30, 30)
deband = core.std.MaskedMerge(deband, out, deband_mask)
out = deband
freeze = core.std.FreezeFrames(out, 120, src.num_frames - 1, 120)
out = freeze
return depth(out, 10)
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
src = depth(src, 16)
out = src
ref = hvf.SMDegrain(out, thSAD=300)
denoise = mvf.BM3D(out, [1.5, 1.25], radius1=1, ref=ref)
out = denoise
dering = hvf.EdgeCleaner(out, 17, smode=1, hot=True)
out = dering
detail_mask = lvf.mask.detail_mask(out, brz_a=2250, brz_b=1000)
deband = vdf.dumb3kdb(out, 15, threshold=17, grain=(24, 0))
deband = core.std.MaskedMerge(deband, out, detail_mask)
out = deband
grain = adptvgrnMod(out, 0.3, static=True, grain_chroma=False, hi=[128, 240], seed=333)
out = grain
decz = vdf.decsiz(out, min_in=128 << 8, max_in=200 << 8)
out = decz
return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2], [0, 1, 2])
from vapoursynth import core, YUV444P8, YUV420P8
from rekt import rektlvls
import havsfunc as haf
import awsmfunc as awf
import lvsfunc as lvf
import G41Fun
guilstein = core.d2v.Source("Guilstein/VTS_01_1.d2v")[:163645]
guilstein = guilstein.decross.DeCross().dedot.Dedot().resize.Bicubic(format=YUV444P8, matrix_s="170m")
topline = guilstein.vinverse.Vinverse().std.Crop(top=63, bottom=70, left=6, right=6).std.CropAbs(top=1, width=guilstein.width-12, height=2)
guilstein = core.std.MaskedMerge(guilstein.vinverse.Vinverse().std.Crop(top=66, left=6, right=6), guilstein.std.Crop(top=66, left=6, right=6).nnedi3.nnedi3(1), guilstein.std.Crop(top=66, left=6, right=6).comb.CombMask().morpho.Dilate())
guilstein = guilstein.std.Crop(bottom=70)
guilstein = core.std.StackVertical([topline, guilstein])
guilstein = rektlvls(guilstein, rownum=[0, 1], rowval=[50, 10], colnum=[0, 1, 2, 3, 4], colval=[14, 10, 9, -3, -2], prot_val=[16, 235])
guilstein = awf.bbmod(guilstein, right=4, thresh=7, blur=16)
guilstein = core.std.Expr([guilstein, awf.bbmod(guilstein, bottom=3, thresh=2, blur=16)], "x y > x y ?")
guilstein = core.std.Expr([guilstein, awf.bbmod(guilstein, left=8, thresh=1, blur=8)], "x y > x y ?")
guilstein = lvf.aa.upscaled_sraa(guilstein, rfactor=2.0)
guilstein = guilstein.dfttest.DFTTest(sigma=2.0)
guilstein = guilstein.f3kdb.Deband(range=30, grainy=2, grainc=2)
guilstein = G41Fun.MaskedDHA(guilstein, rx=1.6, ry=1.6, darkstr=0.0, brightstr=0.6, lowsens=120, highsens=10)
guilstein = haf.EdgeCleaner(guilstein, strength=10)
guilstein = guilstein.resize.Bicubic(format=YUV420P8, matrix_s="170m")
guilstein = guilstein.std.FreezeFrames(first=[110471], last=[110483], replacement=[110470])
guilstein.set_output()
def main(self) -> vs.VideoNode:
"""Vapoursynth filtering"""
src = JPBD.clip_cut
src = depth(src, 16)
src_cru = WEB_CRU.clip_cut
src_aod = WEB_AOD.clip_cut
# Dehardsubbing using .ass file
masksub = Mask.hardsub_mask(src_aod.std.BlankClip(), SUB, FONTDIR)
dehardsub = core.std.MaskedMerge(src_aod, src_cru, masksub)
src_web = dehardsub
# AoD is poorly rescaled
src_y, src_cru_y, src_web_y = map(get_y, [src, src_cru, src_web])
thr = 10
src_web_y = core.std.Expr([src_web_y, src_cru_y],
f'x y - abs {thr} < x y * sqrt y ?')
src_web_y = depth(src_web_y, 16)
ringrid = core.rgvs.Repair(src_web_y,
src_web_y.std.Convolution([1] * 9), 11)
ringrid = core.std.Expr([ringrid, src_web_y], 'x y min')
# Remove ringing with AoD+CR
ring_mask = Mask.ringing_mask(src_y)
bdweb = core.std.MaskedMerge(src_y, ringrid, ring_mask)
bdweb = lvf.rfs(bdweb, src_web_y, [(64, 1413), (32034, 33195),
(33465, 33881), (34174, 34524)])
out = vdf.misc.merge_chroma(bdweb, src)
# ranges_frames = [
# (64, 131), (215, 292), (339, 410), (444, 515), (566, 657),
# (695, 786), (903, 971), (977, 1045), (1058, 1153), (1278, 1335),
# (1355, 1413)
# ]
# cm = partial(vdf.mask.region_mask, clip=out.std.BlankClip(format=vs.GRAY16, color=65535))
# credit_mask = [
# cm()
# ]
# Restore BD changes
dering_src = hvf.EdgeCleaner(src, 20, hot=True)
diff_mask = Mask.diff_mask((src, src_cru), brz=4750.0)
bdchanges = out
bdchanges = lvf.rfs(bdchanges, dering_src, [(882, 902), (5596, 5701),
(9909, 10064),
(11804, 11864)])
bdchanges = lvf.rfs(bdchanges,
core.std.MaskedMerge(out, dering_src, diff_mask),
[(2534, 2682), (2840, 2887), (3188, 3271),
(3818, 3859), (3986, 4087), (4499, 4618),
(5009, 5088), (14736, 14801), (15744, 15872),
(17106, 17135), (17913, 18143), (24247, 24438),
(33196, 33329), (34021, 34173)])
# return bdchanges, diff_mask
out = bdchanges
ref = Denoise.ref_denoise(get_y(out), tr=1)
denoise = Denoise.hybrid_denoise(depth(out, 32),
knlm_h=0.15,
sigma=1,
knlm_args=dict(d=1, a=3, s=3),
bm3d_args=dict(ref=depth(ref, 32)))
denoise = depth(denoise, 16)
out = denoise
pre = get_y(out)
# Remove haloing
dehalo = gf.MaskedDHA(pre,
rx=1.4,
ry=1.4,
darkstr=0.1,
brightstr=1.0,
maskpull=40,
maskpush=255)
bila = core.bilateral.Bilateral(dehalo, sigmaS=1, sigmaR=0.08)
dehalorp = core.rgvs.Repair(dehalo, bila, 13)
dehalo = core.std.MaskedMerge(dehalo, dehalorp,
ring_mask.std.Maximum(), 0)
dehalo = core.std.Expr([dehalo, pre], 'x y min')
out = dehalo
# Antialiasing sraaaaaaaaaa
lineart = vdf.mask.ExPrewitt().get_mask(out, 4000,
7500).std.Convolution([1] * 25)
aaa = AA().upscaled_sraaaaaaaaaa(out, height=1620)
out = aaa
unwarp = self.line_darkening(out, 0.075).warp.AWarpSharp2(depth=-1)
out = unwarp
motion = hvf.SMDegrain(out, tr=3, thSADC=600, RefineMotion=True)
masked = core.std.MaskedMerge(out, motion, lineart)
out = masked
mergechroma = vdf.misc.merge_chroma(out, denoise)
out = mergechroma
db_mask = Mask.deband_mask(out, (4000, 4000, 4000), (2000, 2000, 2000))
deband_1 = vdf.deband.dumb3kdb(out, 17, [36, 48])
deband_2 = vdf.deband.dumb3kdb(out,
17,
30,
sample_mode=4,
use_neo=True)
deband_d = vdf.deband.dumb3kdb(out, 17, 65)
th_lo, th_hi = 22 << 8, 28 << 8
strength = f'{th_hi} x - {th_hi} {th_lo} - /'
deband = core.std.Expr(
[out.std.Convolution([1] * 9), deband_1, deband_2], [
f'x {th_lo} > x {th_hi} < and z ' + strength + ' * y 1 ' +
strength + f' - * + x {th_lo} <= z y ? ?',
'x y * sqrt x z * sqrt * y * z * 0.25 pow'
])
deband = lvf.rfs(deband, deband_d, [(3920, 3985)])
deband = core.std.MaskedMerge(deband, out, db_mask)
out = deband
ref = get_y(out).std.PlaneStats()
adgmask_a = ref.adg.Mask(25)
adgmask_b = ref.adg.Mask(10)
stgrain_a = core.grain.Add(out, 0.1, 0, seed=333, constant=True)
stgrain_a = core.std.MaskedMerge(out, stgrain_a,
adgmask_b.std.Invert())
stgrain_b = sizedgrn(out,
0.2,
0.1,
1.15,
sharp=80,
static=True,
fade_edges=False,
protect_neutral=False,
seed=333)
stgrain_b = core.std.MaskedMerge(out, stgrain_b, adgmask_b)
stgrain_b = core.std.MaskedMerge(out, stgrain_b,
adgmask_a.std.Invert())
stgrain = core.std.MergeDiff(stgrain_b, out.std.MakeDiff(stgrain_a))
dygrain = sizedgrn(out,
0.3,
0.1,
1.25,
sharp=80,
static=False,
fade_edges=False,
protect_neutral=False,
seed=333)
dygrain = core.std.MaskedMerge(out, dygrain, adgmask_a)
grain = core.std.MergeDiff(dygrain, out.std.MakeDiff(stgrain))
out = grain
if int(NUM) != 12:
while out.num_frames < 34646:
out += out[-1]
return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2],
[0, 1, 2])
def main(self) -> vs.VideoNode:
"""Vapoursynth filtering"""
src = JPBD.clip_cut
src = depth(src, 16)
ring_mask = Mask.ringing_mask(get_y(src))
dering_src = hvf.EdgeCleaner(src, 20, hot=True)
out = dering_src
ref = Denoise.ref_denoise(get_y(out), tr=1)
denoise = Denoise.hybrid_denoise(depth(out, 32),
knlm_h=0.15,
sigma=1,
knlm_args=dict(d=1, a=3, s=3),
bm3d_args=dict(ref=depth(ref, 32)))
denoise = depth(denoise, 16)
out = denoise
pre = get_y(out)
# Remove haloing
dehalo = gf.MaskedDHA(pre,
rx=1.4,
ry=1.4,
darkstr=0.1,
brightstr=1.0,
maskpull=40,
maskpush=255)
bila = core.bilateral.Bilateral(dehalo, sigmaS=1, sigmaR=0.08)
dehalorp = core.rgvs.Repair(dehalo, bila, 13)
dehalo = core.std.MaskedMerge(dehalo, dehalorp,
ring_mask.std.Maximum(), 0)
dehalo = core.std.Expr([dehalo, pre], 'x y min')
out = dehalo
# Antialiasing sraaaaaaaaaa
lineart = vdf.mask.ExPrewitt().get_mask(out, 4000,
7500).std.Convolution([1] * 25)
aaa = AA().upscaled_sraaaaaaaaaa(out, height=1620)
out = aaa
unwarp = self.line_darkening(out, 0.075).warp.AWarpSharp2(depth=-1)
out = unwarp
motion = hvf.SMDegrain(out, tr=3, thSADC=600, RefineMotion=True)
masked = core.std.MaskedMerge(out, motion, lineart)
out = masked
mergechroma = vdf.misc.merge_chroma(out, denoise)
out = mergechroma
db_mask = Mask.deband_mask(out, (4000, 4000, 4000), (2000, 2000, 2000))
deband_1 = vdf.deband.dumb3kdb(out, 17, [36, 48])
deband_2 = vdf.deband.dumb3kdb(out,
17,
30,
sample_mode=4,
use_neo=True)
deband_a = vdf.placebo.deband(out,
22,
threshold=8,
iterations=3,
grain=0)
th_lo, th_hi = 22 << 8, 28 << 8
strength = f'{th_hi} x - {th_hi} {th_lo} - /'
deband = core.std.Expr(
[out.std.Convolution([1] * 9), deband_1, deband_2], [
f'x {th_lo} > x {th_hi} < and z ' + strength + ' * y 1 ' +
strength + f' - * + x {th_lo} <= z y ? ?',
'x y * sqrt x z * sqrt * y * z * 0.25 pow'
])
deband = lvf.rfs(deband, deband_a, [(OPSTART + 1382, OPSTART + 1433)])
deband = core.std.MaskedMerge(deband, out, db_mask)
out = deband
ref = get_y(out).std.PlaneStats()
adgmask_a = ref.adg.Mask(25)
adgmask_b = ref.adg.Mask(10)
stgrain_a = core.grain.Add(out, 0.1, 0, seed=333, constant=True)
stgrain_a = core.std.MaskedMerge(out, stgrain_a,
adgmask_b.std.Invert())
stgrain_b = sizedgrn(out,
0.2,
0.1,
1.15,
sharp=80,
static=True,
fade_edges=False,
protect_neutral=False,
seed=333)
stgrain_b = core.std.MaskedMerge(out, stgrain_b, adgmask_b)
stgrain_b = core.std.MaskedMerge(out, stgrain_b,
adgmask_a.std.Invert())
stgrain = core.std.MergeDiff(stgrain_b, out.std.MakeDiff(stgrain_a))
dygrain = sizedgrn(out,
0.3,
0.1,
1.25,
sharp=80,
static=False,
fade_edges=False,
protect_neutral=False,
seed=333)
dygrain = core.std.MaskedMerge(out, dygrain, adgmask_a)
grain = core.std.MergeDiff(dygrain, out.std.MakeDiff(stgrain))
out = grain
if int(NUM) != 12:
while out.num_frames < 2160:
out += out[-1]
return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2],
[0, 1, 2])
def main(self) -> vs.VideoNode:
"""Vapoursynth filtering"""
src = JPBD.clip_cut
src = depth(src, 16)
src_cru = WEB_CRU.clip_cut
src_aod = WEB_AOD.clip_cut
# Dehardsubbing using .ass file
masksub = Mask.hardsub_mask(src_aod.std.BlankClip(), SUB, FONTDIR)
dehardsub = core.std.MaskedMerge(src_aod, src_cru, masksub)
src_web = dehardsub
# AoD is poorly rescaled
src_y, src_cru_y, src_web_y = map(get_y, [src, src_cru, src_web])
thr = 10
src_web_y = core.std.Expr([src_web_y, src_cru_y], f'x y - abs {thr} < x y * sqrt y ?')
src_web_y = depth(src_web_y, 16)
ringrid = core.rgvs.Repair(src_web_y, src_web_y.std.Convolution([1]*9), 11)
ringrid = core.std.Expr([ringrid, src_web_y], 'x y min')
# Remove ringing with AoD+CR
ring_mask = Mask.ringing_mask(src_y)
bdweb = core.std.MaskedMerge(src_y, ringrid, ring_mask)
bdweb = lvf.rfs(bdweb, src_web_y, [(793, 1503), (1696, 2301), (32121, 34164), (34472, 34523)])
out = vdf.misc.merge_chroma(bdweb, src)
# Restore BD changes
dering_src = hvf.EdgeCleaner(src, 20, hot=True)
diff_mask = Mask.diff_mask((src, src_cru), brz=4750.0)
bdchanges = core.std.MaskedMerge(out, dering_src, diff_mask)
bdchanges = lvf.rfs(out, bdchanges, [(9419, 9512), (17731, 17865)])
bdchanges = lvf.rfs(bdchanges, dering_src, [(14977, 15078), (15382, 15540), (23311, 23346)])
# return bdchanges, diff_mask
out = bdchanges
ref = Denoise.ref_denoise(get_y(out), tr=1)
denoise = Denoise.hybrid_denoise(
depth(out, 32), knlm_h=0.15, sigma=1,
knlm_args=dict(d=1, a=3, s=3), bm3d_args=dict(ref=depth(ref, 32))
)
denoise = depth(denoise, 16)
out = denoise
pre = get_y(out)
# Remove haloing
dehalo = gf.MaskedDHA(pre, rx=1.4, ry=1.4, darkstr=0.1, brightstr=1.0, maskpull=40, maskpush=255)
bila = core.bilateral.Bilateral(dehalo, sigmaS=1, sigmaR=0.08)
dehalorp = core.rgvs.Repair(dehalo, bila, 13)
dehalo = core.std.MaskedMerge(dehalo, dehalorp, ring_mask.std.Maximum(), 0)
dehalo = core.std.Expr([dehalo, pre], 'x y min')
out = dehalo
# Antialiasing sraaaaaaaaaa
lineart = vdf.mask.ExPrewitt().get_mask(out, 4000, 7500).std.Convolution([1] * 25)
aaa = AA().upscaled_sraaaaaaaaaa(out, height=1620)
out = aaa
unwarp = self.line_darkening(out, 0.075).warp.AWarpSharp2(depth=-1)
out = unwarp
motion = hvf.SMDegrain(out, tr=3, thSADC=600, RefineMotion=True)
masked = core.std.MaskedMerge(out, motion, lineart)
out = masked
mergechroma = vdf.misc.merge_chroma(out, denoise)
out = mergechroma
db_mask = Mask.deband_mask(out, (4000, 4000, 4000), (2000, 2000, 2000))
deband_1 = vdf.deband.dumb3kdb(out, 17, [36, 48])
deband_2 = vdf.deband.dumb3kdb(out, 17, 30, sample_mode=4, use_neo=True)
deband_x = vdf.placebo.deband(out, 28, 4, iterations=3, grain=0)
th_lo, th_hi = 22 << 8, 28 << 8
strength = f'{th_hi} x - {th_hi} {th_lo} - /'
deband = core.std.Expr(
[out.std.Convolution([1]*9), deband_1, deband_2],
[f'x {th_lo} > x {th_hi} < and z ' + strength + ' * y 1 ' + strength + f' - * + x {th_lo} <= z y ? ?',
'x y * sqrt x z * sqrt * y * z * 0.25 pow'])
deband = lvf.rfs(deband, deband_x, [(6688, 6714)])
deband = core.std.MaskedMerge(deband, out, db_mask)
out = deband
ref = get_y(out).std.PlaneStats()
adgmask_a = ref.adg.Mask(25)
adgmask_b = ref.adg.Mask(10)
stgrain_a = core.grain.Add(out, 0.1, 0, seed=333, constant=True)
stgrain_a = core.std.MaskedMerge(out, stgrain_a, adgmask_b.std.Invert())
stgrain_b = sizedgrn(out, 0.2, 0.1, 1.15, sharp=80, static=True, fade_edges=False, protect_neutral=False, seed=333)
stgrain_b = core.std.MaskedMerge(out, stgrain_b, adgmask_b)
stgrain_b = core.std.MaskedMerge(out, stgrain_b, adgmask_a.std.Invert())
stgrain = core.std.MergeDiff(stgrain_b, out.std.MakeDiff(stgrain_a))
dygrain = sizedgrn(out, 0.3, 0.1, 1.25, sharp=80, static=False, fade_edges=False, protect_neutral=False, seed=333)
dygrain = core.std.MaskedMerge(out, dygrain, adgmask_a)
grain = core.std.MergeDiff(dygrain, out.std.MakeDiff(stgrain))
out = grain
if int(NUM) != 12:
while out.num_frames < 34646:
out += out[-1]
return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2], [0, 1, 2])
def do_filter():
"""Vapoursynth filtering"""
src = WEB.src_cut
src = src.std.AssumeFPS(src)
src = depth(src, 16)
out = src
denoise = hvf.SMDegrain(out, tr=3, thSAD=150, thSADC=150)
out = denoise
dering = hvf.EdgeCleaner(out, 20, smode=1, hot=True)
out = dering
y = get_y(out)
taps = 5
w, h = 1600, 900
descale = core.descale.Delanczos(depth(y, 32), w, h, taps)
upscale = vdf.nnedi3_upscale(descale, pscrn=1, correct_shift=False)
rescale = core.resize.Bicubic(upscale,
1920,
1080,
src_left=.5,
src_top=.5,
filter_param_a=-.5,
filter_param_b=.25)
out = depth(rescale, 16)
sharp = hvf.LSFmod(out,
strength=90,
Smode=3,
edgemode=0,
source=get_y(denoise))
out = sharp
merge = vdf.merge_chroma(out, denoise)
out = merge
detail_mask = lvf.mask.detail_mask(out, brz_a=2250, brz_b=1200)
pref = out.std.Convolution([1, 2, 1, 2, 4, 2, 1, 2,
1]).std.Convolution([1] * 9)
deband1 = vdf.dumb3kdb(pref, 17, 45, grain=16, seed=333)
deband2 = vdf.dumb3kdb(pref,
15,
49,
grain=16,
sample_mode=4,
use_neo=True,
blur_first=False,
seed=333)
th_lo, th_hi = 20 << 8, 26 << 8
strength = '{1} x - {1} {0} - /'.format(th_lo, th_hi)
deband = core.std.Expr([pref, deband1, deband2], [
f'x {th_lo} > x {th_hi} < and z ' + strength + ' * y 1 ' + strength +
f' - * + x {th_lo} <= z y ? ?', 'y'
])
deband = core.std.MergeDiff(deband, out.std.MakeDiff(pref))
deband = core.std.MaskedMerge(deband, out, detail_mask)
out = deband
grain = adptvgrnMod(out,
0.3,
0.15,
size=1.2,
luma_scaling=16,
hi=[128, 240],
protect_neutral=False,
seed=333)
out = grain
ref = denoise
rescale_mask = vdf.drm(src, h, 'spline36', mthr=80).std.Maximum()
credit = out
credit = lvf.rfs(credit, core.std.MaskedMerge(credit, ref, rescale_mask),
[(2374, 4530), (4544, 4648), (4701, 4762), (30070, 30210),
(31266, 33422)])
credit = lvf.rfs(credit, ref, [(33423, src.num_frames - 1)])
out = credit
return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2], [0, 1, 2])
def main(self) -> vs.VideoNode:
"""Vapoursynth filtering"""
src = JPBD.clip_cut
src = depth(src, 16)
src_cru = WEB_CRU.clip_cut
src_aod = WEB_AOD.clip_cut
# Dehardsubbing using .ass file
masksub = Mask.hardsub_mask(src_aod.std.BlankClip(), SUB, FONTDIR)
dehardsub = core.std.MaskedMerge(src_aod, src_cru, masksub)
src_web = dehardsub
# AoD is poorly rescaled
src_y, src_cru_y, src_web_y = map(get_y, [src, src_cru, src_web])
thr = 10
src_web_y = core.std.Expr([src_web_y, src_cru_y],
f'x y - abs {thr} < x y * sqrt y ?')
src_web_y = depth(src_web_y, 16)
ringrid = core.rgvs.Repair(src_web_y,
src_web_y.std.Convolution([1] * 9), 11)
ringrid = core.std.Expr([ringrid, src_web_y], 'x y min')
# Remove ringing with AoD+CR
ring_mask = Mask.ringing_mask(src_y)
bdweb = core.std.MaskedMerge(src_y, ringrid, ring_mask)
out = vdf.misc.merge_chroma(bdweb, src)
# Restore BD changes
dering_src = hvf.EdgeCleaner(src, 20, hot=True)
diff_mask = Mask.diff_mask((src, src_cru), brz=4750.0)
bdchanges = core.std.MaskedMerge(out, dering_src, diff_mask)
bdchanges = lvf.rfs(out, bdchanges, [(4455, 4607), (4876, 5078),
(5199, 5246), (5958, 6035),
(6894, 7076), (7275, 7406),
(7653, 7784), (7863, 7970),
(8142, 8348), (8784, 9065),
(9276, 9800), (10613, 10720),
(10739, 10780), (10949, 10969),
(11105, 11230), (11924, 12289),
(12865, 12891), (13139, 13213),
(15520, 15733), (19160, 19243),
(20351, 20422), (24824, 24979),
(26357, 26527), (27920, 28000),
(29576, 29659), (29780, 29881),
(30128, 30271), (30644, 30763),
(31776, 31811), (32522, 32641)])
# return bdchanges, diff_mask
out = bdchanges
ref = Denoise.ref_denoise(get_y(out), tr=1)
denoise = Denoise.hybrid_denoise(depth(out, 32),
knlm_h=0.15,
sigma=1,
knlm_args=dict(d=1, a=3, s=3),
bm3d_args=dict(ref=depth(ref, 32)))
denoise = depth(denoise, 16)
out = denoise
pre = get_y(out)
# Remove haloing
dehalo = gf.MaskedDHA(pre,
rx=1.4,
ry=1.4,
darkstr=0.1,
brightstr=1.0,
maskpull=40,
maskpush=255)
bila = core.bilateral.Bilateral(dehalo, sigmaS=1, sigmaR=0.08)
dehalorp = core.rgvs.Repair(dehalo, bila, 13)
dehalo = core.std.MaskedMerge(dehalo, dehalorp,
ring_mask.std.Maximum(), 0)
dehalo = core.std.Expr([dehalo, pre], 'x y min')
out = dehalo
# Antialiasing sraaaaaaaaaa
lineart = vdf.mask.ExPrewitt().get_mask(out, 4000,
7500).std.Convolution([1] * 25)
aaa = AA().upscaled_sraaaaaaaaaa(out, height=1620)
out = aaa
unwarp = self.line_darkening(out, 0.075).warp.AWarpSharp2(depth=-1)
out = unwarp
motion = hvf.SMDegrain(out, tr=3, thSADC=600, RefineMotion=True)
masked = core.std.MaskedMerge(out, motion, lineart)
out = masked
mergechroma = vdf.misc.merge_chroma(out, denoise)
out = mergechroma
ref = depth(src_cru, 16)
cred_mask = Mask.credits_mask(src, JPBD_NCOP.clip_cut,
JPBD_NCED.clip_cut, OPSTART, OPEND,
EDSTART, EDEND)
cred = out
cred = lvf.rfs(cred, core.std.MaskedMerge(cred, ref, cred_mask, 0),
[(OPSTART, OPEND), (EDSTART, EDEND)])
out = cred
db_mask = Mask.deband_mask(out, (4000, 4000, 4000), (2000, 2000, 2000))
deband_1 = vdf.deband.dumb3kdb(out, 17, [36, 48])
deband_2 = vdf.deband.dumb3kdb(out,
17,
30,
sample_mode=4,
use_neo=True)
deband_a = vdf.placebo.deband(out,
22,
threshold=8,
iterations=3,
grain=0)
import rekt
deband_c = rekt.rekt_fast(out,
lambda x: vdf.placebo.deband(x, 18, 6, 2, 0),
bottom=600)
deband_d = vdf.deband.dumb3kdb(out, 17, 65)
th_lo, th_hi = 22 << 8, 28 << 8
strength = f'{th_hi} x - {th_hi} {th_lo} - /'
deband = core.std.Expr(
[out.std.Convolution([1] * 9), deband_1, deband_2], [
f'x {th_lo} > x {th_hi} < and z ' + strength + ' * y 1 ' +
strength + f' - * + x {th_lo} <= z y ? ?',
'x y * sqrt x z * sqrt * y * z * 0.25 pow'
])
deband = lvf.rfs(deband, deband_a, [(OPSTART + 1382, OPSTART + 1433)])
deband = lvf.rfs(deband, deband_c, [(12362, 12391)])
deband = lvf.rfs(deband, deband_d, [(14789, 15025)])
deband = core.std.MaskedMerge(deband, out, db_mask)
out = deband
ref = get_y(out).std.PlaneStats()
adgmask_a = ref.adg.Mask(25)
adgmask_b = ref.adg.Mask(10)
stgrain_a = core.grain.Add(out, 0.1, 0, seed=333, constant=True)
stgrain_a = core.std.MaskedMerge(out, stgrain_a,
adgmask_b.std.Invert())
stgrain_b = sizedgrn(out,
0.2,
0.1,
1.15,
sharp=80,
static=True,
fade_edges=False,
protect_neutral=False,
seed=333)
stgrain_b = core.std.MaskedMerge(out, stgrain_b, adgmask_b)
stgrain_b = core.std.MaskedMerge(out, stgrain_b,
adgmask_a.std.Invert())
stgrain = core.std.MergeDiff(stgrain_b, out.std.MakeDiff(stgrain_a))
dygrain = sizedgrn(out,
0.3,
0.1,
1.25,
sharp=80,
static=False,
fade_edges=False,
protect_neutral=False,
seed=333)
dygrain = core.std.MaskedMerge(out, dygrain, adgmask_a)
grain = core.std.MergeDiff(dygrain, out.std.MakeDiff(stgrain))
out = grain
if int(NUM) != 12:
while out.num_frames < 34646:
out += out[-1]
return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2],
[0, 1, 2])
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Main filterchain"""
import EoEfunc as eoe
import havsfunc as haf
import kagefunc as kgf
import lvsfunc as lvf
import vardefunc as vdf
from adptvgrnMod import adptvgrnMod
from ccd import ccd
from vsdpir import DPIR
from vsutil import depth
src = pre_filter()
src = depth(src, 16)
# Fix slight green tint present throughout parts of the OP
src_g = core.std.Expr(src, ["", "", "x 32768 = x x 96 + ?"])
src_g = lvf.rfs(src, src_g, [(None, 873)])
scaled, descale_mask = flt.rescaler(src_g,
height=854,
shader_file=shader_file)
# Denoising this is rough. Lots of fine detail that's easy to destroy.
detail_mask = flt.detail_mask(scaled,
pf_sigma=1.5,
rxsigma=[50, 150, 200, 300],
rad=2,
brz=[2250, 3500])
denoise_y = eoe.dn.BM3D(scaled, sigma=[0.3, 0])
denoise_y_str = flt.to_yuvps(
DPIR(flt.to_rgbs(scaled),
strength=40,
task='deblock',
device_type='cpu'))
denoise_y = lvf.rfs(denoise_y, denoise_y_str, [(1384, 1398)])
denoise_uv = ccd(denoise_y, threshold=7, matrix='709')
denoise_uv_rep = core.std.MaskedMerge(denoise_uv, denoise_y, detail_mask)
stab = haf.GSMC(denoise_uv_rep, radius=1, thSAD=200, planes=[0])
stab = lvf.rfs(
stab, scaled,
[(1399, 1400),
(1408, 1416)]) # Undo denoising because it eats lines on these scenes
decs = vdf.noise.decsiz(stab, sigmaS=8, min_in=200 << 8, max_in=232 << 8)
# F**k ufo lines
eed = lvf.aa.nneedi3_clamp(decs, strength=1.6)
sraa = lvf.sraa(decs, rfactor=1.5, aafun=flt.eedi3_singlerate_custom)
clamp_aa = lvf.aa.clamp_aa(decs, eed, sraa, strength=1.6)
# Certain frames have truly godawful aliasing. We attempt to fix those here
tsraa = flt.transpose_sraa(decs,
rfactor=1.5,
aafun=flt.eedi3_singlerate_custom)
tsraa_rep = core.rgvs.Repair(tsraa, clamp_aa, 13)
aa_rfs = lvf.rfs(clamp_aa, tsraa_rep, strong_aa)
# F**k ufo lines
ec = haf.EdgeCleaner(aa_rfs, strength=4)
# This fixes up all the super red scenes fairly well
crecon = lvf.recon.chroma_reconstruct(ec)
deband_a = flt.masked_f3kdb(crecon,
rad=18,
thr=24,
grain=[24, 16],
mask_args={'brz': (1250, 2250)})
deband_b = flt.masked_f3kdb(crecon,
rad=24,
thr=40,
grain=[32, 24],
mask_args={'brz': (1000, 1750)})
deband_c = flt.placebo_debander(crecon,
grain=2,
iterations=2,
threshold=8,
radius=16)
deband = lvf.rfs(deband_a, deband_b, [])
deband = kgf.crossfade(deband[:2246 + 48], deband_c[2246:], 47)
deband = lvf.rfs(deband, crecon, [(1399, 1400)])
sqmask = lvf.mask.BoundingBox((699, 50), (526, 870)).get_mask(deband)
sqmask = core.bilateral.Gaussian(sqmask, sigma=4)
blur = core.bilateral.Gaussian(deband,
sigma=25).bilateral.Gaussian(sigma=25)
blur_mask = core.std.MaskedMerge(blur, deband, sqmask)
blurred = kgf.crossfade(deband[:2412 + 48], blur_mask[2411:], 48)
blurred_del = core.std.DeleteFrames(blurred, [2293])
grain_a = adptvgrnMod(blurred_del,
seed=42069,
strength=0.15,
static=True,
size=1.15,
sharp=80,
grain_chroma=False)
grain_b = adptvgrnMod(blurred_del,
seed=42069,
strength=0.25,
static=True,
size=1.15,
sharp=100,
grain_chroma=False)
grain_c = adptvgrnMod(blurred_del,
seed=42069,
strength=0.2,
static=False,
size=1.15,
sharp=100,
grain_chroma=False)
grain = lvf.rfs(grain_a, grain_b, [(2390, None)])
grain = lvf.rfs(grain, grain_c, [(885, 1149), (1324, 1345), (1489, 1506),
(1603, 1810), (1981, 1996)])
# Accidentally a frame during one of the previous processes. Easy to fix, though.
oopsie = core.std.DeleteFrames(grain, [grain.num_frames - 1])
out = enc.dither_down(oopsie)
return out
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
src = depth(src, 16)
out = src
edstart1, edend1 = 37428, 37428 + 2160
edstart2, edend2 = edend1 + 12, edend1 + 2160
ref = hvf.SMDegrain(out, thSAD=300)
denoise = mvf.BM3D(out, [1.5, 1.25], radius1=1, ref=ref)
out = denoise
y = get_y(out)
lineart = gf.EdgeDetect(y, 'scharr').morpho.Dilate(2, 2).std.Inflate()
fkrescale = fake_rescale(
y, 882, 0, 1,
deringer=lambda x: gf.MaskedDHA(x, rx=1.85, ry=1.85, darkstr=0.25, brightstr=1.0, maskpull=100, maskpush=200),
antialiser=lambda c: lvf.sraa(c, 2, 13, downscaler=core.resize.Bicubic)
)
merged = core.std.MaskedMerge(y, fkrescale, lineart)
out = vdf.merge_chroma(merged, out)
dering = hvf.EdgeCleaner(out, 17, smode=1, hot=True)
out = dering
out = lvf.rfs(out, denoise, [(edstart1, src.num_frames - 1)])
detail_mask = lvf.mask.detail_mask(out, brz_a=2250, brz_b=1000)
deband = vdf.dumb3kdb(out, 15, threshold=17, grain=(24, 0))
deband = core.std.MaskedMerge(deband, out, detail_mask)
out = deband
grain = adptvgrnMod(out, 0.3, static=True, grain_chroma=False, hi=[128, 240], seed=333)
out = grain
decz = vdf.decsiz(out, min_in=128 << 8, max_in=200 << 8)
out = decz
ref = depth(src, 16)
src_c, src_nced1, src_nced2 = [
depth(x, 16).std.Convolution(
[1, 2, 1, 2, 4, 2, 1, 2, 1]
) for x in [src, JPBD_NCED1.src_cut, JPBD_NCED2.src_cut]
]
ending_mask1 = vdf.dcm(out, src_c[edstart1:edend1 + 1], src_nced1[:edend1 - edstart1 + 1], edstart1, edend1, 2, 2)
ending_mask2 = vdf.dcm(out, src_c[edstart2:edend2 + 1], src_nced2[:edend2 - edstart2 + 1], edstart2, edend2, 2, 2)
ending_mask = core.std.Expr([ending_mask1, ending_mask2], 'x y +')
ending_mask = iterate(ending_mask, core.std.Inflate, 4)
credit = out
credit = lvf.rfs(credit, core.std.MaskedMerge(credit, ref, ending_mask), [(edstart1, edend2)])
credit = lvf.rfs(credit, ref, [(21594, 21737), (39589, 39599), (41744, src.num_frames - 1)])
out = credit
return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2], [0, 1, 2])
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
src = depth(src, 16)
out = src
opstart, opend = 2712, 4869
ref = hvf.SMDegrain(out, thSAD=300)
denoise = mvf.BM3D(out, [1.5, 1.25], radius1=1, ref=ref)
out = denoise
crop = core.std.Crop(out, left=12)
crop = awf.bbmod(crop, left=2, thresh=20 << 8)
resize = core.resize.Bicubic(crop, 1920)
out = lvf.rfs(out, resize, [(86, 201)])
y = get_y(out)
lineart = gf.EdgeDetect(y, 'scharr').morpho.Dilate(2, 2).std.Inflate()
fkrescale = fake_rescale(y,
882,
0,
1,
deringer=lambda x: gf.MaskedDHA(x,
rx=1.85,
ry=1.85,
darkstr=0.25,
brightstr=1.0,
maskpull=100,
maskpush=200),
antialiser=lambda c: lvf.sraa(
c, 2, 13, downscaler=core.resize.Bicubic))
merged = core.std.MaskedMerge(y, fkrescale, lineart)
out = vdf.merge_chroma(merged, out)
dering = hvf.EdgeCleaner(out, 17, smode=1, hot=True)
out = dering
detail_mask = lvf.mask.detail_mask(out, brz_a=2250, brz_b=1000)
deband = vdf.dumb3kdb(out, 15, threshold=17, grain=(24, 0))
deband = core.std.MaskedMerge(deband, out, detail_mask)
out = deband
grain = adptvgrnMod(out,
0.3,
static=True,
grain_chroma=False,
hi=[128, 240],
seed=333)
out = grain
decz = vdf.decsiz(out, min_in=128 << 8, max_in=200 << 8)
out = decz
ref = depth(src, 16)
src_c, src_ncop = [
depth(x, 16).std.Convolution([1, 2, 1, 2, 4, 2, 1, 2, 1])
for x in [src, JPBD_NCOP.src_cut]
]
opening_mask = vdf.dcm(out, src_c[opstart:opend + 1],
src_ncop[:opend - opstart + 1], opstart, opend, 2,
2)
opening_mask = iterate(opening_mask, core.std.Inflate, 4)
credit = out
credit = lvf.rfs(credit, core.std.MaskedMerge(credit, ref, opening_mask),
[(opstart, opend)])
credit = lvf.rfs(credit, ref, [(17985, 18128)])
out = credit
return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2], [0, 1, 2])
def do_filter():
"""Vapoursynth filtering"""
def _sraa(clip: vs.VideoNode, nnargs: dict, eeargs: dict) -> vs.VideoNode:
def _nnedi3(clip):
return clip.nnedi3.nnedi3(0, False, **nnargs)
def _eedi3(clip, sclip):
return clip.eedi3m.EEDI3(0, False, **eeargs, sclip=sclip)
clip = _eedi3(clip, _nnedi3(clip)).std.Transpose()
clip = _eedi3(clip, _nnedi3(clip)).std.Transpose()
return clip
def _nnedi3(clip: vs.VideoNode, factor: float, args: dict) -> vs.VideoNode:
upscale = clip.std.Transpose().nnedi3.nnedi3(0, True, **args) \
.std.Transpose().nnedi3.nnedi3(0, True, **args)
return core.resize.Spline36(upscale,
clip.width * factor,
clip.height * factor,
src_top=.5,
src_left=.5)
def area_resize(clip: vs.VideoNode, width: int,
height: int) -> vs.VideoNode:
blank = core.std.BlankClip(clip, format=vs.GRAY16, color=128 << 8)
clip = join([clip, blank, blank])
clip = core.area.AreaResize(clip, width, height)
return get_y(clip)
src = JPBD.src_cut
src = depth(src, 16)
flashback = [(31665, 31987), (68524, 68569)]
denoise = CoolDegrain(src, tr=1, thsad=48, blksize=8, overlap=4, plane=4)
denoise = lvf.rfs(denoise, src, flashback)
dering = hvf.EdgeCleaner(denoise, 10, rmode=3, smode=1, hot=True)
luma = get_y(dering)
line_mask = TAAmbk(luma, mtype=2, showmask=1).std.Inflate()
upscale = _nnedi3(luma, 2, dict(nsize=4, nns=4, qual=2, pscrn=2))
sraa = _sraa(upscale, dict(nsize=0, nns=3, qual=1, pscrn=1),
dict(alpha=0.2, beta=0.5, gamma=40, nrad=3, mdis=20))
sraa = core.rgvs.Repair(sraa, upscale, 13)
antialias = area_resize(sraa, src.width, src.height)
antialias = lvf.rfs(core.std.MaskedMerge(luma, antialias, line_mask),
antialias, [(22503, 22789)])
antialias_merged = vdf.merge_chroma(antialias, denoise)
deband_mask_a = lvf.denoise.detail_mask(antialias_merged,
brz_a=3000,
brz_b=1200)
deband_mask_b = kgf.retinex_edgemask(antialias_merged)
deband_mask = core.std.Expr([deband_mask_a, deband_mask_b], 'x y +')
deband = dbs.f3kpf(antialias_merged, 18, 30, 30)
deband = core.std.MaskedMerge(deband, antialias_merged, deband_mask)
deband = hvf.ContraSharpening(deband, antialias_merged)
deband = lvf.rfs(deband, antialias_merged, flashback)
grain = core.neo_f3kdb.Deband(deband, preset='depth', grainy=24)
grain_a = kgf.adaptive_grain(grain)
grain_b = core.grain.Add(grain, 1, 0, constant=True)
grain = lvf.rfs(grain_a, grain_b, flashback)
mask_borders = core.std.BlankClip(grain,
format=vs.GRAY16,
color=(256 << 8) - 1)
mask_borders = vdf.region_mask(mask_borders, 0, 0, 132, 132).std.Invert()
final = lvf.rfs(grain, core.std.MaskedMerge(grain, src, mask_borders),
flashback + [(65388, 65413), (113621, 113763)])
smooth = xvs.mvfrc(src[146178:src.num_frames], preset='slow')
vfr = muvf.VFRSplice([final[:146178], smooth], 'sora_timecode.txt')
return depth(vfr, 10)
def do_filter():
"""Vapoursynth filtering"""
src = CLIP_SRC
out = depth(src, 16)
clip = out
clip = core.std.FreezeFrames(clip, 1432, 1433, 1434)
clip = core.std.FreezeFrames(clip, 1503, 1514, 1515)
out = clip
planes = split(out)
planes[1], planes[2] = [
core.resize.Spline16(plane, src_left=-0.25) for plane in planes[1:]
]
out = join(planes)
# qual=2 produces weird artefacts and a stronger alpha/beta/gamma smudges details.
new_fields = core.eedi3m.EEDI3(out,
1,
alpha=0.4,
beta=0.5,
gamma=300,
nrad=3,
mdis=20,
vcheck=3,
sclip=core.nnedi3.nnedi3(out,
1,
nsize=3,
nns=3,
qual=1,
pscrn=4))
out = new_fields
denoise = gf.MCDegrainSharp(
out,
tr=3,
bblur=0.65,
csharp=lambda x: hvf.LSFmod(
x, strength=85, Smode=3, Lmode=1, edgemode=0),
thSAD=285,
rec=True)
out = denoise
edge_cleaner = hvf.EdgeCleaner(out, 35, rmode=13, smode=1, hot=True)
out = edge_cleaner
antialias = lvf.sraa(out,
2,
13,
downscaler=core.resize.Bicubic,
alpha=0.25,
beta=0.35,
gamma=400)
antialias_a = lvf.sraa(out, 1.4, 9, downscaler=core.resize.Bicubic)
antialias = lvf.rfs(antialias, antialias_a, [(1223, 1229)])
out = antialias
chromableed = xvs.WarpFixChromaBlend(out, 72, depth=8)
out = chromableed
detail_mask = lvf.denoise.detail_mask(out, brz_a=2300, brz_b=1000)
deband = placebo.deband(out, 17, 4.25, grain=6)
deband_a = placebo.deband(out, 17, 8, 2, grain=6)
deband_b = placebo.deband(out, 17, 6, grain=6)
deband = lvf.rfs(deband, deband_a, [(1230, 1330)])
deband = lvf.rfs(deband, deband_b, [(1678, 1889)])
deband = core.std.MaskedMerge(deband, out, detail_mask)
out = deband
return depth(out, 10)
