def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """Main VapourSynth filterchain""" import EoEfunc as eoe import havsfunc as haf import lvsfunc as lvf import vardefunc as vdf from vsutil import depth src = JP_BD.clip_cut yt = lvf.src(r"src/『魔法使いの夜』ティザーPV-NHIgc-seeSo.mkv", ref=src) \ .std.AssumeFPS(fpsnum=24000, fpsden=1001) src = core.std.SetFrameProp(src, '_FieldBased', intval=0) se = core.tivtc.TDecimate(src) # Fix range compression and missing frame in TV release csp = core.resize.Bicubic(se, range_in=0, range=1, dither_type="error_diffusion") csp = csp.std.SetFrameProp(prop="_ColorRange", intval=1) merge = csp[:400] + yt[400] + csp[400:] # "Delogoing" and "Edgefixing" sqmask = lvf.mask.BoundingBox( (1753, 27), (118, 50)).get_mask(merge).std.Inflate().std.Inflate().std.Maximum() sqmask = sqmask.std.Maximum().std.Maximum().std.Median().std.Convolution( [1] * 9).std.Convolution([1] * 9) mask_merge = core.std.MaskedMerge(merge, yt[:merge.num_frames], sqmask) sqmask_ef = lvf.mask.BoundingBox( (3, 3), (src.width - 3, src.height - 3)).get_mask(mask_merge) ef = core.std.MaskedMerge(yt, mask_merge, sqmask_ef) ef = depth(ef, 16) debl = lvf.deblock.vsdpir(ef, strength=35, cuda=use_cuda) csharp = eoe.misc.ContraSharpening(debl, ef, radius=2, rep=13) darken = haf.FastLineDarkenMOD(csharp, strength=24) deband = core.average.Mean([ flt.masked_f3kdb(darken, rad=16, thr=[28, 20], grain=[16, 6]), flt.masked_placebo(darken, rad=14, thr=4.5, itr=2, grain=2) ]) grain = vdf.noise.Graigasm(thrs=[x << 8 for x in (32, 80, 128, 176)], strengths=[(0.15, 0.0), (0.10, 0.0), (0.05, 0.0), (0.0, 0.0)], sizes=(1.15, 1.10, 1.05, 1), sharps=(100, 90, 80, 50), grainers=[ vdf.noise.AddGrain(seed=69420, constant=True), vdf.noise.AddGrain(seed=69420, constant=False), vdf.noise.AddGrain(seed=69420, constant=False) ]).graining(deband) return grain
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """Main VapourSynth filterchain""" import EoEfunc as eoe import lvsfunc as lvf import vardefunc as vdf from ccd import ccd from finedehalo import fine_dehalo from vsutil import depth, get_y src, ep = JP_BD.clip_cut, JP_EP.clip_cut ep_ext = ep[0] * 16 + ep # F**K THIS STUDIO HOLY SHIT src = lvf.rfs(src, ep_ext, [(811, 859)]) src = depth(src, 16) # This noise can burn in hell. denoise_pre = get_y(src.dfttest.DFTTest(sigma=1.0)) denoise_ret = core.retinex.MSRCP(denoise_pre, sigma=[50, 200, 350], upper_thr=0.005) denoise_mask = flt.detail_mask(denoise_ret, sigma=2.0, lines_brz=3000).rgvs.RemoveGrain(4) denoise_pre = core.dfttest.DFTTest(src, sigma=4.0) denoise_smd = eoe.dn.CMDegrain(src, tr=5, thSAD=275, freq_merge=True, prefilter=denoise_pre) denoise_masked = core.std.MaskedMerge(denoise_smd, src, denoise_mask) denoise_uv = ccd(denoise_masked, threshold=6) decs = vdf.noise.decsiz(denoise_uv, sigmaS=8, min_in=200 << 8, max_in=235 << 8) # F**K THIS SHOW'S LINEART HOLY SHIT baa = lvf.aa.based_aa(decs.std.Transpose(), str(shader_file), gamma=120) baa = lvf.aa.based_aa(baa.std.Transpose(), str(shader_file), gamma=120) sraa = lvf.sraa(decs, rfactor=1.4) clmp_aa = lvf.aa.clamp_aa(decs, baa, sraa, strength=1.65) # AAing introduces some haloing (zzzzzz) restr_edges = fine_dehalo(clmp_aa, decs) restr_dark = core.std.Expr([clmp_aa, restr_edges], "x y min") deband = core.average.Mean([ flt.masked_f3kdb(restr_dark, rad=17, thr=[28, 20], grain=[12, 8]), flt.masked_f3kdb(restr_dark, rad=21, thr=[36, 32], grain=[24, 12]), flt.masked_placebo(restr_dark, rad=6.5, thr=2.5, itr=2, grain=4) ]) grain = vdf.noise.Graigasm( thrs=[x << 8 for x in (32, 80, 128, 176)], strengths=[(0.25, 0.0), (0.20, 0.0), (0.15, 0.0), (0.0, 0.0)], sizes=(1.20, 1.15, 1.10, 1), sharps=(80, 70, 60, 50), grainers=[ vdf.noise.AddGrain(seed=69420, constant=True), vdf.noise.AddGrain(seed=69420, constant=False), vdf.noise.AddGrain(seed=69420, constant=False) ]).graining(deband) return grain
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """Main VapourSynth filterchain""" import EoEfunc as eoe import lvsfunc as lvf import vardefunc as vdf from ccd import ccd from finedehalo import fine_dehalo from vsutil import depth, get_y, insert_clip src = JP_BD.clip_cut src_c = src src_ncop, src_nced = JP_NCOP.clip_cut, JP_NCED.clip_cut b = core.std.BlankClip(src, length=1) # OP/ED stack comps to check if they line up if opstart is not False: op_scomp = lvf.scomp(src[opstart:opstart+src_ncop.num_frames-1]+b, src_ncop[:-op_offset]+b) \ .text.Text('src', 7).text.Text('op', 9) if edstart is not False: ed_scomp = lvf.scomp(src[edstart:edstart+src_nced.num_frames-1]+b, src_nced[:-ed_offset]+b) \ .text.Text('src', 7).text.Text('ed', 9) # Splicing in NCs and diff'ing back the credits if opstart is not False: src = insert_clip(src, src_ncop[:-op_offset], opstart) src = lvf.rfs(src, src_c, [(opstart + 811, opstart + 859)]) if edstart is not False: src = insert_clip(src, src_nced[:-ed_offset], edstart) den_src, den_ncs = map(partial(core.dfttest.DFTTest, sigma=10), [src_c, src]) den_src, den_ncs = depth(den_src, 32), depth(den_ncs, 32) diff = core.std.MakeDiff(den_src, den_ncs).dfttest.DFTTest(sigma=50.0) # For some reason there's noise from previous credits remaining? Removing that here diff_brz = vdf.misc.merge_chroma(diff.std.Binarize(0.03), diff) diff = core.std.Expr([diff, diff_brz], "x y min") src = depth(src, 16) # This noise can burn in hell. denoise_pre = get_y(src.dfttest.DFTTest(sigma=1.0)) denoise_ret = core.retinex.MSRCP(denoise_pre, sigma=[50, 200, 350], upper_thr=0.005) denoise_mask = flt.detail_mask(denoise_ret, sigma=2.0, lines_brz=3000).rgvs.RemoveGrain(4) denoise_pre = core.dfttest.DFTTest(src, sigma=4.0) denoise_smd = eoe.dn.CMDegrain(src, tr=5, thSAD=275, freq_merge=True, prefilter=denoise_pre) denoise_masked = core.std.MaskedMerge(denoise_smd, src, denoise_mask) denoise_uv = ccd(denoise_masked, threshold=6) decs = vdf.noise.decsiz(denoise_uv, sigmaS=8, min_in=200 << 8, max_in=235 << 8) # F**K THIS SHOW'S LINEART HOLY SHIT baa = lvf.aa.based_aa(decs.std.Transpose(), str(shader_file), gamma=120) baa = lvf.aa.based_aa(baa.std.Transpose(), str(shader_file), gamma=120) sraa = lvf.sraa(decs, rfactor=1.4) clmp_aa = lvf.aa.clamp_aa(decs, baa, sraa, strength=1.65) # AAing introduces some haloing (zzzzzz) restr_edges = fine_dehalo(clmp_aa, decs) restr_dark = core.std.Expr([clmp_aa, restr_edges], "x y min") # Masking credits at the end if there's no NCED get_max = core.std.Expr([restr_dark, decs], "x y max") if opstart is False: restr_dark = lvf.rfs(restr_dark, get_max, [(None, 3500)]) if edstart is False: restr_dark = lvf.rfs(restr_dark, get_max, [(-5000, None)]) deband = core.average.Mean([ flt.masked_f3kdb(restr_dark, rad=17, thr=[28, 20], grain=[12, 8]), flt.masked_f3kdb(restr_dark, rad=21, thr=[36, 32], grain=[24, 12]), flt.masked_placebo(restr_dark, rad=6.5, thr=2.5, itr=2, grain=4) ]) grain = vdf.noise.Graigasm(thrs=[x << 8 for x in (32, 80, 128, 176)], strengths=[(0.25, 0.0), (0.20, 0.0), (0.15, 0.0), (0.0, 0.0)], sizes=(1.20, 1.15, 1.10, 1), sharps=(80, 70, 60, 50), grainers=[ vdf.noise.AddGrain(seed=69420, constant=True), vdf.noise.AddGrain(seed=69420, constant=False), vdf.noise.AddGrain(seed=69420, constant=False) ]).graining(deband) merge_creds = core.std.MergeDiff(depth(grain, 32), diff) return merge_creds
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """Main VapourSynth filterchain""" import havsfunc as haf import lvsfunc as lvf import vardefunc as vdf from ccd import ccd from muvsfunc import SSIM_downsample from vsutil import depth, get_y src = JP_BD.clip_cut src = depth(src, 32) src_y = get_y(src) 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) # Rescaling descale = flt.auto_descale(src_y) desc_i = flt.descale_fields(src_y, kernel=lvf.kernels.BicubicSharp) descale = lvf.rfs(descale, desc_i, [(1555, 1685)]) supersample = vdf.scale.nnedi3cl_double(descale, use_znedi=True, pscrn=1) downscaled = SSIM_downsample(supersample, src.width, src.height, smooth=((3 ** 2 - 1) / 12) ** 0.5, sigmoid=True, filter_param_a=0, filter_param_b=0) scaled_mask = core.std.MaskedMerge(src_y, downscaled, l_mask) scaled = depth(vdf.misc.merge_chroma(scaled_mask, src), 16) # Denoising l_mask_16 = depth(l_mask, 16).std.Minimum() dft = core.dfttest.DFTTest(scaled, sigma=1.25, tbsize=3, tosize=1) dft_masked = core.std.MaskedMerge(dft, scaled, l_mask_16) ccd_uv = ccd(dft, threshold=4, matrix='709') ccd_uv = core.std.MaskedMerge(ccd_uv, dft_masked, l_mask_16, planes=[1, 2]) decs = vdf.noise.decsiz(ccd_uv, sigmaS=4, min_in=212 << 8, max_in=240 << 8) # AA and slight lineart enhancement baa = lvf.aa.based_aa(decs, shader_file) sraa = lvf.sraa(decs, rfactor=1.5, downscaler=lvf.kernels.Bicubic(b=-1/2, c=1/4).scale) clmp = lvf.aa.clamp_aa(decs, baa, sraa, strength=1.5) sraa_strong = flt.transpose_sraa(decs, rfactor=1.2, downscaler=lvf.kernels.Bicubic(b=-1/2, c=1/4).scale) clmp = lvf.rfs(clmp, sraa_strong, []) darken = haf.FastLineDarkenMOD(clmp, strength=36) # Debanding and graining deband = core.average.Mean([ flt.masked_f3kdb(darken, rad=18, thr=[28, 24]), flt.masked_placebo(darken, rad=15, thr=4) ]) grain = vdf.noise.Graigasm( thrs=[x << 8 for x in (32, 80, 128, 176)], strengths=[(0.15, 0.0), (0.10, 0.0), (0.10, 0.0), (0.0, 0.0)], sizes=(1.15, 1.10, 1.05, 1), sharps=(60, 50, 50, 50), grainers=[ vdf.noise.AddGrain(seed=69420, constant=True), vdf.noise.AddGrain(seed=69420, constant=True), vdf.noise.AddGrain(seed=69420, constant=True) ]).graining(deband) return grain
def pre_filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """ Regular filtering to get the output images to stitch. This is preferable over handling it unfiltered, since it'll be faster than encoding it and reduces the amount of jitter caused by the upscale after. """ import lvsfunc as lvf import rekt import vardefunc as vdf from awsmfunc import bbmod from muvsfunc import SSIM_downsample from vsutil import depth, get_y, join, plane src = JP_BD.clip_cut # Fixing animation f**k-ups if freeze_ranges: src = core.std.FreezeFrames( src, [s[0] for s in freeze_ranges], [e[1] for e in freeze_ranges], [f[2] for f in freeze_ranges] ) # Edgefixing ef = rekt.rektlvls( src, prot_val=[16, 235], min=16, max=235, rownum=[0, src.height-1], rowval=[16, 16], colnum=[0, src.width-1], colval=[16, 16], ) bb_y = bbmod(ef, left=1, top=1, right=1, bottom=1, thresh=32, y=True, u=False, v=False) bb_uv = bbmod(bb_y, left=2, top=2, right=2, bottom=2, y=False, u=True, v=True) cshift = flt.shift_chroma(bb_uv, left=0.6) cshift = lvf.rfs(bb_uv, cshift, cshift_left_ranges) bb32 = depth(cshift, 32) bb32_y = get_y(bb32) # Descaling + DPIR while it's at a lower res (so I can actually run it because >memory issues xd) descale = lvf.kernels.Catrom().descale(bb32_y, 1280, 720) downscale = lvf.kernels.Catrom(format=vs.YUV444PS).scale(bb32, 1280, 720) descale_444 = join([descale, plane(downscale, 1), plane(downscale, 2)]) denoise_y = lvf.deblock.vsdpir(descale_444, strength=2.75, mode='deblock', matrix=1, i444=True, cuda=True) supersample = vdf.scale.fsrcnnx_upscale(get_y(denoise_y), shader_file=shader_file, downscaler=None) downscaled = SSIM_downsample(supersample, src.width, src.height, smooth=((3 ** 2 - 1) / 12) ** 0.5, sigmoid=True, filter_param_a=0, filter_param_b=0) # Create credit mask upscale = lvf.kernels.Catrom().scale(descale, src.width, src.height) credit_mask = lvf.scale.descale_detail_mask(bb32_y, upscale, threshold=0.055) \ .std.Deflate().std.Deflate().std.Minimum() # Merge early for additional accuracy with DPIR merged = core.std.MaskedMerge(downscaled, bb32_y, credit_mask) down_y = lvf.kernels.Catrom().scale(merged, src.width/2, src.height/2) down_i444 = join([down_y, plane(bb32, 1), plane(bb32, 2)]) deblock_down = lvf.deblock.vsdpir(down_i444, strength=3, mode='denoise', matrix=1, i444=True, cuda=True) scaled = depth(join([merged, plane(deblock_down, 1), plane(deblock_down, 2)]), 16) # Final bit of "denoising" dft = core.dfttest.DFTTest(scaled, sigma=2.0, tbsize=5, tosize=3, planes=[0]) decs = vdf.noise.decsiz(dft, sigmaS=4, min_in=208 << 8, max_in=232 << 8) # AA baa = lvf.aa.based_aa(decs, str(shader_file)) sraa = lvf.sraa(decs, rfactor=1.65) clmp = lvf.aa.clamp_aa(decs, baa, sraa, strength=1.3) dehalo = lvf.dehalo.masked_dha(clmp, rx=1.4, ry=1.4, brightstr=0.4) cwarp = core.warp.AWarpSharp2(dehalo, thresh=72, blur=3, type=1, depth=4, planes=[1, 2]) # Merge credits (if applicable) merged = core.std.MaskedMerge(cwarp, depth(bb32, 16), depth(credit_mask, 16)) deband = core.average.Mean([ flt.masked_f3kdb(merged, rad=16, thr=[20, 24], grain=[24, 12]), flt.masked_f3kdb(merged, rad=20, thr=[28, 24], grain=[24, 12]), flt.masked_placebo(merged, rad=6, thr=2.5, itr=2, grain=4) ]) no_flt = lvf.rfs(deband, depth(bb32, 16), no_filter) return no_flt
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """Main filterchain""" import lvsfunc as lvf import rekt import vardefunc as vdf from awsmfunc import bbmod from muvsfunc import SSIM_downsample from vsutil import depth, get_y src = JP_BD.clip_cut rkt = rekt.rektlvls(src, [0, -1], [17, 17], [0, -1], [17, 21]) bb_y = bbmod(rkt, top=2, left=2, right=1, u=False, v=False) bb_uv = bbmod(bb_y, left=2, right=2, y=False) bb = depth(bb_uv, 32) descale = lvf.kernels.Mitchell().descale(get_y(bb), 1280, 720) up_chr = vdf.scale.to_444(bb, 1920, 1080, True).resize.Bicubic(1280, 720) descale_merge = vdf.misc.merge_chroma(descale, up_chr) denoise_down = lvf.deblock.vsdpir(descale_merge, strength=5, mode='deblock', matrix=1, i444=True, cuda=True) supersample = vdf.scale.nnedi3_upscale(get_y(denoise_down)) downscaled = SSIM_downsample(supersample, bb.width, bb.height, smooth=((3 ** 2 - 1) / 12) ** 0.5, sigmoid=True, filter_param_a=0, filter_param_b=0) den_chr_up = core.resize.Bicubic(denoise_down, bb.width, bb.height, bb.format.id) den_chr_up_shift = core.resize.Bicubic(denoise_down, bb.width, bb.height, bb.format.id, src_left=-0.5) den_chr_up = lvf.rfs(den_chr_up, den_chr_up_shift, shift_chr) scaled = vdf.misc.merge_chroma(downscaled, den_chr_up) scaled = depth(scaled, 16) decs = vdf.noise.decsiz(scaled, sigmaS=4, min_in=208 << 8, max_in=232 << 8) deband = core.average.Mean([ flt.masked_f3kdb(decs, rad=17, thr=[20, 24], grain=[24, 12]), flt.masked_f3kdb(decs, rad=21, thr=[32, 24], grain=[24, 12]), flt.masked_placebo(decs, rad=6, thr=2.8, itr=2, grain=4) ]) grain = vdf.noise.Graigasm( thrs=[x << 8 for x in (32, 80, 128, 176)], strengths=[(0.25, 0.0), (0.20, 0.0), (0.15, 0.0), (0.0, 0.0)], sizes=(1.25, 1.20, 1.15, 1), sharps=(80, 70, 60, 50), grainers=[ vdf.noise.AddGrain(seed=69420, constant=False), vdf.noise.AddGrain(seed=69420, constant=False), vdf.noise.AddGrain(seed=69420, constant=True) ]).graining(deband) grain_str = vdf.noise.Graigasm( thrs=[x << 8 for x in (32, 80, 128, 176)], strengths=[(0.35, 0.0), (0.30, 0.0), (0.25, 0.0), (0.0, 0.0)], sizes=(1.25, 1.20, 1.15, 1), sharps=(80, 70, 60, 50), grainers=[ vdf.noise.AddGrain(seed=69420, constant=False), vdf.noise.AddGrain(seed=69420, constant=False), vdf.noise.AddGrain(seed=69420, constant=True) ]).graining(deband) grain = lvf.rfs(grain, grain_str, str_grain) 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 VapourSynth filterchain""" import EoEfunc as eoe import lvsfunc as lvf import vardefunc as vdf from ccd import ccd from finedehalo import fine_dehalo from vsutil import depth, get_y src = JP_BD.clip_cut src = depth(src, 16) # This noise can burn in hell. denoise_pre = get_y(src.dfttest.DFTTest(sigma=1.0)) denoise_ret = core.retinex.MSRCP(denoise_pre, sigma=[50, 200, 350], upper_thr=0.005) denoise_mask = flt.detail_mask(denoise_ret, sigma=2.0, lines_brz=3000).rgvs.RemoveGrain(4) denoise_pre = core.dfttest.DFTTest(src, sigma=4.0) denoise_smd = eoe.dn.CMDegrain(src, tr=5, thSAD=275, freq_merge=True, prefilter=denoise_pre) denoise_masked = core.std.MaskedMerge(denoise_smd, src, denoise_mask) denoise_uv = ccd(denoise_masked, threshold=6) decs = vdf.noise.decsiz(denoise_uv, sigmaS=8, min_in=200 << 8, max_in=235 << 8) # F**K THIS SHOW'S LINEART HOLY SHIT baa = lvf.aa.based_aa(decs.std.Transpose(), str(shader_file), gamma=120) baa = lvf.aa.based_aa(baa.std.Transpose(), str(shader_file), gamma=120) sraa = lvf.sraa(decs, rfactor=1.4) clmp_aa = lvf.aa.clamp_aa(decs, baa, sraa, strength=1.65) # AAing introduces some haloing (zzzzzz) restr_edges = fine_dehalo(clmp_aa, decs) restr_dark = core.std.Expr([clmp_aa, restr_edges], "x y min") deband = core.average.Mean([ flt.masked_f3kdb(restr_dark, rad=17, thr=[28, 20], grain=[12, 8]), flt.masked_f3kdb(restr_dark, rad=21, thr=[36, 32], grain=[24, 12]), flt.masked_placebo(restr_dark, rad=6.5, thr=2.5, itr=2, grain=4) ]) grain = vdf.noise.Graigasm( thrs=[x << 8 for x in (32, 80, 128, 176)], strengths=[(0.25, 0.0), (0.20, 0.0), (0.15, 0.0), (0.0, 0.0)], sizes=(1.20, 1.15, 1.10, 1), sharps=(80, 70, 60, 50), grainers=[ vdf.noise.AddGrain(seed=69420, constant=True), vdf.noise.AddGrain(seed=69420, constant=False), vdf.noise.AddGrain(seed=69420, constant=False) ]).graining(deband) # Masking credits at the end get_max = core.std.Expr([grain, decs], "x y max") sq_mask = [ lvf.mask.BoundingBox((782, 603), (507, 389)), lvf.mask.BoundingBox((0, 957), (1920, 123)), lvf.mask.BoundingBox((1139, 835), (478, 142)) ] sqmask = core.std.BlankClip(get_y(src)) for sq in sq_mask: mask = sq.get_mask(src).std.BoxBlur(hpasses=20, vpasses=20) sqmask = core.std.Expr([mask, sqmask], "x y +") max_masked = core.std.MaskedMerge(get_max, grain, sqmask) max_ed = lvf.rfs(grain, max_masked, (5467, None)) return max_ed