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 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 = SRC_CUT src = depth(src, 16) denoise = core.knlm.KNLMeansCL(src, a=2, h=0.8, d=3, device_type='gpu', channels='UV') denoise_mask = core.adg.Mask(src.std.PlaneStats(), 2).std.Invert() denoise = core.std.MaskedMerge(denoise, mvf.BM3D(denoise, 2), denoise_mask) antialias = lvf.sraa(denoise, 1.75, 6, sharp_downscale=True) antialias_mask = core.std.Prewitt(get_y(denoise)).std.Maximum() antialias = core.std.MaskedMerge(denoise, antialias, antialias_mask) preden = core.knlm.KNLMeansCL(antialias, a=2, h=1.5, d=0, device_type='gpu', channels='Y') deband_mask = lvf.denoise.detail_mask(preden, brz_a=2500, brz_b=1000) deband = dbs.f3kpf(preden, 17, 36, 36) diff = core.std.MakeDiff(antialias, preden) deband = core.std.MergeDiff(deband, diff) deband = core.std.MaskedMerge(deband, antialias, deband_mask) final = depth(deband, 10) return final
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) out = src h = 720 w = get_w(h) fixedges = awf.bbmod(out, 2, 2, 2, 2, 64 << 8, 999) out = fixedges clean = core.knlm.KNLMeansCL(out, h=0.55, a=2, d=3, device_type='gpu', device_id=0, channels='UV') clean = core.knlm.KNLMeansCL(clean, h=0.55, a=2, d=3, device_type='gpu', device_id=0, channels='Y') diff_den = core.std.MakeDiff(out, clean) out = depth(clean, 32) luma = get_y(out) line_mask = vdf.edge_detect(luma, 'FDOG', 0.05, (1, 1)) descale = core.descale.Debilinear(luma, w, h) upscale = vdf.nnedi3_upscale(descale, correct_shift=False, pscrn=1).resize.Bicubic(src.width, src.height, src_left=.5, src_top=.5) rescale = core.std.MaskedMerge(luma, upscale, line_mask) merged = vdf.merge_chroma(rescale, out) out = depth(merged, 16) moozzi = warping(out, 0.4, 4) sharp = hvf.LSFmod(moozzi, strength=95, 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, 30, 30) deband = core.std.MaskedMerge(deband, out, deband_mask) out = deband grain_org = core.std.MergeDiff(out, diff_den) out = grain_org return depth(out, 10)
def do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut src = depth(src, 32) h = 720 w = get_w(h) b, c = vdf.get_bicubic_params('robidoux') 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) # 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 = 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 return depth(out, 10)
def do_filter(): """Vapoursynth filtering""" src = SRC_CLIP src = depth(src, 16) denoise = core.knlm.KNLMeansCL(src, a=2, h=0.8, d=3, device_type='gpu', channels='UV') denoise_mask = core.adg.Mask(src.std.PlaneStats(), 6).std.Invert() denoise = core.std.MaskedMerge(denoise, mvf.BM3D(denoise, 1.25), denoise_mask) downscaler = lambda c, w, h: core.fmtc.resample( c, w, h, kernel='gauss', invks=True, invkstaps=1, taps=1, a1=32) antialias = lvf.sraa(denoise, 1.75, 6, downscaler=downscaler) antialias_mask = core.std.Prewitt(get_y(denoise)).std.Maximum() antialias = core.std.MaskedMerge(denoise, antialias, antialias_mask) preden = core.knlm.KNLMeansCL(antialias, a=2, h=1.5, d=0, device_type='gpu', channels='Y') deband_mask = lvf.denoise.detail_mask(preden, brz_a=2500, brz_b=1000) deband = dbs.f3kpf(preden, 17, 36, 36) diff = core.std.MakeDiff(antialias, preden) deband = core.std.MergeDiff(deband, diff) deband = core.std.MaskedMerge(deband, antialias, deband_mask) final = depth(deband, 10) return final
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 do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut src = depth(src, 16) out = src + src[-1] * 3 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) 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 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(): """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 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 = 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 = depth(src, 32) out = src full_range = core.resize.Bicubic(out, range_in=0, range=1, dither_type='error_diffusion') out = full_range radius = 3 y, u, v = split(out) y_m = core.resize.Point(y, 960, 1080, src_left=-1) y_m = core.resize.Bicubic(y_m, 960, 540) def demangle(clip): return vdf.nnedi3_upscale(clip, pscrn=0, correct_shift=False).resize.Spline16(src_left=0.5+0.25, src_top=.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) out = join([y, u_r, v_r]) out = depth(out, 16) dehalo = gf.MaskedDHA(out, rx=1.25, ry=1.25, darkstr=0.10, brightstr=1.0, maskpull=46, maskpush=148) out = dehalo upscale = atf.eedi3Scale(out, 2160, pscrn=0) out = upscale dehalo = gf.MaskedDHA(out, rx=1.15, ry=1.15, darkstr=0.10, brightstr=1.0, maskpull=46, maskpush=148) out = dehalo deband_mask = lvf.denoise.detail_mask(out, brz_a=2000, brz_b=1000) deband = dbs.f3kpf(out, 28, 48, 48) deband = core.std.MaskedMerge(deband, out, deband_mask) out = deband grain = core.grain.Add(out, 1) out = grain return out.std.AssumeFPS(fpsnum=1, fpsden=1)
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""" 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""" src = JPBD.src_cut h = 720 w = get_w(h) edgesfix = awf.bbmod(src, 1, 1, 1, 1, 48, 500) out = edgesfix clip = depth(out, 32) denoise = hybrid_denoise(clip, 0.45, 1.5) out = denoise luma = get_y(out) line_mask = line_mask_func(luma) descale = core.descale.Debilinear(luma, w, h) upscale = vdf.nnedi3_upscale(descale, pscrn=1) antialias = single_rate_antialiasing(upscale, 13, alpha=0.2, beta=0.5, gamma=600, mdis=15) scaled = core.resize.Bicubic(antialias, src.width, src.height) rescale = core.std.MaskedMerge(luma, scaled, depth(line_mask, 32)) merged = vdf.merge_chroma(rescale, out) out = depth(merged, 16) preden = core.knlm.KNLMeansCL(get_y(out), h=0.75, a=2, d=3, device_type='gpu', device_id=0) detail_dark_mask = detail_dark_mask_func(preden, brz_a=8000, brz_b=6000) 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.Convolution([1, 1, 1, 1, 1, 1, 1, 1, 1]) detail_mask = core.std.Expr([preden, detail_mask_grow, detail_mask], f'x {32<<8} < y z ?') deband_a = dbs.f3kpf(out, 16, 30, 42, thr=0.5, elast=2, thrc=0.2) deband_b = placebo.deband(out, 18, 5.5, 2, 4) deband = core.std.MaskedMerge(deband_a, deband_b, preden) deband = core.std.MaskedMerge(deband_a, out, detail_mask) deband = core.neo_f3kdb.Deband(deband, preset='depth', grainy=24, grainc=24) out = deband grain = adptvgrnMod(out, 0.4, 0.3, 1.25, luma_scaling=8, sharp=80, static=False, lo=19) 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, 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 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""" def _fsrcnnx(clip: vs.VideoNode) -> vs.VideoNode: blank = core.std.BlankClip(clip, format=vs.GRAY16, color=128 << 8) clip = join([clip, blank, blank]) # The chroma is upscaled with box AKA nearest but we don't care since we only need the luma. # It's especially faster and speed is the key :^) clip = core.placebo.Shader(clip, 'Shaders/FSRCNNX_x2_56-16-4-1.glsl', clip.width*2, clip.height*2, filter='box') return get_y(clip) def _nnedi(clip: vs.VideoNode) -> vs.VideoNode: args = dict(nsize=4, nns=4, qual=2, pscrn=2) clip = clip.std.Transpose().nnedi3.nnedi3(0, True, **args) \ .std.Transpose().nnedi3.nnedi3(0, True, **args) return core.resize.Spline36(clip, src_top=.5, src_left=.5) def _rescale(clip: vs.VideoNode, thr: int, downscaler: Callable[[vs.VideoNode], vs.VideoNode]) -> vs.VideoNode: return downscaler(core.std.Merge(_nnedi(clip), _fsrcnnx(clip), thr)) src = SRC_CUT fixedges = lvf.ef(src, [1, 1, 1]) denoise = CoolDegrain(depth(fixedges, 16), tr=1, thsad=48, thsadc=84, blksize=8, overlap=4, plane=4) w, h = 1280, 720 b, c = vdf.get_bicubic_params('robidoux') luma = get_y(denoise) descale = depth(core.descale.Debicubic(depth(luma, 32), w, h, b, c), 16) rescale = _rescale(descale, 0.55, lambda c: core.resize.Bicubic(c, src.width, src.height, filter_param_a=0, filter_param_b=0)) line_mask = lvf.denoise.detail_mask(rescale, brz_a=7000, brz_b=2000) rescale = core.std.MaskedMerge(luma, rescale, line_mask) credit_mask = vdf.drm(luma, b=b, c=c, mode='ellipse', sw=3, sh=3) credit = core.std.MaskedMerge(rescale, luma, credit_mask) merged = vdf.merge_chroma(credit, denoise) deband_mask = lvf.denoise.detail_mask(merged, brz_a=3000, brz_b=1500) deband = dbs.f3kpf(merged, 17, 36, 36) deband = core.std.MaskedMerge(deband, merged, deband_mask) grain = core.neo_f3kdb.Deband(deband, preset='depth', grainy=32, output_depth=10, dither_algo=3, keep_tv_range=True) 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, 16, 16) deband = core.std.MaskedMerge(deband, out, deband_mask) out = deband return depth(out, 10)
def do_filter(): """Vapoursynth filtering""" src = JPBD.src_cut src = depth(src, 16) out = src + src[-1] opstart, opend = 2638, 4794 edstart, edend = 31767, 33924 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) 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, 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 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""" 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 do_filter(): """Vapoursynth filtering""" src = JPBD.src_clip src = depth(src, 16) cleanedge = hvf.EdgeCleaner(src, 15, rmode=1, smode=1, hot=True) out = cleanedge deband_mask = lvf.denoise.detail_mask(out, brz_a=2250, brz_b=1500).std.Median() deband = dbs.f3kpf(out, 17, 30, 30) deband = core.std.MaskedMerge(deband, out, deband_mask) out = deband freeze = core.std.FreezeFrames(out, 120, src.num_frames - 1, 120) out = freeze 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 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) 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""" src = JPBD.src_cut src += src[-1] * 2 h = 720 w = get_w(h) edgesfix = awf.bbmod(src, 1, 1, 1, 1, 48, 500) out = edgesfix clip = depth(out, 32) denoise = hybrid_denoise(clip, 0.45, 1.5) out = denoise luma = get_y(out) line_mask = line_mask_func(luma) descale = core.descale.Debilinear(luma, w, h) upscale = vdf.nnedi3_upscale(descale, pscrn=1) antialias = single_rate_antialiasing(upscale, 13, alpha=0.4, beta=0.3, gamma=400, mdis=15).resize.Bilinear( src.width, src.height) rescale = core.std.MaskedMerge(luma, antialias, depth(line_mask, 32)) merged = vdf.merge_chroma(rescale, out) out = depth(merged, 16) preden = core.knlm.KNLMeansCL(get_y(out), h=0.75, a=2, d=3, device_type='gpu', device_id=0) detail_dark_mask = detail_dark_mask_func(preden, brz_a=8000, brz_b=6000) 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.Convolution([1, 1, 1, 1, 1, 1, 1, 1, 1]) detail_mask = core.std.Expr([preden, detail_mask_grow, detail_mask], f'x {32<<8} < y z ?') deband_a = dbs.f3kpf(out, 17, 36, 42, thr=0.5, elast=2, thrc=0.2) deband_b = placebo.deband(out, 18, 5.5, 2, 0) deband = core.std.MaskedMerge(deband_a, deband_b, preden) deband = core.std.MaskedMerge(deband, out, detail_mask) deband = core.neo_f3kdb.Deband(deband, preset='depth', grainy=24, grainc=24) out = deband ref, src = [depth(x, 16) for x in [denoise, src]] credit_mask = vdf.drm(ref, kernel='bilinear', mthr=65) credit = out credit = lvf.rfs(credit, core.std.MaskedMerge(credit, ref, credit_mask, 0), [(0, 1380), (36437, 38719)]) credit = lvf.rfs(credit, ref, [(20810, 20881), (38720, src.num_frames - 1)]) out = credit grain = adptvgrnMod(out, 0.3, 0.15, 1.25, luma_scaling=8, sharp=80, static=False, lo=19) out = grain return depth(out, 10)
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 _line_mask(clip: vs.VideoNode, thr: int) -> vs.VideoNode: mask = core.std.Prewitt(clip) mask = core.std.Expr(mask, 'x 2 *').std.Median() mask = core.std.Expr(mask, f'x {thr} < x x 3 * ?') return mask.std.Inflate().std.Deflate() def _ssharp(clip: vs.VideoNode, strength: float, width: int, height: int, factor: float = 2, b: float = -1, c: float = 6) -> vs.VideoNode: source = clip sharp = core.resize.Bicubic(clip, clip.width*factor, clip.height*factor, \ filter_param_a=b, filter_param_b=c).resize.Lanczos(width, height) source = core.resize.Spline64(source, sharp.width, sharp.height) sharp = core.rgvs.Repair(sharp, source, 13) sharp = mvf.LimitFilter(source, sharp, thrc=0.5, elast=6, brighten_thr=0.5, planes=0) final = core.std.Expr([sharp, source], f'x {strength} * y 1 {strength} - * +') return final 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)) def _perform_masks_credit(path: Path) -> List[MaskCredit]: return [ MaskCredit(lvf.src(str(mask)), int(str(mask.stem).split('_')[2]), int(str(mask.stem).split('_')[3])) for mask in path.glob('*') ] # pylint: disable=unused-argument def _diff(n: int, f: vs.VideoFrame, new: vs.VideoNode, adapt: vs.VideoNode) -> vs.VideoNode: psa = f.props['PlaneStatsAverage'] if psa > 0.5: clip = new elif psa < 0.4: clip = adapt else: weight = (psa - 0.4) * 10 clip = core.std.Merge(adapt, new, weight) return clip def _ret_mask(clip: vs.VideoNode, thr: int) -> vs.VideoNode: mask = kgf.retinex_edgemask(clip) mask = core.std.Median(mask).std.Binarize(thr) mask = iterate(mask, core.std.Median, 2) mask = iterate(mask, core.std.Maximum, 3) mask = iterate(mask, core.std.Minimum, 2) return mask opstart, opend = 1774, 3944 edstart, edend = 31781, 33938 src = JPBD.src_cut src = depth(src, 16) denoise_a = mdf.hybriddenoise_mod(src, 0.55, 2.25) denoise_b = mdf.hybriddenoise_mod(src, 0.55, 10) denoise = lvf.rfs(denoise_a, denoise_b, [(opstart, opstart + 44)]) diff = core.std.MakeDiff(src, denoise, [0, 1, 2]) luma = get_y(denoise) upscale = _nnedi3(luma, 1.5, dict(nsize=0, nns=3, qual=1, pscrn=1)) sraa = _sraa(upscale, dict(nsize=0, nns=3, qual=1, pscrn=1), dict(alpha=0.2, beta=0.5, gamma=80, nrad=3, mdis=18)) sraa = core.rgvs.Repair(sraa, upscale, 3) rescale = _ssharp(sraa, 0.55, src.width, src.height, 2) artefacts_mask = core.std.BlankClip(rescale, color=(256 << 8) - 1) artefacts_mask = vdf.region_mask(artefacts_mask, 2, 2, 2, 2).std.Inflate() rescale = core.std.MaskedMerge(luma, rescale, artefacts_mask) lineart_mask = _line_mask(luma, 8000) antialias = core.std.MaskedMerge(luma, rescale, lineart_mask) antialias_merged = vdf.merge_chroma(antialias, denoise) src_c, src_ncop = [ c.knlm.KNLMeansCL(a=6, h=20, d=0, device_type='gpu') for c in [src, JPBD_NCOP.src_cut[:opend - opstart + 1]] ] credit_mask = vdf.dcm(src, src_c[opstart:opend + 1], src_ncop, opstart, opend, 2, 2).std.Deflate() credit = core.std.MaskedMerge(antialias_merged, denoise, credit_mask) masks_credit_ = _perform_masks_credit(Path('masks_' + JPBD.name[-2:] + '/')) for mask in masks_credit_: credit = lvf.rfs( credit, core.std.MaskedMerge(credit, denoise, to_gray(mask.mask, src).std.Deflate()), [(mask.start_frame, mask.end_frame)]) deband_mask = lvf.denoise.detail_mask(credit, brz_a=3000, brz_b=1500) dark_mask = core.std.Expr([deband_mask, _ret_mask(credit, 12500)], 'x y +') deband_a = dbs.f3kpf(credit, 18, 36, 36) deband_b = dbs.f3kpf(credit, 18, 42, 42) deband_c = placebo.Deband(credit, radius=12, threshold=20, iterations=3, grain=0) deband_d = placebo.Deband(credit, radius=10, threshold=8, iterations=2, grain=0) deband = lvf.rfs(deband_a, deband_b, [(opstart + 483, opstart + 554)]) deband = lvf.rfs(deband, deband_c, [(opstart, opstart + 44)]) deband = lvf.rfs(deband, core.std.MaskedMerge(deband_d, credit, dark_mask), [(opstart + 1070, opstart + 1103)]) deband = lvf.rfs(deband, deband_d, [(opstart + 1104, opstart + 1124)]) deband = core.std.MaskedMerge(deband, credit, deband_mask) grain_original = core.std.MergeDiff(deband, diff, [0, 1, 2]) grain_original_nochroma = core.std.MergeDiff(deband, diff, [0]) grain_new = core.neo_f3kdb.Deband(deband, preset='depth', grainy=32, grainc=32) grain_new_nochroma = vdf.merge_chroma(grain_new, deband) avg = core.std.PlaneStats(deband) adapt_mask = core.adg.Mask(get_y(avg), 28) grain_adapt = core.std.MaskedMerge(grain_new, grain_original, adapt_mask) gf3_args = dict(g1str=5, g2str=3.85, g3str=3.5, g1shrp=50, g2shrp=60, g3shrp=60, g1size=1.65, g2size=1.60, g3size=1.25) grain_a = hvf.GrainFactory3(deband, **gf3_args) grain_b = mdf.adptvgrnMod_mod(deband, 2, size=1.5, sharp=60, static=False, luma_scaling=14) grain = core.std.FrameEval( deband, partial(_diff, new=grain_new, adapt=grain_adapt), avg) grain = lvf.rfs(grain, grain_original, [(5058, 5253), (7871, 7989)]) grain = lvf.rfs(grain, grain_new_nochroma, [(opstart + 117, opstart + 873), (opstart + 921, opstart + 993)]) grain = lvf.rfs(grain, grain_original_nochroma, [(opstart + 874, opstart + 920), (opstart + 994, opstart + 1069), (opstart + 1125, opstart + 1202)]) grain = lvf.rfs(grain, grain_a, [(opstart, opstart + 44)]) grain = lvf.rfs(grain, grain_b, [(opstart + 1070, opstart + 1124)]) stabilize = hvf.GSMC(src, radius=2, planes=0) ending = vdf.merge_chroma(stabilize, denoise) final = lvf.rfs(grain, ending, [(edstart, edend)]) final = final[:opstart] + final[opstart + 2:opstart + 2160] + final[opend + 1:] return depth(final, 10), opstart, opend