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 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 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 filterchain""" import lvsfunc as lvf import muvsfunc as muf import vardefunc as vdf from adptvgrnMod import adptvgrnMod from vsutil import depth, get_w, get_y from xvs import WarpFixChromaBlend src_path = [ r"websrc/CHRONOS RULER E05 [1080p][AAC][JapDub][GerEngSub][Web-DL].mkv", r"websrc/CHRONOS RULER E06 [1080p][AAC][JapDub][GerEngSub][Web-DL].mkv", r"websrc/CHRONOS RULER E07 [1080p][AAC][JapDub][GerEngSub][Web-DL].mkv", r"websrc/CHRONOS RULER E08 [1080p][AAC][JapDub][GerEngSub][Web-DL].mkv", r"websrc/CHRONOS RULER E09 [1080p][AAC][JapDub][GerEngSub][Web-DL].mkv", r"websrc/CHRONOS RULER E10 [1080p][AAC][JapDub][GerEngSub][Web-DL].mkv", r"websrc/CHRONOS RULER E11 [1080p][AAC][JapDub][GerEngSub][Web-DL].mkv", r"websrc/CHRONOS RULER E12 [1080p][AAC][JapDub][GerEngSub][Web-DL].mkv", r"websrc/CHRONOS RULER E13 [1080p][AAC][JapDub][GerEngSub][Web-DL].mkv" ] base = JP_CR.clip_cut src = [lvf.src(c, force_lsmas=True, cachedir='') for c in src_path] src_c = lvf.src(src_path[-3], force_lsmas=True, cachedir='') # Trimming clips to get just the OP src[0] = src[0][2182] * 11 + src[0][2182:2182 + base.num_frames - 11] src[1] = src[1][936:936 + base.num_frames] src[2] = src[2][1104:1104 + base.num_frames] src[3] = src[3][6378:6378 + base.num_frames] src[4] = src[4][5179:5179 + base.num_frames] src[5] = src[5][1200:1200 + base.num_frames] src[6] = src[6][1822:1822 + base.num_frames] src[7] = src[7][1558:1558 + base.num_frames] src[8] = src[8][1224:1224 + base.num_frames] mean = core.average.Mean(src) # type:ignore[attr-defined] mean = mean[:-1] + src_c[1822:3980][-2:] mean = depth(mean, 32) mean_y = get_y(mean) descale = lvf.kernels.Lanczos(taps=5).descale(mean_y, get_w(945), 945) rescale = vdf.scale.nnedi3cl_double(descale, pscrn=1) rescale = muf.SSIM_downsample(rescale, mean_y.width, mean_y.height) scaled = vdf.misc.merge_chroma(rescale, mean) scaled = depth(scaled, 16) decs = vdf.noise.decsiz(scaled, sigmaS=8, min_in=208 << 8, max_in=232 << 8) deband_reg = flt.masked_f3kdb(decs, thr=24, grain=[24, 12]) detail_mask = flt.detail_mask(decs, brz=(1200, 3000)) den_ref = core.knlm.KNLMeansCL(decs, d=1, a=3, s=4, h=0.5, channels='Y') deband_str = flt.placebo_debander(den_ref, placebo_args={'threshold': 4}) deband_str = core.std.MaskedMerge(deband_str, deband_reg, detail_mask) deband = lvf.rfs(deband_reg, deband_str, [(1162, 1193), (1210, 1216)]) grain: vs.VideoNode = adptvgrnMod(deband, seed=42069, strength=0.3, luma_scaling=8, size=1.35, sharp=100, grain_chroma=False) return grain
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 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 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
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