def recreate_OP1E(): src_nc = OP1D.clip_cut src_ep = EP13.clip_cut[6954:6954 + src_nc.num_frames] op = lvf.rfs(src_nc, src_ep, [(2048, 2156)]) mask = vdf.dcm(op, op[0:src_nc.num_frames - 1], src_nc, 0, thr=248, prefilter=True) merge = core.std.MaskedMerge(op, src_nc, mask[2075]) op = lvf.rfs(op, merge, [(2048, 2092)]) pause = src_ep.std.FreezeFrames(2111, src_ep.num_frames - 1, 2111) fade = kgf.crossfade(pause[0:2159], core.std.BlankClip(pause), 32)[0:src_nc.num_frames] merge = core.std.MaskedMerge(op, fade, mask[2155].std.Minimum().std.Minimum()) op = lvf.rfs(op, merge, [(2112, 2156)]) pause = op.std.FreezeFrames(2121, op.num_frames - 1, 2121) fade = kgf.crossfade(pause[0:2159], core.std.BlankClip(pause), 32)[0:src_nc.num_frames] merge = core.std.MaskedMerge(op, fade, mask[2155].std.Minimum().std.Minimum()) op = lvf.rfs(op, merge, [(2112, 2156)]) mask_img = core.imwri.Read(MASK).resize.Point(format=fade.format.id, matrix_s="709") mask = core.std.Binarize(mask_img, 128).std.Maximum().std.Deflate() return core.std.MaskedMerge(fade, op, mask, [0, 1, 2])
def do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut src = depth(src, 16) out = src ref = hvf.SMDegrain(out, thSAD=300) denoise = mvf.BM3D(out, [1.5, 1.25], radius1=1, ref=ref) out = denoise crop = core.std.Crop(out, left=12) crop = awf.bbmod(crop, left=2, thresh=20 << 8) resize = core.resize.Bicubic(crop, 1920) out = lvf.rfs(out, resize, [(78, 89)]) y = get_y(out) lineart = gf.EdgeDetect(y, 'scharr').morpho.Dilate(2, 2).std.Inflate() fkrescale = fake_rescale( y, 882, 0, 1, deringer=lambda x: gf.MaskedDHA(x, rx=1.85, ry=1.85, darkstr=0.25, brightstr=1.0, maskpull=100, maskpush=200), antialiser=lambda c: lvf.sraa(c, 2, 13, downscaler=core.resize.Bicubic) ) merged = core.std.MaskedMerge(y, fkrescale, lineart) out = vdf.merge_chroma(merged, out) dering = hvf.EdgeCleaner(out, 17, smode=1, hot=True) out = dering out = lvf.rfs( out, denoise, [(0, 11), (38, 77), (115, 133), (316, 395), (441, 460), (606, 779), (825, 844), (990, 1127)] ) detail_mask = lvf.mask.detail_mask(out, brz_a=2250, brz_b=1000) deband = vdf.dumb3kdb(out, 15, threshold=17, grain=(24, 0)) deband = core.std.MaskedMerge(deband, out, detail_mask) out = deband grain = adptvgrnMod(out, 0.3, static=True, grain_chroma=False, hi=[128, 240], seed=333) out = grain decz = vdf.decsiz(out, min_in=128 << 8, max_in=200 << 8) out = decz return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2], [0, 1, 2])
def pre_corrections() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """ There were a couple animation 'fixes' in the BDs that I'm reverting here. Alongside that, they also introduced a couple of errors occasionally which I also fix here. Comments with examples of what I'm changing/fixing included if big enough. """ import lvsfunc as lvf src_BD = JP_BD.clip_cut src_WEB = JP_WEB.clip_cut # Make sure the Waka rip matches up to the BD as much as it has to src_WEB = src_WEB[:2421] + src_WEB[2420] + src_WEB[2421:] # Fix mouth misplacement introduced on BDs — https://slow.pics/c/NE6vqUdq sqmask = lvf.mask.BoundingBox( (1084, 663), (225, 200)).get_mask(src_BD).bilateral.Gaussian(sigma=10) fixed = lvf.rfs(src_BD, src_BD.std.MaskedMerge(src_WEB, sqmask), [(1226, 1227)]) # Fix bit of rope they deleted on the BDs — https://slow.pics/c/JdVX7Chb sqmask = lvf.mask.BoundingBox((1841, 458), (67, 17)).get_mask(fixed) fixed = lvf.rfs(fixed, fixed.std.MaskedMerge(src_WEB, sqmask), [(3330, 3365)]) return fixed
def pre_corrections() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """ There were a couple animation 'fixes' in the BDs that I'm reverting here. Alongside that, they also introduced a couple of errors occasionally which I also fix here. Comments with examples of what I'm changing/fixing included if big enough. """ import lvsfunc as lvf src_BD = JP_BD.clip_cut src_WEB = JP_WEB.clip_cut # Make sure the Waka rip matches up to the BD as much as it has to src_WEB = src_WEB[0] + src_WEB # Undoing a Saya face redraw — https://slow.pics/c/zFGJBtNc sqmask = lvf.mask.BoundingBox( (1397, 370), (86, 74)).get_mask(src_BD).bilateral.Gaussian(sigma=10) fixed = lvf.rfs(src_BD, src_BD.std.MaskedMerge(src_WEB, sqmask), [(21248, 21310)]) # Another face redraw undo — https://slow.pics/c/QoxjoSeB sqmask = lvf.mask.BoundingBox( (1310, 356), (94, 80)).get_mask(src_BD).bilateral.Gaussian(sigma=10) fixed = lvf.rfs(fixed, fixed.std.MaskedMerge(src_WEB, sqmask), [(21447, 21493)]) # Very minor line f**k-up sqmask = lvf.mask.BoundingBox((1320, 478), (8, 14)).get_mask(src_BD) fixed = lvf.rfs(fixed, fixed.std.MaskedMerge(src_WEB, sqmask), [(21452, 21454)]) return fixed
def do_filter(): """Vapoursynth filtering""" def _nneedi3_clamp(clip: vs.VideoNode, strength: int = 1): bits = clip.format.bits_per_sample - 8 thr = strength * (1 >> bits) luma = get_y(clip) strong = TAAmbk(luma, aatype='Eedi3', alpha=0.4, beta=0.4) weak = TAAmbk(luma, aatype='Nnedi3') expr = 'x z - y z - * 0 < y x y {0} + min y {0} - max ?'.format(thr) clip_aa = core.std.Expr([strong, weak, luma], expr) return core.std.ShufflePlanes([clip_aa, clip], [0, 1, 2], vs.YUV) src = SRC_CUT interpolate = core.resize.Bicubic(src, src_left=3) f_1 = 1006 src = src[:EDSTART + f_1] + interpolate[EDSTART + f_1] + src[EDSTART + f_1:-1] src = depth(src, 16) blur = core.bilateral.Gaussian(src, [0.45, 0]) den = CoolDegrain(blur, tr=1, thsad=60, blksize=8, overlap=4, plane=4) dering = core.std.MaskedMerge(den, hvf.YAHR(den, 2, 32), muvf.AnimeMask(den, 0.2), 0) aa_a = core.std.MaskedMerge(dering, _nneedi3_clamp(dering), TAAmbk(dering, mtype=2, showmask=1)) aa_b = TAAmbk(src, aatype='Nnedi3', mtype=1, nns=4, qual=2, nsize=6) aa = lvf.rfs(aa_a, aa_b, [(OPSTART, OPEND), (EDSTART, EDEND)]) preden = core.knlm.KNLMeansCL(aa, a=2, h=2, d=0, device_type='gpu', channels='Y') diff = core.std.MakeDiff(aa, preden, 0) db_m = lvf.denoise.detail_mask(aa.std.Median(), brz_a=3000, brz_b=1500) db_a = dbs.f3kpf(aa, 17) db_b = core.placebo.Deband(preden, radius=17, threshold=5.5, iterations=1, grain=4, planes=1 | 2 | 4) db_b = core.std.MergeDiff(db_b, diff, 0) db = lvf.rfs(db_a, db_b, [(9729, 9845), (13652, 14048)]) db = core.std.MaskedMerge(db, aa, db_m) grain = mdf.adptvgrnMod_mod(db, 0.2, size=1.25, sharp=60, luma_scaling=8) final = depth(grain, 10) return final, src
def do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut src = depth(src, 16) out = src opstart, opend = 480, 2637 edstart, edend = 29707, 31863 dehalo = gf.MaskedDHA(out, rx=1.35, ry=1.35, darkstr=0.25, brightstr=1.0, maskpull=46, maskpush=148) out = dehalo antialias = lvf.sraa(out, 1.5, 9, downscaler=core.resize.Bicubic) antialias_b = lvf.sraa(antialias, 1.05, 3, downscaler=core.resize.Bicubic) antialias_b = TAAmbk(antialias_b, aatype='Eedi3SangNom', cycle=4, thin=2, sharp=100, mtype=0, down8=False) antialias = lvf.rfs(antialias, antialias_b, [(19956, 20029)]) out = antialias sharp = hvf.LSFmod(out, strength=75, Smode=3, Lmode=1, edgemode=1, edgemaskHQ=True) out = sharp deband_mask = lvf.denoise.detail_mask(out, brz_a=2000, brz_b=1000) deband = dbs.f3kpf(out, 17, 24, 24) deband = core.std.MaskedMerge(deband, out, deband_mask) out = deband src_c, ncop, nced = [ clip.std.Median() for clip in [src, JPBD_NCOP.src_cut, JPBD_NCED.src_cut] ] opening_mask = vdf.dcm(out, src_c[opstart:opend + 1], ncop[:opend - opstart + 1], opstart, opend, 3, 3) ending_mask = vdf.dcm(out, src_c[edstart:edend + 1], nced[:edend - edstart + 1], edstart, edend, 3, 3) credit_mask = core.std.Expr([opening_mask, ending_mask], 'x y +').std.Convolution([1] * 9) credit = lvf.rfs(out, core.std.MaskedMerge(out, src, credit_mask), [(opstart, opend), (edstart, edend)]) out = credit return depth(out, 10)
def do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut src = depth(src, 16) h = 882 w = get_w(h) kernel = 'lanczos' taps = 5 denoise = CoolDegrain(src, tr=1, thsad=24, blksize=8, overlap=4, plane=4) out = denoise luma = get_y(out) descale = kgf.get_descale_filter(kernel, taps=taps)(depth(luma, 32), w, h) upscale = vdf.fsrcnnx_upscale( depth(descale, 16), src.width, src.height, '_assets/shaders/FSRCNNX_x2_56-16-4-1.glsl', partial(core.resize.Bicubic, filter_param_a=0, filter_param_b=0)) out = upscale unwarp = line_darkening(out, 0.275).warp.AWarpSharp2(depth=-2.5) sharp = hvf.LSFmod(unwarp, strength=90, Smode=3, Lmode=1, edgemode=1, edgemaskHQ=True) stabilize = stabilization(out, sharp, 2, 1, 8, 16) out = vdf.merge_chroma(stabilize, denoise) antialias = lvf.sraa(out, 1.4, rep=7, downscaler=core.resize.Bicubic) out = antialias deband_mask = lvf.denoise.detail_mask(out, brz_a=2000, brz_b=1000) deband = dbs.f3kpf(out, 17, 42, 36) deband = core.std.MaskedMerge(deband, out, deband_mask) deband = core.neo_f3kdb.Deband(deband, preset='depth', grainy=24, grainc=18, keep_tv_range=True) out = deband grain = kgf.adaptive_grain(out, 0.2, luma_scaling=14) out = grain rescale_mask = vdf.drm(src, h, kernel, taps, mthr=40, sw=4, sh=4) credit = out credit = lvf.rfs(credit, core.std.MaskedMerge(credit, src, rescale_mask, 0), [(0, 647), (29954, 34046)]) credit = lvf.rfs(credit, src, [(0, 1)]) out = credit return depth(out, 10)
def do_filter() -> vs.VideoNode: """Vapoursynth filtering""" src = JPBD.src_cut out = src luma = get_y(out) rows = [ core.std.CropAbs(luma, out.width, 1, top=out.height - 1), core.std.CropAbs(luma, out.width, 1, top=out.height - 2) ] diff = core.std.Expr(rows, 'x y - abs').std.PlaneStats() row_fix = vdf.merge_chroma( luma.fb.FillBorders(bottom=1, mode="fillmargins"), out.fb.FillBorders(bottom=2, mode="fillmargins")) fixrow = core.std.FrameEval(out, partial(_select_row, clip=out, row_fix=row_fix), prop_src=diff) out = fixrow fixedge_a = awf.bbmod(out, 1, 1, 1, 1, 20, blur=700, u=False, v=False) fixedge = out fixedge = lvf.rfs(fixedge, fixedge_a, [(EDSTART + 309, EDEND)]) out = fixedge out = depth(out, 16) dehalo = gf.MaskedDHA(out, rx=1.4, ry=1.4, darkstr=0.02, brightstr=1) dehalo = lvf.rfs(out, dehalo, [(EDEND + 1, src.num_frames - 1)]) out = dehalo resize = core.std.Crop(out, right=12, bottom=8).resize.Bicubic(1920, 1080) resize = lvf.rfs(out, resize, [(27005, 27076)]) out = resize # Denoising only the chroma pre = hvf.SMDegrain(out, tr=2, thSADC=300, plane=3) planes = split(out) planes[1], planes[2] = [ mvf.BM3D(planes[i], 1.25, radius2=2, pre=plane(pre, i)) for i in range(1, 3) ] out = join(planes) preden = core.dfttest.DFTTest(out, sbsize=16, sosize=12, tbsize=1) detail_mask = lvf.mask.detail_mask(preden, brz_a=2500, brz_b=1500) deband = vdf.dumb3kdb(preden, 16, threshold=[17, 17], grain=[24, 0]) deband = core.std.MergeDiff(deband, out.std.MakeDiff(preden)) deband = core.std.MaskedMerge(deband, out, detail_mask) out = deband decz = vdf.decsiz(out, min_in=128 << 8, max_in=192 << 8) out = decz return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2], [0, 1, 2])
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 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 do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut src = depth(src, 16) out = src + src[-1] denoise = mvf.BM3D(out, [2.5, 1.5], radius1=1) diff = core.std.MakeDiff(out, denoise) out = denoise luma = get_y(out) dehalo = gf.MaskedDHA(luma, rx=2.5, ry=2.5, darkstr=0.15, brightstr=1.2, maskpull=48, maskpush=140) out = dehalo dering = gf.HQDeringmod(out, sharp=3, drrep=24, thr=24, darkthr=0) out = dering antialias_mask = gf.EdgeDetect(out, 'FDOG') antialias = lvf.sraa(out, 1.5, 13, gamma=100, downscaler=core.resize.Spline64) out = core.std.MaskedMerge(out, antialias, antialias_mask) out = vdf.merge_chroma(out, denoise) warp = xvs.WarpFixChromaBlend(out, 64, depth=8) out = warp deband_mask = lvf.denoise.detail_mask(out, brz_a=2250, brz_b=1500).std.Median() deband = dbs.f3kpf(out, 17, 36, 36) deband_b = dbs.f3kpf(out, 17, 56, 48) deband = lvf.rfs(deband, deband_b, [(23708, 24371)]) deband = core.std.MaskedMerge(deband, out, deband_mask) out = deband grain_original = core.std.MergeDiff(out, diff) grain_new = core.grain.Add(out, 0.15, 0, constant=True) grain_mask = core.adg.Mask(out.std.PlaneStats(), 30).std.Expr(f'x x {96<<8} - 0.25 * +') grain = core.std.MaskedMerge(grain_new, grain_original, grain_mask) out = grain ending = lvf.rfs(out, src, [(31241, src.num_frames - 1)]) out = ending return depth(out, 10)
def do_filter(): """Vapoursynth filtering""" def _nneedi3_clamp(clip: vs.VideoNode, strength: int = 1): bits = clip.format.bits_per_sample - 8 thr = strength * (1 >> bits) luma = get_y(clip) strong = TAAmbk(luma, aatype='Eedi3', alpha=0.4, beta=0.4) weak = TAAmbk(luma, aatype='Nnedi3') expr = 'x z - y z - * 0 < y x y {0} + min y {0} - max ?'.format(thr) clip_aa = core.std.Expr([strong, weak, luma], expr) return core.std.ShufflePlanes([clip_aa, clip], [0, 1, 2], vs.YUV) src = SRC_CUT src += src[-1]*2 interpolate = core.resize.Bicubic(src, src_left=3) f_1 = 1006 src = src[:EDSTART+f_1] + interpolate[EDSTART+f_1] + src[EDSTART+f_1:-1] src = depth(src, 16) blur = core.bilateral.Gaussian(src, [0.45, 0]) den = CoolDegrain(blur, tr=1, thsad=60, blksize=8, overlap=4, plane=4) dering = core.std.MaskedMerge(den, hvf.YAHR(den, 2, 32), muvf.AnimeMask(den, 0.2), 0) aa_a = core.std.MaskedMerge(dering, _nneedi3_clamp(dering), TAAmbk(dering, mtype=2, showmask=1)) aa_b = TAAmbk(src, aatype='Nnedi3', mtype=1, nns=4, qual=2, nsize=6) aa_c = TAAmbk(dering, aatype='Eedi3SangNom', mtype=2, cycle=2) aa_d = TAAmbk(dering, aatype='Eedi3', cycle=2) aa = lvf.rfs(aa_a, aa_b, [(OPSTART, OPEND), (EDSTART, EDEND)]) aa = lvf.rfs(aa, aa_c, [(6448, 6546)]) aa = lvf.rfs(aa, aa_d, [(5467, 5550)]) db_m = lvf.denoise.detail_mask(aa.std.Median(), brz_a=3000, brz_b=1500) db = dbs.f3kpf(aa, 17) db = core.std.MaskedMerge(db, aa, db_m) grain = mdf.adptvgrnMod_mod(db, 0.2, size=1.25, sharp=60, luma_scaling=8) final = depth(grain, 10) return final, src
def do_filter(): """Vapoursynth filtering""" 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) sraa = _sraa(upscale, dict(nsize=3, nns=3, qual=1, pscrn=1)) return core.resize.Bicubic(sraa, clip.width*factor, clip.height*factor, src_top=.5, src_left=.5, filter_param_a=0, filter_param_b=0.25) # My GPU’s dying on it def _sraa(clip: vs.VideoNode, nnargs: dict)-> vs.VideoNode: clip = clip.nnedi3cl.NNEDI3CL(0, False, **nnargs).std.Transpose() clip = clip.nnedi3cl.NNEDI3CL(0, False, **nnargs).std.Transpose() return clip # Fun part / Cutting src_funi, src_wkn = [depth(c, 16) for c in CLIPS_SRC] src_funi, src_wkn = src_funi[744:], src_wkn[0] + src_wkn # Dehardsubbing # comp = lvf.comparison.stack_compare(src_funi, src_wkn, make_diff=True) src = core.std.MaskedMerge(src_wkn, src_funi, kgf.hardsubmask(src_wkn, src_funi)) hardsub_rem = core.std.MaskedMerge(src, src_funi, kgf.hardsubmask_fades(src, src_funi, 8, 2000)) src = lvf.rfs(src, hardsub_rem, [(3917, 4024)]) # Regular filterchain op, ed = (17238, 19468), (31889, 34045) h = 846 w = get_w(h) b, c = vdf.get_bicubic_params('robidoux') luma = get_y(src) thr = 8000 line_mask = gf.EdgeDetect(luma, 'FDOG').std.Median().std.Expr(f'x {thr} < x x 3 * ?') descale = core.descale.Debicubic(depth(luma, 32), w, h, b, c) rescaled = _nnedi3(depth(descale, 16), src.height/h, dict(nsize=0, nns=4, qual=2, pscrn=2)) rescaled = core.std.MaskedMerge(luma, rescaled, line_mask) merged = vdf.merge_chroma(rescaled, src) out = merged cred_m = vdf.drm(src, h, b=b, c=c, mthr=80, mode='ellipse') credit = lvf.rfs(out, core.std.MaskedMerge(out, src, cred_m), [op]) credit = lvf.rfs(credit, src, [ed]) out = credit deband = dbs.f3kpf(out, 17, 36, 36) deband = core.std.MaskedMerge(deband, out, line_mask) grain = core.grain.Add(deband, 0.25) return depth(grain, 10)
def do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut src = depth(src, 32) ed = (30089, 32247) denoise = kgf.hybriddenoise(src, 0.45, 2) out = denoise h = 720 w = get_w(h) b, c = vdf.get_bicubic_params('mitchell') luma = get_y(out) line_mask = shf.edge_mask_simple(luma, 'FDOG', 0.08, (1, 1)) descale = core.descale.Debicubic(luma, w, h, b, c) upscale = shf.fsrcnnx_upscale(descale, src.height, 'shaders/FSRCNNX_x2_56-16-4-1.glsl', partial(SSIM_downsample, kernel='Bicubic')) rescale = core.std.MaskedMerge(luma, upscale, line_mask) merged = vdf.merge_chroma(rescale, denoise) out = depth(merged, 16) mask = shf.detail_mask(out, (10000, 4000), (12000, 3500), [(2, 2), (2, 2)], sigma=[50, 250, 400], upper_thr=0.005) deband = dbs.f3kpf(out, 17, 42, 48, thrc=0.4) deband = core.std.MaskedMerge(deband, out, mask) deband_b = placebo.deband(out, 27, 8, 3, 0) deband = lvf.rfs(deband, deband_b, [(3404, 3450)]) deband_c = shf.deband_stonks(out, 20, 8, 3, shf.edge_mask_simple(out, 'prewitt', 2500, (8, 1))) deband = lvf.rfs(deband, deband_c, [(5642, 5784), (6222, 6479), (7798, 8073), (8133, 8256), (9699, 9817)]) deband_d = placebo.deband(out, 17, 7.5, 1, 0) deband_d = core.std.MaskedMerge(deband_d, out, mask) deband = lvf.rfs(deband, deband_d, [(8074, 8132), (8711, 8766), (12267, 12433), (28468, 28507)]) grain = core.neo_f3kdb.Deband(deband, preset='depth', grainy=24, grainc=24) out = grain grain = adptvgrnMod(out, 0.3, size=4/3, sharp=55, luma_scaling=14, grain_chroma=False) out = grain ending = shinyori_ed01.filtering(src, *ed) final = lvf.rfs(out, ending, [ed]) return depth(final, 10)
def filtering(clip: vs.VideoNode, edstart: int, edend: int)-> vs.VideoNode: """Main function""" clip = depth(clip, 32) denoise = CoolDegrainSF(clip, tr=1, thsad=36, blksize=8, overlap=4) out = denoise luma = get_y(out) descale = core.descale.Debicubic(luma, w, h, b, c) out = descale upscale = shf.nnedi3_upscale(out, clip.height/h, dict(nsize=4, nns=4, qual=2, pscrn=1)) out = upscale antialias = _antialias_stonk(descale, 128) mask = core.std.Sobel(antialias).std.Maximum().std.Maximum() antialias = lvf.rfs(out, core.std.MaskedMerge(out, antialias, mask), [(edstart+683, edstart+730)]) merged = vdf.merge_chroma(antialias, denoise) out = depth(merged, 16) sharp = lvf.rfs(out, _unblur(descale, denoise), [(edstart+501, edstart+617)]) out = sharp ref = core.resize.Point(luma, format=vs.YUV420P16) credit = core.std.MaskedMerge(out, ref, vdf.drm(ref, h, b=b, c=c), 0) out = credit deband_a = shf.deband_stonks(out, 24, 8, 1, shf.edge_mask_simple(out, 'prewitt', 2500, (2, 0))) deband_b = shf.deband_stonks(out, 31, 16, 3, shf.edge_mask_simple(out, 'prewitt', 2500, (6, 0))) deband_c = dbs.f3kpf(out, 17, 36, 36) deband = lvf.rfs(out, deband_a, [(edstart+44, edstart+69), (edstart+94, edstart+165), (edstart+190, edstart+213), (edstart+320, edstart+375), (edstart+683, edstart+730)]) deband = lvf.rfs(deband, deband_b, [(edstart+166, edstart+189)]) deband = lvf.rfs(deband, deband_c, [(edstart+376, edstart+682), (edstart+731, edend)]) out = deband grain = core.neo_f3kdb.Deband(out, preset='depth', grainy=24, grainc=24) out = grain return out
def do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut src = depth(src, 32) edstart, edend = 14969, src.num_frames - 1 denoise = mvf.BM3D(src, 1.1, radius1=1, depth=16) out = denoise antialias = lvf.sraa(out, 2, 13, downscaler=core.resize.Bicubic, gamma=500, nrad=2, mdis=16) out = antialias deband_mask = lvf.denoise.detail_mask(out, brz_a=2250, brz_b=1600).std.Median() deband = dbs.f3kbilateral(out, 17, 48, 48) deband_a = dbs.f3kbilateral(out, 22, 96, 96) deband = lvf.rfs(deband, deband_a, [(edstart, edend)]) deband = core.std.MaskedMerge(deband, out, deband_mask) out = deband grain = core.grain.Add(out, 0.3, constant=True) out = grain endcard = endcard_source( r'endcards\yande.re 611483 isekai_quartet iwamoto_tatsurou maid ram_(re_zero) rem_(re_zero) sketch tanya_degurechaff tate_no_yuusha_no_nariagari uniform youjo_senki.jpg', src) endcard_ar = endcard.width / endcard.height endcard_ev = bool(endcard.format.name == 'YUV420P8') if endcard_ar > 16 / 9: w, h = get_w(src.height, endcard_ar, only_even=endcard_ev), src.height elif endcard_ar < 16 / 9: w, h = src.width, get_h(src.width, endcard_ar, only_even=endcard_ev) else: w, h = src.width, src.height endcard = core.resize.Bicubic(endcard, w, h, vs.YUV444PS, range_in=1, range=0, dither_type='error_diffusion') endcard = mvf.BM3D(endcard, 0.5) endcard = core.std.CropAbs(endcard, 1920, 1080, top=round((endcard.height - 1080) / 2 / 2) * 2) final = core.std.Splice([out, endcard * (17263 - src.num_frames)], mismatch=True) return core.resize.Bicubic(final, format=vs.YUV420P10, dither_type='error_diffusion')
def do_filter(): """Vapoursynth filtering""" def _eedi3_instance(clip, eeargs, nnargs) -> vs.VideoNode: return core.eedi3m.EEDI3(clip, 0, True, **eeargs, sclip=_nnedi3_sclip(clip, nnargs)) def _nnedi3_sclip(clip, nnargs) -> vs.VideoNode: return core.nnedi3.nnedi3(clip, 0, True, **nnargs) def _rescale(clip, width, height, eeargs, nnargs) -> vs.VideoNode: clip = _eedi3_instance(clip, eeargs, nnargs).std.Transpose() clip = _eedi3_instance(clip, eeargs, nnargs).std.Transpose() return core.resize.Bicubic(clip, width, height, src_left=.5, src_top=.5) src = SRC_CUT denoise = mdf.hybriddenoise_mod(src, 0.5, 1.5, depth=32) h = 806 w = get_w(h) b, c = 0.3782, 0.3109 eedi3_args = dict(alpha=.2, beta=.3, gamma=1000, mdis=20, vcheck=3) nnedi3_args = dict(nns=4, nsize=0, qual=2, pscrn=1) luma = get_y(denoise) descale = core.descale.Debicubic(luma, w, h, b, c) scaled = _rescale(descale, src.width, src.height, eedi3_args, nnedi3_args) credit_m = vrf.drm(denoise, h, b=b, c=c, sw=4, sh=4) scaled = lvf.rfs(scaled, core.std.MaskedMerge(scaled, luma, credit_m), [(47, 134)]) merged = core.std.ShufflePlanes([scaled, denoise], [0, 1, 2], vs.YUV) merged = depth(merged, 16) deband_mask = lvf.denoise.detail_mask(merged, brz_a=2500, brz_b=1000) deband_a = dbs.f3kpf(merged, 17, 48, 48) deband_b = core.placebo.Deband(merged, radius=19, threshold=5, iterations=1, grain=2, planes=1|2|4) deband = lvf.rfs(deband_a, deband_b, [(2684, 2743)]) deband = core.std.MaskedMerge(deband, merged, deband_mask) deband = core.placebo.Deband(deband, iterations=0, grain=5, planes=1) grain = mdf.adptvgrnMod_mod(deband, 0.3, size=1.25, sharp=60, static=False, luma_scaling=6) final = lvf.rfs(grain, depth(src, 16), [(2904, src.num_frames-1)]) final = depth(final, 10) return final
def antialias( clip: vs.VideoNode, heavy: Optional[Union[int, Tuple[int, int]]] = None) -> vs.VideoNode: aa_lo = lvf.aa.taa(clip, lvf.aa.nnedi3()) aa_hi = lvf.aa.upscaled_sraa(clip, 1.5) aa_clamp = lvf.aa.clamp_aa(clip, aa_lo, aa_hi, strength=2) aa = lvf.rfs(aa_clamp, aa_hi, ranges=heavy) return aa
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 vsutil import depth src = JP_BD.clip_cut cloc = core.resize.Bicubic(src, chromaloc_in=2, chromaloc=0) src = depth(cloc, 16) halo_mask = lvf.mask.halo_mask(src, rad=1, brz=0.85, thmi=0.35, thma=0.95) halo_mask = halo_mask.std.Maximum().std.Inflate() bidehalo = lvf.dehalo.bidehalo(src, sigmaR=8 / 255, sigmaS=2.0, sigmaS_final=1.5) dehalo_den = core.dfttest.DFTTest(bidehalo, sigma=8.0) dehalo_clean = haf.EdgeCleaner(dehalo_den, strength=8, smode=1, hot=True) dehalo = core.std.MaskedMerge(src, dehalo_clean, halo_mask) # Certain cuts have a strong camera effect that amplifies haloing, and is likely intentional dehalo = lvf.rfs(dehalo, src, [(773, 786), (867, 886)]) denoise = core.dfttest.DFTTest(dehalo, sigma=1.75) cdenoise = ccd(denoise, threshold=4, matrix='709') decs = vdf.noise.decsiz(cdenoise, sigmaS=8.0, min_in=208 << 8, max_in=232 << 8) baa = lvf.aa.based_aa(decs, str(shader_file)) sraa = lvf.sraa(decs, rfactor=1.45) clmp = lvf.aa.clamp_aa(decs, baa, sraa, strength=1.45) darken = haf.FastLineDarkenMOD(clmp, strength=12) # Debanding and graining deband = flt.masked_f3kdb(darken, rad=18, thr=[24, 20]) grain = vdf.noise.Graigasm(thrs=[x << 8 for x in (32, 80, 128, 176)], strengths=[(0.20, 0.0), (0.15, 0.0), (0.10, 0.0), (0.0, 0.0)], sizes=(1.20, 1.15, 1.10, 1), sharps=(70, 60, 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 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 do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut src = depth(src, 16) denoise = CoolDegrain(src, tr=1, thsad=24, blksize=8, overlap=4, plane=4) out = denoise deband_mask = lvf.denoise.detail_mask(out, brz_a=2000, brz_b=1000) deband = dbs.f3kpf(out, 17, 30, 30) deband_b = dbs.f3kpf(out, 17, 84, 84) deband_c = placebo.deband(out, 32, 12, 3, 4) deband = lvf.rfs(deband, deband_b, [(2090, 2107)]) deband = lvf.rfs(deband, deband_c, [(2108, src.num_frames - 1)]) deband = core.std.MaskedMerge(deband, out, deband_mask) out = deband return depth(out, 10)
def do_filter(): """Vapoursynth filtering""" opstart_ep10 = 768 ncop = JPBD_NCOP.src_cut ep10 = JPBD_10.src_cut ncop = lvf.rfs(ncop, ep10[opstart_ep10:], [(0, 79), (1035, 1037)]) return ncop
def do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut src = depth(src, 16) out = src opstart, opend = 1080, 3236 edstart, edend = 30593, 32751 dehalo = gf.MaskedDHA(out, rx=1.35, ry=1.35, darkstr=0.25, brightstr=1.0, maskpull=46, maskpush=148) out = dehalo antialias = lvf.sraa(out, 1.5, 9, downscaler=core.resize.Bicubic) antialias_b = lvf.sraa(antialias, 1.25, 3, downscaler=core.resize.Bicubic) antialias = lvf.rfs(antialias, antialias_b, [(12113, 12157), (12760, 12826), (14023, 14079), (23982, 24031), (27733, 27803)]) out = antialias sharp = hvf.LSFmod(out, strength=75, Smode=3, Lmode=1, edgemode=1, edgemaskHQ=True) out = sharp deband_mask = lvf.denoise.detail_mask(out, brz_a=2000, brz_b=1000) deband = dbs.f3kpf(out, 17, 24, 24) deband = core.std.MaskedMerge(deband, out, deband_mask) out = deband src_c, ncop, nced = [clip.std.Median() for clip in [src, JPBD_NCOP.src_cut, JPBD_NCED.src_cut]] opening_mask = vdf.dcm(out, src_c[opstart:opend+1], ncop[:opend-opstart+1], opstart, opend, 3, 3) ending_mask = vdf.dcm(out, src_c[edstart:edend+1], nced[:edend-edstart+1], edstart, edend, 3, 3) credit_mask = core.std.Expr([opening_mask, ending_mask], 'x y +').std.Convolution([1]*9) credit = lvf.rfs(out, core.std.MaskedMerge(out, src, credit_mask), [(opstart, opend), (edstart, edend)]) out = credit return depth(out, 10)
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """Main filterchain""" import debandshit as dbs import havsfunc as haf import lvsfunc as lvf import vardefunc as vdf from adptvgrnMod import adptvgrnMod from vsutil import depth src = JP_BD.clip_cut src = depth(src, 16) up = vdf.scale.to_444(src, src.width, src.height, join_planes=True) cbl = haf.FixChromaBleedingMod(up, cx=-0.35, cy=0, thr=4, strength=1, blur=False) debl = lvf.deblock.vsdpir(cbl, matrix=1, strength=25, mode='deblock', i444=True) aa = lvf.aa.nneedi3_clamp(debl, strength=1.5) aa = lvf.rfs(debl, aa, aliasing_ranges) aa = depth(aa, 16).std.Limiter(16 >> 8, [235 << 8, 240 << 8], [0, 1, 2]) dehalo = lvf.dehalo.masked_dha(aa, brightstr=0.35) dehalo = lvf.rfs(aa, dehalo, haloing_ranges) deband = dbs.dumb3kdb(dehalo, threshold=[16, 12]) grain: vs.VideoNode = adptvgrnMod(deband, strength=0.15, size=1.15, sharp=70, grain_chroma=False, static=False, seed=42069, luma_scaling=10) return grain
def deband( clip: vs.VideoNode, lineart: vs.VideoNode, heavy: Optional[Union[int, Tuple[int, int]]] = None) -> vs.VideoNode: detail_mask = lvf.mask.detail_mask(clip, brz_a=0.03) deband_lo = dumb3kdb(clip, radius=16, threshold=36) deband_hi = dumb3kdb(clip, radius=18, threshold=72) deband_replace = lvf.rfs(deband_lo, deband_hi, ranges=heavy) deband = core.std.MaskedMerge(deband_replace, lineart, detail_mask) return deband
def do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut src = depth(src, 32) edstart, edend = 14313, 16383 denoise = mvf.BM3D(src, 1.1, radius1=1, depth=16) out = denoise antialias = lvf.sraa(out, 2, 13, downscaler=core.resize.Bicubic, gamma=500, nrad=2, mdis=16) out = antialias deband_mask = lvf.denoise.detail_mask(out, brz_a=2250, brz_b=1600).std.Median() deband = dbs.f3kbilateral(out, 17, 48, 48) deband_a = dbs.f3kbilateral(out, 22, 96, 96) deband = lvf.rfs(deband, deband_a, [(edstart, edend)]) deband = core.std.MaskedMerge(deband, out, deband_mask) out = deband grain = core.grain.Add(out, 0.3, constant=True) out = grain endcard = endcard_source( r'endcards\yande.re 607473 cheerleader isekai_quartet pointy_ears ram_(re_zero) rem_(re_zero) satou_kazuma seifuku tagme tanya_degurechaff trap youjo_senki.jpg', src) endcard_ar = endcard.width / endcard.height endcard_ev = bool(endcard.format.name == 'YUV420P8') if endcard_ar > 16 / 9: w, h = get_w(src.height, endcard_ar, only_even=endcard_ev), src.height elif endcard_ar < 16 / 9: w, h = src.width, get_h(src.width, endcard_ar, only_even=endcard_ev) else: w, h = src.width, src.height endcard = core.resize.Bicubic(endcard, w, h, range_in=1, range=0, dither_type='error_diffusion') endcard = lvf.sraa(depth(endcard, 16), 1.5, 7) final = core.std.Splice([out, endcard * (17263 - src.num_frames)], mismatch=True) return core.resize.Bicubic(final, format=vs.YUV420P10, dither_type='error_diffusion')
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 do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut src = depth(src, 16) denoise = CoolDegrain(src, tr=1, thsad=24, blksize=8, overlap=4, plane=4) out = denoise deband_mask = lvf.denoise.detail_mask(out, brz_a=2000, brz_b=1000) deband = dbs.f3kpf(out, 17, 30, 30) deband_b = dbs.f3kpf(out, 17, 48, 48) deband = lvf.rfs(deband, deband_b, [(0, 89)]) deband = core.std.MaskedMerge(deband, out, deband_mask) out = deband grain = kgf.adaptive_grain(out, 0.2, luma_scaling=8) grain = lvf.rfs(out, grain, [(0, 89)]) out = grain return depth(out, 10)
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 ccd import ccd from muvsfunc import SSIM_downsample from vsutil import depth, get_y src = JP_BD.clip_cut rkt = rekt.rektlvls(src, [0, -1], [30, 17], [0], [17]) bb_y = bbmod(rkt, top=2, left=2, right=2, bottom=2, u=False, v=False, blur=9999) bb_uv = bbmod(bb_y, left=2, right=2, y=False) bb = depth(bb_uv, 32) descale = lvf.kernels.Spline36().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=0.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) scaled = vdf.misc.merge_chroma(downscaled, bb) scaled = depth(scaled, 16) den_uv = ccd(scaled, matrix='709') decs = vdf.noise.decsiz(den_uv, sigmaS=8, min_in=200 << 8, max_in=232 << 8) nn_aa = lvf.aa.nnedi3(opencl=True, dh=False)(decs) sraa = lvf.sraa(decs, rfactor=1.75) clmp = lvf.aa.clamp_aa(decs, nn_aa, sraa) dehalo = lvf.dehalo.masked_dha(clmp, brightstr=0.65) deband = flt.masked_f3kdb(dehalo, rad=17, thr=[24, 16], grain=[24, 12]) grain = vdf.noise.Graigasm( thrs=[x << 8 for x in (32, 80, 128, 176)], strengths=[(0.20, 0.0), (0.15, 0.0), (0.10, 0.0), (0.0, 0.0)], sizes=(1.20, 1.15, 1.10, 1), sharps=(100, 80, 60, 20), grainers=[ vdf.noise.AddGrain(seed=69420, constant=False), vdf.noise.AddGrain(seed=69420, constant=False), vdf.noise.AddGrain(seed=69420, constant=True) ]).graining(deband) no_flt = lvf.rfs(grain, depth(bb, 16), no_filter) return no_flt
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """Regular VapourSynth filterchain""" import havsfunc as haf import lvsfunc as lvf import vardefunc as vdf from adptvgrnMod import adptvgrnMod from muvsfunc import SSIM_downsample from vsutil import depth, get_y, iterate src = pre_freeze() src = depth(src, 16) 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.3, channels='Y') decs = vdf.noise.decsiz(denoise, sigmaS=4, min_in=208 << 8, max_in=232 << 8) dehalo = haf.YAHR(decs, blur=2, depth=28) halo_mask = lvf.mask.halo_mask(decs, rad=3, brz=0.3, thma=0.42) dehalo_masked = core.std.MaskedMerge(decs, dehalo, halo_mask) aa = lvf.aa.nneedi3_clamp(dehalo_masked, strength=1.5) # Strong aliasing on the transformation scene (and probably elsewhere that I missed). Thanks, Silver Link! aa_strong = lvf.sraa(dehalo_masked, rfactor=1.35) aa_spliced = lvf.rfs(aa, aa_strong, [(7056, 7322)]) 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