def test_retinex_edgemask(self):
mask = kgf.retinex_edgemask(self.BLACK_SAMPLE_CLIP)
self.assert_same_bitdepth(mask, self.BLACK_SAMPLE_CLIP)
self.assert_same_length(mask, self.BLACK_SAMPLE_CLIP)
self.assertEqual(mask.format.color_family, vs.GRAY)
# request a frame to see if that errors
mask.get_frame(0)
def _ret_mask(clip: vs.VideoNode, thr: int) -> vs.VideoNode:
mask = kgf.retinex_edgemask(clip)
mask = core.std.Median(mask).std.Binarize(thr)
mask = iterate(mask, core.std.Median, 2)
mask = iterate(mask, core.std.Maximum, 3)
mask = iterate(mask, core.std.Minimum, 2)
return mask
def _fsrlineart(clip: vs.VideoNode, width: int, height: int) -> vs.VideoNode:
clip = clip.resize.Point(1440, 810)
assert clip.format is not None
nn = depth(nnedi3_double(depth(clip, 16)), clip.format.bits_per_sample)
fsr = fsrcnnx_upscale(clip, width, height, upscaled_smooth=nn, shader_file=FSRCNNX)
mask = retinex_edgemask(depth(fsr.std.ShufflePlanes(0, vs.GRAY), 16))
mask = mask.std.Binarize(scale_thresh(0.65, mask)).std.Maximum()
mask = depth(mask, clip.format.bits_per_sample, range_in=CRange.FULL, range=CRange.FULL)
return core.std.MaskedMerge(nn.resize.Bicubic(width, height, filter_param_a=0, filter_param_b=1/2), fsr, mask)
def nneedi3_clamp(clip: vs.VideoNode,
mask: vs.VideoNode = None,
ret_mask: bool = False, show_mask: bool = False,
opencl: bool = False,
strength: int = 1,
alpha: float = 0.25, beta: float = 0.5, gamma: int = 40,
nrad: int = 2, mdis: int = 20,
nsize: int = 3, nns: int = 3,
qual: int = 1) -> vs.VideoNode:
funcname = "nneedi3_clamp"
"""
Script written by Zastin. What it does is clamp the "change" done by eedi3 to the "change" of nnedi3.
This should fix every issue created by eedi3. For example: https://i.imgur.com/hYVhetS.jpg
:param mask: Allows for user to use their own mask
:param ret_mask: bool: Whether or not to use a binarized kgf.retinex_edgemask
to replace more lineart with nnedi3
:param show_mask: bool: Whether or not to return the mask instead of the processed clip
:param opencl: bool: Allows TAAmbk to use opencl acceleration when anti-aliasing
:param strength: (Default value = 1)
:param alpha: float: (Default value = 0.25)
:param beta: float: (Default value = 0.5)
:param gamma: (Default value = 40)
:param nrad: (Default value = 2)
:param mdis: (Default value = 20)
:param nsize: (Default value = 3)
:param nns: (Default value = 3)
:param qual: (Default value = 1)
"""
bits = clip.format.bits_per_sample - 8
thr = strength * (1 >> bits)
strong = TAAmbk(clip, aatype='Eedi3', alpha=alpha, beta=beta, gamma=gamma, nrad=nrad, mdis=mdis, mtype=0,
opencl=opencl)
weak = TAAmbk(clip, aatype='Nnedi3', nsize=nsize, nns=nns, qual=qual, mtype=0, opencl=opencl)
expr = 'x z - y z - * 0 < y x y {0} + min y {0} - max ?'.format(thr)
if clip.format.num_planes > 1:
expr = [expr, '']
aa = core.std.Expr([strong, weak, clip], expr)
if mask:
merged = clip.std.MaskedMerge(aa, mask, planes=0)
elif ret_mask:
mask = kgf.retinex_edgemask(clip, 1).std.Binarize()
merged = clip.std.MaskedMerge(aa, mask, planes=0)
else:
mask = clip.std.Prewitt(planes=0).std.Binarize(planes=0).std.Maximum(planes=0).std.Convolution([1] * 9, planes=0)
mask = get_y(mask)
merged = clip.std.MaskedMerge(aa, mask, planes=0)
if show_mask:
return mask
return merged if clip.format.color_family == vs.GRAY else core.std.ShufflePlanes([merged, clip], [0, 1, 2], vs.YUV)
def _inverse_mask(clip: vs.VideoNode,
reupscaled: vs.VideoNode,
franges: List[FadeRange] = [],
dranges: List[Range] = []) -> vs.VideoNode:
reupscaled = reupscaled.resize.Bicubic(format=clip.format.id)
line_mask = retinex_edgemask(clip, 0.0001).std.Binarize(10000)
fade_mask = _fade_ranges_with_refs(clip, reupscaled, franges)
mask = core.std.Expr([fade_mask, line_mask.std.Invert()], "x y +")
if dranges:
detail_mask = descale_detail_mask(clip, reupscaled, threshold=1500)
mask_with_detail = core.std.Expr([mask, detail_mask], "x y +")
mask = replace_ranges(mask, mask_with_detail, dranges)
return mask.resize.Bicubic(format=clip.format.id)
def do_filter():
"""Vapoursynth filtering"""
def _nneedi3_clamp(clip: vs.VideoNode, strength: int = 1)-> vs.VideoNode:
bits = clip.format.bits_per_sample - 8
thr = strength * (1 >> bits)
luma = get_y(clip)
def _strong(clip: vs.VideoNode)-> vs.VideoNode:
args = dict(alpha=0.25, beta=0.5, gamma=40, nrad=2, mdis=20, vcheck=3)
clip = core.eedi3m.EEDI3(clip, 1, True, **args).std.Transpose()
clip = core.eedi3m.EEDI3(clip, 1, True, **args).std.Transpose()
return core.resize.Spline36(clip, luma.width, luma.height, src_left=-.5, src_top=-.5)
def _weak(clip: vs.VideoNode)-> vs.VideoNode:
args = dict(nsize=3, nns=2, qual=2)
clip = core.znedi3.nnedi3(clip, 1, True, **args).std.Transpose()
clip = core.znedi3.nnedi3(clip, 1, True, **args).std.Transpose()
return core.resize.Spline36(clip, luma.width, luma.height, src_left=-.5, src_top=-.5)
clip_aa = core.std.Expr([_strong(luma), _weak(luma), luma],
'x z - y z - * 0 < y x y {0} + min y {0} - max ?'.format(thr))
return vdf.merge_chroma(clip_aa, clip)
src = JPBD.src_cut
src = depth(src, 16)
denoise = CoolDegrain(src, tr=2, thsad=48, blksize=8, overlap=4, plane=4)
antialias = _nneedi3_clamp(denoise)
predenoise = mClean(antialias, thSAD=200, chroma=False)
detail_mask = lvf.denoise.detail_mask(predenoise, rad=2, radc=2, brz_a=3250, brz_b=1250)
ret_mask = kgf.retinex_edgemask(predenoise).std.Binarize(9250).std.Median().std.Inflate()
line_mask = core.std.Expr([detail_mask, ret_mask], 'x y max')
deband = core.neo_f3kdb.Deband(antialias, 17, 42, 42, 42, 12, 0, sample_mode=4, keep_tv_range=True)
deband = core.std.MaskedMerge(deband, antialias, line_mask)
grain = kgf.adaptive_grain(deband, 0.25, luma_scaling=10)
final = core.resize.Bicubic(grain, format=vs.YUV420P10, dither_type='error_diffusion')
final = core.std.Limiter(final, 16, [235 << 2, 240 << 2])
return depth(final, 10)
def nneedi3_clamp(clip: vs.VideoNode, strength: int = 1,
mask: vs.VideoNode = None,
ret_mask: bool = False, show_mask: bool = False,
opencl: bool = False) -> vs.VideoNode:
funcname = "nneedi3_clamp"
"""
Script written by Zastin. What it does is clamp the "change" done by eedi3 to the "change" of nnedi3.
This should fix every issue created by eedi3. For example: https://i.imgur.com/hYVhetS.jpg
:param strength: Set threshold strength
:param mask: Allows for user to use their own mask
:param ret_mask: bool: Replace default mask with a retinex edgemask
:param show_mask: bool: Return mask
:param opencl: bool: Opencl acceleration
"""
bits = clip.format.bits_per_sample - 8
thr = strength * (1 >> bits)
strong = TAAmbk(clip, aatype='Eedi3', alpha=0.25, beta=0.5, gamma=40, nrad=2, mdis=20, mtype=0,
opencl=opencl)
weak = TAAmbk(clip, aatype='Nnedi3', nsize=3, nns=3, qual=1, mtype=0, opencl=opencl)
expr = 'x z - y z - * 0 < y x y {0} + min y {0} - max ?'.format(thr)
if clip.format.num_planes > 1:
expr = [expr, '']
aa = core.std.Expr([strong, weak, clip], expr)
if mask:
merged = clip.std.MaskedMerge(aa, mask, planes=0)
elif ret_mask:
mask = kgf.retinex_edgemask(clip, 1).std.Binarize()
merged = clip.std.MaskedMerge(aa, mask, planes=0)
else:
mask = clip.std.Prewitt(planes=0).std.Binarize(planes=0).std.Maximum(planes=0).std.Convolution([1] * 9, planes=0)
mask = get_y(mask)
merged = clip.std.MaskedMerge(aa, mask, planes=0)
if show_mask:
return mask
return merged if clip.format.color_family == vs.GRAY else core.std.ShufflePlanes([merged, clip], [0, 1, 2], vs.YUV)
def deband(clip: vs.VideoNode, hard: List[Range],
harder: List[Range]) -> vs.VideoNode:
line = retinex_edgemask(clip).std.Binarize(9500).rgvs.RemoveGrain(3) \
.std.Inflate()
nf3kdb = clip.neo_f3kdb.Deband(range=18,
y=32,
cb=24,
cr=24,
grainy=24,
grainc=0,
output_depth=16,
sample_mode=4)
nf3kdb = core.std.MaskedMerge(nf3kdb, clip, line)
placebo = clip.placebo.Deband(iterations=3,
threshold=3,
radius=24,
grain=4)
placebo2 = clip.placebo.Deband(iterations=3,
threshold=5,
radius=32,
grain=4)
debanded = replace_ranges(nf3kdb, placebo, hard)
debanded = replace_ranges(debanded, placebo2, harder)
return debanded
def RainbowSmooth(clip, radius=3, lthresh=0, hthresh=220, mask="original"):
core = vs.core
if isinstance(mask, str):
if mask == "original":
mask = core.std.Expr(clips=[clip.std.Maximum(planes=0), clip.std.Minimum(planes=0)], expr=["x y - 90 > 255 x y - 255 90 / * ?", "", ""])
elif mask == "prewitt":
mask = core.std.Prewitt(clip=clip, planes=0)
elif mask == "sobel":
mask = core.std.Sobel(clip=clip, planes=0)
elif mask == "tcanny":
mask = core.tcanny.TCanny(clip)
elif mask == "fast_sobel":
import kagefunc as kage
mask = kage.fast_sobel(clip)
elif mask == "kirsch":
import kagefunc as kage
mask = kage.kirsch(clip)
elif mask == "retinex_edgemask":
import kagefunc as kage
mask = kage.retinex_edgemask(clip)
lderain = clip
if lthresh > 0:
lderain = clip.smoothuv.SmoothUV(radius=radius, threshold=lthresh, interlaced=False)
hderain = clip.smoothuv.SmoothUV(radius=radius, threshold=hthresh, interlaced=False)
if hthresh > lthresh:
return core.std.MaskedMerge(clipa=lderain, clipb=hderain, mask=mask, planes=[1, 2], first_plane=True)
else:
return lderain
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
src = depth(src, 32)
h = 720
w = get_w(h)
b, c = vdf.get_bicubic_params('robidoux')
opstart, opend = 1392, 3788
edstart, edend = 31889, src.num_frames - 1
full_stuff = [(3801, 3908), (16203, 16358)]
denoise = hybrid_denoise(src, 0.5, 2)
out = denoise
luma = get_y(out)
line_mask = vdf.edge_detect(luma, 'FDOG', 0.05, (1, 1))
descale = core.descale.Debicubic(luma, w, h, b, c)
upscale = vdf.fsrcnnx_upscale(descale, None, descale.height * 2,
'_shaders/FSRCNNX_x2_56-16-4-1.glsl',
core.resize.Point)
upscale_smooth = vdf.nnedi3_upscale(descale, pscrn=1)
upscale = lvf.rfs(upscale, upscale_smooth, [(18547, 18586)])
antialias = single_rate_antialiasing(upscale,
13,
alpha=0.3,
beta=0.45,
gamma=320,
mdis=18)
scaled = muvf.SSIM_downsample(antialias,
src.width,
src.height,
kernel='Bicubic')
rescale = core.std.MaskedMerge(luma, scaled, line_mask)
merged = vdf.merge_chroma(rescale, out)
out = depth(merged, 16)
antialias = lvf.rfs(
out,
lvf.sraa(out,
1.65,
9,
alpha=0.3,
beta=0.45,
gamma=240,
nrad=3,
mdis=25), [(opstart + 840, opstart + 881)])
out = antialias
# Slight sharp though CAS
sharp = hvf.LSFmod(out,
strength=75,
Smode=3,
Lmode=1,
edgemode=1,
edgemaskHQ=True)
out = sharp
dering = gf.HQDeringmod(out, thr=16, darkthr=0.1)
out = dering
warp = xvs.WarpFixChromaBlend(out, thresh=48, depth=8)
out = warp
preden = core.knlm.KNLMeansCL(out,
d=0,
a=3,
h=0.6,
device_type='GPU',
channels='Y')
deband_mask = lvf.denoise.detail_mask(preden, brz_a=2000, brz_b=800, rad=4)
deband = dbs.f3kpf(out, 17, 42, 42)
deband_b = placebo.deband(out, 22, 6, 2)
deband = lvf.rfs(deband, deband_b, [(opstart + 1515, opstart + 1603)])
deband_c = placebo.deband(out, 17, 8, 3)
import kagefunc
deband_mask_c = kagefunc.retinex_edgemask(preden)
deband_mask_c = iterate(deband_mask_c, core.std.Maximum,
3).std.Binarize(15000).std.Deflate()
deband = lvf.rfs(deband,
core.std.MaskedMerge(deband_c, deband, deband_mask_c),
[(7409, 7600), (7960, 8055)])
deband = core.std.MaskedMerge(deband, out, deband_mask)
out = deband
adg_mask = core.adg.Mask(out.std.PlaneStats(),
20).std.Expr(f'x x {128<<8} - 0.25 * +')
grain = core.grain.Add(out, 0.2, constant=True)
grain = core.std.MaskedMerge(out, grain, adg_mask, 0)
out = grain
rescale_mask = vdf.drm(luma, b=b, c=c, sw=4, sh=4)
ref, rescale_mask, src, src_ncop, src_nced = [
depth(x, 16) for x in
[denoise, rescale_mask, src, JPBD_NCOP.src_cut, JPBD_NCED.src_cut]
]
credit = lvf.rfs(out, core.std.MaskedMerge(out, ref, rescale_mask),
full_stuff)
out = credit
src_c, src_ncop, src_nced = [
c.knlm.KNLMeansCL(a=7, h=35, d=0, device_type='gpu')
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, 4,
4).std.Inflate()
ending_mask = vdf.dcm(out, src_c[edstart:edend + 1],
src_nced[:edend - edstart + 1], edstart, edend, 4,
4).std.Inflate()
credit_mask = core.std.Expr([opening_mask, ending_mask], 'x y +')
credit = lvf.rfs(out, core.std.MaskedMerge(out, ref, credit_mask),
[(opstart, opend), (edstart, edend)])
out = credit
return depth(out, 10)
def smart_descale(clip: vs.VideoNode,
res: List[int],
b: float = 1/3, c: float = 1/3,
thresh1: float = 0.03, thresh2: float = 0.7,
no_mask: float = False,
show_mask: bool = False, show_dmask: bool = False,
sraa_upscale: bool = False, rfactor: float = 1.5,
sraa_sharp: bool = False) -> vs.VideoNode:
funcname = "smart_descale"
"""
Original function written by kageru and modified into a general function by me.
For more information and comments I suggest you check out the original script:
https://git.kageru.moe/kageru/vs-scripts/src/branch/master/abyss1.py
A descaling function that compares relative errors between multiple resolutions and descales accordingly.
Most of this code was leveraged from kageru's Made in Abyss script.
As this is an incredibly complex function, I will offer only minimal support.
:param res: List[int]: A list of resolutions to descale to. For example: [900, 871, 872, 877]
:param thresh1: float: Threshold for when a frame will be descaled.
:param thresh2: float: Threshold for when a frame will not be descaled.
:param sraa_upscale: bool: Use upscaled_sraa to upscale the frames (warning: very slow!)
:param rfactor: float: Image enlargement factor for upscaled_sraa
"""
def _descaling(clip: vs.VideoNode, h: int, b: float, c: float):
# Descale and return a tuple of descaled clip and diff mask between that and the original.
down = clip.descale.Debicubic(get_w(h), h, b, c)
up = down.resize.Bicubic(clip.width, clip.height, filter_param_a=b, filter_param_b=c)
diff = core.std.Expr([clip, up], 'x y - abs').std.PlaneStats()
return down, diff
def _select(n, y, debic_list, sraa_upscale, rfactor, f):
# This simply descales to each of those and selects the most appropriate for each frame.
errors = [x.props.PlaneStatsAverage for x in f]
y_deb = debic_list[errors.index(min(errors))]
dmask = core.std.Expr([y, y_deb.resize.Bicubic(clip.width, clip.height)], 'x y - abs 0.025 > 1 0 ?').std.Maximum().std.SetFrameProp("_descaled_resolution", intval=y_deb.height)
if sraa_upscale:
up = upscaled_sraa(y_deb, rfactor, h=clip.height).resize.Bicubic(clip.width, clip.height)
else:
up = fvf.Depth(nnedi3_rpow2(fvf.Depth(y_deb, 16), nns=4, correct_shift=True, width=clip.width, height=clip.height), 32)
return core.std.ClipToProp(up, dmask)
def _square():
top = core.std.BlankClip(length=len(y), format=vs.GRAYS, height=4, width=10, color=[1])
side = core.std.BlankClip(length=len(y), format=vs.GRAYS, height=2, width=4, color=[1])
center = core.std.BlankClip(length=len(y), format=vs.GRAYS, height=2, width=2, color=[0])
t1 = core.std.StackHorizontal([side, center, side])
return core.std.StackVertical([top, t1, top])
def _restore_original(n, f, clip: vs.VideoNode, orig: vs.VideoNode, thresh_a: float, thresh_b: float):
# Just revert the entire scaling if the difference is too big. This should catch the 1080p scenes.
if f.props.PlaneStatsAverage < thresh_a:
return clip.std.SetFrameProp("_descaled", intval=1)
elif f.props.PlaneStatsAverage > thresh_b:
return orig.std.SetFrameProp("_descaled", intval=0)
return core.std.Merge(clip, orig, (f.props.PlaneStatsAverage - thresh_a) * 20).std.SetFrameProp("_descaled", intval=2)
# Error handling
if len(res) < 2:
return error(funcname, 'This function requires more than two resolutions to descale to')
og = clip
clip32 = fvf.Depth(clip, 32)
if one_plane(clip32):
y = get_y(clip32)
else:
y, u, v = split(clip32)
debic_listp = [_descaling(y, h, b, c) for h in res]
debic_list = [a[0] for a in debic_listp]
debic_props = [a[1] for a in debic_listp]
y_deb = core.std.FrameEval(y, partial(_select, y=y, debic_list=debic_list,
sraa_upscale=sraa_upscale, rfactor=rfactor), prop_src=debic_props)
# TO-DO: It returns a frame size error here for whatever reason. Need to figure out what causes it and fix it
dmask = core.std.PropToClip(y_deb)
if show_dmask:
return dmask
# TO-DO: Figure out how to make it properly round depending on resolution (although this should usually be 1080p anyway)
line = core.std.StackHorizontal([_square()]*192)
full_squares = core.std.StackVertical([line]*108)
artifacts = core.misc.Hysteresis(dmask.resize.Bicubic(clip32.width, clip32.height, _format=vs.GRAYS),
core.std.Expr([get_y(clip32).tcanny.TCanny(sigma=3), full_squares], 'x y min'))
ret_raw = kgf.retinex_edgemask(fvf.Depth(clip, 16))
ret = ret_raw.std.Binarize(30).rgvs.RemoveGrain(3)
mask = core.std.Expr([ret.resize.Point(_format=vs.GRAYS), kgf.iterate(artifacts, core.std.Maximum, 3)], 'x y -').std.Binarize(0.4)
mask = mask.std.Inflate().std.Convolution(matrix=[1]*9).std.Convolution(matrix=[1]*9)
if show_mask:
return mask
y = core.std.MaskedMerge(y, y_deb, mask)
merged = join([y, u, v]) if not one_plane(og) else y
merged = fvf.Depth(merged, get_depth(og))
if no_mask:
return merged
dmask = dmask.std.PlaneStats() # TO-DO: It returns a frame size error here for whatever reason. Need to figure out what causes it and fix it
return merged.std.FrameEval(partial(_restore_original, clip=merged, orig=og, thresh_a=thresh1, thresh_b=thresh2), prop_src=dmask)#.std.SetFrameProp("_descaled_resolution", intval=y_deb.height)
def do_filter():
"""Vapoursynth filtering"""
def _nneedi3_clamp(clip: vs.VideoNode, strength: int = 1) -> vs.VideoNode:
bits = clip.format.bits_per_sample - 8
thr = strength * (1 >> bits)
luma = get_y(clip)
def _strong(clip: vs.VideoNode) -> vs.VideoNode:
args = dict(alpha=0.25,
beta=0.5,
gamma=40,
nrad=2,
mdis=20,
vcheck=3)
clip = core.eedi3m.EEDI3(clip, 1, True, **args).std.Transpose()
clip = core.eedi3m.EEDI3(clip, 1, True, **args).std.Transpose()
return core.resize.Spline36(clip,
luma.width,
luma.height,
src_left=-.5,
src_top=-.5)
def _weak(clip: vs.VideoNode) -> vs.VideoNode:
args = dict(nsize=3, nns=2, qual=2)
clip = core.znedi3.nnedi3(clip, 1, True, **args).std.Transpose()
clip = core.znedi3.nnedi3(clip, 1, True, **args).std.Transpose()
return core.resize.Spline36(clip,
luma.width,
luma.height,
src_left=-.5,
src_top=-.5)
clip_aa = core.std.Expr(
[_strong(luma), _weak(luma), luma],
'x z - y z - * 0 < y x y {0} + min y {0} - max ?'.format(thr))
return vdf.merge_chroma(clip_aa, clip)
def _perform_endcard(path: str, ref: vs.VideoNode) -> vs.VideoNode:
endcard = lvf.src(path).std.AssumeFPS(ref)
endcard = core.std.CropRel(endcard, left=6, top=20, right=0, bottom=6)
endcard = core.resize.Bicubic(endcard,
ref.width,
ref.height,
vs.RGBS,
dither_type='error_diffusion')
endcard = iterate(
endcard, partial(core.w2xc.Waifu2x, noise=3, scale=1, photo=True),
2)
endcard = core.resize.Bicubic(endcard,
format=vs.YUV444PS,
matrix_s='709',
dither_type='error_diffusion')
endcard = lvf.util.quick_resample(
endcard,
lambda c: core.neo_f3kdb.Deband(c, 15, 36, 36, 36, 24, 24, 4))
return Tweak(endcard, sat=1.2, bright=-0.05, cont=1.2)
src = JPBD.src_cut
src = depth(src, 16)
edstart = 31769
denoise_a = CoolDegrain(src, tr=2, thsad=48, blksize=8, overlap=4, plane=4)
denoise_b = CoolDegrain(src, tr=3, thsad=96, blksize=8, overlap=4, plane=4)
denoise = lvf.rfs(denoise_a, denoise_b, [(edstart + 1870, edstart + 1900)])
antialias_a = _nneedi3_clamp(denoise)
downscaler = lambda c, w, h: core.fmtc.resample(
c, w, h, kernel='gauss', invks=True, invkstaps=1, taps=1, a1=32)
antialias_b = rekt_fast(
denoise,
lambda c: lvf.sraa(c, 1.45, rep=13, downscaler=downscaler),
top=482)
antialias = lvf.rfs(antialias_a, antialias_b, [(8185, 8280)])
predenoise = mClean(antialias, thSAD=200, chroma=False)
detail_mask = lvf.denoise.detail_mask(predenoise,
rad=2,
radc=2,
brz_a=3250,
brz_b=1250)
ret_mask = kgf.retinex_edgemask(predenoise).std.Binarize(
9250).std.Median().std.Inflate()
line_mask = core.std.Expr([detail_mask, ret_mask], 'x y max')
deband_a = core.neo_f3kdb.Deband(antialias,
17,
42,
42,
42,
12,
0,
sample_mode=4,
keep_tv_range=True)
deband_a = core.std.MaskedMerge(deband_a, antialias, line_mask)
deband_b = core.neo_f3kdb.Deband(deband_a,
18,
48,
48,
48,
0,
0,
sample_mode=2,
keep_tv_range=True)
deband = lvf.rfs(deband_a, deband_b, [(edstart + 1870, edstart + 1900)])
deband = lvf.rfs(deband, deband_b, [(13611, 13661), (20022, 20057)])
grain = kgf.adaptive_grain(deband, 0.25, luma_scaling=10)
endcard = _perform_endcard(
'[BDMV][200610][Magia Record][Vol.3]/Scans/endcard6_front_descreen.png',
src)
endcard_length = 119
final = core.std.Splice([grain, endcard * endcard_length], True)
final = core.resize.Bicubic(final,
format=vs.YUV420P10,
dither_type='error_diffusion')
final = core.std.Limiter(final, 16, [235 << 2, 240 << 2])
return depth(final, 10), endcard_length
def nneedi3_clamp(clip: vs.VideoNode,
strength: int = 1,
mask: Optional[vs.VideoNode] = None,
ret_mask: bool = False,
show_mask: bool = False,
opencl: bool = False) -> vs.VideoNode:
"""
A function that clamps eedi3 to nnedi3 for the purpose of reducing eedi3 artifacts.
This should fix every issue created by eedi3. For example: https://i.imgur.com/hYVhetS.jpg
Original function written by Zastin, modified by LightArrowsEXE.
Dependencies:
* kagefunc (optional: retinex edgemask)
* vapoursynth-retinex (optional: retinex edgemask)
* vapoursynth-tcanny (optional: retinex edgemask)
* vapoursynth-eedi3
* vapoursynth-nnedi3 or znedi3
* vapoursynth-nnedi3cl (optional: opencl)
* vsTAAmbk
:param clip: Input clip
:param strength: Set threshold strength (Default: 1)
:param mask: Clip to use for custom mask (Default: None)
:param ret_mask: Replace default mask with a retinex edgemask (Default: False)
:param show_mask: Return mask instead of clip (Default: False)
:param opencl: OpenCL acceleration (Default: False)
:return: Antialiased clip
"""
try:
from vsTAAmbk import TAAmbk
except ModuleNotFoundError:
raise ModuleNotFoundError(
"nnedi3_clamp: missing dependency 'vsTAAmbk'")
bits = clip.format.bits_per_sample - 8
thr = strength * (1 >> bits)
strong = TAAmbk(clip,
aatype='Eedi3',
alpha=0.25,
beta=0.5,
gamma=40,
nrad=2,
mdis=20,
mtype=0,
opencl=opencl)
weak = TAAmbk(clip,
aatype='Nnedi3',
nsize=3,
nns=3,
qual=1,
mtype=0,
opencl=opencl)
expr = 'x z - y z - * 0 < y x y {0} + min y {0} - max ?'.format(thr)
if clip.format.num_planes > 1:
expr = [expr, '']
aa = core.std.Expr([strong, weak, clip], expr)
if mask:
merged = clip.std.MaskedMerge(aa, mask, planes=0)
elif ret_mask:
try:
import kagefunc as kgf
except ModuleNotFoundError:
raise ModuleNotFoundError(
"nnedi3_clamp: missing dependency 'kagefunc'")
mask = kgf.retinex_edgemask(clip, 1).std.Binarize()
merged = clip.std.MaskedMerge(aa, mask, planes=0)
else:
mask = clip.std.Prewitt(planes=0).std.Binarize(planes=0).std.Maximum(
planes=0).std.Convolution([1] * 9, planes=0)
mask = get_y(mask)
merged = clip.std.MaskedMerge(aa, mask, planes=0)
if show_mask:
return mask
return merged if clip.format.color_family == vs.GRAY else core.std.ShufflePlanes(
[merged, clip], [0, 1, 2], vs.YUV)
def do_filter():
"""Vapoursynth filtering"""
def _nneedi3_clamp(clip: vs.VideoNode, strength: int = 1) -> vs.VideoNode:
bits = clip.format.bits_per_sample - 8
thr = strength * (1 >> bits)
luma = get_y(clip)
def _strong(clip: vs.VideoNode) -> vs.VideoNode:
args = dict(alpha=0.25,
beta=0.5,
gamma=40,
nrad=2,
mdis=20,
vcheck=3)
clip = core.eedi3m.EEDI3(clip, 1, True, **args).std.Transpose()
clip = core.eedi3m.EEDI3(clip, 1, True, **args).std.Transpose()
return core.resize.Spline36(clip,
luma.width,
luma.height,
src_left=-.5,
src_top=-.5)
def _weak(clip: vs.VideoNode) -> vs.VideoNode:
args = dict(nsize=3, nns=2, qual=2)
clip = core.znedi3.nnedi3(clip, 1, True, **args).std.Transpose()
clip = core.znedi3.nnedi3(clip, 1, True, **args).std.Transpose()
return core.resize.Spline36(clip,
luma.width,
luma.height,
src_left=-.5,
src_top=-.5)
clip_aa = core.std.Expr(
[_strong(luma), _weak(luma), luma],
'x z - y z - * 0 < y x y {0} + min y {0} - max ?'.format(thr))
return vdf.merge_chroma(clip_aa, clip)
def _perform_endcard(path: str, ref: vs.VideoNode) -> vs.VideoNode:
endcard = lvf.src(path).std.AssumeFPS(ref)
endcard = core.std.CropRel(endcard,
left=10,
top=17,
right=17,
bottom=23)
endcard = core.resize.Bicubic(endcard,
ref.width,
ref.height,
vs.RGBS,
dither_type='error_diffusion')
endcard = iterate(
endcard, partial(core.w2xc.Waifu2x, noise=3, scale=1, photo=True),
2)
endcard = core.resize.Bicubic(endcard,
format=vs.YUV444PS,
matrix_s='709',
dither_type='error_diffusion')
return Tweak(endcard, sat=1.2, bright=-0.05, cont=1.2)
src = JPBD.src_cut
src = depth(src, 16)
denoise = CoolDegrain(src, tr=2, thsad=48, blksize=8, overlap=4, plane=4)
antialias_a = _nneedi3_clamp(denoise)
antialias_b = lvf.sraa(denoise, rep=6)
antialias = lvf.rfs(antialias_a, antialias_b, [(29453, 29476),
(29510, 29532),
(29640, 29663),
(29775, 29798),
(29866, 29889),
(30011, 30034)])
predenoise = mClean(antialias, thSAD=200, chroma=False)
detail_mask = lvf.denoise.detail_mask(predenoise,
rad=2,
radc=2,
brz_a=3250,
brz_b=1250)
ret_mask = kgf.retinex_edgemask(predenoise).std.Binarize(
9250).std.Median().std.Inflate()
line_mask = core.std.Expr([detail_mask, ret_mask], 'x y max')
deband = core.neo_f3kdb.Deband(antialias,
17,
42,
42,
42,
12,
0,
sample_mode=4,
keep_tv_range=True)
deband = core.std.MaskedMerge(deband, antialias, line_mask)
grain_a = kgf.adaptive_grain(deband, 0.25, luma_scaling=10)
grain_b = adptvgrnMod(deband,
2,
size=2,
luma_scaling=2,
static=False,
grain_chroma=False)
grain = lvf.rfs(grain_a, grain_b, [(5149, 5598), (8691, 10137)])
borders_mask = vdf.region_mask(
src.std.BlankClip(format=vs.GRAY16, color=(256 << 8) - 1), 240 + 2,
240 + 2, 0, 0)
borders = core.std.MaskedMerge(src, grain, borders_mask)
borders = lvf.rfs(grain, borders, [(5149, 5598)])
endcard = _perform_endcard(
'[BDMV][200304][Magia Record][Vol.1]/Scans/endcard1_front_descreen.png',
src)
endcard_length = 119
final = core.std.Splice([borders, endcard * endcard_length], True)
final = core.resize.Bicubic(final,
format=vs.YUV420P10,
dither_type='error_diffusion')
final = core.std.Limiter(final, 16, [235 << 2, 240 << 2])
return depth(final, 10), endcard_length
def do_filter():
"""Vapoursynth filtering"""
def _nneedi3_clamp(clip: vs.VideoNode, strength: int = 1)-> vs.VideoNode:
bits = clip.format.bits_per_sample - 8
thr = strength * (1 >> bits)
luma = get_y(clip)
def _strong(clip: vs.VideoNode)-> vs.VideoNode:
args = dict(alpha=0.25, beta=0.5, gamma=40, nrad=2, mdis=20, vcheck=3)
clip = core.eedi3m.EEDI3(clip, 1, True, **args).std.Transpose()
clip = core.eedi3m.EEDI3(clip, 1, True, **args).std.Transpose()
return core.resize.Spline36(clip, luma.width, luma.height, src_left=-.5, src_top=-.5)
def _weak(clip: vs.VideoNode)-> vs.VideoNode:
args = dict(nsize=3, nns=2, qual=2)
clip = core.znedi3.nnedi3(clip, 1, True, **args).std.Transpose()
clip = core.znedi3.nnedi3(clip, 1, True, **args).std.Transpose()
return core.resize.Spline36(clip, luma.width, luma.height, src_left=-.5, src_top=-.5)
clip_aa = core.std.Expr([_strong(luma), _weak(luma), luma],
'x z - y z - * 0 < y x y {0} + min y {0} - max ?'.format(thr))
return vdf.merge_chroma(clip_aa, clip)
def _perform_endcard(path: str, ref: vs.VideoNode)-> vs.VideoNode:
endcard = lvf.src(path).std.AssumeFPS(ref)
endcard = core.std.CropRel(endcard, left=7, top=0, right=11, bottom=22)
endcard = core.resize.Bicubic(endcard, ref.width, ref.height, vs.RGBS, dither_type='error_diffusion')
endcard = core.w2xc.Waifu2x(endcard, noise=3, scale=1, photo=True)
endcard = core.resize.Bicubic(endcard, format=vs.YUV444PS, matrix_s='709', dither_type='error_diffusion')
endcard = lvf.util.quick_resample(endcard, lambda c: core.neo_f3kdb.Deband(c, 15, 36, 36, 36, 24, 24, 4))
return Tweak(endcard, sat=1.4, cont=1.2)
def _perform_motion_mask(clip: vs.VideoNode, brz: int)-> vs.VideoNode:
clip = depth(clip, 8)
sup = core.hqdn3d.Hqdn3d(clip).neo_fft3d.FFT3D().mv.Super(sharp=1)
fv1 = core.mv.Analyse(sup, isb=False, delta=1, truemotion=False, dct=2)
fv2 = core.mv.Analyse(sup, isb=True, delta=1, truemotion=True, dct=2)
momask1 = core.mv.Mask(clip, fv1, ml=2, kind=1)
momask2 = core.mv.Mask(clip, fv2, ml=3, kind=1)
momask = core.std.Merge(momask1, momask2).rgvs.RemoveGrain(3).std.Binarize(brz)
momask = momask.std.Minimum().std.Minimum()
return depth(get_y(momask), 16)
src = JPBD.src_cut
src = depth(src, 16)
denoise_a = CoolDegrain(src, tr=2, thsad=48, blksize=8, overlap=4, plane=4)
denoise = denoise_a
antialias = _nneedi3_clamp(denoise)
antialias_a = TAAmbk(antialias, aatype='Eedi3', cycle=3)
antialias_b = lvf.sraa(denoise, 2, 13)
motion_mask = _perform_motion_mask(denoise[16914:17001], 140).std.FreezeFrames([0, 18, 57], [2, 38, 86], [2, 38, 57])
motion_mask = insert_clip(src.std.BlankClip(format=vs.GRAY16), motion_mask, 16914)
antialias = lvf.rfs(antialias, core.std.MaskedMerge(antialias_a, antialias, motion_mask), [(16914, 17000)])
antialias = lvf.rfs(antialias, antialias_b, [(18084, 18179)])
predenoise = mClean(antialias, thSAD=200, chroma=False)
detail_mask = lvf.denoise.detail_mask(predenoise, rad=2, radc=2, brz_a=3250, brz_b=1250)
ret_mask = kgf.retinex_edgemask(predenoise).std.Binarize(9250).std.Median().std.Inflate()
line_mask = core.std.Expr([detail_mask, ret_mask], 'x y max')
deband_a = core.neo_f3kdb.Deband(antialias, 17, 42, 42, 42, 12, 0, sample_mode=4, keep_tv_range=True)
deband_a = core.std.MaskedMerge(deband_a, antialias, line_mask)
deband = deband_a
grain = kgf.adaptive_grain(deband, 0.25, luma_scaling=10)
ending = lvf.rfs(grain, src, [(32079, 33098)])
endcard = _perform_endcard(r'[BDMV][200902][Magia Record][Vol.5]\Scans\endcard13_front_descreen.png', src)
endcard_length = 119
final = core.std.Splice([ending, endcard * endcard_length], True)
final = core.resize.Bicubic(final, format=vs.YUV420P10, dither_type='error_diffusion')
final = core.std.Limiter(final, 16, [235 << 2, 240 << 2])
return depth(final, 10), endcard_length
def do_filter():
"""Vapoursynth filtering"""
def _nneedi3_clamp(clip: vs.VideoNode, strength: int = 1) -> vs.VideoNode:
bits = clip.format.bits_per_sample - 8
thr = strength * (1 >> bits)
luma = get_y(clip)
def _strong(clip: vs.VideoNode) -> vs.VideoNode:
args = dict(alpha=0.25,
beta=0.5,
gamma=40,
nrad=2,
mdis=20,
vcheck=3)
clip = core.eedi3m.EEDI3(clip, 1, True, **args).std.Transpose()
clip = core.eedi3m.EEDI3(clip, 1, True, **args).std.Transpose()
return core.resize.Spline36(clip,
luma.width,
luma.height,
src_left=-.5,
src_top=-.5)
def _weak(clip: vs.VideoNode) -> vs.VideoNode:
args = dict(nsize=3, nns=2, qual=2)
clip = core.znedi3.nnedi3(clip, 1, True, **args).std.Transpose()
clip = core.znedi3.nnedi3(clip, 1, True, **args).std.Transpose()
return core.resize.Spline36(clip,
luma.width,
luma.height,
src_left=-.5,
src_top=-.5)
clip_aa = core.std.Expr(
[_strong(luma), _weak(luma), luma],
'x z - y z - * 0 < y x y {0} + min y {0} - max ?'.format(thr))
return vdf.merge_chroma(clip_aa, clip)
def _perform_endcard(path: str, ref: vs.VideoNode) -> vs.VideoNode:
endcard = lvf.src(path).std.AssumeFPS(ref)
endcard = core.std.CropRel(endcard,
left=14,
top=12,
right=18,
bottom=23)
endcard = core.resize.Bicubic(endcard,
ref.width,
ref.height,
vs.RGBS,
dither_type='error_diffusion')
endcard = iterate(
endcard, partial(core.w2xc.Waifu2x, noise=3, scale=1, photo=True),
2)
endcard = core.resize.Bicubic(endcard,
format=vs.YUV444PS,
matrix_s='709',
dither_type='error_diffusion')
return Tweak(endcard, sat=1.2, bright=-0.05, cont=1.2)
src = JPBD.src_cut
src = depth(src, 16)
edstart = 32012
denoise_a = CoolDegrain(src, tr=2, thsad=48, blksize=8, overlap=4, plane=4)
denoise_b = CoolDegrain(src, tr=3, thsad=96, blksize=8, overlap=4, plane=4)
denoise = lvf.rfs(denoise_a, denoise_b, [(edstart + 1870, edstart + 1900)])
antialias_a = _nneedi3_clamp(denoise)
antialias_b = lvf.sraa(denoise, 2, rep=13)
antialias = lvf.rfs(antialias_a, antialias_b, [(14667, 14696)])
predenoise = mClean(antialias, thSAD=200, chroma=False)
detail_mask = lvf.denoise.detail_mask(predenoise,
rad=2,
radc=2,
brz_a=3250,
brz_b=1250)
adapt_mask = core.adg.Mask(predenoise.std.PlaneStats(), 40)
ret_mask = kgf.retinex_edgemask(predenoise).std.Binarize(
9250).std.Median().std.Inflate()
line_mask = core.std.Expr([detail_mask, ret_mask], 'x y max')
deband_a = core.neo_f3kdb.Deband(antialias,
17,
42,
42,
42,
12,
0,
sample_mode=4,
keep_tv_range=True)
deband_a = core.std.MaskedMerge(deband_a, antialias, line_mask)
deband_b = core.neo_f3kdb.Deband(deband_a,
18,
48,
48,
48,
0,
0,
sample_mode=2,
keep_tv_range=True)
deband_ca = dbs.f3kbilateral(deband_b, 8, 270, 270)
deband_cb = dbs.f3kbilateral(deband_b, 12, 110, 110)
deband_c = core.std.MaskedMerge(deband_ca, deband_cb, adapt_mask)
deband = lvf.rfs(deband_a, deband_b, [(edstart + 1870, edstart + 1900),
(13041, 13180), (13932, 13949),
(14121, 14168), (14647, 14666)])
deband = lvf.rfs(deband, deband_c, [(14667, 14669), (14673, 14674),
(14676, 14677)])
grain = kgf.adaptive_grain(deband, 0.25, luma_scaling=10)
crop = core.std.Crop(grain, 0, 0, 132, 132)
edgefixe = core.edgefixer.ContinuityFixer(crop, 0, [2, 1, 1], 0, [1, 1, 1])
borders = core.std.AddBorders(edgefixe, 0, 0, 132, 132)
borders = lvf.rfs(grain, borders, [(0, 2905)])
endcard = _perform_endcard(
'[BDMV][200304][Magia Record][Vol.1]/Scans/endcard3_front_descreen.png',
src)
endcard_length = 117
final = core.std.Splice([borders, endcard * endcard_length], True)
final = core.resize.Bicubic(final,
format=vs.YUV420P10,
dither_type='error_diffusion')
final = core.std.Limiter(final, 16, [235 << 2, 240 << 2])
return depth(final, 10), endcard_length
cunny = cunny.vivtc.VDecimate()
cunny = cunny[:44972]
cunny = cunny.std.Crop(left=6, right=4)
cunny = awf.fb(cunny, top=1)
cunny = cunny.resize.Bicubic(src_top=1)
cunny = cunny.fb.FillBorders(top=1, bottom=1, mode="fixborders")
cunny = cunny.vinverse.Vinverse()
black = core.tcm.TColorMask(cunny.std.Minimum(), ["$000000"],
tolerance=7,
bt601=True,
gray=False,
lutthr=9)
cunny = rektlvls(cunny, colnum=[1, 709], colval=[-9, 35])
aa = taa.TAAmbk(cunny, "Nnedi3")
sangnom = taa.TAAmbk(cunny, "Nnedi3SangNom")
mask = kgf.retinex_edgemask(cunny).std.Binarize(200).std.Deflate(threshold=250)
cunny = cunny.placebo.Deband(threshold=6, radius=16, grain=4)
cunny = awf.ReplaceFrames(core.std.MaskedMerge(cunny, aa, mask),
core.std.MaskedMerge(cunny, sangnom, mask),
"[4708 4850] [5290 5421] [5542 5698] [5770 5803]")
no_bbmod = cunny
censor = cunny.fb.FillBorders(top=2, mode="fixborders")
censor = awf.bbmod(censor, top=4, thresh=200, blur=10)
censor = awf.bbmod(censor, right=4, thresh=2, blur=5)
censor = awf.bbmod(censor, left=4, thresh=6, blur=8)
censor = awf.bbmod(censor, right=1)
cunny = awf.bbmod(cunny, right=4, top=4, thresh=2, blur=5)
cunny = awf.bbmod(cunny, left=4, thresh=6, blur=8)
cunny = awf.bbmod(cunny, right=1)
cunny = core.std.MaskedMerge(cunny, no_bbmod, black)
cunny = awf.ReplaceFrames(cunny, no_bbmod, "[0 15] [42581 44935]")
def faggotdb_mod(clip: vs.VideoNode,
thrY=40,
thrC=None,
radiusY=15,
radiusC=15,
CbY=44,
CrY=44,
CbC=44,
CrC=44,
grainY=32,
grainC=None,
grainCC=0,
sample_mode=2,
neo=True,
dynamic_grainY=False,
dynamic_grainC=False,
tv_range=True,
mask="retinex",
binarize=False,
binarize_thr=70,
grayscale=True,
bitresamp=False,
outbits=None,
blurmask=True,
horizblur=2,
vertblur=2) -> vs.VideoNode:
funcName = "faggotdb_mod" # name kept to be fallback compatible
# Original Idea: Author who created Fag3kdb. Edited by AlucardSama04; additional modifications by l00t
if not isinstance(clip, vs.VideoNode):
raise TypeError(f"{funcName}: This is not a clip")
if outbits is None:
outbits = clip.format.bits_per_sample
if bitresamp:
if clip.format.bits_per_sample != outbits:
clip = fvf.Depth(
clip,
bits=outbits) # instead of error, auto convert to 16 bits
elif clip.format.bits_per_sample != outbits:
raise TypeError(f"{funcName}: Input-output bitdepth mismatch")
# if not isinstance(mask, vs.VideoNode):
# raise vs.Error(f"{funcName}: mask' only clip inputs")
if mask in [-1]: # more user friendly if we do the masking intentionally
mask = clip
blurmask = False
elif mask in [0, "retinex"]:
mask = kgf.retinex_edgemask(clip)
elif mask in [1, "kirsch"]:
mask = kgf.kirsch(clip)
elif mask in [2, "Sobel"]:
mask = core.std.Sobel(clip, scale=1)
elif mask in [3, "Prewitt"]:
mask = core.std.Prewitt(clip)
elif mask in [4, "GF"]:
mask = fvf.GradFun3(clip, mask=2, debug=1)
else:
raise ValueError(f"{funcName}: Unknown Mask Mode")
if grayscale:
mask = core.std.ShufflePlanes(mask, planes=0, colorfamily=vs.GRAY)
if binarize: # binarize threshold should be adjusted according to bitdepth
mask = core.std.Binarize(mask, threshold=binarize_thr)
if blurmask:
mask = core.std.BoxBlur(mask, hradius=horizblur, vradius=vertblur)
if thrC is None:
thrC = int(round(thrY / 2))
if grainC is None:
grainC = int(round(grainY / 2))
if grainCC is None:
grainCC = 0
f3kdb = core.neo_f3kdb.Deband if neo else core.f3kdb.Deband
U = plane(clip, 1)
V = plane(clip, 2)
U = f3kdb(U,
range=radiusC,
y=thrC,
cb=CbC,
cr=CrC,
grainy=grainC,
grainc=0,
sample_mode=sample_mode,
dynamic_grain=dynamic_grainC,
keep_tv_range=tv_range,
output_depth=outbits)
V = f3kdb(V,
range=radiusC,
y=thrC,
cb=CbC,
cr=CrC,
grainy=grainC,
grainc=0,
sample_mode=sample_mode,
dynamic_grain=dynamic_grainC,
keep_tv_range=tv_range,
output_depth=outbits)
filtered = core.std.ShufflePlanes([clip, U, V], [0, 0, 0], vs.YUV)
filtered = f3kdb(filtered,
range=radiusY,
y=thrY,
cb=CbY,
cr=CrY,
grainy=grainY,
grainc=grainCC,
sample_mode=sample_mode,
dynamic_grain=dynamic_grainY,
keep_tv_range=tv_range,
output_depth=outbits
) # if grainCC > 0 UV planes will be debanded once again
return core.std.MaskedMerge(filtered, clip, mask)
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"""
def _nneedi3_clamp(clip: vs.VideoNode, strength: int = 1) -> vs.VideoNode:
bits = clip.format.bits_per_sample - 8
thr = strength * (1 >> bits)
luma = get_y(clip)
def _strong(clip: vs.VideoNode) -> vs.VideoNode:
args = dict(alpha=0.25,
beta=0.5,
gamma=40,
nrad=2,
mdis=20,
vcheck=3)
clip = core.eedi3m.EEDI3(clip, 1, True, **args).std.Transpose()
clip = core.eedi3m.EEDI3(clip, 1, True, **args).std.Transpose()
return core.resize.Spline36(clip,
luma.width,
luma.height,
src_left=-.5,
src_top=-.5)
def _weak(clip: vs.VideoNode) -> vs.VideoNode:
args = dict(nsize=3, nns=2, qual=2)
clip = core.znedi3.nnedi3(clip, 1, True, **args).std.Transpose()
clip = core.znedi3.nnedi3(clip, 1, True, **args).std.Transpose()
return core.resize.Spline36(clip,
luma.width,
luma.height,
src_left=-.5,
src_top=-.5)
clip_aa = core.std.Expr(
[_strong(luma), _weak(luma), luma],
'x z - y z - * 0 < y x y {0} + min y {0} - max ?'.format(thr))
return vdf.merge_chroma(clip_aa, clip)
def _perform_endcard(path: str, ref: vs.VideoNode) -> vs.VideoNode:
endcard = lvf.src(path).std.AssumeFPS(ref)
endcard = core.std.CropRel(endcard, left=4, top=12, right=0, bottom=21)
endcard = core.resize.Bicubic(endcard,
ref.width,
ref.height,
vs.RGBS,
dither_type='error_diffusion')
endcard = iterate(
endcard, partial(core.w2xc.Waifu2x, noise=3, scale=1, photo=True),
2)
endcard = core.resize.Bicubic(endcard,
format=vs.YUV444PS,
matrix_s='709',
dither_type='error_diffusion')
endcard = lvf.util.quick_resample(
endcard,
lambda c: core.neo_f3kdb.Deband(c, 15, 36, 36, 36, 24, 24, 4))
return Tweak(endcard, sat=1.2, bright=-0.05, cont=1.2)
def to_gray(clip: vs.VideoNode, ref: vs.VideoNode) -> vs.VideoNode:
clip = core.std.AssumeFPS(clip, ref)
return core.resize.Point(clip,
format=vs.GRAY16,
matrix_s=mvf.GetMatrix(ref))
src = JPBD.src_cut
src = depth(src, 16)
edstart = 30618
denoise_a = CoolDegrain(src, tr=2, thsad=48, blksize=8, overlap=4, plane=4)
denoise_b = CoolDegrain(src, tr=3, thsad=96, blksize=8, overlap=4, plane=4)
denoise = lvf.rfs(denoise_a, denoise_b, [(edstart + 1870, edstart + 1900)])
antialias_a = _nneedi3_clamp(denoise)
antialias_b = TAAmbk(denoise, aatype='Eedi3', mtype=1)
antialias = lvf.rfs(antialias_a, antialias_b, [(9478, 9501)])
predenoise = mClean(antialias, thSAD=200, chroma=False)
detail_mask = lvf.denoise.detail_mask(predenoise,
rad=2,
radc=2,
brz_a=3250,
brz_b=1250)
ret_mask = kgf.retinex_edgemask(predenoise).std.Binarize(
9250).std.Median().std.Inflate()
line_mask = core.std.Expr([detail_mask, ret_mask], 'x y max')
deband_a = core.neo_f3kdb.Deband(antialias,
17,
42,
42,
42,
12,
0,
sample_mode=4,
keep_tv_range=True)
deband_a = core.std.MaskedMerge(deband_a, antialias, line_mask)
deband_b = core.neo_f3kdb.Deband(deband_a,
18,
48,
48,
48,
0,
0,
sample_mode=2,
keep_tv_range=True)
deband_c = core.neo_f3kdb.Deband(deband_a,
20,
64,
64,
64,
24,
0,
sample_mode=2,
keep_tv_range=True)
deband = lvf.rfs(deband_a, deband_b, [(edstart + 1870, edstart + 1900)])
deband = lvf.rfs(
deband,
core.std.MaskedMerge(
deband_c, deband_a,
to_gray(lvf.src('masks/magia_07_mask_01.png'), src)),
[(6729, 6865)])
grain = kgf.adaptive_grain(deband, 0.25, luma_scaling=10)
borders = vdf.region_mask(grain, 240, 240, 0, 0)
borders = lvf.rfs(grain, borders, [(25623, 25670)])
endcard = _perform_endcard(
'[BDMV][200610][Magia Record][Vol.3]/Scans/endcard7_front_descreen.png',
src)
endcard_length = 119
final = core.std.Splice([borders, endcard * endcard_length], True)
final = core.resize.Bicubic(final,
format=vs.YUV420P10,
dither_type='error_diffusion')
final = core.std.Limiter(final, 16, [235 << 2, 240 << 2])
return depth(final, 10), endcard_length
