def regrain(clip: vs.VideoNode) -> vs.VideoNode: sgrain: vs.VideoNode = kgf.adaptive_grain(clip, 0.15, luma_scaling=10) dgrain: vs.VideoNode = kgf.adaptive_grain(clip, 0.1, luma_scaling=25, static=False) grain = dgrain.std.MergeDiff(clip.std.MakeDiff(sgrain)) return grain
def ED(ed_in: vs.VideoNode) -> vs.VideoNode: src = ed_in # Rescale using a modified version of Zastin's dogahomo() rescale = rvs.questionable_rescale(vsutil.depth(src, 16), 810, b=1/3, c=1/3, mask_thresh=0.05) # Detail- and linemasking for denoising det_mask = lvf.mask.detail_mask(rescale, brz_a=0.25, brz_b=0.15) denoise_ya = core.knlm.KNLMeansCL(rescale, d=2, a=3, s=3, h=1.2, channels="Y") denoise_ca = core.knlm.KNLMeansCL(rescale, d=2, a=2, s=3, h=1.0, channels="UV") denoise_a = core.std.ShufflePlanes([denoise_ya,denoise_ca,denoise_ca], [0,1,2], colorfamily=vs.YUV) denoise_b = mvf.BM3D(rescale, sigma=[1.9], ref=denoise_a, profile1="fast", radius1=3) # BM3D left some gunk in chroma, most noticeably around hard contrast edges denoise = core.std.ShufflePlanes([denoise_b,denoise_a,denoise_a], [0,1,2], colorfamily=vs.YUV) denoise = core.std.MaskedMerge(denoise, rescale, det_mask) # Thanks for handling the effort of AA for me, Light aa = lvf.aa.nneedi3_clamp(denoise, strength=1.25, mthr=0.25) # Dehaloing it dehalom = rvs.dehalo_mask(aa, iter_out=3) dehalo_a = haf.DeHalo_alpha(aa, darkstr=0.9, brightstr=1.1) dehalo_a = vsutil.depth(dehalo_a, 16) dehalo = core.std.MaskedMerge(aa, dehalo_a, dehalom) # Generate a new detail mask and deband it, putting back fine detail the way it was det_mask = lvf.mask.detail_mask(dehalo, rad=2, radc=1, brz_a=0.05, brz_b=0.09) y,u,v = vsutil.split(dehalo) deband_a = vsutil.join([pdb(y, threshold=3.0, grain=6.5), pdb(u, threshold=3.0, grain=2.0), pdb(v, threshold=3.0, grain=2.0)]) deband = core.std.MaskedMerge(deband_a, dehalo, det_mask) # Finish up and output grain = kgf.adaptive_grain(deband, strength=0.65, luma_scaling=5) out = vsutil.depth(grain, 10) return out
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 luma = get_y(out) antialias = vdf.nnedi3_upscale(luma, correct_shift=False, pscrn=4) \ .resize.Bicubic(src.width, src.height, src_left=.5, src_top=.5, filter_param_a=0, filter_param_b=1/2) out = vdf.merge_chroma(antialias, out) 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 grain = kgf.adaptive_grain(out, 0.2, luma_scaling=14) out = grain return depth(out, 10)
def do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut src = depth(src, 16) src = core.std.FreezeFrames(src, 45219, 45219, 45219 - 1) adg_mask = core.adg.Mask(src.std.PlaneStats(), 20) denoise_a = CoolDegrain(src, tr=1, thsad=48, blksize=8, overlap=4, plane=4) denoise_b = CoolDegrain(src, tr=1, thsad=24, blksize=8, overlap=4, plane=4) denoise = core.std.MaskedMerge(denoise_a, denoise_b, adg_mask) denoise = vdf.merge_chroma(denoise, denoise_a) out = denoise deband_mask = lvf.denoise.detail_mask(out.std.Median(), brz_a=3000, brz_b=1500) deband = dbs.f3kpf(out, 20, 24, 30) deband = core.std.MaskedMerge(deband, out, deband_mask) out = deband grain = kgf.adaptive_grain(out, 0.1, luma_scaling=16) out = grain return depth(out, 10)
def _dbgra(clip: vs.VideoNode) -> vs.VideoNode: clip = depth(clip, 16) clip = hvf.SMDegrain(clip, tr=1, thSAD=200) clip = vdf.deband.dumb3kdb(clip, threshold=45) clip = core.std.Expr(clip, ['x 64 -', 'x 32 +', 'x 32 +']) clip = kgf.adaptive_grain(clip, 0.4) return clip
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 general_filtering(clip: vs.VideoNode, mode='low', denoise=True, deband=True, grain=True): """ Generic filterchain. You can set the overall strenght by changing the mode. Modes: - lower - low - medium - high - higher """ # There's probably way nicer ways to do this modes = { 'lower': (0.1, 2, 10, 16, 0.1), 'low': (0.4, 3, 14, 24, 0.2), 'medium': (0.6, 4, 16, 32, 0.3), 'high': (1.0, 6, 18, 40, 0.8), 'higher': (2.0, 10, 23, 64, 2.0) } try: h, sigma, range, y, grain_strength = modes[mode] except KeyError: raise ValueError("general_filtering: Unknown mode!") filtered = clip if denoise: filtered = lvf.quick_denoise(filtered, h=h, sigma=sigma) if deband: cb = cr = y - 8 filtered = core.f3kdb.Deband(filtered, range=range, y=y, cb=cb, cr=cr, grainy=0, grainc=0, output_depth=16) if grain: filtered = kgf.adaptive_grain(filtered, strength=grain_strength) return filtered
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) src = JPBD.src_cut src = depth(src, 16) denoise = CoolDegrain(src, tr=2, thsad=48, blksize=8, overlap=4, plane=4) antialias = _nneedi3_clamp(denoise) predenoise = mClean(antialias, thSAD=200, chroma=False) detail_mask = lvf.denoise.detail_mask(predenoise, rad=2, radc=2, brz_a=3250, brz_b=1250) 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 = core.neo_f3kdb.Deband(antialias, 17, 42, 42, 42, 12, 0, sample_mode=4, keep_tv_range=True) deband = core.std.MaskedMerge(deband, antialias, line_mask) grain = kgf.adaptive_grain(deband, 0.25, luma_scaling=10) final = core.resize.Bicubic(grain, format=vs.YUV420P10, dither_type='error_diffusion') final = core.std.Limiter(final, 16, [235 << 2, 240 << 2]) return depth(final, 10)
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 radius = 2 clip_in = depth(out, 32) y, u, v = split(clip_in) y_m = core.resize.Bicubic(y, 960, 540, src_left=-.5, filter_param_a=1 / 3, filter_param_b=1 / 3) def demangle(clip): return core.resize.Bicubic(clip, 1920, 1080, src_left=.5) y_m, u, v = map(demangle, (y_m, u, v)) y_fixup = core.std.MakeDiff(y, y_m) yu, yv = Regress(y_m, u, v, radius=radius) 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) scaled = depth(join([y, u_r, v_r]), 16) out = scaled 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 grain = kgf.adaptive_grain(out, 0.2, luma_scaling=14) out = grain return depth(out, 10)
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 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 = vdf.merge_chroma(upscale, out) deband_mask = lvf.denoise.detail_mask(out, brz_a=2000, brz_b=1000) deband = dbs.f3kpf(out, 17, 30, 30) 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 return depth(out, 10)
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=6, top=20, right=0, bottom=6) 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') endcard = lvf.util.quick_resample( endcard, lambda c: core.neo_f3kdb.Deband(c, 15, 36, 36, 36, 24, 24, 4)) return Tweak(endcard, sat=1.2, bright=-0.05, cont=1.2) src = JPBD.src_cut src = depth(src, 16) edstart = 31769 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) downscaler = lambda c, w, h: core.fmtc.resample( c, w, h, kernel='gauss', invks=True, invkstaps=1, taps=1, a1=32) antialias_b = rekt_fast( denoise, lambda c: lvf.sraa(c, 1.45, rep=13, downscaler=downscaler), top=482) antialias = lvf.rfs(antialias_a, antialias_b, [(8185, 8280)]) predenoise = mClean(antialias, thSAD=200, chroma=False) detail_mask = lvf.denoise.detail_mask(predenoise, rad=2, radc=2, brz_a=3250, brz_b=1250) 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 = lvf.rfs(deband_a, deband_b, [(edstart + 1870, edstart + 1900)]) deband = lvf.rfs(deband, deband_b, [(13611, 13661), (20022, 20057)]) grain = kgf.adaptive_grain(deband, 0.25, luma_scaling=10) endcard = _perform_endcard( '[BDMV][200610][Magia Record][Vol.3]/Scans/endcard6_front_descreen.png', src) endcard_length = 119 final = core.std.Splice([grain, 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 finalize(clip: vs.VideoNode) -> vs.VideoNode: final = adaptive_grain(clip, 0.3) final = final.fmtc.bitdepth(bits=10, dmode=3) return final
def do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut src = depth(src, 16) h = 882 w = get_w(h) kernel = 'lanczos' taps = 5 opstart, opend = 1918, 4076 edstart, edend = 31768, 33925 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 import G41Fun as gf from vsTAAmbk import TAAmbk dehalo = gf.MaskedDHA(out, rx=2.8, ry=2.8, darkstr=0.4, brightstr=1.4, maskpull=48, maskpush=140) aaa = TAAmbk(dehalo, 'Eedi3SangNom', cycle=4, mtype=0) aaa = lvf.rfs(out, aaa, [(16052, 16105)]) out = aaa 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 = lvf.rfs(antialias, vdf.merge_chroma(upscale, denoise), [(edstart, edend)]) deband_mask = lvf.denoise.detail_mask(out, brz_a=2000, brz_b=1000) deband = dbs.f3kpf(out, 17, 36, 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) creditless_mask = core.std.Expr([ vdf.dcm(src, src[opstart:opend + 1], JPBD_NCOP.src_cut[:opend - opstart + 1], opstart, opend, 2, 2).std.Deflate(), vdf.dcm(src, src[edstart:edend + 1], JPBD_NCED.src_cut[:edend - edstart + 1], edstart, edend, 2, 2).std.Deflate() ], 'x y +') credit = out credit = lvf.rfs(credit, core.std.MaskedMerge(credit, src, rescale_mask, 0), [(opstart + 425, opstart + 698), (33972, src.num_frames - 1), (21962, 22009)]) credit = lvf.rfs(credit, core.std.MaskedMerge(credit, src, creditless_mask, 0), [(opstart, opend), (edstart, edend)]) credit = lvf.rfs(credit, src, [(5057, 5104), (12371, 12418)]) 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 opstart, opend = 936, 3092 edstart, edend = 31769, 33926 clip_in = depth(src, 32) dedimm = gf.Tweak(clip_in, sat=1.65, cont=1.65) dedimm = vdf.fade_filter(clip_in, clip_in, dedimm, 26133, 26183) out = depth(dedimm, 16) denoise = CoolDegrain(out, 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 = lvf.rfs(antialias, vdf.merge_chroma(upscale, denoise), [(edstart, edend)]) deband_mask = lvf.denoise.detail_mask(out, brz_a=2000, brz_b=1000) deband = dbs.f3kpf(out, 17, 30, 30) 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) creditless_mask = core.std.Expr([ vdf.dcm(src, src[opstart:opend + 1], JPBD_NCOP.src_cut[:opend - opstart + 1], opstart, opend, 2, 2).std.Deflate(), vdf.dcm(src, src[edstart:edend + 1], JPBD_NCED.src_cut[:edend - edstart + 1], edstart, edend, 2, 2).std.Deflate() ], 'x y +') credit = out credit = lvf.rfs(credit, core.std.MaskedMerge(credit, src, rescale_mask, 0), [(opstart + 425, opstart + 698), (33973, src.num_frames - 1)]) credit = lvf.rfs(credit, core.std.MaskedMerge(credit, src, creditless_mask, 0), [(opstart, opend), (edstart, edend)]) credit = lvf.rfs(credit, src, [(16911, 16970), (24486, 24533)]) out = credit return depth(out, 10)
def do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut src = depth(src, 16) out = src edstart, edend = 31888, src.num_frames-1 shift = core.resize.Point(out, src_left=1).edgefixer.ContinuityFixer([2, 1, 1], 0, 0, 0) out = lvf.rfs(out, shift, [(235, 318)]) ref = hvf.SMDegrain(out, tr=1, thSAD=300, plane=4) denoise = mvf.BM3D(out, [1.5, 1], 1, profile1='lc', ref=ref) out = denoise y = get_y(out) lineart = vdf.edge_detect(y, 'FDOG', scale_value(0.065, 32, 16), (1, 1)).std.Median().std.BoxBlur(0, 1, 1, 1, 1) rescale = fake_rescale(y, 837.5, 1/3, 1/3, coef_dering=0.1, coef_dark=1.25, coef_warp=1.15, coef_sharp=0.75, coef_finalsharp=0.85) rescale = core.std.MaskedMerge(y, rescale, lineart) out = vdf.merge_chroma(rescale, out) preden = core.dfttest.DFTTest(get_y(out), ftype=0, sigma=0.5, sbsize=16, sosize=12, tbsize=1) detail_dark_mask = detail_dark_mask_func(preden, brz_a=6000, brz_b=5000) detail_light_mask = lvf.denoise.detail_mask(preden, 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([preden, detail_mask_grow, detail_mask], f'x {40<<8} < y z ?') pf = vdf.merge_chroma(preden, out) deband = dumb3kdb(pf, 17, 40) deband_b = dumb3kdb(pf, 20, 80) deband = lvf.rfs(deband, deband_b, [(2194, 2216), (2283, 2306)]) deband = core.std.MergeDiff(deband, out.std.MakeDiff(pf)) deband = core.std.MaskedMerge(deband, out, detail_light_mask) out = deband grain = kgf.adaptive_grain(out, 0.35) out = grain ref = depth(src, 16) src_c, src_nced = [depth(x, 16) for x in [src, JPBD_NCED.src_cut[13:]]] ending_mask = vdf.dcm(out, src_c[edstart:edend+1], src_nced[:edend-edstart+1], edstart, edend, 2, 2).std.BoxBlur(0, 2, 2, 2, 2) credit = out credit = lvf.rfs(credit, core.std.MaskedMerge(credit, ref, ending_mask), [(31900, src.num_frames-1)]) out = credit return depth(out, 10).std.Limiter(16<<2, [235<<2, 240<<2], [0, 1, 2])
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=4, top=12, right=0, bottom=21) 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') endcard = lvf.util.quick_resample( endcard, lambda c: core.neo_f3kdb.Deband(c, 15, 36, 36, 36, 24, 24, 4)) return Tweak(endcard, sat=1.2, bright=-0.05, cont=1.2) def to_gray(clip: vs.VideoNode, ref: vs.VideoNode) -> vs.VideoNode: clip = core.std.AssumeFPS(clip, ref) return core.resize.Point(clip, format=vs.GRAY16, matrix_s=mvf.GetMatrix(ref)) src = JPBD.src_cut src = depth(src, 16) edstart = 30618 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 = TAAmbk(denoise, aatype='Eedi3', mtype=1) antialias = lvf.rfs(antialias_a, antialias_b, [(9478, 9501)]) predenoise = mClean(antialias, thSAD=200, chroma=False) detail_mask = lvf.denoise.detail_mask(predenoise, rad=2, radc=2, brz_a=3250, brz_b=1250) 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_c = core.neo_f3kdb.Deband(deband_a, 20, 64, 64, 64, 24, 0, sample_mode=2, keep_tv_range=True) deband = lvf.rfs(deband_a, deband_b, [(edstart + 1870, edstart + 1900)]) deband = lvf.rfs( deband, core.std.MaskedMerge( deband_c, deband_a, to_gray(lvf.src('masks/magia_07_mask_01.png'), src)), [(6729, 6865)]) grain = kgf.adaptive_grain(deband, 0.25, luma_scaling=10) borders = vdf.region_mask(grain, 240, 240, 0, 0) borders = lvf.rfs(grain, borders, [(25623, 25670)]) endcard = _perform_endcard( '[BDMV][200610][Magia Record][Vol.3]/Scans/endcard7_front_descreen.png', src) endcard_length = 119 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 masked_f3kdb(clip: vs.VideoNode, mask: Optional[vs.VideoNode] = None, range: int = 15, y: int = 40, cb: Optional[int] = None, cr: Optional[int] = None, grainy: int = 0, grainc: int = 0, agrain: int = 0, luma_scaling: int = 12, sample_mode: int = 2, keep_tv_range: bool = True, output_depth: Optional[int] = None) -> vs.VideoNode: """Wrapper function for neo_f3kdb. Additional changes include sane defaults, the ability to merge with an external mask clip, and additionally add kagefunc's adaptive_grain to the final, debanded clip. grainy, grainc, and adaptive_grain are applied to the final, post-merged clip. Differing default behavior: - y defaults to 40 and cr/cb default to y//2. - output_depth defaults to the source bit depth. - grainy and grainc default to 0. - grain is always static. - keep_tv_range defaults to True (since typical sources are TV range). Args: Most f3kdb arguments: https://f3kdb.readthedocs.io/en/latest/index.html mask: Mask clip to use for merging with debanded clip. agrain: The strength arg for adaptive_grain. luma_scaling: The luma_scaling arg for adaptive_grain. """ name = 'masked_f3kdb' if not isinstance(clip, vs.VideoNode): raise TypeError(name + ": 'clip' must be a clip") if mask is not None and not isinstance(mask, vs.VideoNode): raise TypeError(name + ": 'mask' must be a clip") src_bits = clip.format.bits_per_sample if cb is None: cb = y // 2 if cr is None: cr = y // 2 if output_depth is None: output_depth = src_bits if mask is not None and mask.format.bits_per_sample != src_bits: mask = fvf.Depth(mask, src_bits, dither_type='none') debanded = core.neo_f3kdb.Deband(clip, range=range, y=y, cb=cb, cr=cr, grainy=0, grainc=0, sample_mode=sample_mode, keep_tv_range=keep_tv_range, output_depth=src_bits) if mask is not None: debanded = core.std.MaskedMerge(debanded, clip, mask) if grainy > 0 or grainc > 0: debanded = core.neo_f3kdb.Deband(debanded, range=0, y=0, cb=0, cr=0, grainy=grainy, grainc=grainc, sample_mode=sample_mode, keep_tv_range=keep_tv_range, output_depth=src_bits) if agrain > 0: debanded = kgf.adaptive_grain(debanded, strength=agrain, luma_scaling=luma_scaling) return fvf.Depth(debanded, output_depth)
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 _fsrcnnx(clip: vs.VideoNode, width: int, height: int) -> vs.VideoNode: blank = core.std.BlankClip(clip, format=vs.GRAY16, color=128 << 8) clip = join([clip, blank, blank]) clip = core.placebo.Shader(clip, 'FSRCNNX_x2_56-16-4-1.glsl', clip.width * 2, clip.height * 2) return core.resize.Spline36(get_y(clip), width, height) src = SRC_CUT fe = lvf.ef(src, [1, 1, 1]) fe = depth(fe, 16) h = 864 w = get_w(864) b, c = 0, 1 / 2 luma = get_y(fe) descale = core.descale.Debicubic(depth(luma, 32), w, h, b, c) descale = depth(descale, 16) rescale_a = nnedi3_rpow2(descale, 2, src.width, src.height, nns=4, qual=2, pscrn=2) rescale_b = _fsrcnnx(descale, src.width, src.height) rescale = core.std.Merge(rescale_a, rescale_b, 0.75) rescale_mask = vrf.drm(fe, 864, b=b, c=c, mthr=80, sw=4, sh=4) rescale = core.std.MaskedMerge(rescale, luma, rescale_mask) rescale = lvf.rfs(rescale, luma, [(OPSTART + 483, OPSTART + 721), (OPSTART + 822, OPSTART + 1083)]) merge = core.std.ShufflePlanes([rescale, fe], [0, 1, 2], vs.YUV) antialias = join([lvf.sraa(plane) for plane in split(merge)]) antialias = lvf.rfs(merge, antialias, [(2836, 2870)]) denoise = core.knlm.KNLMeansCL(antialias, a=2, h=0.65, d=0, device_type='gpu', channels='UV') preden = CoolDegrain(denoise, tr=2, thsad=60, blksize=8, overlap=4, plane=4) diff = core.std.MakeDiff(denoise, preden) deband_mask = lvf.denoise.detail_mask(preden, brz_a=3000, brz_b=1500) deband_a = dbs.f3kpf(preden, 17, 42, 42) deband_b = core.placebo.Deband(preden, radius=17, threshold=6, iterations=1, grain=0, planes=1 | 2 | 4) deband = lvf.rfs(deband_a, deband_b, [(2081, 2216), (2450, 2550), (3418, 3452), (3926, 3926)]) deband = core.std.MaskedMerge(deband, preden, deband_mask) deband = core.std.MergeDiff(deband, diff) grain = kgf.adaptive_grain(deband, 0.25, luma_scaling=8) final = depth(grain, 10) return final
import fvsfunc as fvf import kagefunc as kgf import lvsfunc #from acsuite import eztrim ep1 = core.ffms2.Source("Sukeban.Deka.S01.480p.AMZN.WEB-DL.DDP2.0.H.264-ARiN/Sukeban.Deka.S01E01.480p.AMZN.WEB-DL.DDP2.0.H.264-ARiN.mkv") #eztrim(ep1, [(24,36876)], 'Sukeban.Deka.S01E01.480p.AMZN.WEB-DL.DDP2.0.H.264-ARiN.track_2.ac3') ep1 = ep1[24:36876] ep1 = havsfunc.Deblock_QED(ep1) ep1 = awf.bbmod(ep1, left=3, thresh=5, blur=4) ep1 = core.fb.FillBorders(ep1, right=2) ep1 = rektlvls(ep1, colnum=[2,638], colval=[-20,-17]) ep1 = awf.bbmod(ep1, right=4, thresh=40, blur=40) ep1 = core.resize.Bicubic(ep1, src_left=-1) ep1 = rektlvls(ep1, colnum=[0,4,5], colval=[-40,-30,-10]) ep1 = rektlvls(ep1, colnum=[0,1,3,4,5], colval=[20,-10,20,30,10]) ep1 = awf.bbmod(ep1, right=6, thresh=10, blur=10) ep1 = awf.bbmod(ep1, left=7, thresh=10, blur=90) ep1 = lvsfunc.misc.fix_cr_tint(ep1) ep1 = fvf.GradFun3(ep1, thr=0.35, radius=12, elast=8.0, mode=3, ampo=1, ampn=0, pat=32, dyn=False, staticnoise=False, thr_det=2 + round(max(1 - 0.35, 0) / 0.3), debug=False, thrc=1, radiusc=12, planes=list(range(ep1.format.num_planes)), ref=ep1, bits=ep1.format.bits_per_sample) ep1 = kgf.adaptive_grain(ep1, strength=.25, static=True, luma_scaling=12, show_mask=False) ep1 = havsfunc.FineDehalo(ep1) ep1.set_output(0)
def do_filter(): """Vapoursynth filtering""" def _sraa(clip: vs.VideoNode, nnargs: dict, eeargs: dict) -> vs.VideoNode: def _nnedi3(clip): return clip.nnedi3.nnedi3(0, False, **nnargs) def _eedi3(clip, sclip): return clip.eedi3m.EEDI3(0, False, **eeargs, sclip=sclip) clip = _eedi3(clip, _nnedi3(clip)).std.Transpose() clip = _eedi3(clip, _nnedi3(clip)).std.Transpose() return clip def _nnedi3(clip: vs.VideoNode, factor: float, args: dict) -> vs.VideoNode: upscale = clip.std.Transpose().nnedi3.nnedi3(0, True, **args) \ .std.Transpose().nnedi3.nnedi3(0, True, **args) return core.resize.Spline36(upscale, clip.width * factor, clip.height * factor, src_top=.5, src_left=.5) def area_resize(clip: vs.VideoNode, width: int, height: int) -> vs.VideoNode: blank = core.std.BlankClip(clip, format=vs.GRAY16, color=128 << 8) clip = join([clip, blank, blank]) clip = core.area.AreaResize(clip, width, height) return get_y(clip) src = JPBD.src_cut src = depth(src, 16) flashback = [(31665, 31987), (68524, 68569)] denoise = CoolDegrain(src, tr=1, thsad=48, blksize=8, overlap=4, plane=4) denoise = lvf.rfs(denoise, src, flashback) dering = hvf.EdgeCleaner(denoise, 10, rmode=3, smode=1, hot=True) luma = get_y(dering) line_mask = TAAmbk(luma, mtype=2, showmask=1).std.Inflate() upscale = _nnedi3(luma, 2, dict(nsize=4, nns=4, qual=2, pscrn=2)) sraa = _sraa(upscale, dict(nsize=0, nns=3, qual=1, pscrn=1), dict(alpha=0.2, beta=0.5, gamma=40, nrad=3, mdis=20)) sraa = core.rgvs.Repair(sraa, upscale, 13) antialias = area_resize(sraa, src.width, src.height) antialias = lvf.rfs(core.std.MaskedMerge(luma, antialias, line_mask), antialias, [(22503, 22789)]) antialias_merged = vdf.merge_chroma(antialias, denoise) deband_mask_a = lvf.denoise.detail_mask(antialias_merged, brz_a=3000, brz_b=1200) deband_mask_b = kgf.retinex_edgemask(antialias_merged) deband_mask = core.std.Expr([deband_mask_a, deband_mask_b], 'x y +') deband = dbs.f3kpf(antialias_merged, 18, 30, 30) deband = core.std.MaskedMerge(deband, antialias_merged, deband_mask) deband = hvf.ContraSharpening(deband, antialias_merged) deband = lvf.rfs(deband, antialias_merged, flashback) grain = core.neo_f3kdb.Deband(deband, preset='depth', grainy=24) grain_a = kgf.adaptive_grain(grain) grain_b = core.grain.Add(grain, 1, 0, constant=True) grain = lvf.rfs(grain_a, grain_b, flashback) mask_borders = core.std.BlankClip(grain, format=vs.GRAY16, color=(256 << 8) - 1) mask_borders = vdf.region_mask(mask_borders, 0, 0, 132, 132).std.Invert() final = lvf.rfs(grain, core.std.MaskedMerge(grain, src, mask_borders), flashback + [(65388, 65413), (113621, 113763)]) smooth = xvs.mvfrc(src[146178:src.num_frames], preset='slow') vfr = muvf.VFRSplice([final[:146178], smooth], 'sora_timecode.txt') return depth(vfr, 10)
def do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut src = depth(src, 32) src += src[-1] src = core.std.FreezeFrames(src, 3130, 3153, 3129) black = src.std.BlankClip().grain.Add(0.2) src = vdf.fade_filter(src, src, black, 3130, 3154) src = depth(src, 16) h = 882 w = get_w(h) kernel = 'lanczos' taps = 5 opstart, opend = 264, 2421 edstart, edend = 31767, 33924 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 = lvf.rfs(antialias, vdf.merge_chroma(upscale, denoise), [(edstart, edend)]) deband_mask = lvf.denoise.detail_mask(out, brz_a=2000, brz_b=1000) deband = dbs.f3kpf(out, 17, 36, 36) deband_b = dbs.f3kpf(out, 17, 56, 56) deband = lvf.rfs(deband, out, [(3149, 3153)]) deband = lvf.rfs(deband, deband_b, [(30213, 30422)]) 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) creditless_mask = core.std.Expr([ vdf.dcm(src, src[opstart:opend+1], JPBD_NCOP.src_cut[:opend-opstart+1], opstart, opend, 2, 2).std.Deflate(), vdf.dcm(src, src[edstart:edend+1], JPBD_NCED.src_cut[:edend-edstart+1], edstart, edend, 2, 2).std.Deflate()], 'x y +') credit = out credit = lvf.rfs(credit, core.std.MaskedMerge(credit, src, rescale_mask, 0), [(opstart+425, opstart+698), (33971, src.num_frames-1)]) credit = lvf.rfs(credit, core.std.MaskedMerge(credit, src, creditless_mask, 0), [(opstart, opend), (edstart, edend)]) credit = lvf.rfs(credit, src, [(7670, 7717), (20824, 20871), (26581, 26628)]) out = credit return depth(out, 10)
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=10, top=17, right=17, 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) denoise = CoolDegrain(src, tr=2, thsad=48, blksize=8, overlap=4, plane=4) antialias_a = _nneedi3_clamp(denoise) antialias_b = lvf.sraa(denoise, rep=6) antialias = lvf.rfs(antialias_a, antialias_b, [(29453, 29476), (29510, 29532), (29640, 29663), (29775, 29798), (29866, 29889), (30011, 30034)]) predenoise = mClean(antialias, thSAD=200, chroma=False) detail_mask = lvf.denoise.detail_mask(predenoise, rad=2, radc=2, brz_a=3250, brz_b=1250) 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 = core.neo_f3kdb.Deband(antialias, 17, 42, 42, 42, 12, 0, sample_mode=4, keep_tv_range=True) deband = core.std.MaskedMerge(deband, antialias, line_mask) grain_a = kgf.adaptive_grain(deband, 0.25, luma_scaling=10) grain_b = adptvgrnMod(deband, 2, size=2, luma_scaling=2, static=False, grain_chroma=False) grain = lvf.rfs(grain_a, grain_b, [(5149, 5598), (8691, 10137)]) borders_mask = vdf.region_mask( src.std.BlankClip(format=vs.GRAY16, color=(256 << 8) - 1), 240 + 2, 240 + 2, 0, 0) borders = core.std.MaskedMerge(src, grain, borders_mask) borders = lvf.rfs(grain, borders, [(5149, 5598)]) endcard = _perform_endcard( '[BDMV][200304][Magia Record][Vol.1]/Scans/endcard1_front_descreen.png', src) endcard_length = 119 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 test_adaptive_grain(self): grained = kgf.adaptive_grain(self.BLACK_SAMPLE_CLIP) self.assert_same_metadata(grained, self.BLACK_SAMPLE_CLIP) grained.get_frame(0)
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=7, top=0, right=11, bottom=22) endcard = core.resize.Bicubic(endcard, ref.width, ref.height, vs.RGBS, dither_type='error_diffusion') endcard = core.w2xc.Waifu2x(endcard, noise=3, scale=1, photo=True) endcard = core.resize.Bicubic(endcard, format=vs.YUV444PS, matrix_s='709', dither_type='error_diffusion') endcard = lvf.util.quick_resample(endcard, lambda c: core.neo_f3kdb.Deband(c, 15, 36, 36, 36, 24, 24, 4)) return Tweak(endcard, sat=1.4, cont=1.2) def _perform_motion_mask(clip: vs.VideoNode, brz: int)-> vs.VideoNode: clip = depth(clip, 8) sup = core.hqdn3d.Hqdn3d(clip).neo_fft3d.FFT3D().mv.Super(sharp=1) fv1 = core.mv.Analyse(sup, isb=False, delta=1, truemotion=False, dct=2) fv2 = core.mv.Analyse(sup, isb=True, delta=1, truemotion=True, dct=2) momask1 = core.mv.Mask(clip, fv1, ml=2, kind=1) momask2 = core.mv.Mask(clip, fv2, ml=3, kind=1) momask = core.std.Merge(momask1, momask2).rgvs.RemoveGrain(3).std.Binarize(brz) momask = momask.std.Minimum().std.Minimum() return depth(get_y(momask), 16) src = JPBD.src_cut src = depth(src, 16) denoise_a = CoolDegrain(src, tr=2, thsad=48, blksize=8, overlap=4, plane=4) denoise = denoise_a antialias = _nneedi3_clamp(denoise) antialias_a = TAAmbk(antialias, aatype='Eedi3', cycle=3) antialias_b = lvf.sraa(denoise, 2, 13) motion_mask = _perform_motion_mask(denoise[16914:17001], 140).std.FreezeFrames([0, 18, 57], [2, 38, 86], [2, 38, 57]) motion_mask = insert_clip(src.std.BlankClip(format=vs.GRAY16), motion_mask, 16914) antialias = lvf.rfs(antialias, core.std.MaskedMerge(antialias_a, antialias, motion_mask), [(16914, 17000)]) antialias = lvf.rfs(antialias, antialias_b, [(18084, 18179)]) predenoise = mClean(antialias, thSAD=200, chroma=False) detail_mask = lvf.denoise.detail_mask(predenoise, rad=2, radc=2, brz_a=3250, brz_b=1250) 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 = deband_a grain = kgf.adaptive_grain(deband, 0.25, luma_scaling=10) ending = lvf.rfs(grain, src, [(32079, 33098)]) endcard = _perform_endcard(r'[BDMV][200902][Magia Record][Vol.5]\Scans\endcard13_front_descreen.png', src) endcard_length = 119 final = core.std.Splice([ending, 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 adptvgrnMod(clip_in: vs.VideoNode, strength=0.25, cstrength=None, size=1, sharp=50, static=False, luma_scaling=12, grain_chroma=True, grainer=None, fade_edges=True, tv_range=True, lo=None, hi=None, protect_neutral=True, seed=-1, show_mask=False) -> vs.VideoNode: """ Original header: Generates grain based on frame and pixel brightness. Details can be found here: https://kageru.moe/blog/article/adaptivegrain Strength is the strength of the grain generated by AddGrain, static=True for static grain, luma_scaling manipulates the grain alpha curve. Higher values will generate less grain (especially in brighter scenes), while lower values will generate more grain, even in brighter scenes. ==================================================================================================================== This mod simply adds the size and sharpness features from havsfunc's GrainFactory3. Additionally, the option to process only luma is added. Requires YUV input. New: - Option to add your own graining function (i.e. grainer=lambda x: core.f3kdb.Deband(x, y=0, cr=0, cb=0, grainy=64, dynamic_grain=True, keep_tv_range=True, output_depth=16) - Fixed grain_chroma and added cstrength. Mod 2 sources with size=1 now work, too. - Option to fade amount of grain added on edge values where grain raises/lowers average plane value. - Additional protect_neutral parameter to keep neutral chroma in blacks neutral. - Added seed option. - Change defaults: static=False, fade_edges=True - Added custom hi and lo params. """ dpth = get_depth(clip_in) try: from kagefunc import adaptive_grain mask = adaptive_grain(clip_in, luma_scaling=luma_scaling, show_mask=True) except ModuleNotFoundError: mask = core.adg.Mask(clip_in.std.PlaneStats(), luma_scaling) if get_depth(mask) != dpth: mask = depth(mask, dpth) if show_mask: return mask grained = sizedgrn(clip_in, strength=strength, cstrength=cstrength, size=size, sharp=sharp, static=static, grain_chroma=grain_chroma, grainer=grainer, fade_edges=fade_edges, tv_range=tv_range, lo=lo, hi=hi, protect_neutral=protect_neutral, seed=seed) return core.std.MaskedMerge(clip_in, grained, mask)