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)