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""" 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 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 605709 albedo_(overlord) armor cleavage gun horns isekai_quartet maid overlord rem_(re_zero) tagme thighhighs uniform weapon youjo_senki.jpg', src) endcard_ar = endcard.width/endcard.height endcard_ev = bool(endcard.format.name == 'YUV420P8') endcard = depth(endcard, 16) endcard = gf.MaskedDHA(endcard, rx=2.0, ry=2.0, darkstr=0.3, brightstr=1.0, maskpull=48, maskpush=140) 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(endcard, 1.45, 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 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 617224 albedo crossover emilia_(re_zero) horns isekai_quartet megumin neko overlord pack_(re_zero) pointy_ears tagme uniform witch youjo_senki.jpg', src) endcard_ar = endcard.width/endcard.height endcard_ev = bool(endcard.format.name == 'YUV420P8') endcard = depth(endcard, 16) endcard = dbs.f3kpf(endcard, 22, 48, 48).grain.Add(50, constant=True) 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') 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""" src = JPBD.src_cut src = depth(src, 32) 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, 36, 36) deband = core.std.MaskedMerge(deband, out, deband_mask) out = deband grain = core.grain.Add(out, 0.3, constant=True) out = grain return depth(out, 10)
def do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut src = depth(src, 32) 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, 36, 36) 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 602496 isekai_quartet minami_seira overlord raphtalia re_zero_kara_hajimeru_isekai_seikatsu tagme tate_no_yuusha_no_nariagari youjo_senki.jpg', src) endcard = core.resize.Bicubic(endcard, get_w(src.height, endcard.width/endcard.height, only_even=bool(endcard.format.name == 'YUV420P8')), src.height, range_in=1, range=0, dither_type='error_diffusion') final = core.std.Splice([out, endcard * 223], mismatch=True) return core.resize.Bicubic(final, format=vs.YUV420P10, dither_type='error_diffusion')
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, 54, 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 603981 ass bikini breast_hold crossover horns isekai_quartet open_shirt overlord rem_(re_zero) swimsuits thong tsuji_santa weapon wings youjo_senki.jpg', src) endcard = core.resize.Bicubic( endcard, get_w(src.height, endcard.width / endcard.height, only_even=bool(endcard.format.name == 'YUV420P8')), src.height, range_in=1, range=0, dither_type='error_diffusion') final = core.std.Splice([out, endcard * 223], mismatch=True) return core.resize.Bicubic(final, format=vs.YUV420P10, dither_type='error_diffusion')
def deband(clip: vs.VideoNode) -> vs.VideoNode: """ mostly stole this from varde """ grad_mask, yrangebig = morpho_mask( clip.dfttest.DFTTest(sigma=14, sigma2=10, sbsize=1, sosize=0).rgvs.RemoveGrain(3)) y = vsutil.get_y(clip) mask = detail_mask(y, brz_a=0.05, brz_b=0.03) dumb: vs.VideoNode = dumb3kdb(clip) deband_weak = core.std.MaskedMerge(vsutil.get_y(dumb), y, mask) deband_norm = f3kbilateral(y, y=36) deband_strong = f3kbilateral(y, y=65) deband = core.std.MaskedMerge(deband_strong, deband_norm, grad_mask) deband = core.std.MaskedMerge(deband, deband_weak, yrangebig) deband = core.std.ShufflePlanes([deband, dumb], planes=[0, 1, 2], colorfamily=vs.YUV) return deband
def do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut src = depth(src, 32) denoise = mvf.BM3D(src, 1.1, radius1=1, depth=16) out = denoise 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, [(112, 2182)]) deband = core.std.MaskedMerge(deband, out, deband_mask) out = deband grain = core.grain.Add(out, 0.3, constant=True) out = grain return depth(out, 10)
def do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut src = depth(src, 32) 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 = 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 622847 animal_ears armor chibi dress emilia_(re_zero) firo horns isekai_quartet neko overlord pack_(re_zero) raphtalia uniform wallpaper 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') 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 deband(clip: vs.VideoNode, strong: Optional[List[Range]] = None, nuclear: Optional[List[Range]] = None) -> vs.VideoNode: dmask = detail_mask(clip) deb = dumb3kdb(clip, radius=16, threshold=30) if strong: debs = dumb3kdb(clip, radius=24, threshold=60) deb = replace_ranges(deb, debs, strong or []) if nuclear: debn = core.std.ShufflePlanes([ f3kbilateral(clip.std.ShufflePlanes(planes=0, colorfamily=vs.GRAY), y=60), deb ], planes=[0, 1, 2], colorfamily=vs.YUV) deb = replace_ranges(deb, debn, nuclear or []) return core.std.MaskedMerge(deb, clip, dmask)
def do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut src = depth(src, 32) 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 = 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 609548 albedo_(overlord) cleavage crossover dress horns isekai_quartet no_bra nopan ookuma_nekosuke overlord petelgeuse_romanee-conti valentine wings.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 = 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 deband(clip: vs.VideoNode) -> vs.VideoNode: grad_mask, yrangebig = morpho_mask( clip.dfttest.DFTTest(sigma=14, sigma2=10, sbsize=1, sosize=0).rgvs.RemoveGrain(3)) y = vsutil.get_y(clip) mask = lvf.mask.detail_mask(clip, brz_b=0.03) deband_dumb: vs.VideoNode = vdf.dumb3kdb(clip, radius=16, threshold=24) deband_weak: vs.VideoNode = core.std.MaskedMerge(vsutil.get_y(deband_dumb), y, mask) deband_norm: vs.VideoNode = vsutil.get_y( vdf.dumb3kdb(clip, radius=16, threshold=30)) deband_strong: vs.VideoNode = f3kbilateral(y, range=12, y=50) deband = core.std.MaskedMerge(deband_strong, deband_norm, grad_mask) deband = core.std.MaskedMerge(deband, deband_weak, yrangebig) deband = core.std.ShufflePlanes([deband, deband_dumb], planes=[0, 1, 2], colorfamily=vs.YUV) return deband
def do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut src += src[-1] ep10 = JPBD_10.src_cut h = 720 w = get_w(h) b, c = vdf.get_bicubic_params('robidoux') opstart, opend = 2973, 5370 edstart, edend = 31887, src.num_frames - 1 opstart_ep10, opend_ep10 = 768, 3164 full_stuff = [(5449, 5580), (16465, 16620)] # Fix compositing error in the OP op_src, op_10 = src[opstart:opend + 1], ep10[opstart_ep10:opend_ep10 + 1] fix = lvf.rfs(op_src, op_10, [(0, 79), (1035, 1037)]) fix_src = insert_clip(src, fix, opstart) src = depth(fix_src, 32) denoise = hybrid_denoise(src, 0.5, 2) out = denoise luma = get_y(out) line_mask = vdf.edge_detect(luma, 'FDOG', 0.05, (1, 1)) descale = core.descale.Debicubic(luma, w, h, b, c) upscale = vdf.fsrcnnx_upscale(descale, None, descale.height * 2, '_shaders/FSRCNNX_x2_56-16-4-1.glsl', core.resize.Point) antialias = single_rate_antialiasing(upscale, 13, alpha=0.3, beta=0.45, gamma=320, mdis=18) scaled = muvf.SSIM_downsample(antialias, src.width, src.height, kernel='Bicubic') rescale = core.std.MaskedMerge(luma, scaled, line_mask) merged = vdf.merge_chroma(rescale, out) out = depth(merged, 16) antialias = lvf.rfs( out, lvf.sraa(out, 1.65, 9, alpha=0.3, beta=0.45, gamma=240, nrad=3, mdis=25), [(opstart + 840, opstart + 881)]) out = antialias # Slight sharp though CAS sharp = hvf.LSFmod(out, strength=75, Smode=3, Lmode=1, edgemode=1, edgemaskHQ=True) out = sharp dering = gf.HQDeringmod(out, thr=16, darkthr=0.1) out = dering warp = xvs.WarpFixChromaBlend(out, thresh=48, depth=8) out = warp preden = core.knlm.KNLMeansCL(out, d=0, a=3, h=0.6, device_type='GPU', channels='Y') deband_mask = lvf.denoise.detail_mask(preden, brz_a=2000, brz_b=800, rad=4) deband = dbs.f3kpf(out, 17, 42, 42) deband_b = placebo.deband(out, 22, 6, 2) deband = lvf.rfs(deband, deband_b, [(opstart + 1515, opstart + 1603)]) deband_c = placebo.deband(deband, 17, 5, 1) deband_c = dbs.f3kbilateral(deband_c, 22, 64, 64) deband = lvf.rfs(deband, deband_c, [(15612, 15695)]) deband_mask2 = vdf.edge_detect( out.knlm.KNLMeansCL(d=2, a=2, h=0.4, device_type='GPU', channels='Y'), 'FDOG', 1100, (8, 1)) deband_mask2 = iterate(deband_mask2, core.std.Deflate, 4) deband_d = placebo.deband(out, 16, 12, 3) deband_d = core.std.MaskedMerge(deband_d, out, deband_mask2) deband = lvf.rfs(deband, deband_d, [(16339, 16542)]) deband = core.std.MaskedMerge(deband, out, deband_mask) out = deband adg_mask = core.adg.Mask(out.std.PlaneStats(), 20).std.Expr(f'x x {128<<8} - 0.25 * +') grain = core.grain.Add(out, 0.2, constant=True) grain = core.std.MaskedMerge(out, grain, adg_mask, 0) out = grain rescale_mask = vdf.drm(luma, b=b, c=c, sw=4, sh=4) ref, rescale_mask, src, src_ncop, src_nced = [ depth(x, 16) for x in [denoise, rescale_mask, src, JPBD_NCOP.src_cut, JPBD_NCED.src_cut] ] credit = lvf.rfs(out, core.std.MaskedMerge(out, ref, rescale_mask), full_stuff) out = credit src_c, src_ncop, src_nced = [ c.knlm.KNLMeansCL(a=7, h=35, d=0, device_type='gpu') for c in [src, src_ncop, src_nced] ] opening_mask = vdf.dcm(out, src_c[opstart:opend + 1], src_ncop[:opend - opstart + 1], opstart, opend, 4, 4).std.Inflate() ending_mask = vdf.dcm(out, src_c[edstart:edend + 1], src_nced[:edend - edstart + 1], edstart, edend, 4, 4).std.Inflate() credit_mask = core.std.Expr([opening_mask, ending_mask], 'x y +') credit = lvf.rfs(out, core.std.MaskedMerge(out, ref, credit_mask), [(opstart, opend), (edstart, edend)]) out = credit return depth(out, 10)
def do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut # Variables opstart, opend = 792, 2948 edstart, edend = 31648, 33807 full_zone = [(18461, 18508), (31588, 31647), (33988, src.num_frames - 1) ] # eyecatch, episode name and next episode shabc_zone = [(edstart + 15, edstart + 1215), (edstart + 1882, edstart + 2126)] h = 720 w = get_w(h) # Bicubic sharp parts don't have bad edges edges_a = core.edgefixer.ContinuityFixer(src, *[[2, 1, 1]] * 4) edges_b = awf.bbmod(src, left=6, thresh=32, blur=200) edges = lvf.rfs(edges_a, edges_b, [(edstart + 1275, edstart + 1757)]) edges = lvf.rfs(edges, src, [(opstart, opend)] + full_zone) out = depth(edges, 32) # Denoise ref = hvf.SMDegrain(depth(get_y(out), 16), thSAD=450) denoise = hybrid_denoise(out, 0.35, 1.4, dict(a=2, d=1), dict(ref=depth(ref, 32))) out = denoise # Descale luma = get_y(out) lineart = vdf.edge_detect(luma, 'FDOG', 0.055, (1, 1)).std.Median().std.BoxBlur(0, 1, 1, 1, 1) descale_a = core.descale.Despline36(luma, w, h).std.SetFrameProp('descaleKernel', data='spline36') descale_b = core.descale.Debicubic(luma, w, h, 0, 1).std.SetFrameProp( 'descaleKernel', data='sharp_bicubic') descale = lvf.rfs(descale_a, descale_b, shabc_zone) # Chroma reconstruction # y_m is the assumed mangled luma. # Descale 1080p -> Bad conversion in 422 720p -> Regular 1080p 420 radius = 2 y, u, v = descale, plane(out, 1), plane(out, 2) y_m = core.resize.Point(y, 640, 720, src_left=-1).resize.Bicubic(960, 540, filter_param_a=1 / 3, filter_param_b=1 / 3) # 0.25 for 444 and 0.25 for right shifting y_m, u, v = [ c.resize.Bicubic(w, h, src_left=0.25 + 0.25, filter_param_a=0, filter_param_b=.5) for c in [y_m, u, v] ] y_fixup = core.std.MakeDiff(y, y_m) yu, yv = Regress(y_m, u, v, radius=radius, eps=1e-7) u_fixup = ReconstructMulti(y_fixup, yu, radius=radius) u_r = core.std.MergeDiff(u, u_fixup) v_fixup = ReconstructMulti(y_fixup, yv, radius=radius) v_r = core.std.MergeDiff(v, v_fixup) # -0.5 * 720/1080 = -1/3 # -1/3 for the right shift # https://forum.doom9.org/showthread.php?p=1802716#post1802716 u_r, v_r = [ c.resize.Bicubic(960, 540, src_left=-1 / 3, filter_param_a=-.5, filter_param_b=.25) for c in [u_r, v_r] ] upscale = vdf.fsrcnnx_upscale( descale, height=h * 2, shader_file=r'shaders\FSRCNNX_x2_56-16-4-1.glsl', upscaler_smooth=eedi3_upscale, profile='zastin') antialias = sraa_eedi3(upscale, 3, alpha=0.2, beta=0.4, gamma=40, nrad=3, mdis=20) downscale = muvf.SSIM_downsample(antialias, src.width, src.height, filter_param_a=0, filter_param_b=0) downscale = core.std.MaskedMerge(luma, downscale, lineart) merged_a = join([downscale, u_r, v_r]) merged_b = vdf.merge_chroma(downscale, denoise) merged = lvf.rfs(merged_a, merged_b, shabc_zone) out = depth(merged, 16) warp = xvs.WarpFixChromaBlend(out, 80, 2, depth=8) out = warp dering = gf.MaskedDHA(out, rx=1.25, ry=1.25, darkstr=0.05, brightstr=1.0, maskpull=48, maskpush=140) out = dering qtgmc = hvf.QTGMC(out, Preset="Slower", InputType=1, ProgSADMask=2.0) qtgmc = vdf.fade_filter(out, out, qtgmc, edstart + 1522, edstart + 1522 + 24) qtgmc = lvf.rfs(out, qtgmc, [(edstart + 1522 + 25, edstart + 1757)]) out = qtgmc out = lvf.rfs(out, depth(denoise, 16), [(opstart, opend)]) detail_dark_mask = detail_dark_mask_func(get_y(out), brz_a=8000, brz_b=6000) detail_light_mask = lvf.denoise.detail_mask(out, brz_a=2500, brz_b=1200) detail_mask = core.std.Expr([detail_dark_mask, detail_light_mask], 'x y +').std.Median() detail_mask_grow = iterate(detail_mask, core.std.Maximum, 2) detail_mask_grow = iterate(detail_mask_grow, core.std.Inflate, 2).std.BoxBlur(0, 1, 1, 1, 1) detail_mask = core.std.Expr([get_y(out), detail_mask_grow, detail_mask], f'x {32<<8} < y z ?') deband = dumb3kdb(out, 22, 30) import rekt as rkt import debandshit as dbs deband_b = rkt.rekt_fast( out, lambda c: dbs.f3kbilateral(c, 22, 120, 120).grain.Add(0.2, 0.15), left=376, right=1062, bottom=500) deband_c = dumb3kdb(out, 24, 48) deband = lvf.rfs(deband, deband_b, [(7312, 7388)]) deband = lvf.rfs(deband, deband_c, [(29089, 29100)]) deband = core.std.MaskedMerge(deband, out, detail_mask) out = deband ref = get_y(out).std.PlaneStats() adgmask_a = core.adg.Mask(ref, 30) adgmask_b = core.adg.Mask(ref, 12) stgrain = sizedgrn(out, 0.1, 0.05, 1.05, sharp=80) stgrain = core.std.MaskedMerge(out, stgrain, adgmask_b) stgrain = core.std.MaskedMerge(out, stgrain, adgmask_a.std.Invert()) dygrain = sizedgrn(out, 0.2, 0.05, 1.15, sharp=80, static=False) dygrain = core.std.MaskedMerge(out, dygrain, adgmask_a) grain = core.std.MergeDiff(dygrain, out.std.MakeDiff(stgrain)) out = grain ref = depth(edges, 16) credit = out rescale_mask = vdf.diff_rescale_mask(ref, h, b=0, c=1, mthr=40, sw=0, sh=0) rescale_mask = vdf.region_mask(rescale_mask, *[10] * 4) rescale_mask = hvf.mt_expand_multi(rescale_mask, mode='ellipse', sw=4, sh=4).std.BoxBlur(0, 1, 1, 1, 1) credit = lvf.rfs(credit, ref, full_zone) credit = lvf.rfs(credit, core.std.MaskedMerge(credit, ref, rescale_mask), [(edstart, edend)]) out = credit return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2])
def do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut out = depth(src, 16) denoise = hvf.SMDegrain(out, thSAD=150, thSADC=75) out = denoise y = get_y(out) lineart = core.std.Sobel(y).std.Binarize( 75 << 8).std.Maximum().std.Inflate() antialias = lvf.sraa(y, 1.5, 9, downscaler=core.resize.Spline36, gamma=200, mdis=18) sharp = hvf.LSFmod(antialias, strength=95, Smode=3, Lmode=1, edgemode=1, edgemaskHQ=True) minmax = core.std.Expr([y, sharp, antialias], 'x y z min max y z max min') merge = core.std.MaskedMerge(y, minmax, lineart) out = vdf.merge_chroma(merge, out) y = get_y(out) detail_dark_mask = detail_dark_mask_func(y, brz_a=10000, brz_b=9000) detail_light_mask = lvf.denoise.detail_mask(y, brz_a=2500, brz_b=1200) detail_mask = core.std.Expr([detail_dark_mask, detail_light_mask], 'x y +').std.Median() detail_mask_grow = iterate(detail_mask, core.std.Maximum, 2) detail_mask_grow = iterate(detail_mask_grow, core.std.Inflate, 2).std.Convolution([1, 1, 1, 1, 1, 1, 1, 1, 1]) detail_mask = core.std.Expr([y, detail_mask_grow, detail_mask], f'x {28<<8} < y z ?') deband = dbs.f3kpf(out, 17, 24, 24) deband_b = dbs.f3kbilateral(out, 20, 128, 128) deband = lvf.rfs(deband, deband_b, [(17700, 17803), (22056, 22088), (22136, 22170)]) deband = core.std.MaskedMerge(deband, out, detail_mask) out = deband grain = adptvgrnMod(out, 0.2, 0.1, 1.25, luma_scaling=14, sharp=80, static=False, lo=19, hi=[192, 240]) out = grain return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2], [0, 1, 2])
def do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut # src += src[-1] src = depth(src, 16) out = src opstart, opend = 480, 2637 edstart, edend = 32249, 34405 # Remove the noise ref = hvf.SMDegrain(out, tr=1, thSAD=300, plane=4) denoise = mvf.BM3D(out, sigma=[2, 1], radius1=1, ref=ref) out = denoise # Limited antialiasing y = get_y(out) lineart = core.std.Sobel(y).std.Binarize(75<<8).std.Maximum().std.Inflate() aa = lvf.sraa(y, 2, 13, downscaler=partial(core.resize.Bicubic, filter_param_a=-0.5, filter_param_b=0.25)) sharp = hvf.LSFmod(aa, strength=70, Smode=3, edgemode=0, source=y) y = core.std.MaskedMerge(y, sharp, lineart) out = vdf.merge_chroma(y, out) # Deband masks planes = split(out) preden = core.dfttest.DFTTest(out, sigma=14.0, sigma2=10.0, sbsize=1, sosize=0).rgvs.RemoveGrain(3) grad_mask, yrangebig = morpho_mask(preden) rgb = core.resize.Bicubic(preden, 960, 540, format=vs.RGB48).std.SetFrameProp('_Matrix', delete=True) chroma_masks = [core.std.Prewitt(p).std.Binarize(5500).rgvs.RemoveGrain(11) for p in split(rgb) + split(preden)[1:]] chroma_mask = core.std.Expr(chroma_masks, 'x y + z + a + b +').std.Maximum() chroma_mask = core.std.Merge(chroma_mask, chroma_mask.std.Minimum()).std.BoxBlur(0, 1, 1, 1, 1) fdogmask = vdf.edge_detect(preden.std.Median(), 'FDOG', 8250, (4, 1)).std.BoxBlur(0, 2, 1, 2, 1) detail_mask = lvf.denoise.detail_mask(planes[0].std.BoxBlur(0, 1, 1, 1, 1), brz_a=3300, brz_b=2000) # Debanding stages debands = [None] * 3 deband_y_strong = dbs.f3kbilateral(planes[0], 16, 65) deband_y_normal = dumb3kdb(planes[0], 16, 36) deband_y_light = core.std.MaskedMerge(dumb3kdb(planes[0], 14, 32), planes[0], detail_mask) debands[1] = dbs.f3kbilateral(planes[1], 12, 50) debands[2] = dbs.f3kbilateral(planes[2], 12, 50) debands[0] = core.std.MaskedMerge(deband_y_strong, deband_y_normal, grad_mask) debands[0] = core.std.MaskedMerge(debands[0], deband_y_light, yrangebig) debands[1], debands[2] = [core.std.MaskedMerge(debands[i], planes[i], chroma_mask) for i in range(1, 3)] deband = join(debands) deband = lvf.rfs(deband, core.std.MaskedMerge(dbs.f3kbilateral(out, 20, 97), out, fdogmask), [(opstart+2019, opstart+2036), (opstart+1504, opstart+1574)]) out = deband # Regraining ref = get_y(out).std.PlaneStats() adgmask_a = core.adg.Mask(ref, 25) adgmask_b = core.adg.Mask(ref, 10) stgrain_a = core.grain.Add(out, 0.1, 0, seed=333) stgrain_a = core.std.MaskedMerge(out, stgrain_a, adgmask_b.std.Invert()) stgrain_b = sizedgrn(out, 0.2, 0.1, 1.15, sharp=80, seed=333) stgrain_b = core.std.MaskedMerge(out, stgrain_b, adgmask_b) stgrain_b = core.std.MaskedMerge(out, stgrain_b, adgmask_a.std.Invert()) stgrain = core.std.MergeDiff(stgrain_b, out.std.MakeDiff(stgrain_a)) dygrain = sizedgrn(out, 0.3, 0.1, 1.25, sharp=80, static=False, seed=333) dygrain = core.std.MaskedMerge(out, dygrain, adgmask_a) grain = core.std.MergeDiff(dygrain, out.std.MakeDiff(stgrain)) out = grain # Credits OP and ED ref = src src_ncop, src_nced = [depth(c, 16) for c in [JPBD_NCOP.src_cut, JPBD_NCED.src_cut]] src_c, src_ncop, src_nced = [c.std.BoxBlur(0, 2, 1, 2, 1) for c in [src, src_ncop, src_nced]] opening_mask = vdf.dcm(out, src_c[opstart:opend+1], src_ncop[:opend-opstart+1], opstart, opend, 2, 2) ending_mask = vdf.dcm(out, src_c[edstart:edend+1], src_nced[:edend-edstart+1], edstart, edend, 2, 2) credit_mask = core.std.Expr([opening_mask, ending_mask], 'x y +').std.Inflate() credit = lvf.rfs(out, core.std.MaskedMerge(out, ref, credit_mask), [(opstart, opend), (edstart, edend)]) out = credit # Fix letterboxes ending crop = core.std.Crop(out, 0, 0, 132, 132).edgefixer.ContinuityFixer(0, 1, 0, 0) crop = core.std.AddBorders(crop, 0, 0, 132, 132) out = lvf.rfs(out, crop, [(edstart, edend)]) return depth(out, 10).std.Limiter(16<<2, [235<<2, 240<<2], [0, 1, 2])
def do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut src = depth(src, 32) edstart, edend = 13572, 15642 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 619247 cleavage cocytus crossover dress emilia_(re_zero) isekai_quartet masha mecha neko overlord thighhighs uniform wings youjo_senki.jpg', src) endcard_ar = endcard.width / endcard.height endcard_ev = bool(endcard.format.name == 'YUV420P8') endcard = depth(endcard, 16) endcard = gf.MaskedDHA(endcard, rx=1.4, ry=1.4, darkstr=0.3, brightstr=1.0, maskpull=48, maskpush=140) endcard = dbs.f3kpf(endcard, 22, 48, 48).grain.Add(10, constant=True) 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 = 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 _nneedi3_clamp(clip: vs.VideoNode, strength: int = 1) -> vs.VideoNode: bits = clip.format.bits_per_sample - 8 thr = strength * (1 >> bits) luma = get_y(clip) def _strong(clip: vs.VideoNode) -> vs.VideoNode: args = dict(alpha=0.25, beta=0.5, gamma=40, nrad=2, mdis=20, vcheck=3) clip = core.eedi3m.EEDI3(clip, 1, True, **args).std.Transpose() clip = core.eedi3m.EEDI3(clip, 1, True, **args).std.Transpose() return core.resize.Spline36(clip, luma.width, luma.height, src_left=-.5, src_top=-.5) def _weak(clip: vs.VideoNode) -> vs.VideoNode: args = dict(nsize=3, nns=2, qual=2) clip = core.znedi3.nnedi3(clip, 1, True, **args).std.Transpose() clip = core.znedi3.nnedi3(clip, 1, True, **args).std.Transpose() return core.resize.Spline36(clip, luma.width, luma.height, src_left=-.5, src_top=-.5) clip_aa = core.std.Expr( [_strong(luma), _weak(luma), luma], 'x z - y z - * 0 < y x y {0} + min y {0} - max ?'.format(thr)) return vdf.merge_chroma(clip_aa, clip) def _perform_endcard(path: str, ref: vs.VideoNode) -> vs.VideoNode: endcard = lvf.src(path).std.AssumeFPS(ref) endcard = core.std.CropRel(endcard, left=14, top=12, right=18, bottom=23) endcard = core.resize.Bicubic(endcard, ref.width, ref.height, vs.RGBS, dither_type='error_diffusion') endcard = iterate( endcard, partial(core.w2xc.Waifu2x, noise=3, scale=1, photo=True), 2) endcard = core.resize.Bicubic(endcard, format=vs.YUV444PS, matrix_s='709', dither_type='error_diffusion') return Tweak(endcard, sat=1.2, bright=-0.05, cont=1.2) src = JPBD.src_cut src = depth(src, 16) edstart = 32012 denoise_a = CoolDegrain(src, tr=2, thsad=48, blksize=8, overlap=4, plane=4) denoise_b = CoolDegrain(src, tr=3, thsad=96, blksize=8, overlap=4, plane=4) denoise = lvf.rfs(denoise_a, denoise_b, [(edstart + 1870, edstart + 1900)]) antialias_a = _nneedi3_clamp(denoise) antialias_b = lvf.sraa(denoise, 2, rep=13) antialias = lvf.rfs(antialias_a, antialias_b, [(14667, 14696)]) predenoise = mClean(antialias, thSAD=200, chroma=False) detail_mask = lvf.denoise.detail_mask(predenoise, rad=2, radc=2, brz_a=3250, brz_b=1250) adapt_mask = core.adg.Mask(predenoise.std.PlaneStats(), 40) ret_mask = kgf.retinex_edgemask(predenoise).std.Binarize( 9250).std.Median().std.Inflate() line_mask = core.std.Expr([detail_mask, ret_mask], 'x y max') deband_a = core.neo_f3kdb.Deband(antialias, 17, 42, 42, 42, 12, 0, sample_mode=4, keep_tv_range=True) deband_a = core.std.MaskedMerge(deband_a, antialias, line_mask) deband_b = core.neo_f3kdb.Deband(deband_a, 18, 48, 48, 48, 0, 0, sample_mode=2, keep_tv_range=True) deband_ca = dbs.f3kbilateral(deband_b, 8, 270, 270) deband_cb = dbs.f3kbilateral(deband_b, 12, 110, 110) deband_c = core.std.MaskedMerge(deband_ca, deband_cb, adapt_mask) deband = lvf.rfs(deband_a, deband_b, [(edstart + 1870, edstart + 1900), (13041, 13180), (13932, 13949), (14121, 14168), (14647, 14666)]) deband = lvf.rfs(deband, deband_c, [(14667, 14669), (14673, 14674), (14676, 14677)]) grain = kgf.adaptive_grain(deband, 0.25, luma_scaling=10) crop = core.std.Crop(grain, 0, 0, 132, 132) edgefixe = core.edgefixer.ContinuityFixer(crop, 0, [2, 1, 1], 0, [1, 1, 1]) borders = core.std.AddBorders(edgefixe, 0, 0, 132, 132) borders = lvf.rfs(grain, borders, [(0, 2905)]) endcard = _perform_endcard( '[BDMV][200304][Magia Record][Vol.1]/Scans/endcard3_front_descreen.png', src) endcard_length = 117 final = core.std.Splice([borders, endcard * endcard_length], True) final = core.resize.Bicubic(final, format=vs.YUV420P10, dither_type='error_diffusion') final = core.std.Limiter(final, 16, [235 << 2, 240 << 2]) return depth(final, 10), endcard_length
def do_filter(): """Vapoursynth filtering""" def _single_rate_aa(clip): nnargs = dict(nsize=0, nns=2, qual=1) eeargs = dict(alpha=0.2, beta=0.4, gamma=250, nrad=3, mdis=20) clip = core.eedi3m.EEDI3(clip, 0, 0, 0, sclip=core.nnedi3.nnedi3( clip, 0, 0, 0, **nnargs), **eeargs).std.Transpose() clip = core.eedi3m.EEDI3(clip, 0, 0, 0, sclip=core.nnedi3.nnedi3( clip, 0, 0, 0, **nnargs), **eeargs).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, height=540, 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, [(3368, 3451)]) # Regular filterchain op, ed, eyec = (1200, 3356), (18989, 19108), (31888, 34046) opstart = op[0] denoise = CoolDegrain(src, tr=1, thsad=36, blksize=8, overlap=4, plane=4) h = 846 w = get_w(h) b, c = vdf.get_bicubic_params('mitchell') luma = get_y(denoise) descale = core.descale.Debicubic(depth(luma, 32), w, h, b, c) upscale = vdf.fsrcnnx_upscale(depth(descale, 16), descale.height * 2, "Shaders/FSRCNNX_x2_56-16-4-1.glsl", core.resize.Point) sraa = _single_rate_aa(upscale) rescaled = core.resize.Bicubic(sraa, src.width, src.height, filter_param_a=0, filter_param_b=0) dering = core.std.MaskedMerge( rescaled, core.bilateral.Gaussian(rescaled, 0.3), hvf.HQDeringmod(rescaled, incedge=True, show=True)) rescaled = lvf.rfs(rescaled, dering, [(opstart, opstart + 498)]) merged = vdf.merge_chroma(rescaled, src) out = merged dehalo = fine_dehalo(out, rx=2.2, darkstr=0, brightstr=1, contra=True, useMtEdge=True) out = dehalo 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, [eyec, ed]) out = credit thr = 7000 line_mask = gf.EdgeDetect( out, 'FDOG').std.Median().std.Expr(f'x {thr} < x x 3 * ?') deband = dbs.f3kpf(out, 17, 36, 36) deband_b = dbs.f3kbilateral(out, 20, 64, 64) deband = lvf.rfs(deband, deband_b, [(14775, 14846)]) deband = core.std.MaskedMerge(deband, out, line_mask) out = deband dedimm = gf.Tweak(out, sat=1.1, cont=1.1) dedimm = lvf.rfs(out, dedimm, [(12957, 13061)]) out = dedimm grain = core.grain.Add(out, 0.1) out = grain return depth(out, 10)
def do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut src = depth(src, 16) out = src h = 900 w = get_w(h) # Remove the grain ref = hvf.SMDegrain(out, tr=1, thSAD=300, plane=4) degrain = mvf.BM3D(out, sigma=[1.5, 1], radius1=1, ref=ref) degrain = insert_clip(degrain, smhdegrain(out[5539:5670], 2, 280), 5539) degrain = insert_clip(degrain, smhdegrain(out[5933:5992], 2, 200), 5933) degrain = insert_clip(degrain, smhdegrain(out[6115:6180], 2, 200), 6115) degrain = insert_clip(degrain, smhdegrain(out[6180:6281], 2, 200), 6180) degrain = insert_clip(degrain, smhdegrain(out[39303:39482], 2, 280), 39303) degrain = insert_clip(degrain, smhdegrain(out[40391:40837], 2, 200), 40391) degrain = insert_clip(degrain, smhdegrain(out[40908:41087], 2, 280), 40908) degrain = insert_clip(degrain, smhdegrain(out[41671:41791], 2, 280), 41671) degrain = insert_clip(degrain, smhdegrain(out[41791:41977], 2, 280), 41791) degrain = insert_clip(degrain, smhdegrain(out[41977:42073], 2, 280), 41977) degrain = insert_clip(degrain, smhdegrain(out[43083:44462], 2, 350), 43083) degrain = lvf.rfs(degrain, out, [(51749, 52387)]) out = depth(degrain, 32) luma = get_y(out) line_mask = vdf.edge_detect(luma, 'kirsch', 0.075, (1, 1)).std.Median().std.Inflate() descale = core.descale.Debilinear(luma, w, h) upscale = eedi3_upscale(descale) antialias = single_rate_antialiasing(upscale, 13, alpha=0.2, beta=0.6, gamma=300, mdis=15).resize.Bicubic( src.width, src.height) rescale = core.std.MaskedMerge(luma, antialias, line_mask) merged = vdf.merge_chroma(rescale, out) out = depth(merged, 16) y = get_y(out) detail_light_mask = lvf.denoise.detail_mask(y.std.Median(), brz_a=2500, brz_b=1200) pf = out.std.Convolution([1] * 9).std.Merge(out, 0.45) diffdb = core.std.MakeDiff(out, pf) deband = dumb3kdb(pf, 16, 30) deband_b = dbs.f3kbilateral(pf, 20, 100) deband = lvf.rfs(deband, deband_b, [(43083, 44461)]) deband = core.std.MergeDiff(deband, diffdb) deband = core.std.MaskedMerge(deband, out, detail_light_mask) deband = lvf.rfs(deband, out, [(51749, 52387)]) out = deband sharp = hvf.LSFmod(out, strength=65, Smode=3, Lmode=1, edgemode=1, edgemaskHQ=True) out = sharp ref = get_y(out).std.PlaneStats() adgmask_a = core.adg.Mask(ref, 30) adgmask_b = core.adg.Mask(ref, 12) stgrain = sizedgrn(out, 0.1, 0.05, 1.00) stgrain = core.std.MaskedMerge(out, stgrain, adgmask_b) stgrain = core.std.MaskedMerge(out, stgrain, adgmask_a.std.Invert()) dygrain = sizedgrn(out, 0.2, 0.05, 1.05, sharp=60, static=False) dygrain = core.std.MaskedMerge(out, dygrain, adgmask_a) grain = core.std.MergeDiff(dygrain, out.std.MakeDiff(stgrain)) out = grain ref = src rescale_mask = vdf.drm(ref, h, mthr=65, sw=4, sh=4) credit = out credit = lvf.rfs(credit, core.std.MaskedMerge(credit, ref, rescale_mask, 0), [(0, 2956), (43104, 45749)]) credit = lvf.rfs(credit, ref, [(45824, 50401), (52388, src.num_frames - 1)]) out = credit return depth(out, 10)
def do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut src = depth(src, 16) out = src # Remove the noise ref = hvf.SMDegrain(out, tr=1, thSAD=300, plane=4) denoise = mvf.BM3D(out, sigma=[2, 1], radius1=1, ref=ref) out = denoise # Limited antialiasing y = get_y(out) lineart = core.std.Sobel(y).std.Binarize( 75 << 8).std.Maximum().std.Inflate() aa = lvf.sraa(y, 2, 13, downscaler=partial(core.resize.Bicubic, filter_param_a=-0.5, filter_param_b=0.25)) sharp = hvf.LSFmod(aa, strength=70, Smode=3, edgemode=0, source=y) y = core.std.MaskedMerge(y, sharp, lineart) out = vdf.merge_chroma(y, out) # Deband masks planes = split(out) preden = core.dfttest.DFTTest(out, sigma=14.0, sigma2=10.0, sbsize=1, sosize=0, planes=[0, 1, 2]).rgvs.RemoveGrain(3) grad_mask, yrangebig = morpho_mask(preden) rgb = core.resize.Bicubic(preden, 960, 540, format=vs.RGB48).std.SetFrameProp('_Matrix', delete=True) chroma_masks = [ core.std.Prewitt(p).std.Binarize(5500).rgvs.RemoveGrain(11) for p in split(rgb) + split(preden)[1:] ] chroma_mask = core.std.Expr(chroma_masks, 'x y + z + a + b +').std.Maximum() chroma_mask = core.std.Merge(chroma_mask, chroma_mask.std.Minimum()).std.BoxBlur( 0, 1, 1, 1, 1) detail_mask = lvf.denoise.detail_mask(planes[0].std.BoxBlur(0, 1, 1, 1, 1), brz_a=3300, brz_b=2000) # Debanding stages debands = [None] * 3 deband_y_strong = dbs.f3kbilateral(planes[0], 16, 65) deband_y_normal = dumb3kdb(planes[0], 16, 41) deband_y_light = core.std.MaskedMerge(dumb3kdb(planes[0], 14, 32), planes[0], detail_mask) debands[1] = dbs.f3kbilateral(planes[1], 12, 50) debands[2] = dbs.f3kbilateral(planes[2], 12, 50) debands[0] = core.std.MaskedMerge(deband_y_strong, deband_y_normal, grad_mask) debands[0] = core.std.MaskedMerge(debands[0], deband_y_light, yrangebig) debands[1], debands[2] = [ core.std.MaskedMerge(debands[i], planes[i], chroma_mask) for i in range(1, 3) ] deband = join(debands) out = deband # Regraining ref = get_y(out).std.PlaneStats() adgmask_a = core.adg.Mask(ref, 25) adgmask_b = core.adg.Mask(ref, 10) stgrain_a = core.grain.Add(out, 0.1, 0, seed=333) stgrain_a = core.std.MaskedMerge(out, stgrain_a, adgmask_b.std.Invert()) stgrain_b = sizedgrn(out, 0.2, 0.1, 1.15, sharp=80, seed=333) stgrain_b = core.std.MaskedMerge(out, stgrain_b, adgmask_b) stgrain_b = core.std.MaskedMerge(out, stgrain_b, adgmask_a.std.Invert()) stgrain = core.std.MergeDiff(stgrain_b, out.std.MakeDiff(stgrain_a)) dygrain = sizedgrn(out, 0.3, 0.1, 1.25, sharp=80, static=False, seed=333) dygrain = core.std.MaskedMerge(out, dygrain, adgmask_a) grain = core.std.MergeDiff(dygrain, out.std.MakeDiff(stgrain)) out = grain return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2], [0, 1, 2])