def main() -> vs.VideoNode:
"""Vapoursynth filtering"""
from adptvgrnMod import adptvgrnMod
from havsfunc import FastLineDarkenMOD
from vsutil import depth
src_op = JPBD_NCOP.clip_cut
src_ep = JPBD_EP.clip_cut
src = replace_ranges(src_op, src_ep, replace_op)
scaled = flt.rescaler(src, 720)
denoised = flt.denoiser(scaled, bm3d_sigma=[0.8, 0.6], bm3d_rad=1)
aa_rep = flt.clamped_aa(denoised)
trans_sraa = flt.transpose_sraa(denoised)
aa_ranges = replace_ranges(aa_rep, trans_sraa, red_circle)
darken = FastLineDarkenMOD(aa_ranges, strength=48, protection=6, luma_cap=255, threshold=2)
deband = flt.masked_deband(darken, denoised=True, deband_args={'iterations': 2, 'threshold': 5.0, 'radius': 8, 'grain': 6})
pdeband = flt.placebo_debander(darken, grain=4, deband_args={'iterations': 2, 'threshold': 8.0, 'radius': 10})
deband = replace_ranges(deband, pdeband, op_aisle)
grain = adptvgrnMod(deband, strength=0.3, luma_scaling=10, size=1.25, sharp=80, grain_chroma=False, seed=42069)
return depth(grain, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2], [0, 1, 2])
def antialias(clip: vs.VideoNode,
stronger: Optional[List[Range]] = None,
strong: Optional[List[Range]] = None,
weak: Optional[List[Range]] = None,
noaa: Optional[List[Range]] = None,
dehalo: bool = True,
sharpen: bool = False) -> vs.VideoNode:
def _sraa_pp_sharpdehalo(sraa: vs.VideoNode) -> vs.VideoNode:
if sharpen: # all this really seems to do is make the haloing worse, will not be using!
y = LSFmod(vsutil.get_y(sraa),
strength=70,
Smode=3,
edgemode=0,
source=vsutil.get_y(clip))
sraa = core.std.ShufflePlanes([y, sraa],
planes=[0, 1, 2],
colorfamily=vs.YUV)
sraa = MaskedDHA(sraa, rx=1.7, ry=1.7, darkstr=0,
brightstr=0.75) if dehalo else sraa
return sraa
mask = combine_mask(clip, weak or [])
clamp = sraa_clamp(clip, mask=mask, postprocess=_sraa_pp_sharpdehalo)
sraa = core.std.MaskedMerge(
clip,
upscaled_sraa(clip, rfactor=2, downscaler=Bicubic(b=0, c=1 / 2).scale),
mask)
sraa13 = upscaled_sraa(clip,
rfactor=1.3,
downscaler=Bicubic(b=0, c=1 / 2).scale)
return replace_ranges(
replace_ranges(replace_ranges(clamp, clip, noaa or []), sraa, strong
or []), sraa13, stronger or [])
def main() -> vs.VideoNode:
"""Vapoursynth filtering"""
import rekt
from adptvgrnMod import adptvgrnMod
from havsfunc import FastLineDarkenMOD
from vsutil import depth
from xvs import WarpFixChromaBlend
src_ep = JPBD_EP.clip_cut
src_NCOP1 = JPBD_NCOP1.clip_cut
src_NCOP2 = JPBD_NCOP2.clip_cut
src_NCOP = replace_ranges(src_NCOP2, src_NCOP1, replace_op)
src_NCOP = replace_ranges(src_NCOP, src_ep, replace_ep)
rkt = rekt.rektlvls(src_NCOP,
rownum=[0, 1079], rowval=[15, 15],
colnum=[0, 1919], colval=[15, 15]
)
no_rkt = replace_ranges(rkt, src_NCOP, [(526, 597), (1350, 1575), (1613, 1673), (1735, 1933)])
scaled = flt.rescaler(no_rkt, 720)
denoised = flt.denoiser(scaled, bm3d_sigma=[0.8, 0.6], bm3d_rad=1)
aa_rep = flt.clamped_aa(denoised)
trans_sraa = flt.transpose_sraa(denoised)
aa_ranges = replace_ranges(aa_rep, trans_sraa, red_circle)
darken = FastLineDarkenMOD(aa_ranges, strength=48, protection=6, luma_cap=255, threshold=2)
deband = flt.masked_deband(darken, denoised=True, deband_args={'iterations': 2, 'threshold': 5.0, 'radius': 8, 'grain': 6})
grain = adptvgrnMod(deband, strength=0.3, luma_scaling=10, size=1.25, sharp=80, grain_chroma=False, seed=42069)
return depth(grain, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2], [0, 1, 2])
def descale(clip: vs.VideoNode,
force_scale: List[Range] = [],
no_scale: List[Range] = [],
fade_ranges: List[FadeRange] = [],
detail_ranges: List[Range] = [],
show_mask: bool = False) -> vs.VideoNode:
kernel = Bicubic(b=1 / 3, c=1 / 3)
heights = [871, 872, 873]
y = vsutil.get_y(clip)
ys = ldescale(y,
upscaler=_sraa_reupscale,
height=heights,
kernel=kernel,
threshold=0.003,
mask=_inverse_mask(franges=fade_ranges,
dranges=detail_ranges),
show_mask=show_mask)
if show_mask:
return ys
yf = ldescale(y,
upscaler=_sraa_reupscale,
height=heights,
kernel=kernel,
threshold=0,
mask=_inverse_mask(franges=fade_ranges,
dranges=detail_ranges))
yd = replace_ranges(ys, yf, force_scale)
scaled = core.std.ShufflePlanes([yd, clip],
planes=[0, 1, 2],
colorfamily=vs.YUV)
scaled = replace_ranges(scaled, clip, no_scale)
return scaled
def waka_replace(
src: vs.VideoNode, wakas: List[vs.VideoNode],
ranges: List[List[Range]]) -> Tuple[vs.VideoNode, List[vs.VideoNode]]:
if len(wakas) == 0:
return src, wakas
new_wakas = []
for waka, r in zip(wakas, ranges):
tmp = src
src = replace_ranges(src, waka, r)
new_wakas.append(replace_ranges(waka, tmp, r))
return src, new_wakas
def deband(clip: vs.VideoNode, strong: Optional[List[Range]] = None,
nuclear: Optional[List[Range]] = None) -> vs.VideoNode:
dmask = detail_mask(clip)
deb = dumb3kdb(clip, radius=16, threshold=30)
if strong:
debs = dumb3kdb(clip, radius=24, threshold=60)
deb = replace_ranges(deb, debs, strong or [])
if nuclear:
debn = core.std.ShufflePlanes([
f3kbilateral(clip.std.ShufflePlanes(planes=0, colorfamily=vs.GRAY), y=60),
deb
], planes=[0, 1, 2], colorfamily=vs.YUV)
deb = replace_ranges(deb, debn, nuclear or [])
return core.std.MaskedMerge(deb, clip, dmask)
def stupid_op_scenefilter(aa: vs.VideoNode, deb: vs.VideoNode,
start: Optional[int]) -> vs.VideoNode:
if start is None:
return aa
aastrong, masks = get_op_scenefilters(start)
sraa = replace_ranges(
aa,
upscaled_sraa(deb, rfactor=2, downscaler=Bicubic(b=0, c=1 / 2).scale),
aastrong)
for mask in masks:
sraa = replace_ranges(
sraa, core.std.MaskedMerge(sraa, aa, mask.get_mask(deb, deb)),
mask.ranges)
return sraa
def antialias(clip: vs.VideoNode,
weak: Optional[List[Range]] = None,
strong: Optional[List[Range]] = None,
stronger: Optional[List[Range]] = None,
noaa: Optional[List[Range]] = None) -> vs.VideoNode:
mask = partial(antialiasing.combine_mask, weak=weak or [])
clamp = antialiasing.sraa_clamp(clip, mask=mask)
sraa = upscaled_sraa(clip, rfactor=2)
sraa = core.std.MaskedMerge(clip, sraa, mask(sraa))
sraa_13 = upscaled_sraa(clip, rfactor=1.3)
sraa_13 = core.std.MaskedMerge(clip, sraa_13, mask(sraa_13))
return replace_ranges(
replace_ranges(replace_ranges(clamp, clip, noaa or []), sraa, strong
or []), sraa_13, stronger or [])
def scenefilter_ed(clip: vs.VideoNode,
src: vs.VideoNode,
ed: Optional[int],
mask: bool = True) -> vs.VideoNode:
if ed is None:
return clip
den = denoise(src)
dehalo = MaskedDHA(den, rx=2, darkstr=0.1, brightstr=0.75)
edc = replace_ranges(den, dehalo, [(ed + 2121, ed + 2159)])
edc = antialias(edc)
edc = regrain(edc)
if mask:
nc = depth(core.lsmas.LWLibavSource(NCED)[24:-24], 16)
dcm = diff_creditless_mask(src, src[ed:], nc, ed, 6425, prefilter=True)
edc = core.std.MaskedMerge(edc, den, dcm)
return replace_ranges(clip, edc, [(ed, ed + 2159)])
def mask_logo(clip: vs.VideoNode, src: vs.VideoNode, src_logo: vs.VideoNode,
range: Range) -> vs.VideoNode:
mask = vsutil.get_y(src_logo).std.Binarize(19).fmtc.bitdepth(bits=16)
mask = vsutil.iterate(mask, core.std.Inflate, 5)
merge = core.std.MaskedMerge(clip, src, mask)
merge = replace_ranges(clip, merge, [range])
return merge
def antialias(clip: vs.VideoNode, strong: Optional[List[Range]] = None,
sangnom: Optional[List[Tuple[Range, List[BoundingBox]]]] = None) -> vs.VideoNode:
clamp = sraa_clamp(clip, mask=mask_strong)
if strong or sangnom:
sraa_13 = upscaled_sraa(clip, rfactor=1.3)
sraa_13 = core.std.MaskedMerge(clip, sraa_13, mask_strong(sraa_13))
clamp = replace_ranges(clamp, sraa_13, strong or [])
if sangnom:
sn = upscaled_sraa(sraa_13, aafun=lambda c: c.sangnom.SangNom())
sn = core.std.MaskedMerge(sraa_13, sn, mask_strong(sn))
for r, ms in sangnom:
mask = core.std.BlankClip(clip.std.ShufflePlanes(planes=0, colorfamily=vs.GRAY))
for m in ms:
mask = core.std.Expr([mask, m.get_mask(clip)], "x y max")
clamp = replace_ranges(clamp, core.std.MaskedMerge(clamp, sn, mask), r)
return clamp
def deband(clip: vs.VideoNode,
strong: Optional[List[Range]] = None) -> vs.VideoNode:
mask = detail_mask(clip)
deband = core.std.MaskedMerge(dumb3kdb(clip, radius=16, threshold=40),
clip, mask)
deband_strong = core.std.MaskedMerge(
dumb3kdb(clip, radius=16, threshold=50), clip, mask)
return replace_ranges(deband, deband_strong, strong or [])
def letterbox_edgefix(clip: vs.VideoNode,
crops: Optional[List[Range]] = None,
fades: Optional[List[Range]] = None) -> vs.VideoNode:
assert clip.format is not None
fixed = clip
if fades:
fy = _fixplane(clip.std.ShufflePlanes(planes=0, colorfamily=vs.GRAY),
top=132,
bottom=131,
bbt=2,
bbb=2)
fu = _fixplane(clip.std.ShufflePlanes(planes=1, colorfamily=vs.GRAY),
top=66,
bottom=65,
bbt=1,
bbb=2,
chroma=True)
fv = _fixplane(clip.std.ShufflePlanes(planes=2, colorfamily=vs.GRAY),
top=66,
bottom=66,
bbt=1,
bbb=2,
chroma=True)
f = core.std.ShufflePlanes([fy, fu, fv],
planes=[0, 0, 0],
colorfamily=vs.YUV)
fixed = replace_ranges(fixed, f, fades)
if crops:
black = [
vsutil.scale_value(0,
8,
clip.format.bits_per_sample,
range_in=vsutil.Range.FULL,
range=vsutil.Range.LIMITED,
scale_offsets=True),
scale_thresh(0.5, clip),
scale_thresh(0.5, clip),
]
crop = clip.std.Crop(top=132, bottom=132)
bb = bbmod(crop, top=2, bottom=2, blur=500)
f = bb.std.AddBorders(top=132, bottom=132, color=black)
fixed = replace_ranges(fixed, f, crops)
return fixed
def _fade_ranges_with_refs(clip: vs.VideoNode, reupscaled: vs.VideoNode,
ranges: List[FadeRange]) -> vs.VideoNode:
mask = core.std.BlankClip(clip)
for r in ranges:
rmask = descale_detail_mask(clip[r.ref],
reupscaled[r.ref],
threshold=1500)
rmask = core.std.Expr([mask, rmask], "x y +")
mask = replace_ranges(mask, rmask, [r.range_])
return mask
def letterbox_refix(aa: vs.VideoNode, noaa: vs.VideoNode,
ranges: List[Range]) -> vs.VideoNode:
return replace_ranges(
aa,
core.std.StackVertical([
aa.std.Crop(bottom=aa.height - 130),
noaa.std.Crop(top=130, bottom=aa.height - 134),
aa.std.Crop(top=134, bottom=132),
noaa.std.Crop(top=aa.height - 132, bottom=130),
aa.std.Crop(top=aa.height - 130)
]), ranges)
def w2x(clip: vs.VideoNode, w2x_range: List[Range]) -> vs.VideoNode:
rgb = clip.resize.Bicubic(format=vs.RGBS, matrix_in_s="709")
w2x = rgb.w2xnvk.Waifu2x(noise=1, scale=1, model=2) \
.resize.Bicubic(format=clip.format.id, matrix_s="709")
bm3d = BM3D(clip, sigma=[0, 5], ref=w2x)
bm3d = core.std.ShufflePlanes([w2x, bm3d],
planes=[0, 1, 2],
colorfamily=vs.YUV)
denoise = replace_ranges(clip, bm3d, w2x_range)
return denoise
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 descale720(clip: vs.VideoNode,
src: vs.VideoNode,
ranges: List[Range] = []) -> vs.VideoNode:
y = ldescale(vsutil.get_y(src),
upscaler=_sraa_reupscale,
height=720,
kernel=Bicubic(b=1 / 3, c=1 / 3),
threshold=0,
mask=_inverse_mask)
scaled = core.std.ShufflePlanes([y, src],
planes=[0, 1, 2],
colorfamily=vs.YUV)
scaled = replace_ranges(clip, scaled, ranges)
return scaled
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 wd_scenefilter(aa: vs.VideoNode, deb: vs.VideoNode,
start: Optional[int]) -> vs.VideoNode:
# this does icky things to the credits but until we get NC it's way worth it
if start is None:
return aa
WD_AA_STRONG: List[Range] = [
(start + 26, start + 33),
(start + 34, start + 41),
(start + 984, start + 1076),
(start + 1077, start + 1169),
(start + 1170, start + 1262),
(start + 1263, start + 1355),
(start + 1468, start + 1617),
]
sraa = upscaled_sraa(deb,
rfactor=1.6,
downscaler=Bicubic(b=0, c=1 / 2).scale)
return replace_ranges(aa, sraa, WD_AA_STRONG)
def get_mask(self, clip: vs.VideoNode, ref: vs.VideoNode) -> vs.VideoNode:
"""
Get the bounded mask.
:param clip: Source
:param ref: Reference clip
:return: Bounded mask
"""
if self.bound:
bm = self.bound.get_mask(ref)
bm = bm if not self.blur else bm.std.BoxBlur(
hradius=5, vradius=5, hpasses=5, vpasses=5)
if self.prebrz:
clip = vsutil.get_y(clip).std.Binarize(
scale_thresh(self.prebrz, clip)).std.Invert()
ref = vsutil.get_y(ref).std.Binarize(scale_thresh(
self.prebrz, ref)).std.Invert()
if ref.format is None or clip.format is None:
raise ValueError(
"SelfDehardsub: 'Variable-format clips not supported'")
if len(self.refframes) == 0:
hm = vsutil.depth(self._mask(clip, ref),
clip.format.bits_per_sample,
range=vsutil.Range.FULL,
range_in=vsutil.Range.FULL)
else:
hm = core.std.BlankClip(ref,
format=ref.format.replace(
color_family=vs.GRAY,
subsampling_h=0,
subsampling_w=0).id)
for range, rf in zip(self.ranges, self.refframes):
mask = vsutil.depth(self._mask(clip, ref[rf]),
clip.format.bits_per_sample,
range=vsutil.Range.FULL,
range_in=vsutil.Range.FULL)
hm = replace_ranges(
hm, core.std.Expr([hm, mask * len(hm)], expr="x y max"),
range)
return hm if self.bound is None else core.std.MaskedMerge(
core.std.BlankClip(hm), hm, bm)
def preqpfileflt(self) -> None:
"""Pre-QP file generation filtering so the scenes match properly"""
self.file.clip_cut = replace_ranges(self.file.clip_cut,
JPBD_NCOP2.clip_cut, replace_op)
self.file.clip_cut = insert_clip(self.file.clip_cut,
JPBD_NCOP2.clip_cut[826:1038], 823)
def preqpfileflt(self) -> None:
"""Pre-QP file generation filtering so the scenes match properly"""
self.file.clip_cut = replace_ranges(self.file.clip_cut, JPBD_EP.clip_cut, replace_op)
