def quick_denoise(clip: vs.VideoNode,
ref: vs.VideoNode = None,
cmode: str = 'knlm',
sigma: float = 2,
**kwargs) -> vs.VideoNode:
funcname = "quick_denoise"
"""
A rewrite of my old 'quick_denoise'. I still hate it, but whatever.
This will probably be removed in a future commit.
This wrapper is used to denoise both the luma and chroma using various denoisers of your choosing.
If you wish to use just one denoiser,
you're probably better off using that specific filter rather than this wrapper.
BM3D is used for denoising the luma.
Special thanks to kageru for helping me out with some ideas and pointers.
:param sigma: Denoising strength for BM3D
:param cmode: Chroma denoising modes:
1 - Use knlmeans for denoising the chroma
2 - Use tnlmeans for denoising the chroma
3 - Use dfttest for denoising the chroma (requires setting 'sbsize' in kwargs)
4 - Use SMDegrain for denoising the chroma
:param ref: vs.VideoNode: Optional reference clip to replace BM3D's basic estimate
"""
y, u, v = kgf.split(clip)
cmode = cmode.lower()
if cmode in [1, 'knlm', 'knlmeanscl']:
den_u = u.knlm.KNLMeansCL(d=3, a=2, **kwargs)
den_v = v.knlm.KNLMeansCL(d=3, a=2, **kwargs)
elif cmode in [2, 'tnlm', 'tnlmeans']:
den_u = u.tnlm.TNLMeans(ax=2, ay=2, az=2, **kwargs)
den_v = v.tnlm.TNLMeans(ax=2, ay=2, az=2, **kwargs)
elif cmode in [3, 'dft', 'dfttest']:
if 'sbsize' in kwargs:
den_u = u.dfttest.DFTTest(sosize=kwargs['sbsize'] * 0.75, **kwargs)
den_v = v.dfttest.DFTTest(sosize=kwargs['sbsize'] * 0.75, **kwargs)
else:
return error(funcname, "'sbsize' not specified")
elif cmode in [4, 'smd', 'smdegrain']:
den_u = haf.SMDegrain(u, prefilter=3, **kwargs)
den_v = haf.SMDegrain(v, prefilter=3, **kwargs)
else:
return error(funcname, 'unknown cmode')
den_y = mvf.BM3D(y, sigma=sigma, psample=0, radius1=1, ref=ref)
return core.std.ShufflePlanes([den_y, den_u, den_v], 0, vs.YUV)
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 _dbgra(clip: vs.VideoNode) -> vs.VideoNode:
clip = depth(clip, 16)
clip = hvf.SMDegrain(clip, tr=1, thSAD=200)
clip = vdf.deband.dumb3kdb(clip, threshold=45)
clip = core.std.Expr(clip, ['x 64 -', 'x 32 +', 'x 32 +'])
clip = kgf.adaptive_grain(clip, 0.4)
return clip
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 do_filter() -> vs.VideoNode:
"""Vapoursynth filtering"""
src = JPBD.src_cut
out = src
luma = get_y(out)
rows = [
core.std.CropAbs(luma, out.width, 1, top=out.height - 1),
core.std.CropAbs(luma, out.width, 1, top=out.height - 2)
]
diff = core.std.Expr(rows, 'x y - abs').std.PlaneStats()
row_fix = vdf.merge_chroma(
luma.fb.FillBorders(bottom=1, mode="fillmargins"),
out.fb.FillBorders(bottom=2, mode="fillmargins"))
fixrow = core.std.FrameEval(out,
partial(_select_row, clip=out,
row_fix=row_fix),
prop_src=diff)
out = fixrow
fixedge_a = awf.bbmod(out, 1, 1, 1, 1, 20, blur=700, u=False, v=False)
fixedge = out
fixedge = lvf.rfs(fixedge, fixedge_a, [(EDSTART + 309, EDEND)])
out = fixedge
out = depth(out, 16)
dehalo = gf.MaskedDHA(out, rx=1.4, ry=1.4, darkstr=0.02, brightstr=1)
dehalo = lvf.rfs(out, dehalo, [(EDEND + 1, src.num_frames - 1)])
out = dehalo
resize = core.std.Crop(out, right=12, bottom=8).resize.Bicubic(1920, 1080)
resize = lvf.rfs(out, resize, [(27005, 27076)])
out = resize
# Denoising only the chroma
pre = hvf.SMDegrain(out, tr=2, thSADC=300, plane=3)
planes = split(out)
planes[1], planes[2] = [
mvf.BM3D(planes[i], 1.25, radius2=2, pre=plane(pre, i))
for i in range(1, 3)
]
out = join(planes)
preden = core.dfttest.DFTTest(out, sbsize=16, sosize=12, tbsize=1)
detail_mask = lvf.mask.detail_mask(preden, brz_a=2500, brz_b=1500)
deband = vdf.dumb3kdb(preden, 16, threshold=[17, 17], grain=[24, 0])
deband = core.std.MergeDiff(deband, out.std.MakeDiff(preden))
deband = core.std.MaskedMerge(deband, out, detail_mask)
out = deband
decz = vdf.decsiz(out, min_in=128 << 8, max_in=192 << 8)
out = decz
return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2], [0, 1, 2])
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
out = depth(src, 16)
denoise = hvf.SMDegrain(out, thSAD=150, thSADC=75)
out = denoise
y = get_y(out)
lineart = core.std.Sobel(y).std.Binarize(
75 << 8).std.Maximum().std.Inflate()
antialias = lvf.sraa(y,
1.5,
9,
downscaler=core.resize.Spline36,
gamma=200,
mdis=18)
sharp = hvf.LSFmod(antialias,
strength=95,
Smode=3,
Lmode=1,
edgemode=1,
edgemaskHQ=True)
minmax = core.std.Expr([y, sharp, antialias], 'x y z min max y z max min')
merge = core.std.MaskedMerge(y, minmax, lineart)
out = vdf.merge_chroma(merge, out)
y = get_y(out)
detail_dark_mask = detail_dark_mask_func(y, brz_a=10000, brz_b=9000)
detail_light_mask = lvf.denoise.detail_mask(y, brz_a=2500, brz_b=1200)
detail_mask = core.std.Expr([detail_dark_mask, detail_light_mask],
'x y +').std.Median()
detail_mask_grow = iterate(detail_mask, core.std.Maximum, 2)
detail_mask_grow = iterate(detail_mask_grow, core.std.Inflate,
2).std.Convolution([1, 1, 1, 1, 1, 1, 1, 1, 1])
detail_mask = core.std.Expr([y, detail_mask_grow, detail_mask],
f'x {28<<8} < y z ?')
deband = dbs.f3kpf(out, 17, 24, 24)
deband = core.std.MaskedMerge(deband, out, detail_mask)
out = deband
grain = adptvgrnMod(out,
0.2,
0.1,
1.25,
luma_scaling=14,
sharp=80,
static=False,
lo=19,
hi=[192, 240])
out = grain
return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2], [0, 1, 2])
def do_filter() -> vs.VideoNode:
"""Vapoursynth filtering"""
src = JPBD.src_cut
out = src
luma = get_y(out)
rows = [
core.std.CropAbs(luma, out.width, 1, top=out.height - 1),
core.std.CropAbs(luma, out.width, 1, top=out.height - 2)
]
diff = core.std.Expr(rows, 'x y - abs').std.PlaneStats()
row_fix = vdf.merge_chroma(
luma.fb.FillBorders(bottom=1, mode="fillmargins"),
out.fb.FillBorders(bottom=2, mode="fillmargins"))
fixrow = core.std.FrameEval(out,
partial(_select_row, clip=out,
row_fix=row_fix),
prop_src=diff)
out = fixrow
out = depth(out, 16)
# Denoising only the chroma
pre = hvf.SMDegrain(out, tr=2, thSADC=300, plane=3)
planes = split(out)
planes[1], planes[2] = [
mvf.BM3D(planes[i], 1.25, radius2=2, pre=plane(pre, i))
for i in range(1, 3)
]
out = join(planes)
preden = core.dfttest.DFTTest(out, sbsize=16, sosize=12, tbsize=1)
detail_mask = lvf.mask.detail_mask(preden, brz_a=2500, brz_b=1500)
deband = vdf.dumb3kdb(preden, 16, threshold=[17, 17], grain=[24, 0])
deband = core.std.MergeDiff(deband, out.std.MakeDiff(preden))
deband = core.std.MaskedMerge(deband, out, detail_mask)
out = deband
decz = vdf.decsiz(out, min_in=128 << 8, max_in=192 << 8)
out = decz
ref = depth(src, 16)
credit = out
credit = lvf.rfs(out, ref, CREDITS)
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
edges = core.edgefixer.ContinuityFixer(src, *[[2, 1, 1]] * 4)
out = depth(edges, 32)
ref = hvf.SMDegrain(depth(get_y(out), 16), thSAD=450)
denoise = hybrid_denoise(out, 0.35, 1.75, dict(a=2, d=1),
dict(ref=depth(ref, 32)))
out = depth(denoise, 16)
detail_dark_mask = detail_dark_mask_func(get_y(out),
brz_a=8000,
brz_b=6000)
detail_light_mask = lvf.denoise.detail_mask(out, brz_a=2500, brz_b=1200)
detail_mask = core.std.Expr([detail_dark_mask, detail_light_mask],
'x y +').std.Median()
detail_mask_grow = iterate(detail_mask, core.std.Maximum, 2)
detail_mask_grow = iterate(detail_mask_grow, core.std.Inflate,
2).std.Convolution([*[1] * 9])
detail_mask = core.std.Expr([get_y(out), detail_mask_grow, detail_mask],
f'x {32<<8} < y z ?')
deband = dumb3kdbv2(out, 22, 24)
deband = core.std.MaskedMerge(deband, out, detail_mask)
deband_b = dumb3kdbv2(out, 24, 64)
deband_b = core.std.MaskedMerge(deband_b, out, detail_light_mask)
deband = lvf.rfs(deband, deband_b, [(414, 496)])
out = deband
ref = get_y(out).std.PlaneStats()
adgmask_a = core.adg.Mask(ref, 30)
adgmask_b = core.adg.Mask(ref, 12)
stgrain = sizedgrn(out, 0.1, 0.05, 1.05, sharp=80)
stgrain = core.std.MaskedMerge(out, stgrain, adgmask_b)
stgrain = core.std.MaskedMerge(out, stgrain, adgmask_a.std.Invert())
dygrain = sizedgrn(out, 0.2, 0.05, 1.15, sharp=80, static=False)
dygrain = core.std.MaskedMerge(out, dygrain, adgmask_a)
grain = core.std.MergeDiff(dygrain, out.std.MakeDiff(stgrain))
out = grain
return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2])
def quick_denoise(clip: vs.VideoNode, mode='knlm', bm3d=True, sigma=3, h=1.0, refine_motion=True, sbsize=16, resample=True):
"""
Wrapper for generic denoising. Denoising is done by BM3D with a given denoisers being used for ref. Returns the denoised clip used
as ref if BM3D=False.
Mode 1 = KNLMeansCL
Mode 2 = SMDegrain
Mode 3 = DFTTest
Will be removed eventuallyTM.
"""
if resample:
if clip.format.bits_per_sample != 16:
clip = fvf.Depth(clip, 16)
clipY = core.std.ShufflePlanes(clip, 0, vs.GRAY)
if mode in [1, 'knlm']:
denoiseY = clipY.knlm.KNLMeansCL(d=3, a=2, h=h)
elif mode in [2, 'SMD', 'SMDegrain']:
denoiseY = haf.SMDegrain(clipY, prefilter=3, RefineMotion=refine_motion)
elif mode in [3, 'DFT', 'dfttest']:
denoiseY = clipY.dfttest.DFTTest(sigma=4.0, tbsize=1, sbsize=sbsize, sosize=sbsize*0.75)
else:
raise ValueError('denoise: unknown mode')
if bm3d:
denoisedY = mvf.BM3D(clipY, sigma=sigma, psample=0, radius1=1, ref=denoiseY)
elif bm3d is False:
denoisedY = denoiseY
if clip.format.color_family is vs.GRAY:
return denoisedY
else:
srcU = clip.std.ShufflePlanes(1, vs.GRAY)
srcV = clip.std.ShufflePlanes(2, vs.GRAY)
merged = core.std.ShufflePlanes([denoisedY, srcU, srcV], 0, vs.YUV)
return merged
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])
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
# Variables
opstart, opend = 6161, 8319
eptitle_s, eptitle_e = 8320, 8439
edstart, edend = 31170, 33326
preview_s, preview_e = 33687, src.num_frames - 1
h = 720
w = get_w(h)
edges = core.edgefixer.ContinuityFixer(src, *[[2, 1, 1]] * 4)
out = depth(edges, 32)
ref = hvf.SMDegrain(depth(get_y(out), 16), thSAD=450)
denoise = hybrid_denoise(out, 0.35, 1.75, dict(a=2, d=1),
dict(ref=depth(ref, 32)))
out = denoise
y = get_y(out)
lineart = vdf.edge_detect(y, 'FDOG', 0.055,
(1, 1)).std.Median().std.Convolution([*[1] * 9])
descale = core.descale.Debilinear(y, w, h)
upscale = vdf.fsrcnnx_upscale(
descale,
height=h * 2,
shader_file=r'shaders\FSRCNNX_x2_56-16-4-1.glsl',
upscaler_smooth=eedi3_upscale,
profile='slow',
strength=85)
antialias = sraa_eedi3(upscale, 9)
downscale = muvf.SSIM_downsample(antialias,
src.width,
src.height,
filter_param_a=0,
filter_param_b=0)
downscale = core.std.MaskedMerge(y, downscale, lineart)
merged = vdf.merge_chroma(downscale, out)
merged = lvf.rfs(merged, out, [(opstart, opend), (eptitle_s, eptitle_e),
(preview_s, preview_e)])
out = depth(merged, 16)
detail_dark_mask = detail_dark_mask_func(get_y(out),
brz_a=8000,
brz_b=6000)
detail_light_mask = lvf.denoise.detail_mask(out, brz_a=2500, brz_b=1200)
detail_mask = core.std.Expr([detail_dark_mask, detail_light_mask],
'x y +').std.Median()
detail_mask_grow = iterate(detail_mask, core.std.Maximum, 2)
detail_mask_grow = iterate(detail_mask_grow, core.std.Inflate,
2).std.Convolution([*[1] * 9])
detail_mask = core.std.Expr([get_y(out), detail_mask_grow, detail_mask],
f'x {32<<8} < y z ?')
deband = dumb3kdbv2(out, 22, 24)
deband = core.std.MaskedMerge(deband, out, detail_mask)
out = deband
ref = get_y(out).std.PlaneStats()
adgmask_a = core.adg.Mask(ref, 30)
adgmask_b = core.adg.Mask(ref, 12)
stgrain = sizedgrn(out, 0.1, 0.05, 1.05, sharp=80)
stgrain = core.std.MaskedMerge(out, stgrain, adgmask_b)
stgrain = core.std.MaskedMerge(out, stgrain, adgmask_a.std.Invert())
dygrain = sizedgrn(out, 0.2, 0.05, 1.15, sharp=80, static=False)
dygrain = core.std.MaskedMerge(out, dygrain, adgmask_a)
grain = core.std.MergeDiff(dygrain, out.std.MakeDiff(stgrain))
out = grain
ref = depth(src, 16)
rescale_mask = vdf.drm(ref, 720, 'bilinear', mthr=30, sw=0, sh=0)
rescale_mask = vdf.region_mask(rescale_mask, *[10] * 4)
rescale_mask = hvf.mt_expand_multi(rescale_mask,
mode='ellipse',
sw=4,
sh=4)
rescale_mask = rescale_mask.std.Binarize(scale_value(
100, 8, 16)).std.Inflate().std.Convolution([*[1] * 9])
dehalo_ref = gf.MaskedDHA(ref,
rx=1.65,
ry=1.65,
darkstr=0.15,
brightstr=1.0,
maskpull=48,
maskpush=140)
dehalo_mask_a = vdf.region_mask(rescale_mask, top=650)
dehalo_mask_b = vdf.region_mask(rescale_mask, right=400)
credit = out
dehalo_range_a = [(25, 205), (518, 612), (2090, 2172), (14449, 14537)]
dehalo_range_b = [(3893, 3981)]
credit = lvf.rfs(credit, core.std.MaskedMerge(credit, ref, rescale_mask,
0),
[(2197, 2252), (4072, 4129), (4409, 4527), (5390, 5484),
(8473, 8603), (8610, 8669), (9826, 9909), (10666, 10713),
(12088, 12507), (14943, 15052), (17988, 18136),
(18897, 18976),
(edstart, edend)] + dehalo_range_a + dehalo_range_b)
credit = lvf.rfs(
credit, core.std.MaskedMerge(credit, dehalo_ref, dehalo_mask_a, 0),
dehalo_range_a)
credit = lvf.rfs(
credit, core.std.MaskedMerge(credit, dehalo_ref, dehalo_mask_b, 0),
dehalo_range_b)
out = credit
return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2])
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
# src += src[-1]
src = depth(src, 16)
out = src
opstart, opend = 480, 2637
edstart, edend = 32249, 34405
# Remove the noise
ref = hvf.SMDegrain(out, tr=1, thSAD=300, plane=4)
denoise = mvf.BM3D(out, sigma=[2, 1], radius1=1, ref=ref)
out = denoise
# Limited antialiasing
y = get_y(out)
lineart = core.std.Sobel(y).std.Binarize(75<<8).std.Maximum().std.Inflate()
aa = lvf.sraa(y, 2, 13, downscaler=partial(core.resize.Bicubic, filter_param_a=-0.5, filter_param_b=0.25))
sharp = hvf.LSFmod(aa, strength=70, Smode=3, edgemode=0, source=y)
y = core.std.MaskedMerge(y, sharp, lineart)
out = vdf.merge_chroma(y, out)
# Deband masks
planes = split(out)
preden = core.dfttest.DFTTest(out, sigma=14.0, sigma2=10.0, sbsize=1, sosize=0).rgvs.RemoveGrain(3)
grad_mask, yrangebig = morpho_mask(preden)
rgb = core.resize.Bicubic(preden, 960, 540, format=vs.RGB48).std.SetFrameProp('_Matrix', delete=True)
chroma_masks = [core.std.Prewitt(p).std.Binarize(5500).rgvs.RemoveGrain(11) for p in split(rgb) + split(preden)[1:]]
chroma_mask = core.std.Expr(chroma_masks, 'x y + z + a + b +').std.Maximum()
chroma_mask = core.std.Merge(chroma_mask, chroma_mask.std.Minimum()).std.BoxBlur(0, 1, 1, 1, 1)
fdogmask = vdf.edge_detect(preden.std.Median(), 'FDOG', 8250, (4, 1)).std.BoxBlur(0, 2, 1, 2, 1)
detail_mask = lvf.denoise.detail_mask(planes[0].std.BoxBlur(0, 1, 1, 1, 1), brz_a=3300, brz_b=2000)
# Debanding stages
debands = [None] * 3
deband_y_strong = dbs.f3kbilateral(planes[0], 16, 65)
deband_y_normal = dumb3kdb(planes[0], 16, 36)
deband_y_light = core.std.MaskedMerge(dumb3kdb(planes[0], 14, 32), planes[0], detail_mask)
debands[1] = dbs.f3kbilateral(planes[1], 12, 50)
debands[2] = dbs.f3kbilateral(planes[2], 12, 50)
debands[0] = core.std.MaskedMerge(deband_y_strong, deband_y_normal, grad_mask)
debands[0] = core.std.MaskedMerge(debands[0], deband_y_light, yrangebig)
debands[1], debands[2] = [core.std.MaskedMerge(debands[i], planes[i], chroma_mask) for i in range(1, 3)]
deband = join(debands)
deband = lvf.rfs(deband, core.std.MaskedMerge(dbs.f3kbilateral(out, 20, 97), out, fdogmask), [(opstart+2019, opstart+2036), (opstart+1504, opstart+1574)])
out = deband
# Regraining
ref = get_y(out).std.PlaneStats()
adgmask_a = core.adg.Mask(ref, 25)
adgmask_b = core.adg.Mask(ref, 10)
stgrain_a = core.grain.Add(out, 0.1, 0, seed=333)
stgrain_a = core.std.MaskedMerge(out, stgrain_a, adgmask_b.std.Invert())
stgrain_b = sizedgrn(out, 0.2, 0.1, 1.15, sharp=80, 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, seed=333)
dygrain = core.std.MaskedMerge(out, dygrain, adgmask_a)
grain = core.std.MergeDiff(dygrain, out.std.MakeDiff(stgrain))
out = grain
# Credits OP and ED
ref = src
src_ncop, src_nced = [depth(c, 16) for c in [JPBD_NCOP.src_cut, JPBD_NCED.src_cut]]
src_c, src_ncop, src_nced = [c.std.BoxBlur(0, 2, 1, 2, 1) for c in [src, src_ncop, src_nced]]
opening_mask = vdf.dcm(out, src_c[opstart:opend+1], src_ncop[:opend-opstart+1], opstart, opend, 2, 2)
ending_mask = vdf.dcm(out, src_c[edstart:edend+1], src_nced[:edend-edstart+1], edstart, edend, 2, 2)
credit_mask = core.std.Expr([opening_mask, ending_mask], 'x y +').std.Inflate()
credit = lvf.rfs(out, core.std.MaskedMerge(out, ref, credit_mask), [(opstart, opend), (edstart, edend)])
out = credit
# Fix letterboxes ending
crop = core.std.Crop(out, 0, 0, 132, 132).edgefixer.ContinuityFixer(0, 1, 0, 0)
crop = core.std.AddBorders(crop, 0, 0, 132, 132)
out = lvf.rfs(out, crop, [(edstart, edend)])
return depth(out, 10).std.Limiter(16<<2, [235<<2, 240<<2], [0, 1, 2])
def main(self: Filtering) -> vs.VideoNode:
"""Vapoursynth filtering"""
src = JPBD.clip_cut
src = depth(src, 16)
out = src
h = 800 # noqa
w = get_w(h) # noqa
opstart, opend = 2830, 4986
edstart, edend = 31504, 33661
inp = get_y(out)
out = inp
# Remove the grain
ref = hvf.SMDegrain(out, tr=1, thSAD=300, plane=0)
preden = mvf.BM3D(out, sigma=2, radius1=1, ref=ref)
out = preden
# Rescale / Antialiasing / Limiting
out = depth(out, 32)
lineart = vdf.mask.FDOG().get_mask(out, lthr=0.065, hthr=0.065).std.Maximum().std.Minimum()
lineart = lineart.std.Median().std.Convolution([1] * 9)
descale_clips = [core.resize.Bicubic(out, w, h, filter_param_a=1/3, filter_param_b=1/3),
core.descale.Debicubic(out, w, h, 0, 1/2),
core.descale.Debilinear(out, w, h)]
descale = core.std.Expr(descale_clips, 'x y z min max y z max min z min')
upscale = vdf.scale.fsrcnnx_upscale(descale, height=h * 2, shader_file=r'_shaders\FSRCNNX_x2_56-16-4-1.glsl',
upscaled_smooth=vdf.scale.eedi3_upscale(descale), profile='zastin',
sharpener=partial(gf.DetailSharpen, sstr=1.65, power=4, mode=0, med=True))
antialias = self.sraa_eedi3(upscale, 3, alpha=0.2, beta=0.4, gamma=100, mdis=20, nrad=3)
downscale = muvf.SSIM_downsample(antialias, src.width, src.height, kernel='Bicubic', filter_param_a=0, filter_param_b=0)
adaptmask = core.adg.Mask(downscale.std.PlaneStats(), 25).std.Minimum().std.Minimum().std.Convolution([1] * 9)
contra = gf.ContraSharpening(downscale, depth(preden, 32), radius=2).rgsf.Repair(downscale, 1)
contra = core.std.MaskedMerge(downscale, contra, adaptmask)
scaled = core.std.MaskedMerge(out, contra, lineart)
merged = vdf.misc.merge_chroma(depth(scaled, 16), src)
out = merged
detail_light_mask = lvf.mask.detail_mask(out, brz_a=1500, brz_b=600)
deband = vdf.deband.dumb3kdb(out, 16, [33, 1], sample_mode=4, use_neo=True)
deband = core.std.MaskedMerge(deband, out, detail_light_mask)
out = deband
# Restore the grain
neutral = inp.std.BlankClip(960, 540, color=128 << 8)
diff = join([inp.std.MakeDiff(preden), neutral, neutral])
grain = core.std.MergeDiff(out, diff)
out = grain
crop_a = self.crop_and_fix(out, src, top=128, bottom=136)
crop_b = self.crop_and_fix(out, src, top=132, bottom=140)
crop = out
crop = lvf.rfs(crop, crop_a, [(25696, 25750), (25768, 25963), (26916, 27095),
(27213, 27319), (27368, 27395), (27615, 27810)])
crop = lvf.rfs(crop, crop_b, [(25751, 25767), (25964, 26723), (26786, 26915),
(27096, 27212), (27320, 27367), (27396, 27614)])
out = crop
ref = src
creditless_mask = vdf.mask.diff_creditless_mask(
ref, src[opstart:opend+1], JPBD_NCOP.clip_cut[:opend-opstart+1], opstart, thr=25 << 8, sw=3, sh=3, prefilter=True
).std.Deflate()
ringing_mask = hvf.HQDeringmod(ref, mrad=1, msmooth=2, mthr=40, show=True)
credit = out
credit = lvf.rfs(credit, ref, [(edstart, edend)])
credit = lvf.rfs(credit, core.std.MaskedMerge(credit, ref, creditless_mask, 0), [(opstart, opend)])
credit = lvf.rfs(credit, core.std.MaskedMerge(credit, ref, ringing_mask, 0),
[(opstart + 169, opstart + 411)])
out = credit
endcard = out + out[31757] * 119
out = endcard
decs = vdf.noise.decsiz(out, sigmaS=10, min_in=110 << 8, max_in=192 << 8, gamma=1.1)
out = decs
return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2])
def main(self: Filtering) -> vs.VideoNode:
"""Vapoursynth filtering"""
src = JPBD.clip_cut
src = depth(src, 16)
out = src
h = 800 # noqa
w = get_w(h) # noqa
edstart, edend = 31384, 33540
inp = get_y(out)
out = inp
# Remove the grain
ref = hvf.SMDegrain(out, tr=1, thSAD=300, plane=0)
preden = mvf.BM3D(out, sigma=2, radius1=1, ref=ref)
out = preden
# Rescale / Antialiasing / Limiting
out = depth(out, 32)
lineart = vdf.mask.FDOG().get_mask(out, lthr=0.065, hthr=0.065).std.Maximum().std.Minimum()
lineart = lineart.std.Median().std.Convolution([1] * 9)
descale_clips = [core.resize.Bicubic(out, w, h, filter_param_a=1/3, filter_param_b=1/3),
core.descale.Debicubic(out, w, h, 0, 1 / 2),
core.descale.Debilinear(out, w, h)]
descale = core.std.Expr(descale_clips, 'x y z min max y z max min z min')
upscale = vdf.scale.fsrcnnx_upscale(descale, height=h * 2, shader_file=r'_shaders\FSRCNNX_x2_56-16-4-1.glsl',
upscaled_smooth=vdf.scale.eedi3_upscale(descale), profile='zastin',
sharpener=partial(gf.DetailSharpen, sstr=1.65, power=4, mode=0, med=True))
antialias = self.sraa_eedi3(upscale, 3, alpha=0.2, beta=0.4, gamma=100, mdis=20, nrad=3)
downscale = muvf.SSIM_downsample(antialias, src.width, src.height, kernel='Bicubic', filter_param_a=0, filter_param_b=0)
adaptmask = core.adg.Mask(downscale.std.PlaneStats(), 25).std.Minimum().std.Minimum().std.Convolution([1] * 9)
contra = gf.ContraSharpening(downscale, depth(preden, 32), radius=2).rgsf.Repair(downscale, 1)
contra = core.std.MaskedMerge(downscale, contra, adaptmask)
scaled = core.std.MaskedMerge(out, contra, lineart)
merged = vdf.misc.merge_chroma(depth(scaled, 16), src)
out = merged
detail_light_mask = lvf.mask.detail_mask(out, brz_a=1500, brz_b=600)
deband_a = vdf.deband.dumb3kdb(out, 16, [33, 1], sample_mode=4, use_neo=True)
deband_b = vdf.deband.dumb3kdb(out, 17, 40)
deband = lvf.rfs(deband_a, deband_b, [(11812, 11931), (33541, 33600)])
deband = core.std.MaskedMerge(deband, out, detail_light_mask)
out = deband
# Restore the grain
neutral = inp.std.BlankClip(960, 540, color=128 << 8)
diff = join([inp.std.MakeDiff(preden), neutral, neutral])
grain = core.std.MergeDiff(out, diff)
out = grain
ref = src
credit = out
credit = lvf.rfs(credit, ref, [(edstart, edend)])
out = credit
endcard = out + out[31717] * 121
out = endcard
decs = vdf.noise.decsiz(out, sigmaS=10, min_in=110 << 8, max_in=192 << 8, gamma=1.1)
out = decs
return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2])
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
# Variables
opstart, opend = 2038, 4196
eptitle_s, eptitle_e = 4197, 4316
edstart, edend = 31530, 33687
preview_s, preview_e = 33688, src.num_frames - 1
h = 720
w = get_w(h)
edges = core.edgefixer.ContinuityFixer(src, *[[2, 1, 1]] * 4)
out = depth(edges, 32)
ref = hvf.SMDegrain(depth(get_y(out), 16), thSAD=450)
denoise = hybrid_denoise(out, 0.35, 1.75, dict(a=2, d=1),
dict(ref=depth(ref, 32)))
out = denoise
y = get_y(out)
lineart = vdf.edge_detect(y, 'FDOG', 0.055,
(1, 1)).std.Median().std.Convolution([*[1] * 9])
descale = core.descale.Debilinear(y, w, h)
upscale = vdf.fsrcnnx_upscale(
descale,
height=h * 2,
shader_file=r'shaders\FSRCNNX_x2_56-16-4-1.glsl',
upscaler_smooth=eedi3_upscale,
profile='slow',
strength=85)
antialias = sraa_eedi3(upscale, 9)
downscale = muvf.SSIM_downsample(antialias,
src.width,
src.height,
filter_param_a=0,
filter_param_b=0)
downscale = core.std.MaskedMerge(y, downscale, lineart)
merged = vdf.merge_chroma(downscale, out)
merged = lvf.rfs(merged, out, [(opstart, opend), (eptitle_s, eptitle_e),
(preview_s, preview_e)])
out = depth(merged, 16)
detail_dark_mask = detail_dark_mask_func(get_y(out),
brz_a=8000,
brz_b=6000)
detail_light_mask = lvf.denoise.detail_mask(out, brz_a=2500, brz_b=1200)
detail_mask = core.std.Expr([detail_dark_mask, detail_light_mask],
'x y +').std.Median()
detail_mask_grow = iterate(detail_mask, core.std.Maximum, 2)
detail_mask_grow = iterate(detail_mask_grow, core.std.Inflate,
2).std.Convolution([*[1] * 9])
detail_mask = core.std.Expr([get_y(out), detail_mask_grow, detail_mask],
f'x {32<<8} < y z ?')
deband = dumb3kdbv2(out, 22, 24)
deband = core.std.MaskedMerge(deband, out, detail_mask)
deband_b = dumb3kdbv2(out, 24, 64)
deband_b = core.std.MaskedMerge(deband_b, out, detail_light_mask)
deband = lvf.rfs(deband, deband_b, [(opstart + 414, opstart + 496)])
out = deband
ref = get_y(out).std.PlaneStats()
adgmask_a = core.adg.Mask(ref, 30)
adgmask_b = core.adg.Mask(ref, 12)
stgrain = sizedgrn(out, 0.1, 0.05, 1.05, sharp=80)
stgrain = core.std.MaskedMerge(out, stgrain, adgmask_b)
stgrain = core.std.MaskedMerge(out, stgrain, adgmask_a.std.Invert())
dygrain = sizedgrn(out, 0.2, 0.05, 1.15, sharp=80, static=False)
dygrain = core.std.MaskedMerge(out, dygrain, adgmask_a)
grain = core.std.MergeDiff(dygrain, out.std.MakeDiff(stgrain))
out = grain
ref = depth(src, 16)
rescale_mask = vdf.drm(ref, 720, 'bilinear', mthr=30, sw=0, sh=0)
rescale_mask = vdf.region_mask(rescale_mask, *[10] * 4)
rescale_mask = hvf.mt_expand_multi(rescale_mask,
mode='ellipse',
sw=4,
sh=4)
rescale_mask = rescale_mask.std.Binarize(scale_value(
100, 8, 16)).std.Inflate().std.Convolution([*[1] * 9])
credit = out
credit = lvf.rfs(credit, core.std.MaskedMerge(credit, ref, rescale_mask,
0), [(8993, 9066),
(20104, 20223),
(edstart, edend)])
out = credit
return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 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, [(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 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
h = 900
w = get_w(h)
# Remove the grain
ref = hvf.SMDegrain(out, tr=1, thSAD=300, plane=4)
degrain = mvf.BM3D(out, sigma=[1.5, 1], radius1=1, ref=ref)
degrain = insert_clip(degrain, smhdegrain(out[5539:5670], 2, 280), 5539)
degrain = insert_clip(degrain, smhdegrain(out[5933:5992], 2, 200), 5933)
degrain = insert_clip(degrain, smhdegrain(out[6115:6180], 2, 200), 6115)
degrain = insert_clip(degrain, smhdegrain(out[6180:6281], 2, 200), 6180)
degrain = insert_clip(degrain, smhdegrain(out[39303:39482], 2, 280), 39303)
degrain = insert_clip(degrain, smhdegrain(out[40391:40837], 2, 200), 40391)
degrain = insert_clip(degrain, smhdegrain(out[40908:41087], 2, 280), 40908)
degrain = insert_clip(degrain, smhdegrain(out[41671:41791], 2, 280), 41671)
degrain = insert_clip(degrain, smhdegrain(out[41791:41977], 2, 280), 41791)
degrain = insert_clip(degrain, smhdegrain(out[41977:42073], 2, 280), 41977)
degrain = insert_clip(degrain, smhdegrain(out[43083:44462], 2, 350), 43083)
degrain = lvf.rfs(degrain, out, [(51749, 52387)])
out = depth(degrain, 32)
luma = get_y(out)
line_mask = vdf.edge_detect(luma, 'kirsch', 0.075,
(1, 1)).std.Median().std.Inflate()
descale = core.descale.Debilinear(luma, w, h)
upscale = eedi3_upscale(descale)
antialias = single_rate_antialiasing(upscale,
13,
alpha=0.2,
beta=0.6,
gamma=300,
mdis=15).resize.Bicubic(
src.width, src.height)
rescale = core.std.MaskedMerge(luma, antialias, line_mask)
merged = vdf.merge_chroma(rescale, out)
out = depth(merged, 16)
y = get_y(out)
detail_light_mask = lvf.denoise.detail_mask(y.std.Median(),
brz_a=2500,
brz_b=1200)
pf = out.std.Convolution([1] * 9).std.Merge(out, 0.45)
diffdb = core.std.MakeDiff(out, pf)
deband = dumb3kdb(pf, 16, 30)
deband_b = dbs.f3kbilateral(pf, 20, 100)
deband = lvf.rfs(deband, deband_b, [(43083, 44461)])
deband = core.std.MergeDiff(deband, diffdb)
deband = core.std.MaskedMerge(deband, out, detail_light_mask)
deband = lvf.rfs(deband, out, [(51749, 52387)])
out = deband
sharp = hvf.LSFmod(out,
strength=65,
Smode=3,
Lmode=1,
edgemode=1,
edgemaskHQ=True)
out = sharp
ref = get_y(out).std.PlaneStats()
adgmask_a = core.adg.Mask(ref, 30)
adgmask_b = core.adg.Mask(ref, 12)
stgrain = sizedgrn(out, 0.1, 0.05, 1.00)
stgrain = core.std.MaskedMerge(out, stgrain, adgmask_b)
stgrain = core.std.MaskedMerge(out, stgrain, adgmask_a.std.Invert())
dygrain = sizedgrn(out, 0.2, 0.05, 1.05, sharp=60, static=False)
dygrain = core.std.MaskedMerge(out, dygrain, adgmask_a)
grain = core.std.MergeDiff(dygrain, out.std.MakeDiff(stgrain))
out = grain
ref = src
rescale_mask = vdf.drm(ref, h, mthr=65, sw=4, sh=4)
credit = out
credit = lvf.rfs(credit, core.std.MaskedMerge(credit, ref, rescale_mask,
0), [(0, 2956),
(43104, 45749)])
credit = lvf.rfs(credit, ref, [(45824, 50401),
(52388, src.num_frames - 1)])
out = credit
return depth(out, 10)
def ref_denoise(clip: vs.VideoNode, **kwargs) -> vs.VideoNode:
return hvf.SMDegrain(clip, **kwargs)
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
src = depth(src, 16)
out = src
# Remove the noise
ref = hvf.SMDegrain(out, tr=1, thSAD=300, plane=4)
denoise = mvf.BM3D(out, sigma=[2, 1], radius1=1, ref=ref)
out = denoise
# Limited antialiasing
y = get_y(out)
lineart = core.std.Sobel(y).std.Binarize(
75 << 8).std.Maximum().std.Inflate()
aa = lvf.sraa(y,
2,
13,
downscaler=partial(core.resize.Bicubic,
filter_param_a=-0.5,
filter_param_b=0.25))
sharp = hvf.LSFmod(aa, strength=70, Smode=3, edgemode=0, source=y)
y = core.std.MaskedMerge(y, sharp, lineart)
out = vdf.merge_chroma(y, out)
# Deband masks
planes = split(out)
preden = core.dfttest.DFTTest(out,
sigma=14.0,
sigma2=10.0,
sbsize=1,
sosize=0,
planes=[0, 1, 2]).rgvs.RemoveGrain(3)
grad_mask, yrangebig = morpho_mask(preden)
rgb = core.resize.Bicubic(preden, 960, 540,
format=vs.RGB48).std.SetFrameProp('_Matrix',
delete=True)
chroma_masks = [
core.std.Prewitt(p).std.Binarize(5500).rgvs.RemoveGrain(11)
for p in split(rgb) + split(preden)[1:]
]
chroma_mask = core.std.Expr(chroma_masks,
'x y + z + a + b +').std.Maximum()
chroma_mask = core.std.Merge(chroma_mask,
chroma_mask.std.Minimum()).std.BoxBlur(
0, 1, 1, 1, 1)
detail_mask = lvf.denoise.detail_mask(planes[0].std.BoxBlur(0, 1, 1, 1, 1),
brz_a=3300,
brz_b=2000)
# Debanding stages
debands = [None] * 3
deband_y_strong = dbs.f3kbilateral(planes[0], 16, 65)
deband_y_normal = dumb3kdb(planes[0], 16, 41)
deband_y_light = core.std.MaskedMerge(dumb3kdb(planes[0], 14, 32),
planes[0], detail_mask)
debands[1] = dbs.f3kbilateral(planes[1], 12, 50)
debands[2] = dbs.f3kbilateral(planes[2], 12, 50)
debands[0] = core.std.MaskedMerge(deband_y_strong, deband_y_normal,
grad_mask)
debands[0] = core.std.MaskedMerge(debands[0], deband_y_light, yrangebig)
debands[1], debands[2] = [
core.std.MaskedMerge(debands[i], planes[i], chroma_mask)
for i in range(1, 3)
]
deband = join(debands)
out = deband
# Regraining
ref = get_y(out).std.PlaneStats()
adgmask_a = core.adg.Mask(ref, 25)
adgmask_b = core.adg.Mask(ref, 10)
stgrain_a = core.grain.Add(out, 0.1, 0, seed=333)
stgrain_a = core.std.MaskedMerge(out, stgrain_a, adgmask_b.std.Invert())
stgrain_b = sizedgrn(out, 0.2, 0.1, 1.15, sharp=80, 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, seed=333)
dygrain = core.std.MaskedMerge(out, dygrain, adgmask_a)
grain = core.std.MergeDiff(dygrain, out.std.MakeDiff(stgrain))
out = grain
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 += src[-1]
# Variables
opstart, opend = 2206, 4362
eptitle_s, eptitle_e = 4363, 4482
edstart, edend = 31528, 33685
preview_s, preview_e = 33686, src.num_frames - 1
h = 720
w = get_w(h)
edges = core.edgefixer.ContinuityFixer(src, *[[2, 1, 1]] * 4)
out = depth(edges, 32)
ref = hvf.SMDegrain(depth(get_y(out), 16), thSAD=450)
denoise = hybrid_denoise(out, 0.35, 1.75, dict(a=2, d=1),
dict(ref=depth(ref, 32)))
out = denoise
y = get_y(out)
lineart = vdf.edge_detect(y, 'FDOG', 0.055,
(1, 1)).std.Median().std.Convolution([*[1] * 9])
descale = core.descale.Debilinear(y, w, h)
upscale = vdf.fsrcnnx_upscale(
descale,
height=h * 2,
shader_file=r'shaders\FSRCNNX_x2_56-16-4-1.glsl',
upscaler_smooth=eedi3_upscale,
profile='slow',
strength=85)
antialias = sraa_eedi3(upscale, 9)
downscale = muvf.SSIM_downsample(antialias,
src.width,
src.height,
filter_param_a=0,
filter_param_b=0)
downscale = core.std.MaskedMerge(y, downscale, lineart)
merged = vdf.merge_chroma(downscale, out)
merged = lvf.rfs(merged, out, [(opstart, opend), (eptitle_s, eptitle_e),
(preview_s, preview_e)])
out = depth(merged, 16)
detail_dark_mask = detail_dark_mask_func(get_y(out),
brz_a=8000,
brz_b=6000)
detail_light_mask = lvf.denoise.detail_mask(out, brz_a=2500, brz_b=1200)
detail_mask = core.std.Expr([detail_dark_mask, detail_light_mask],
'x y +').std.Median()
detail_mask_grow = iterate(detail_mask, core.std.Maximum, 2)
detail_mask_grow = iterate(detail_mask_grow, core.std.Inflate,
2).std.Convolution([*[1] * 9])
detail_mask = core.std.Expr([get_y(out), detail_mask_grow, detail_mask],
f'x {32<<8} < y z ?')
deband = dumb3kdbv2(out, 22, 24)
deband = core.std.MaskedMerge(deband, out, detail_mask)
out = deband
ref = get_y(out).std.PlaneStats()
adgmask_a = core.adg.Mask(ref, 30)
adgmask_b = core.adg.Mask(ref, 12)
stgrain = sizedgrn(out, 0.1, 0.05, 1.05, sharp=80)
stgrain = core.std.MaskedMerge(out, stgrain, adgmask_b)
stgrain = core.std.MaskedMerge(out, stgrain, adgmask_a.std.Invert())
dygrain = sizedgrn(out, 0.2, 0.05, 1.15, sharp=80, static=False)
dygrain = core.std.MaskedMerge(out, dygrain, adgmask_a)
grain = core.std.MergeDiff(dygrain, out.std.MakeDiff(stgrain))
out = grain
ref = depth(src, 16)
rescale_mask = vdf.drm(ref, 720, 'bilinear', mthr=30, sw=0, sh=0)
rescale_mask = vdf.region_mask(rescale_mask, *[10] * 4)
rescale_mask = hvf.mt_expand_multi(rescale_mask,
mode='ellipse',
sw=4,
sh=4)
rescale_mask = rescale_mask.std.Binarize(scale_value(
100, 8, 16)).std.Inflate().std.Convolution([*[1] * 9])
dehalo_ref = gf.MaskedDHA(ref,
rx=1.65,
ry=1.65,
darkstr=0.15,
brightstr=1.0,
maskpull=48,
maskpush=140)
dehalo_mask_b = vdf.region_mask(rescale_mask, right=400)
credit = out
dehalo_range_b = [(18, 101), (16853, 16917)]
credit = lvf.rfs(credit, core.std.MaskedMerge(credit, ref, rescale_mask,
0),
[(126, 160), (1722, 1761), (7749, 7795), (8189, 8232),
(8445, 8504), (9020, 9067), (9727, 9768), (12430, 12520),
(12876, 12971), (13608, 13646), (15833, 15879),
(20526, 20586), (20783, 20823), (21193, 21239),
(23812, 23854), (24018, 24059),
(edstart, edend)] + dehalo_range_b)
credit = lvf.rfs(
credit, core.std.MaskedMerge(credit, dehalo_ref, dehalo_mask_b, 0),
dehalo_range_b)
out = credit
return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 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 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 = JPBD.src_cut
# Variables
opstart, opend = 2111, 4268
edstart, edend = 31650, 33809
full_zone = [(18727, 18774), (31590, 31649), (33990, src.num_frames - 1)
] # eyecatch, episode name and next episode
shabc_zone = [(edstart + 15, edstart + 1215),
(edstart + 1882, edstart + 2126)]
h = 720
w = get_w(h)
# Bicubic sharp parts don't have bad edges
edges_a = core.edgefixer.ContinuityFixer(src, *[[2, 1, 1]] * 4)
edges_b = awf.bbmod(src, left=6, thresh=32, blur=200)
edges = lvf.rfs(edges_a, edges_b, [(edstart + 1275, edstart + 1757)])
edges = lvf.rfs(edges, src, [(opstart, opend)] + full_zone)
out = depth(edges, 32)
# Denoise
ref = hvf.SMDegrain(depth(get_y(out), 16), thSAD=450)
denoise = hybrid_denoise(out, 0.35, 1.4, dict(a=2, d=1),
dict(ref=depth(ref, 32)))
out = denoise
# denoise = out
# Descale
luma = get_y(out)
lineart = vdf.edge_detect(luma, 'FDOG', 0.055,
(1, 1)).std.Median().std.BoxBlur(0, 1, 1, 1, 1)
descale_a = core.descale.Despline36(luma, w,
h).std.SetFrameProp('descaleKernel',
data='spline36')
descale_b = core.descale.Debicubic(luma, w, h, 0, 1).std.SetFrameProp(
'descaleKernel', data='sharp_bicubic')
descale = lvf.rfs(descale_a, descale_b, shabc_zone)
# Chroma reconstruction
# y_m is the assumed mangled luma.
# Descale 1080p -> Bad conversion in 422 720p -> Regular 1080p 420
radius = 2
y, u, v = descale, plane(out, 1), plane(out, 2)
y_m = core.resize.Point(y, 640, 720,
src_left=-1).resize.Bicubic(960,
540,
filter_param_a=1 / 3,
filter_param_b=1 / 3)
# 0.25 for 444 and 0.25 for right shifting
y_m, u, v = [
c.resize.Bicubic(w,
h,
src_left=0.25 + 0.25,
filter_param_a=0,
filter_param_b=.5) for c in [y_m, u, v]
]
y_fixup = core.std.MakeDiff(y, y_m)
yu, yv = Regress(y_m, u, v, radius=radius, eps=1e-7)
u_fixup = ReconstructMulti(y_fixup, yu, radius=radius)
u_r = core.std.MergeDiff(u, u_fixup)
v_fixup = ReconstructMulti(y_fixup, yv, radius=radius)
v_r = core.std.MergeDiff(v, v_fixup)
# -0.5 * 720/1080 = -1/3
# -1/3 for the right shift
# https://forum.doom9.org/showthread.php?p=1802716#post1802716
u_r, v_r = [
c.resize.Bicubic(960,
540,
src_left=-1 / 3,
filter_param_a=-.5,
filter_param_b=.25) for c in [u_r, v_r]
]
upscale = vdf.fsrcnnx_upscale(
descale,
height=h * 2,
shader_file=r'shaders\FSRCNNX_x2_56-16-4-1.glsl',
upscaler_smooth=eedi3_upscale,
profile='zastin')
antialias = sraa_eedi3(upscale,
3,
alpha=0.2,
beta=0.4,
gamma=40,
nrad=3,
mdis=20)
downscale = muvf.SSIM_downsample(antialias,
src.width,
src.height,
filter_param_a=0,
filter_param_b=0)
downscale = core.std.MaskedMerge(luma, downscale, lineart)
merged_a = join([downscale, u_r, v_r])
merged_b = vdf.merge_chroma(downscale, denoise)
merged = lvf.rfs(merged_a, merged_b, shabc_zone)
out = depth(merged, 16)
warp = xvs.WarpFixChromaBlend(out, 80, 2, depth=8)
out = warp
dering = gf.MaskedDHA(out,
rx=1.25,
ry=1.25,
darkstr=0.05,
brightstr=1.0,
maskpull=48,
maskpush=140)
out = dering
qtgmc = hvf.QTGMC(out, Preset="Slower", InputType=1, ProgSADMask=2.0)
qtgmc = vdf.fade_filter(out, out, qtgmc, edstart + 1522,
edstart + 1522 + 24)
qtgmc = lvf.rfs(out, qtgmc, [(edstart + 1522 + 25, edstart + 1757)])
out = qtgmc
out = lvf.rfs(out, depth(denoise, 16), [(opstart, opend)])
detail_dark_mask = detail_dark_mask_func(get_y(out),
brz_a=8000,
brz_b=6000)
detail_light_mask = lvf.denoise.detail_mask(out, brz_a=2500, brz_b=1200)
detail_mask = core.std.Expr([detail_dark_mask, detail_light_mask],
'x y +').std.Median()
detail_mask_grow = iterate(detail_mask, core.std.Maximum, 2)
detail_mask_grow = iterate(detail_mask_grow, core.std.Inflate,
2).std.BoxBlur(0, 1, 1, 1, 1)
detail_mask = core.std.Expr([get_y(out), detail_mask_grow, detail_mask],
f'x {32<<8} < y z ?')
deband = dumb3kdb(out, 22, 30)
deband = core.std.MaskedMerge(deband, out, detail_mask)
out = deband
ref = get_y(out).std.PlaneStats()
adgmask_a = core.adg.Mask(ref, 30)
adgmask_b = core.adg.Mask(ref, 12)
stgrain = sizedgrn(out, 0.1, 0.05, 1.05, sharp=80)
stgrain = core.std.MaskedMerge(out, stgrain, adgmask_b)
stgrain = core.std.MaskedMerge(out, stgrain, adgmask_a.std.Invert())
dygrain = sizedgrn(out, 0.2, 0.05, 1.15, sharp=80, static=False)
dygrain = core.std.MaskedMerge(out, dygrain, adgmask_a)
grain = core.std.MergeDiff(dygrain, out.std.MakeDiff(stgrain))
out = grain
ref = depth(edges, 16)
credit = out
rescale_mask = vdf.diff_rescale_mask(ref, h, b=0, c=1, mthr=40, sw=0, sh=0)
rescale_mask = vdf.region_mask(rescale_mask, *[10] * 4)
rescale_mask = hvf.mt_expand_multi(rescale_mask,
mode='ellipse',
sw=4,
sh=4).std.BoxBlur(0, 1, 1, 1, 1)
credit = lvf.rfs(credit, ref, full_zone)
credit = lvf.rfs(credit, core.std.MaskedMerge(credit, ref, rescale_mask),
[(edstart, edend)])
out = credit
return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2])
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
src = depth(src, 16)
out = src
edstart, edend = 31888, src.num_frames-1
shift = core.resize.Point(out, src_left=1).edgefixer.ContinuityFixer([2, 1, 1], 0, 0, 0)
out = lvf.rfs(out, shift, [(235, 318)])
ref = hvf.SMDegrain(out, tr=1, thSAD=300, plane=4)
denoise = mvf.BM3D(out, [1.5, 1], 1, profile1='lc', ref=ref)
out = denoise
y = get_y(out)
lineart = vdf.edge_detect(y, 'FDOG', scale_value(0.065, 32, 16), (1, 1)).std.Median().std.BoxBlur(0, 1, 1, 1, 1)
rescale = fake_rescale(y, 837.5, 1/3, 1/3, coef_dering=0.1, coef_dark=1.25,
coef_warp=1.15, coef_sharp=0.75, coef_finalsharp=0.85)
rescale = core.std.MaskedMerge(y, rescale, lineart)
out = vdf.merge_chroma(rescale, out)
preden = core.dfttest.DFTTest(get_y(out), ftype=0, sigma=0.5, sbsize=16, sosize=12, tbsize=1)
detail_dark_mask = detail_dark_mask_func(preden, brz_a=6000, brz_b=5000)
detail_light_mask = lvf.denoise.detail_mask(preden, brz_a=2500, brz_b=1200)
detail_mask = core.std.Expr([detail_dark_mask, detail_light_mask], 'x y +').std.Median()
detail_mask_grow = iterate(detail_mask, core.std.Maximum, 2)
detail_mask_grow = iterate(detail_mask_grow, core.std.Inflate, 2).std.BoxBlur(0, 1, 1, 1, 1)
detail_mask = core.std.Expr([preden, detail_mask_grow, detail_mask], f'x {40<<8} < y z ?')
pf = vdf.merge_chroma(preden, out)
deband = dumb3kdb(pf, 17, 40)
deband_b = dumb3kdb(pf, 20, 80)
deband = lvf.rfs(deband, deband_b, [(2194, 2216), (2283, 2306)])
deband = core.std.MergeDiff(deband, out.std.MakeDiff(pf))
deband = core.std.MaskedMerge(deband, out, detail_light_mask)
out = deband
grain = kgf.adaptive_grain(out, 0.35)
out = grain
ref = depth(src, 16)
src_c, src_nced = [depth(x, 16) for x in [src, JPBD_NCED.src_cut[13:]]]
ending_mask = vdf.dcm(out, src_c[edstart:edend+1], src_nced[:edend-edstart+1], edstart, edend, 2, 2).std.BoxBlur(0, 2, 2, 2, 2)
credit = out
credit = lvf.rfs(credit, core.std.MaskedMerge(credit, ref, ending_mask), [(31900, 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 = 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 smhdegrain(clip: vs.VideoNode, tr, th) -> vs.VideoNode:
return hvf.SMDegrain(clip, tr=tr, thSAD=th, plane=4)
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 do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
src += src[-1]
# Variables
opstart, opend = 8296, 10452
eptitle_s, eptitle_e = 10453, 10572
edstart, edend = 31528, 33685
preview_s, preview_e = 33686, src.num_frames - 1
h = 720
w = get_w(h)
edges = core.edgefixer.ContinuityFixer(src, *[[2, 1, 1]] * 4)
out = depth(edges, 32)
ref = hvf.SMDegrain(depth(get_y(out), 16), thSAD=450)
denoise = hybrid_denoise(out, 0.35, 1.75, dict(a=2, d=1),
dict(ref=depth(ref, 32)))
out = denoise
y = get_y(out)
lineart = vdf.edge_detect(y, 'FDOG', 0.055,
(1, 1)).std.Median().std.Convolution([*[1] * 9])
descale = core.descale.Debilinear(y, w, h)
upscale = vdf.fsrcnnx_upscale(
descale,
height=h * 2,
shader_file=r'shaders\FSRCNNX_x2_56-16-4-1.glsl',
upscaler_smooth=eedi3_upscale,
profile='slow',
strength=85)
antialias = sraa_eedi3(upscale, 9)
downscale = muvf.SSIM_downsample(antialias,
src.width,
src.height,
filter_param_a=0,
filter_param_b=0)
downscale = core.std.MaskedMerge(y, downscale, lineart)
merged = vdf.merge_chroma(downscale, out)
merged = lvf.rfs(merged, out, [(opstart, opend), (eptitle_s, eptitle_e),
(preview_s, preview_e)])
out = depth(merged, 16)
detail_dark_mask = detail_dark_mask_func(get_y(out),
brz_a=8000,
brz_b=6000)
detail_light_mask = lvf.denoise.detail_mask(out, brz_a=2500, brz_b=1200)
detail_mask = core.std.Expr([detail_dark_mask, detail_light_mask],
'x y +').std.Median()
detail_mask_grow = iterate(detail_mask, core.std.Maximum, 2)
detail_mask_grow = iterate(detail_mask_grow, core.std.Inflate,
2).std.Convolution([*[1] * 9])
detail_mask = core.std.Expr([get_y(out), detail_mask_grow, detail_mask],
f'x {32<<8} < y z ?')
deband = dumb3kdbv2(out, 22, 24)
deband = core.std.MaskedMerge(deband, out, detail_mask)
deband_b = dumb3kdbv2(out, 24, 64)
deband_b = core.std.MaskedMerge(deband_b, out, detail_light_mask)
deband = lvf.rfs(deband, deband_b, [(opstart + 414, opstart + 496)])
out = deband
ref = get_y(out).std.PlaneStats()
adgmask_a = core.adg.Mask(ref, 30)
adgmask_b = core.adg.Mask(ref, 12)
stgrain = sizedgrn(out, 0.1, 0.05, 1.05, sharp=80)
stgrain = core.std.MaskedMerge(out, stgrain, adgmask_b)
stgrain = core.std.MaskedMerge(out, stgrain, adgmask_a.std.Invert())
dygrain = sizedgrn(out, 0.2, 0.05, 1.15, sharp=80, static=False)
dygrain = core.std.MaskedMerge(out, dygrain, adgmask_a)
grain = core.std.MergeDiff(dygrain, out.std.MakeDiff(stgrain))
out = grain
ref = depth(src, 16)
rescale_mask = vdf.drm(ref, 720, 'bilinear', mthr=30, sw=0, sh=0)
rescale_mask = vdf.region_mask(rescale_mask, *[10] * 4)
rescale_mask = hvf.mt_expand_multi(rescale_mask,
mode='ellipse',
sw=4,
sh=4)
rescale_mask = rescale_mask.std.Binarize(scale_value(
100, 8, 16)).std.Inflate().std.Convolution([*[1] * 9])
dehalo_ref = gf.MaskedDHA(ref,
rx=1.65,
ry=1.65,
darkstr=0.15,
brightstr=1.0,
maskpull=48,
maskpush=140)
dehalo_mask_a = vdf.region_mask(rescale_mask, top=650, right=200)
credit = out
dehalo_range_a = [(18, 130), (1291, 1355), (14691, 14846), (15126, 15189)]
credit = lvf.rfs(credit, core.std.MaskedMerge(credit, ref, rescale_mask,
0),
[(131, 220), (400, 505), (817, 899), (1766, 1809),
(1925, 2041), (4033, 4116), (4342, 4453), (4964, 5031),
(6422, 6515), (7848, 7978),
(10606, 10728), (11619, 11701), (15339, 15457),
(edstart, edend)] + dehalo_range_a)
credit = lvf.rfs(
credit, core.std.MaskedMerge(credit, dehalo_ref, dehalo_mask_a, 0),
dehalo_range_a)
out = credit
return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2])
def quick_denoise(clip: vs.VideoNode,
ref: Optional[vs.VideoNode] = None,
cmode: str = 'knlm',
sigma: float = 2,
**kwargs: Any) -> vs.VideoNode:
"""
This wrapper is used to denoise both the luma and chroma using various denoisers of your choosing.
If you wish to use just one denoiser,
you're probably better off using that specific filter rather than this wrapper.
A rewrite of my old 'quick_denoise'. I still hate it, but whatever.
This will probably be removed in a future commit.
BM3D is used for denoising the luma.
Special thanks to kageru for helping me out with some ideas and pointers.
Alias for this function is `lvsfunc.qden`.
Dependencies: havsfunc (optional: SMDegrain mode), mvsfunc
Deciphering havsfunc's dependencies is left as an excercise for the user.
:param clip: Input clip
:param cmode: Chroma denoising modes:
'knlm' - Use knlmeans for denoising the chroma (Default),
'tnlm' - Use tnlmeans for denoising the chroma,
'dft' - Use dfttest for denoising the chroma (requires setting 'sbsize' in kwargs),
'smd' - Use SMDegrain for denoising the chroma,
:param sigma: Denoising strength for BM3D (Default: 2)
:param ref: Optional reference clip to replace BM3D's basic estimate
:param kwargs: Parameters passed to chroma denoiser
:return: Denoised clip
"""
try:
import mvsfunc as mvf
except ModuleNotFoundError:
raise ModuleNotFoundError(
"quick_denoise: missing dependency 'mvsfunc'")
if clip.format is None or clip.format.color_family not in (vs.YUV,
vs.YCOCG,
vs.RGB):
raise ValueError(
"quick_denoise: input clip must be vs.YUV, vs.YCOCG, or vs.RGB")
planes = split(clip)
cmode = cmode.lower()
if cmode in [1, 'knlm', 'knlmeanscl']:
planes[1] = planes[1].knlm.KNLMeansCL(d=3, a=2, **kwargs)
planes[2] = planes[2].knlm.KNLMeansCL(d=3, a=2, **kwargs)
elif cmode in [2, 'tnlm', 'tnlmeans']:
planes[1] = planes[1].tnlm.TNLMeans(ax=2, ay=2, az=2, **kwargs)
planes[2] = planes[2].tnlm.TNLMeans(ax=2, ay=2, az=2, **kwargs)
elif cmode in [3, 'dft', 'dfttest']:
try:
sbsize = cast(int, kwargs['sbsize'])
planes[1] = planes[1].dfttest.DFTTest(sosize=int(sbsize * 0.75),
**kwargs)
planes[2] = planes[2].dfttest.DFTTest(sosize=int(sbsize * 0.75),
**kwargs)
except KeyError:
raise ValueError("quick_denoise: '\"sbsize\" not specified'")
elif cmode in [4, 'smd', 'smdegrain']:
try:
import havsfunc as haf
except ModuleNotFoundError:
raise ModuleNotFoundError(
"quick_denoise: missing dependency 'havsfunc'")
planes[1] = haf.SMDegrain(planes[1], prefilter=3, **kwargs)
planes[2] = haf.SMDegrain(planes[2], prefilter=3, **kwargs)
else:
raise ValueError("quick_denoise: 'Unknown cmode'")
ref = ref or planes[0]
planes[0] = mvf.BM3D(planes[0], sigma=sigma, psample=0, radius1=1, ref=ref)
return join(planes)
