def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """Main filterchain""" import havsfunc as haf import lvsfunc as lvf import rekt import vardefunc as vdf from adptvgrnMod import adptvgrnMod from ccd import ccd from vsutil import depth, get_w, get_y src: vs.VideoNode = pre_corrections() # type:ignore[assignment] src_NCED = JP_BD_NCED.clip_cut # Masking credits ed_mask = vdf.dcm( src, src[edstart:edstart+src_NCED.num_frames-ed_offset], src_NCED[:-ed_offset], start_frame=edstart, thr=25, prefilter=False) if edstart is not False \ else get_y(core.std.BlankClip(src)) credit_mask = depth(ed_mask, 16).std.Binarize() rkt = rekt.rektlvls(src, [0, 1079], [7, 7], [0, 1919], [7, 7], prot_val=None) rkt = depth(rkt, 16) denoise_uv = ccd(rkt, threshold=7, matrix='709') stab = haf.GSMC(denoise_uv, radius=1, thSAD=200, planes=[0]) decs = vdf.noise.decsiz(stab, sigmaS=8, min_in=208 << 8, max_in=232 << 8) l_mask = vdf.mask.FDOG().get_mask(get_y(decs), lthr=0.065, hthr=0.065).std.Maximum().std.Minimum() l_mask = l_mask.std.Median().std.Convolution([1] * 9) aa_weak = lvf.aa.taa(decs, lvf.aa.nnedi3(opencl=True)) aa_strong = lvf.aa.upscaled_sraa(decs, downscaler=lvf.kernels.Bicubic(b=-1 / 2, c=1 / 4).scale) aa_clamp = lvf.aa.clamp_aa(decs, aa_weak, aa_strong, strength=1.5) aa_masked = core.std.MaskedMerge(decs, aa_clamp, l_mask) dehalo = haf.FineDehalo(aa_masked, rx=1.6, ry=1.6, darkstr=0, brightstr=1.25) darken = flt.line_darkening(dehalo, 0.275).warp.AWarpSharp2(depth=2) merged_credits = core.std.MaskedMerge(darken, decs, credit_mask) deband = flt.masked_f3kdb(merged_credits, rad=18, thr=32, grain=[32, 12]) grain: vs.VideoNode = adptvgrnMod(deband, seed=42069, strength=0.35, luma_scaling=8, size=1.05, sharp=80, grain_chroma=False) return grain
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """Regular VapourSynth filterchain""" import EoEfunc as eoe import havsfunc as haf import lvsfunc as lvf import vardefunc as vdf from adptvgrnMod import adptvgrnMod from ccd import ccd from muvsfunc import SSIM_downsample from vsutil import depth, get_y, iterate src = pre_freeze().std.AssumeFPS(fpsnum=24000, fpsden=1001) src = depth(src, 16) # TO-DO: Figure out how they post-sharpened it. Probably some form of unsharpening? src_y = depth(get_y(src), 32) descale = lvf.kernels.Bicubic(b=0, c=3 / 4).descale(src_y, 1440, 810) double = vdf.scale.nnedi3cl_double(descale, pscrn=1) rescale = depth(SSIM_downsample(double, 1920, 1080), 16) scaled = vdf.misc.merge_chroma(rescale, src) denoise = core.knlm.KNLMeansCL(scaled, d=1, a=3, s=4, h=0.4, channels='Y') stab = haf.GSMC(denoise, radius=2, planes=[0]) cdenoise = ccd(stab, threshold=5, matrix='709') decs = vdf.noise.decsiz(cdenoise, sigmaS=4, min_in=208 << 8, max_in=232 << 8) dehalo = haf.YAHR(decs, blur=2, depth=32) halo_mask = lvf.mask.halo_mask(decs, rad=3, brz=0.3, thma=0.42) dehalo_masked = core.std.MaskedMerge(decs, dehalo, halo_mask) dehalo_min = core.std.Expr([dehalo_masked, decs], "x y min") aa = lvf.aa.nneedi3_clamp(dehalo_min, strength=1.5) # Some scenes have super strong aliasing that I really don't wanna scenefilter until BDs. Thanks, Silver Link! aa_strong = lvf.sraa(dehalo_min, rfactor=1.35) aa_spliced = lvf.rfs(aa, aa_strong, []) upscale = lvf.kernels.Bicubic(b=0, c=3 / 4).scale(descale, 1920, 1080) credit_mask = lvf.scale.descale_detail_mask(src_y, upscale, threshold=0.08) credit_mask = iterate(credit_mask, core.std.Deflate, 3) credit_mask = iterate(credit_mask, core.std.Inflate, 3) credit_mask = iterate(credit_mask, core.std.Maximum, 2) merge_credits = core.std.MaskedMerge(aa_spliced, src, depth(credit_mask, 16)) deband = flt.masked_f3kdb(merge_credits, rad=18, thr=32, grain=[24, 0]) grain: vs.VideoNode = adptvgrnMod(deband, seed=42069, strength=0.15, luma_scaling=10, size=1.25, sharp=80, static=True, grain_chroma=False) return grain
def vapoursynthFilter(self): if VSCORE_MEM_CACHE_MAX is not None: core.max_cache_size = VSCORE_MEM_CACHE_MAX video = core.ffms2.Source(source=self.sourcefile) video = core.std.CropRel(video, top=140, bottom=140) video = haf.GSMC(video, thSAD=150, radius=2) video = core.f3kdb.Deband(video, dynamic_grain=True, preset='Low') video = core.std.AddBorders(video, top=140, bottom=140) return video
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """Main filterchain""" import havsfunc as haf import lvsfunc as lvf import vardefunc as vdf from adptvgrnMod import adptvgrnMod from ccd import ccd from vsutil import depth src = JP_BD.clip_cut src = depth(src, 16) scaled, descale_mask = flt.rescaler(src, height=855) denoise_y = core.knlm.KNLMeansCL(scaled, d=2, a=3, h=0.15) denoise_uv = ccd(denoise_y, threshold=7, matrix='709') denoise_uv_str = ccd(denoise_y, threshold=15, matrix='709') denoise_uv = lvf.rfs(denoise_uv, denoise_uv_str, [(1999, 2041)]) stab = haf.GSMC(denoise_uv, radius=1, thSAD=200, planes=[0]) decs = vdf.noise.decsiz(stab, sigmaS=8, min_in=200 << 8, max_in=232 << 8) aa_weak = lvf.aa.nneedi3_clamp(decs, strength=4) aa_strong = lvf.sraa(decs, rfactor=1.6) aa_clamp = lvf.aa.clamp_aa(decs, aa_weak, aa_strong, strength=2) halo_mask = lvf.mask.halo_mask(aa_clamp) darken = flt.line_darkening(aa_clamp, strength=0.35) dehalo = core.std.MaskedMerge( darken, lvf.dehalo.bidehalo(darken, sigmaS_final=1.2, sigmaR=11 / 255), halo_mask) # ufo w h y y y y y this is why I hate working on your shows halo_mask_str = lvf.mask.halo_mask(aa_clamp, rad=1, brz=0.9, thlima=0.55) dehalo_str = core.std.MaskedMerge( darken, lvf.dehalo.bidehalo(darken, sigmaS=4.0, sigmaS_final=3.6, sigmaR=22 / 255), halo_mask_str) dehalo = lvf.rfs(dehalo, dehalo_str, [(2042, 2077)]) merged_credits = core.std.MaskedMerge(dehalo, src, descale_mask) deband = flt.masked_f3kdb(merged_credits, rad=21, thr=[28, 24], grain=[32, 16]) grain: vs.VideoNode = adptvgrnMod(deband, seed=42069, strength=0.25, luma_scaling=10, size=1.35, sharp=80, grain_chroma=False) return grain
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """Main filterchain""" import EoEfunc as eoe import havsfunc as haf import lvsfunc as lvf import vardefunc as vdf from adptvgrnMod import adptvgrnMod from ccd import ccd from vsutil import depth src = JP_BD.clip_cut src = depth(src, 16) # Native 855p OP. scaled, descale_mask = flt.rescaler(src, height=855) # Weak denoising for most of the clip to smoothen out the compression noise. Stronger over heavy grain scenes. denoise_y_wk = core.knlm.KNLMeansCL(scaled, d=2, a=3, h=0.3) denoise_y_str = eoe.dn.BM3D(scaled, sigma=[0.85, 0]) denoise_y = lvf.rfs(denoise_y_wk, denoise_y_str, [(273, 676), (1303, 1428)]) denoise_uv = ccd(denoise_y, threshold=9, matrix='709') # Grain stabilising and blurring away super bright areas to save more filesize by limiting intra-frame differences. stab = haf.GSMC(denoise_uv, radius=1, thSAD=250, planes=[0]) decs = vdf.noise.decsiz(stab, sigmaS=8, min_in=200 << 8, max_in=232 << 8) # Clamped AA to try and force ufo's meh lineart along and deal with some leftover lineart fuckery from rescaling. aa_weak = lvf.aa.nneedi3_clamp(decs, strength=4) aa_strong = lvf.sraa(decs, rfactor=1.6) aa_clamp = lvf.aa.clamp_aa(decs, aa_weak, aa_strong, strength=2) # AA has a tendency to slightly brighten lines, so we perform pretty weak line darkening here halo_mask = lvf.mask.halo_mask(aa_clamp) darken = flt.line_darkening(aa_clamp, strength=0.35) dehalo = core.std.MaskedMerge( darken, lvf.dehalo.bidehalo(darken, sigmaS_final=1.2, sigmaR=11 / 255), halo_mask) # But the dehaloing also destroys select scenes too much, so we undo that here. no_dehalo_aa = lvf.rfs(dehalo, decs, [(2967, 3031)]) merged_credits = core.std.MaskedMerge(no_dehalo_aa, src, descale_mask) # Medium debanding. Smears the darker backgrounds a tiny bit, but the added grain should help hide that. deband = flt.masked_f3kdb(merged_credits, rad=21, thr=[28, 24], grain=[32, 16]) grain: vs.VideoNode = adptvgrnMod(deband, seed=42069, strength=0.25, luma_scaling=10, size=1.35, sharp=80, grain_chroma=False) return grain
def do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut src = depth(src, 16) denoise_chroma = core.knlm.KNLMeansCL(src, a=2, h=0.55, d=3, device_type='gpu', channels='UV') stabilize = hvf.GSMC(denoise_chroma, radius=2, planes=0) return depth(stabilize, 10)
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """Main filterchain""" import havsfunc as haf import lvsfunc as lvf import vardefunc as vdf from adptvgrnMod import adptvgrnMod from ccd import ccd from vsutil import depth, insert_clip src = JP_BD.clip_cut src = depth(src, 16) scaled, descale_mask = flt.rescaler(src, height=855) denoise_y = core.knlm.KNLMeansCL(scaled, d=2, a=3, h=0.35) denoise_uv = ccd(denoise_y, threshold=7, matrix='709') stab = haf.GSMC(denoise_uv, radius=1, thSAD=200, planes=[0]) decs = vdf.noise.decsiz(stab, sigmaS=8, min_in=200 << 8, max_in=232 << 8) aa_weak = lvf.aa.nneedi3_clamp(decs, strength=4) aa_strong = lvf.sraa(decs, rfactor=1.6) aa_clamp = lvf.aa.clamp_aa(decs, aa_weak, aa_strong, strength=2) aa_rfs = lvf.rfs(aa_clamp, aa_strong, [(434, 592)]) halo_mask = lvf.mask.halo_mask(aa_rfs) darken = flt.line_darkening(aa_rfs, strength=0.35) dehalo = core.std.MaskedMerge( darken, lvf.dehalo.bidehalo(darken, sigmaS_final=1.2, sigmaR=11 / 255), halo_mask) merged_credits = core.std.MaskedMerge(dehalo, src, descale_mask) deband = flt.masked_f3kdb(merged_credits, rad=21, thr=[28, 24], grain=[32, 16]) grain: vs.VideoNode = adptvgrnMod(deband, seed=42069, strength=0.25, luma_scaling=10, size=1.35, sharp=80, grain_chroma=False) # Making sure there's no weird dynamic noise on the titlecard final = insert_clip(grain, grain[869] * (903 - 869), 869) return final
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """Main filterchain""" import havsfunc as haf import lvsfunc as lvf import rekt import vardefunc as vdf from adptvgrnMod import adptvgrnMod from awsmfunc import bbmod from ccd import ccd from vsutil import depth, get_y from xvs import WarpFixChromaBlend src = JP_BD.clip_cut src_NCOP, src_NCED = JP_BD_NCOP.clip_cut, JP_BD_NCED.clip_cut src_NCOP = src_NCOP + src_NCOP[-1] * 11 src_NCED = src_NCED + src_NCED[-1] src_03 = JP_BD_03.clip_cut # b = core.std.BlankClip(src, length=1) # Fixing an animation error in the NCOP sqmask_NCOP = lvf.mask.BoundingBox((419, 827), (1500, 68)) masked_NCOP = core.std.MaskedMerge(src_NCOP, src_03, sqmask_NCOP.get_mask(src_NCOP)) masked_NCOP = lvf.rfs(src_NCOP, masked_NCOP, [(opstart + 2064, opstart + 2107)]) # OP/ED stack comps to check that it lines up # op_scomp = lvf.scomp(src[opstart:opstart+src_NCOP.num_frames-1]+b, masked_NCOP[:-op_offset]+b) # noqa # ed_scomp = lvf.scomp(src[edstart:edstart+src_NCED.num_frames-1]+b, src_NCED[:-ed_offset]+b) # noqa # Masking credits op_mask = vdf.dcm( src, src[opstart:opstart+src_NCOP.num_frames-op_offset], masked_NCOP[:-op_offset], start_frame=opstart, thr=25, prefilter=True) if opstart is not False \ else get_y(core.std.BlankClip(src)) ed_mask = vdf.dcm( src, src[edstart:edstart+src_NCED.num_frames-ed_offset], src_NCED[:-ed_offset], start_frame=edstart, thr=25, prefilter=False) if edstart is not False \ else get_y(core.std.BlankClip(src)) credit_mask = core.std.Expr([op_mask, ed_mask], expr='x y +') credit_mask = depth(credit_mask, 16).std.Binarize() # Edgefixing ef = bbmod(src, left=1, right=1, top=1, bottom=1, u=False, v=False) ef = bbmod(ef, left=2, right=2, top=2, bottom=2, y=False) ef = depth(ef, 32) # Descaling + Rescaling src_y = get_y(ef) descaled = lvf.kernels.Lanczos(taps=5).descale(src_y, 1280, 720) rescaled = vdf.scale.nnedi3_upscale(descaled) downscaled = lvf.kernels.BicubicDidee().scale(rescaled, 1920, 1080) l_mask = vdf.mask.FDOG().get_mask(src_y, lthr=0.065, hthr=0.065).std.Maximum().std.Minimum() l_mask = l_mask.std.Median().std.Convolution([1] * 9) rescaled_masked = core.std.MaskedMerge(src_y, downscaled, l_mask) scaled = depth(vdf.misc.merge_chroma(rescaled_masked, ef), 16) unwarp = flt.line_darkening(scaled, 0.145).warp.AWarpSharp2(depth=2) sharp = haf.LSFmod(unwarp, strength=65, Smode=3, Lmode=1, edgemode=1, edgemaskHQ=True) mask_sharp = core.std.MaskedMerge(scaled, sharp, depth(l_mask, 16)) upscaled = lvf.kernels.Bicubic().scale(descaled, 1920, 1080) descale_mask = lvf.scale.descale_detail_mask(src_y, upscaled) scale_restore_mask = core.std.Expr([credit_mask, descale_mask], "x y +") credits_merged = core.std.MaskedMerge(mask_sharp, depth(ef, 16), scale_restore_mask) # Denoising denoise_y = core.knlm.KNLMeansCL(credits_merged, d=1, a=3, s=4, h=0.15, channels='Y') denoise_uv = ccd(denoise_y, threshold=6, matrix='709') stab = haf.GSMC(denoise_uv, radius=2, planes=[0]) decs = vdf.noise.decsiz(stab, sigmaS=8, min_in=208 << 8, max_in=232 << 8) # Fixing chroma cshift = core.resize.Bicubic(decs, chromaloc_in=1, chromaloc=0) cwarp = WarpFixChromaBlend(cshift, thresh=88, blur=3, depth=6) # Regular debanding + graining detail_mask = flt.detail_mask(cwarp, brz=(1800, 3500)) deband = vdf.deband.dumb3kdb(cwarp, threshold=32, grain=16) deband_masked = core.std.MaskedMerge(deband, cwarp, detail_mask) grain: vs.VideoNode = adptvgrnMod(deband_masked, 0.2, luma_scaling=10, size=1.35, static=True, grain_chroma=False) return grain
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 _line_mask(clip: vs.VideoNode, thr: int) -> vs.VideoNode: mask = core.std.Prewitt(clip) mask = core.std.Expr(mask, 'x 2 *').std.Median() mask = core.std.Expr(mask, f'x {thr} < x x 3 * ?') return mask.std.Inflate().std.Deflate() def _ssharp(clip: vs.VideoNode, strength: float, width: int, height: int, factor: float = 2, b: float = -1, c: float = 6) -> vs.VideoNode: source = clip sharp = core.resize.Bicubic(clip, clip.width*factor, clip.height*factor, \ filter_param_a=b, filter_param_b=c).resize.Lanczos(width, height) source = core.resize.Spline64(source, sharp.width, sharp.height) sharp = core.rgvs.Repair(sharp, source, 13) sharp = mvf.LimitFilter(source, sharp, thrc=0.5, elast=6, brighten_thr=0.5, planes=0) final = core.std.Expr([sharp, source], f'x {strength} * y 1 {strength} - * +') return final 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)) def _perform_masks_credit(path: Path) -> List[MaskCredit]: return [ MaskCredit(lvf.src(str(mask)), int(str(mask.stem).split('_')[2]), int(str(mask.stem).split('_')[3])) for mask in path.glob('*') ] # pylint: disable=unused-argument def _diff(n: int, f: vs.VideoFrame, new: vs.VideoNode, adapt: vs.VideoNode) -> vs.VideoNode: psa = f.props['PlaneStatsAverage'] if psa > 0.5: clip = new elif psa < 0.4: clip = adapt else: weight = (psa - 0.4) * 10 clip = core.std.Merge(adapt, new, weight) return clip 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 opstart, opend = 1774, 3944 edstart, edend = 31781, 33938 src = JPBD.src_cut src = depth(src, 16) denoise_a = mdf.hybriddenoise_mod(src, 0.55, 2.25) denoise_b = mdf.hybriddenoise_mod(src, 0.55, 10) denoise = lvf.rfs(denoise_a, denoise_b, [(opstart, opstart + 44)]) diff = core.std.MakeDiff(src, denoise, [0, 1, 2]) luma = get_y(denoise) upscale = _nnedi3(luma, 1.5, dict(nsize=0, nns=3, qual=1, pscrn=1)) sraa = _sraa(upscale, dict(nsize=0, nns=3, qual=1, pscrn=1), dict(alpha=0.2, beta=0.5, gamma=80, nrad=3, mdis=18)) sraa = core.rgvs.Repair(sraa, upscale, 3) rescale = _ssharp(sraa, 0.55, src.width, src.height, 2) artefacts_mask = core.std.BlankClip(rescale, color=(256 << 8) - 1) artefacts_mask = vdf.region_mask(artefacts_mask, 2, 2, 2, 2).std.Inflate() rescale = core.std.MaskedMerge(luma, rescale, artefacts_mask) lineart_mask = _line_mask(luma, 8000) antialias = core.std.MaskedMerge(luma, rescale, lineart_mask) antialias_merged = vdf.merge_chroma(antialias, denoise) src_c, src_ncop = [ c.knlm.KNLMeansCL(a=6, h=20, d=0, device_type='gpu') for c in [src, JPBD_NCOP.src_cut[:opend - opstart + 1]] ] credit_mask = vdf.dcm(src, src_c[opstart:opend + 1], src_ncop, opstart, opend, 2, 2).std.Deflate() credit = core.std.MaskedMerge(antialias_merged, denoise, credit_mask) masks_credit_ = _perform_masks_credit(Path('masks_' + JPBD.name[-2:] + '/')) for mask in masks_credit_: credit = lvf.rfs( credit, core.std.MaskedMerge(credit, denoise, to_gray(mask.mask, src).std.Deflate()), [(mask.start_frame, mask.end_frame)]) deband_mask = lvf.denoise.detail_mask(credit, brz_a=3000, brz_b=1500) dark_mask = core.std.Expr([deband_mask, _ret_mask(credit, 12500)], 'x y +') deband_a = dbs.f3kpf(credit, 18, 36, 36) deband_b = dbs.f3kpf(credit, 18, 42, 42) deband_c = placebo.Deband(credit, radius=12, threshold=20, iterations=3, grain=0) deband_d = placebo.Deband(credit, radius=10, threshold=8, iterations=2, grain=0) deband = lvf.rfs(deband_a, deband_b, [(opstart + 483, opstart + 554)]) deband = lvf.rfs(deband, deband_c, [(opstart, opstart + 44)]) deband = lvf.rfs(deband, core.std.MaskedMerge(deband_d, credit, dark_mask), [(opstart + 1070, opstart + 1103)]) deband = lvf.rfs(deband, deband_d, [(opstart + 1104, opstart + 1124)]) deband = core.std.MaskedMerge(deband, credit, deband_mask) grain_original = core.std.MergeDiff(deband, diff, [0, 1, 2]) grain_original_nochroma = core.std.MergeDiff(deband, diff, [0]) grain_new = core.neo_f3kdb.Deband(deband, preset='depth', grainy=32, grainc=32) grain_new_nochroma = vdf.merge_chroma(grain_new, deband) avg = core.std.PlaneStats(deband) adapt_mask = core.adg.Mask(get_y(avg), 28) grain_adapt = core.std.MaskedMerge(grain_new, grain_original, adapt_mask) gf3_args = dict(g1str=5, g2str=3.85, g3str=3.5, g1shrp=50, g2shrp=60, g3shrp=60, g1size=1.65, g2size=1.60, g3size=1.25) grain_a = hvf.GrainFactory3(deband, **gf3_args) grain_b = mdf.adptvgrnMod_mod(deband, 2, size=1.5, sharp=60, static=False, luma_scaling=14) grain = core.std.FrameEval( deband, partial(_diff, new=grain_new, adapt=grain_adapt), avg) grain = lvf.rfs(grain, grain_original, [(5058, 5253), (7871, 7989)]) grain = lvf.rfs(grain, grain_new_nochroma, [(opstart + 117, opstart + 873), (opstart + 921, opstart + 993)]) grain = lvf.rfs(grain, grain_original_nochroma, [(opstart + 874, opstart + 920), (opstart + 994, opstart + 1069), (opstart + 1125, opstart + 1202)]) grain = lvf.rfs(grain, grain_a, [(opstart, opstart + 44)]) grain = lvf.rfs(grain, grain_b, [(opstart + 1070, opstart + 1124)]) stabilize = hvf.GSMC(src, radius=2, planes=0) ending = vdf.merge_chroma(stabilize, denoise) final = lvf.rfs(grain, ending, [(edstart, edend)]) final = final[:opstart] + final[opstart + 2:opstart + 2160] + final[opend + 1:] return depth(final, 10), opstart, opend
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """Main filterchain""" import havsfunc as haf import lvsfunc as lvf import rekt import vardefunc as vdf from adptvgrnMod import adptvgrnMod from awsmfunc import bbmod from ccd import ccd from vsutil import depth, get_y from xvs import WarpFixChromaBlend src = JP_NCED.clip_cut src_13 = JP_BD_13.clip_cut src = lvf.rfs(src, src_13, [(2073, None)]) # Edgefixing rkt = rekt.rektlvls(src, [0, 1079], [17, 16], [0, 1, 2, 3] + [1917, 1918, 1919], [16, 4, -2, 2] + [-2, 5, 14]) ef = bbmod(rkt, left=4, right=3, y=False) ef = depth(ef, 32) # Descaling + Rescaling src_y = get_y(ef) descaled = lvf.kernels.Bicubic().descale(src_y, 1280, 720) rescaled = vdf.scale.nnedi3_upscale(descaled) downscaled = lvf.kernels.Bicubic(-1 / 2, 1 / 4).scale(rescaled, 1920, 1080) l_mask = vdf.mask.FDOG().get_mask(src_y, lthr=0.065, hthr=0.065).std.Maximum().std.Minimum() l_mask = l_mask.std.Median().std.Convolution([1] * 9) rescaled_masked = core.std.MaskedMerge(src_y, downscaled, l_mask) scaled = depth(vdf.misc.merge_chroma(rescaled_masked, ef), 16) unwarp = flt.line_darkening(scaled, 0.145).warp.AWarpSharp2(depth=2) sharp = haf.LSFmod(unwarp, strength=65, Smode=3, Lmode=1, edgemode=1, edgemaskHQ=True) mask_sharp = core.std.MaskedMerge(scaled, sharp, depth(l_mask, 16)) upscaled = lvf.kernels.Bicubic().scale(descaled, 1920, 1080) descale_mask = lvf.scale.descale_detail_mask(src_y, upscaled) details_merged = core.std.MaskedMerge(mask_sharp, depth(ef, 16), depth(descale_mask, 16)) # Denoising denoise_y = core.knlm.KNLMeansCL(details_merged, d=1, a=3, s=4, h=0.15, channels='Y') denoise_uv = ccd(denoise_y, threshold=6, matrix='709') stab = haf.GSMC(denoise_uv, radius=2, adapt=1, planes=[0]) decs = vdf.noise.decsiz(stab, sigmaS=8, min_in=208 << 8, max_in=232 << 8) # Fixing chroma cshift = core.resize.Bicubic(decs, chromaloc_in=1, chromaloc=0) cwarp = WarpFixChromaBlend(cshift, thresh=88, blur=3, depth=6) # Regular debanding + graining detail_mask = flt.detail_mask(cwarp, brz=(1800, 3500)) deband = vdf.deband.dumb3kdb(cwarp, threshold=32, grain=16) deband_masked = core.std.MaskedMerge(deband, cwarp, detail_mask) grain: vs.VideoNode = adptvgrnMod(deband_masked, 0.2, luma_scaling=10, size=1.35, static=True, grain_chroma=False) return grain
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """Main VapourSynth filterchain""" import debandshit as dbs import havsfunc as haf import lvsfunc as lvf import rekt import vardefunc as vdf from awsmfunc import bbmod from ccd import ccd from muvsfunc import SSIM_downsample from vsutil import depth, get_w, get_y src = JP_BD.clip_cut src = depth(src, 16) rkt_a = rekt.rektlvls(src, [0, 1, -2, -1], [12, -12, -10, 11], [0, 1, -2, -1], [11, -12, -10, 11]) rkt_b = rekt.rektlvls(src, [0, -1], [15, 15], [0, 1, 2, 3, -4, -2, -1], [12, 3, -1, 1, 2, 4, 12]) rkt_c = rekt.rektlvls(src, [-2, -1], [6, 11], [0, -2, -1], [15, 10, 15]) bb_c = bbmod(rkt_c, bottom=2, blur=35, y=False) rkt = lvf.rfs(rkt_a, rkt_b, [(458, 522), (806, 919), (1148, 1179), (1321, 1442), (1989, 2129)]) rkt = lvf.rfs(rkt, bb_c, [(2130, None)]) ef = depth(rkt, 32) src_y = get_y(ef) pre_den = core.dfttest.DFTTest(src_y, sigma=3.0) l_mask = vdf.mask.FDOG().get_mask( pre_den, lthr=0.125, hthr=0.050).rgsf.RemoveGrain(4).rgsf.RemoveGrain(4) l_mask = l_mask.std.Minimum().std.Deflate().std.Median().std.Convolution( [1] * 9).std.Maximum() # Descaling. descaled = lvf.kernels.Catrom().descale( src_y, get_w(720, src_y.width / src_y.height), 720) descaled = core.resize.Bicubic(descaled, format=vs.YUV444P16) # Slight AA in an attempt to forcibly fix starved lineart. baa = lvf.aa.based_aa(descaled, shader_file) sraa = lvf.aa.upscaled_sraa(descaled, rfactor=1.45) clamp_aa = lvf.aa.clamp_aa(descaled, baa, sraa, strength=1.15) clamp_aa = depth(get_y(clamp_aa), 32) # Doing a mixed reupscale using nn3/fsrcnnx, grabbing the darkest parts of each rescaled_nn3 = vdf.scale.nnedi3cl_double(clamp_aa, use_znedi=True, pscrn=1) rescaled_fsrcnnx = vdf.scale.fsrcnnx_upscale(clamp_aa, rescaled_nn3.width, rescaled_nn3.height, shader_file) rescaled = core.std.Expr([rescaled_nn3, rescaled_fsrcnnx], "x y min") downscaled = SSIM_downsample(rescaled, src_y.width, src_y.height, smooth=((3**2 - 1) / 12)**0.5, sigmoid=True, filter_param_a=-1 / 2, filter_param_b=1 / 4) downscaled = core.std.MaskedMerge(src_y, downscaled, l_mask) scaled = depth(vdf.misc.merge_chroma(downscaled, ef), 16) # Chroma warping to forcibly wrap it a bit nicer around the lineart. Also fixing slight shift. 4:2:0 was a mistake. cwarp = scaled.warp.AWarpSharp2(thresh=72, blur=3, type=1, depth=6, planes=[1, 2]) # The textures and detail are very smeary, so gotta be careful not to make it even worse stab = haf.GSMC(cwarp, radius=3, planes=[0], thSAD=75) den_uv = ccd(stab, threshold=5, matrix='709') decs = vdf.noise.decsiz(den_uv, sigmaS=8.0, min_in=200 << 8, max_in=240 << 8) # Scenefiltered debanding. Not graining, since we kept most of the original grain anyway. deband_wk = dbs.debanders.dumb3kdb(decs, radius=16, threshold=[28, 0], grain=0) deband_wk = core.placebo.Deband(deband_wk, iterations=2, threshold=3.5, radius=12, grain=0, planes=2 | 4) # Strong denoising + debanding to hopefully deal with all the awful bands. Courtesy of :b:arde dft = core.dfttest.DFTTest(decs, sigma=4.0) ccd_uv = ccd(dft, threshold=10, matrix='709') f3k = dbs.debanders.dumb3kdb(ccd_uv, radius=8, threshold=[36, 24], grain=0) plac = flt.masked_placebo(f3k, rad=18, thr=5.5, itr=2, grain=3.0, mask_args={ 'detail_brz': 100, 'lines_brz': 450 }) dft_diff = core.std.MakeDiff(decs, dft) plac_diff = core.std.MergeDiff(plac, dft_diff) deband = lvf.rfs(deband_wk, plac_diff, strong_debanding) return deband
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """Main filterchain""" import EoEfunc as eoe import havsfunc as haf import kagefunc as kgf import lvsfunc as lvf import vardefunc as vdf from adptvgrnMod import adptvgrnMod from ccd import ccd from vsdpir import DPIR from vsutil import depth src = pre_filter() src = depth(src, 16) # Fix slight green tint present throughout parts of the OP src_g = core.std.Expr(src, ["", "", "x 32768 = x x 96 + ?"]) src_g = lvf.rfs(src, src_g, [(None, 873)]) scaled, descale_mask = flt.rescaler(src_g, height=854, shader_file=shader_file) # Denoising this is rough. Lots of fine detail that's easy to destroy. detail_mask = flt.detail_mask(scaled, pf_sigma=1.5, rxsigma=[50, 150, 200, 300], rad=2, brz=[2250, 3500]) denoise_y = eoe.dn.BM3D(scaled, sigma=[0.3, 0]) denoise_y_str = flt.to_yuvps( DPIR(flt.to_rgbs(scaled), strength=40, task='deblock', device_type='cpu')) denoise_y = lvf.rfs(denoise_y, denoise_y_str, [(1384, 1398)]) denoise_uv = ccd(denoise_y, threshold=7, matrix='709') denoise_uv_rep = core.std.MaskedMerge(denoise_uv, denoise_y, detail_mask) stab = haf.GSMC(denoise_uv_rep, radius=1, thSAD=200, planes=[0]) stab = lvf.rfs( stab, scaled, [(1399, 1400), (1408, 1416)]) # Undo denoising because it eats lines on these scenes decs = vdf.noise.decsiz(stab, sigmaS=8, min_in=200 << 8, max_in=232 << 8) # F**k ufo lines eed = lvf.aa.nneedi3_clamp(decs, strength=1.6) sraa = lvf.sraa(decs, rfactor=1.5, aafun=flt.eedi3_singlerate_custom) clamp_aa = lvf.aa.clamp_aa(decs, eed, sraa, strength=1.6) # Certain frames have truly godawful aliasing. We attempt to fix those here tsraa = flt.transpose_sraa(decs, rfactor=1.5, aafun=flt.eedi3_singlerate_custom) tsraa_rep = core.rgvs.Repair(tsraa, clamp_aa, 13) aa_rfs = lvf.rfs(clamp_aa, tsraa_rep, strong_aa) # F**k ufo lines ec = haf.EdgeCleaner(aa_rfs, strength=4) # This fixes up all the super red scenes fairly well crecon = lvf.recon.chroma_reconstruct(ec) deband_a = flt.masked_f3kdb(crecon, rad=18, thr=24, grain=[24, 16], mask_args={'brz': (1250, 2250)}) deband_b = flt.masked_f3kdb(crecon, rad=24, thr=40, grain=[32, 24], mask_args={'brz': (1000, 1750)}) deband_c = flt.placebo_debander(crecon, grain=2, iterations=2, threshold=8, radius=16) deband = lvf.rfs(deband_a, deband_b, []) deband = kgf.crossfade(deband[:2246 + 48], deband_c[2246:], 47) deband = lvf.rfs(deband, crecon, [(1399, 1400)]) sqmask = lvf.mask.BoundingBox((699, 50), (526, 870)).get_mask(deband) sqmask = core.bilateral.Gaussian(sqmask, sigma=4) blur = core.bilateral.Gaussian(deband, sigma=25).bilateral.Gaussian(sigma=25) blur_mask = core.std.MaskedMerge(blur, deband, sqmask) blurred = kgf.crossfade(deband[:2412 + 48], blur_mask[2411:], 48) blurred_del = core.std.DeleteFrames(blurred, [2293]) grain_a = adptvgrnMod(blurred_del, seed=42069, strength=0.15, static=True, size=1.15, sharp=80, grain_chroma=False) grain_b = adptvgrnMod(blurred_del, seed=42069, strength=0.25, static=True, size=1.15, sharp=100, grain_chroma=False) grain_c = adptvgrnMod(blurred_del, seed=42069, strength=0.2, static=False, size=1.15, sharp=100, grain_chroma=False) grain = lvf.rfs(grain_a, grain_b, [(2390, None)]) grain = lvf.rfs(grain, grain_c, [(885, 1149), (1324, 1345), (1489, 1506), (1603, 1810), (1981, 1996)]) # Accidentally a frame during one of the previous processes. Easy to fix, though. oopsie = core.std.DeleteFrames(grain, [grain.num_frames - 1]) out = enc.dither_down(oopsie) return out
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """Main filterchain""" import havsfunc as haf import lvsfunc as lvf import muvsfunc as muf import debandshit as dbs import vardefunc as vdf from vsutil import depth, get_y, insert_clip, join, plane src = JP_DVD.clip_cut.std.AssumeFPS(fpsnum=24000, fpsden=1001) src_ncop, src_nced = JP_BD_NCOP.clip_cut, JP_BD_NCED.clip_cut src_ncop = src_ncop + src_ncop[-1] * 11 src_nced = src_nced + src_nced[-1] src_03 = JP_BD_03.clip_cut src_ncop = flt.rekt(src_ncop) src_nced = flt.rekt(src_nced) src_03 = flt.rekt(src_03) # Fixing an animation error in the NCOP sqmask_ncop = lvf.mask.BoundingBox((419, 827), (1500, 68)) masked_ncop = core.std.MaskedMerge(src_ncop, src_03, sqmask_ncop.get_mask(src_ncop)) masked_ncop = lvf.rfs(src_ncop, masked_ncop, [(opstart+2064, opstart+2107)]) op_mask = vdf.dcm( src_03, src_03[opstart:opstart+masked_ncop.num_frames-op_offset], masked_ncop[:-op_offset], start_frame=opstart, thr=85, prefilter=True) if opstart is not False \ else get_y(core.std.BlankClip(src)) op_mask = depth(core.resize.Bicubic(op_mask, 1296, 728).std.Crop(top=4, bottom=4), 16) # Stick credits ontop of NC because it looks way better masked_ncop = src_ncop.resize.Bicubic(chromaloc_in=1, chromaloc=0) cwarp_ncop = masked_ncop.warp.AWarpSharp2(thresh=88, blur=3, type=1, depth=6, planes=[1, 2]) descale_ncop = lvf.kernels.Bicubic().descale(plane(depth(src_ncop, 16), 0), 1280, 720) chroma_down_ncop = core.resize.Bicubic(cwarp_ncop, 1280, 720, vs.YUV444P16) scaled_ncop = join([descale_ncop, plane(chroma_down_ncop, 1), plane(chroma_down_ncop, 2)]) scaled_ncop = scaled_ncop.resize.Bicubic(1296, 728).std.Crop(top=4, bottom=4) downscale_03 = src_03.resize.Bicubic(1296, 728, vs.YUV444P16).std.Crop(top=4, bottom=4) merge_credits_03 = core.std.MaskedMerge(scaled_ncop, downscale_03, op_mask) for prop, val in PROPS_DVD: src = src.std.SetFrameProp(prop, intval=val) dvd_i444 = vdf.scale.to_444(depth(src, 32), src.width, src.height, join_planes=True) dvd_rgb = dvd_i444.resize.Bicubic(format=vs.RGB24, dither_type='error_diffusion', matrix_in=6) upscale = vsgan.run(dvd_rgb) conv = core.resize.Bicubic(upscale, format=vs.YUV444P16, matrix=1) scaled = depth(muf.SSIM_downsample(conv, 1296, 720), 16) splice_op = lvf.rfs(scaled, merge_credits_03, [(0, 203), (263, 1740), (1836, 2018)]) # Splicing for the ED. Halves of the ED have visuals, others are credits masked_nced = src_nced.resize.Bicubic(chromaloc_in=1, chromaloc=0) cwarp_nced = masked_nced.warp.AWarpSharp2(thresh=88, blur=3, type=1, depth=6, planes=[1, 2]) descale_nced = lvf.kernels.Bicubic().descale(plane(depth(src_nced, 16), 0), 1280, 720) chroma_down_nced = core.resize.Bicubic(cwarp_nced, 1280, 720, vs.YUV444P16) scaled_nced = join([descale_nced, plane(chroma_down_nced, 1), plane(chroma_down_nced, 2)]) scaled_nced = scaled_nced.resize.Bicubic(1296, 728).std.Crop(top=4, bottom=4) ed_nc = scaled_nced ed_dvd = splice_op[31888:] sq_top = lvf.mask.BoundingBox((0, 0), (ed_nc.width, ed_nc.height/2)).get_mask(ed_nc) sq_left = lvf.mask.BoundingBox((0, 0), (ed_nc.width/2, ed_nc.height)).get_mask(ed_nc) sq_right = sq_left.std.Invert() mask_top = core.std.MaskedMerge(ed_dvd, ed_nc, sq_top) mask_left = core.std.MaskedMerge(ed_dvd, ed_nc, sq_left) mask_right = core.std.MaskedMerge(ed_dvd, ed_nc, sq_right) ed_splice = lvf.rfs(ed_dvd, mask_top, [(0, 1213), (1613, 1673), (1794, None)]) ed_splice = lvf.rfs(ed_splice, mask_left, [(1390, 1503)]) ed_splice = lvf.rfs(ed_splice, mask_right, [(1214, 1389), (1504, 1612), (1674, 1793)]) splice_ed = insert_clip(splice_op, ed_splice, edstart) # Back to more regular filtering stab = haf.GSMC(splice_ed, radius=2, planes=[0]) decs = vdf.noise.decsiz(stab, sigmaS=8, min_in=208 << 8, max_in=232 << 8) detail_mask = flt.detail_mask(decs, brz=(1800, 3500)) deband = dbs.debanders.dumb3kdb(decs, threshold=32, grain=16) deband_masked = core.std.MaskedMerge(deband, decs, detail_mask) grain = vdf.noise.Graigasm( # Mostly stolen from Varde tbh thrs=[x << 8 for x in (32, 80, 128, 176)], strengths=[(0.25, 0.0), (0.2, 0.0), (0.15, 0.0), (0.0, 0.0)], sizes=(1.2, 1.15, 1.05, 1), sharps=(65, 50, 40, 40), grainers=[ vdf.noise.AddGrain(seed=69420, constant=True), vdf.noise.AddGrain(seed=69420, constant=False), vdf.noise.AddGrain(seed=69420, constant=False) ]).graining(deband_masked) return grain
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 _line_mask(clip: vs.VideoNode, thr: int) -> vs.VideoNode: mask = core.std.Prewitt(clip) mask = core.std.Expr(mask, 'x 2 *').std.Median() mask = core.std.Expr(mask, f'x {thr} < x x 3 * ?') return mask.std.Inflate().std.Deflate() def _ssharp(clip: vs.VideoNode, strength: float, width: int, height: int, factor: float = 2, b: float = -1, c: float = 6) -> vs.VideoNode: source = clip sharp = core.resize.Bicubic(clip, clip.width*factor, clip.height*factor, \ filter_param_a=b, filter_param_b=c).resize.Lanczos(width, height) source = core.resize.Spline64(source, sharp.width, sharp.height) sharp = core.rgvs.Repair(sharp, source, 13) sharp = mvf.LimitFilter(source, sharp, thrc=0.5, elast=6, brighten_thr=0.5, planes=0) final = core.std.Expr([sharp, source], f'x {strength} * y 1 {strength} - * +') return final 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)) def _perform_masks_credit(path: Path) -> List[MaskCredit]: return [ MaskCredit(lvf.src(str(mask)), int(str(mask.stem).split('_')[2]), int(str(mask.stem).split('_')[3])) for mask in path.glob('*') ] # pylint: disable=unused-argument def _diff(n: int, f: vs.VideoFrame, new: vs.VideoNode, adapt: vs.VideoNode) -> vs.VideoNode: psa = f.props['PlaneStatsAverage'] if psa > 0.5: clip = new elif psa < 0.4: clip = adapt else: weight = (psa - 0.4) * 10 clip = core.std.Merge(adapt, new, weight) return clip edstart, edend = 31782, 33939 src = JPBD.src_cut src = depth(src, 16) denoise = mdf.hybriddenoise_mod(src, 0.55, 2.25) diff = core.std.MakeDiff(src, denoise, [0, 1, 2]) luma = get_y(denoise) upscale = _nnedi3(luma, 1.5, dict(nsize=0, nns=3, qual=1, pscrn=1)) sraa = _sraa(upscale, dict(nsize=0, nns=3, qual=1, pscrn=1), dict(alpha=0.2, beta=0.5, gamma=80, nrad=3, mdis=18)) sraa = core.rgvs.Repair(sraa, upscale, 3) rescale = _ssharp(sraa, 0.55, src.width, src.height, 2) artefacts_mask = core.std.BlankClip(rescale, color=(256 << 8) - 1) artefacts_mask = vdf.region_mask(artefacts_mask, 2, 2, 2, 2).std.Inflate() rescale = core.std.MaskedMerge(luma, rescale, artefacts_mask) lineart_mask = _line_mask(luma, 8000) antialias = core.std.MaskedMerge(luma, rescale, lineart_mask) antialias_merged = vdf.merge_chroma(antialias, denoise) antialias_merged = lvf.rfs(antialias_merged, denoise, [(1894, 2013)]) credit = antialias_merged masks_credit_ = _perform_masks_credit(Path('masks_' + JPBD.name[-2:] + '/')) for mask in masks_credit_: credit = lvf.rfs( credit, core.std.MaskedMerge(credit, denoise, to_gray(mask.mask, src).std.Deflate()), [(mask.start_frame, mask.end_frame)]) deband_mask = lvf.denoise.detail_mask(credit, brz_a=3000, brz_b=1500) deband_a = dbs.f3kpf(credit, 18, 36, 36) deband_b = dbs.f3kpf(credit, 18, 56, 56) deband = lvf.rfs(deband_a, deband_b, [(9380, 9444)]) deband = core.std.MaskedMerge(deband, credit, deband_mask) grain_original = core.std.MergeDiff(deband, diff, [0, 1, 2]) grain_new = core.neo_f3kdb.Deband(deband, preset='depth', grainy=32, grainc=32) avg = core.std.PlaneStats(deband) adapt_mask = core.adg.Mask(get_y(avg), 28) grain_adapt = core.std.MaskedMerge(grain_new, grain_original, adapt_mask) grain = core.std.FrameEval( deband, partial(_diff, new=grain_new, adapt=grain_adapt), avg) grain = lvf.rfs(grain, grain_original, [(8405, 8548)]) stabilize = hvf.GSMC(src, radius=2, planes=0) ending = vdf.merge_chroma(stabilize, denoise) final = lvf.rfs(grain, ending, [(edstart, edend)]) return depth(final, 10)