def fix_edges(clip, rownum, rowval, colnum, colval, **kwargs): import rekt import awsmfunc as awsm bbmod_args = dict(top=3, bottom=3, left=3, right=3, thresh=None, blur=20) bbmod_args |= kwargs fix = rekt.rektlvls(clip, rownum, rowval, colnum, colval) return fix.std.MaskedMerge( awsm.bbmod(clip, **bbmod_args), core.std.Expr([ fix, rekt.rektlvls(clip, rownum, rowval, colnum, colval, [16, 256]) ], 'x y - abs 0 > 65535 0 ?'), 0, True)
def main() -> vs.VideoNode: """Vapoursynth filtering""" import rekt from adptvgrnMod import adptvgrnMod from havsfunc import FastLineDarkenMOD from vsutil import depth from xvs import WarpFixChromaBlend src_ep = JPBD_EP.clip_cut src_NCOP1 = JPBD_NCOP1.clip_cut src_NCOP2 = JPBD_NCOP2.clip_cut src_NCOP = replace_ranges(src_NCOP2, src_NCOP1, replace_op) src_NCOP = replace_ranges(src_NCOP, src_ep, replace_ep) rkt = rekt.rektlvls(src_NCOP, rownum=[0, 1079], rowval=[15, 15], colnum=[0, 1919], colval=[15, 15] ) no_rkt = replace_ranges(rkt, src_NCOP, [(526, 597), (1350, 1575), (1613, 1673), (1735, 1933)]) scaled = flt.rescaler(no_rkt, 720) denoised = flt.denoiser(scaled, bm3d_sigma=[0.8, 0.6], bm3d_rad=1) aa_rep = flt.clamped_aa(denoised) trans_sraa = flt.transpose_sraa(denoised) aa_ranges = replace_ranges(aa_rep, trans_sraa, red_circle) darken = FastLineDarkenMOD(aa_ranges, strength=48, protection=6, luma_cap=255, threshold=2) deband = flt.masked_deband(darken, denoised=True, deband_args={'iterations': 2, 'threshold': 5.0, 'radius': 8, 'grain': 6}) grain = adptvgrnMod(deband, strength=0.3, luma_scaling=10, size=1.25, sharp=80, grain_chroma=False, seed=42069) return depth(grain, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2], [0, 1, 2])
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """Main filterchain""" import havsfunc as haf import lvsfunc as lvf import rekt import vardefunc as vdf from adptvgrnMod import adptvgrnMod from ccd import ccd from vsutil import depth, get_w, get_y src: vs.VideoNode = pre_corrections() # type:ignore[assignment] src_NCED = JP_BD_NCED.clip_cut # Masking credits ed_mask = vdf.dcm( src, src[edstart:edstart+src_NCED.num_frames-ed_offset], src_NCED[:-ed_offset], start_frame=edstart, thr=25, prefilter=False) if edstart is not False \ else get_y(core.std.BlankClip(src)) credit_mask = depth(ed_mask, 16).std.Binarize() rkt = rekt.rektlvls(src, [0, 1079], [7, 7], [0, 1919], [7, 7], prot_val=None) rkt = depth(rkt, 16) denoise_uv = ccd(rkt, threshold=7, matrix='709') stab = haf.GSMC(denoise_uv, radius=1, thSAD=200, planes=[0]) decs = vdf.noise.decsiz(stab, sigmaS=8, min_in=208 << 8, max_in=232 << 8) l_mask = vdf.mask.FDOG().get_mask(get_y(decs), lthr=0.065, hthr=0.065).std.Maximum().std.Minimum() l_mask = l_mask.std.Median().std.Convolution([1] * 9) aa_weak = lvf.aa.taa(decs, lvf.aa.nnedi3(opencl=True)) aa_strong = lvf.aa.upscaled_sraa(decs, downscaler=lvf.kernels.Bicubic(b=-1 / 2, c=1 / 4).scale) aa_clamp = lvf.aa.clamp_aa(decs, aa_weak, aa_strong, strength=1.5) aa_masked = core.std.MaskedMerge(decs, aa_clamp, l_mask) dehalo = haf.FineDehalo(aa_masked, rx=1.6, ry=1.6, darkstr=0, brightstr=1.25) darken = flt.line_darkening(dehalo, 0.275).warp.AWarpSharp2(depth=2) merged_credits = core.std.MaskedMerge(darken, decs, credit_mask) deband = flt.masked_f3kdb(merged_credits, rad=18, thr=32, grain=[32, 12]) grain: vs.VideoNode = adptvgrnMod(deband, seed=42069, strength=0.35, luma_scaling=8, size=1.05, sharp=80, grain_chroma=False) return grain
def rekt(clip: vs.VideoNode) -> vs.VideoNode: """Apply rekt consistently across multiple clips""" import rekt from awsmfunc import bbmod rkt = rekt.rektlvls(clip, [0, 1079], [17, 16], [0, 1, 2, 3] + [1917, 1918, 1919], [16, 4, -2, 2] + [-2, 5, 14]) return bbmod(rkt, left=4, right=3, y=False)
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """Main filterchain""" import lvsfunc as lvf import rekt import vardefunc as vdf from awsmfunc import bbmod from ccd import ccd from muvsfunc import SSIM_downsample from vsutil import depth, get_y src = JP_BD.clip_cut rkt = rekt.rektlvls(src, [0, -1], [30, 17], [0], [17]) bb_y = bbmod(rkt, top=2, left=2, right=2, bottom=2, u=False, v=False, blur=9999) bb_uv = bbmod(bb_y, left=2, right=2, y=False) bb = depth(bb_uv, 32) descale = lvf.kernels.Spline36().descale(get_y(bb), 1280, 720) up_chr = vdf.scale.to_444(bb, 1920, 1080, True).resize.Bicubic(1280, 720) descale_merge = vdf.misc.merge_chroma(descale, up_chr) denoise_down = lvf.deblock.vsdpir(descale_merge, strength=0.5, mode='deblock', matrix=1, i444=True, cuda=True) supersample = vdf.scale.nnedi3_upscale(get_y(denoise_down)) downscaled = SSIM_downsample(supersample, bb.width, bb.height, smooth=((3 ** 2 - 1) / 12) ** 0.5, sigmoid=True, filter_param_a=0, filter_param_b=0) scaled = vdf.misc.merge_chroma(downscaled, bb) scaled = depth(scaled, 16) den_uv = ccd(scaled, matrix='709') decs = vdf.noise.decsiz(den_uv, sigmaS=8, min_in=200 << 8, max_in=232 << 8) nn_aa = lvf.aa.nnedi3(opencl=True, dh=False)(decs) sraa = lvf.sraa(decs, rfactor=1.75) clmp = lvf.aa.clamp_aa(decs, nn_aa, sraa) dehalo = lvf.dehalo.masked_dha(clmp, brightstr=0.65) deband = flt.masked_f3kdb(dehalo, rad=17, thr=[24, 16], grain=[24, 12]) grain = vdf.noise.Graigasm( thrs=[x << 8 for x in (32, 80, 128, 176)], strengths=[(0.20, 0.0), (0.15, 0.0), (0.10, 0.0), (0.0, 0.0)], sizes=(1.20, 1.15, 1.10, 1), sharps=(100, 80, 60, 20), grainers=[ vdf.noise.AddGrain(seed=69420, constant=False), vdf.noise.AddGrain(seed=69420, constant=False), vdf.noise.AddGrain(seed=69420, constant=True) ]).graining(deband) no_flt = lvf.rfs(grain, depth(bb, 16), no_filter) return no_flt
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """Main filterchain""" import lvsfunc as lvf import rekt import vardefunc as vdf from muvsfunc import SSIM_downsample from vsutil import depth, get_y src = JP_BD.clip_cut rkt = rekt.rektlvls(src, [0, -1], [15, 15], [0, -1], [15, 15]) cloc = depth(rkt, 32).resize.Bicubic(chromaloc_in=1, chromaloc=0) descale = lvf.kernels.Bilinear().descale(get_y(cloc), 1280, 720) supersample = vdf.scale.nnedi3_upscale(descale) downscaled = SSIM_downsample(supersample, src.width, src.height, smooth=((3**2 - 1) / 12)**0.5, sigmoid=True, filter_param_a=0, filter_param_b=0) scaled = vdf.misc.merge_chroma(downscaled, cloc) scaled = depth(scaled, 16) dft = core.dfttest.DFTTest(scaled, sigma=0.6, sbsize=8, sosize=6, tbsize=3, tosize=1) decs = vdf.noise.decsiz(dft, sigmaS=4, min_in=200 << 8, max_in=232 << 8) baa = lvf.aa.based_aa(decs, str(shader_file)) sraa = lvf.sraa(decs, rfactor=1.5) clmp = lvf.aa.clamp_aa(decs, baa, sraa, strength=1.5) deband = flt.masked_f3kdb(clmp, rad=16, thr=[20, 16]) grain = vdf.noise.Graigasm(thrs=[x << 8 for x in (32, 80, 128, 176)], strengths=[(0.25, 0.0), (0.20, 0.0), (0.15, 0.0), (0.0, 0.0)], sizes=(1.20, 1.15, 1.10, 1), sharps=(80, 70, 60, 50), grainers=[ vdf.noise.AddGrain(seed=69420, constant=False), vdf.noise.AddGrain(seed=69420, constant=False), vdf.noise.AddGrain(seed=69420, constant=True) ]).graining(deband) return grain
def prepare_hr(self, clip: vs.VideoNode, dvd_clip: vs.VideoNode) -> vs.VideoNode: """ Match with the DVD @640x480: bd.resize.Bicubic(720, 486, src_left=-0.75).std.Crop(top=3, bottom=3) """ import havsfunc as haf import lvsfunc as lvf import muvsfunc as muf import rekt import vardefunc as vdf from awsmfunc import bbmod from vsutil import depth, join, plane from xvs import WarpFixChromaBlend rkt = rekt.rektlvls(clip, [0, 1079], [17, 16], [0, 1, 2, 3] + [1917, 1918, 1919], [16, 4, -2, 2] + [-2, 5, 14]) ef = bbmod(rkt, left=4, right=3, y=False) clip = depth(ef, 32).std.AssumeFPS(fpsnum=24, fpsden=1) bd_descale = lvf.kernels.Bicubic().descale(plane(clip, 0), 1280, 720) bd_doubled = vdf.scale.nnedi3_upscale(bd_descale) bd_down = muf.SSIM_downsample(bd_doubled, dvd_clip.width * 2, 486 * 2) # Need to do some fuckery to make sure the chroma matches up perfectly bd_cshift = clip.resize.Bicubic(chromaloc_in=1, chromaloc=0, format=vs.YUV420P16) bd_cwarp = bd_cshift.warp.AWarpSharp2(thresh=88, blur=3, type=1, depth=6, planes=[1, 2]) bd_chroma = bd_cwarp.resize.Bicubic(format=vs.YUV444P16, width=bd_down.width, height=bd_down.height) bd_i444 = core.std.ShufflePlanes([depth(bd_down, 16), bd_chroma]) bd_shift = bd_i444.resize.Bicubic(src_left=-0.75).std.Crop(top=6, bottom=6) return bd_shift.resize.Bicubic(format=vs.RGB24, dither_type='error_diffusion') \ .std.ShufflePlanes([1, 2, 0], vs.RGB)
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """Main filterchain""" import lvsfunc as lvf import rekt import vardefunc as vdf from awsmfunc import bbmod from ccd import ccd from vsutil import depth src = JP_BD.clip_cut rkt = rekt.rektlvls(src, [0, -1], [30, 17], [0], [17]) bb_y = bbmod(rkt, top=2, left=2, right=2, bottom=2, blur=9999, u=False, v=False) bb_uv = bbmod(bb_y, left=2, right=2, y=False) bb = depth(bb_uv, 16) den = core.dfttest.DFTTest(bb, sigma=3.6, tbsize=5, tosize=3) den_uv = ccd(den, matrix='709') decs = vdf.noise.decsiz(den_uv, sigmaS=8, min_in=200 << 8, max_in=232 << 8) cwarp = core.warp.AWarpSharp2(decs, thresh=72, blur=3, type=1, depth=4, planes=[1, 2]) deband = flt.masked_f3kdb(cwarp, rad=17, thr=[24, 16], grain=[24, 12]) grain = vdf.noise.Graigasm( thrs=[x << 8 for x in (32, 80, 128, 176)], strengths=[(0.20, 0.0), (0.15, 0.0), (0.10, 0.0), (0.0, 0.0)], sizes=(1.20, 1.15, 1.10, 1), sharps=(100, 80, 60, 20), grainers=[ vdf.noise.AddGrain(seed=69420, constant=True), vdf.noise.AddGrain(seed=69420, constant=True), vdf.noise.AddGrain(seed=69420, constant=True) ]).graining(deband) no_flt = lvf.rfs(grain, depth(bb, 16), no_filter) return no_flt
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """Main filterchain""" import havsfunc as haf import lvsfunc as lvf import rekt import vardefunc as vdf from adptvgrnMod import adptvgrnMod from awsmfunc import bbmod from ccd import ccd from vsutil import depth, get_y from xvs import WarpFixChromaBlend src = JP_NCED.clip_cut src_13 = JP_BD_13.clip_cut src = lvf.rfs(src, src_13, [(2073, None)]) # Edgefixing rkt = rekt.rektlvls(src, [0, 1079], [17, 16], [0, 1, 2, 3] + [1917, 1918, 1919], [16, 4, -2, 2] + [-2, 5, 14]) ef = bbmod(rkt, left=4, right=3, y=False) ef = depth(ef, 32) # Descaling + Rescaling src_y = get_y(ef) descaled = lvf.kernels.Bicubic().descale(src_y, 1280, 720) rescaled = vdf.scale.nnedi3_upscale(descaled) downscaled = lvf.kernels.Bicubic(-1 / 2, 1 / 4).scale(rescaled, 1920, 1080) l_mask = vdf.mask.FDOG().get_mask(src_y, lthr=0.065, hthr=0.065).std.Maximum().std.Minimum() l_mask = l_mask.std.Median().std.Convolution([1] * 9) rescaled_masked = core.std.MaskedMerge(src_y, downscaled, l_mask) scaled = depth(vdf.misc.merge_chroma(rescaled_masked, ef), 16) unwarp = flt.line_darkening(scaled, 0.145).warp.AWarpSharp2(depth=2) sharp = haf.LSFmod(unwarp, strength=65, Smode=3, Lmode=1, edgemode=1, edgemaskHQ=True) mask_sharp = core.std.MaskedMerge(scaled, sharp, depth(l_mask, 16)) upscaled = lvf.kernels.Bicubic().scale(descaled, 1920, 1080) descale_mask = lvf.scale.descale_detail_mask(src_y, upscaled) details_merged = core.std.MaskedMerge(mask_sharp, depth(ef, 16), depth(descale_mask, 16)) # Denoising denoise_y = core.knlm.KNLMeansCL(details_merged, d=1, a=3, s=4, h=0.15, channels='Y') denoise_uv = ccd(denoise_y, threshold=6, matrix='709') stab = haf.GSMC(denoise_uv, radius=2, adapt=1, planes=[0]) decs = vdf.noise.decsiz(stab, sigmaS=8, min_in=208 << 8, max_in=232 << 8) # Fixing chroma cshift = core.resize.Bicubic(decs, chromaloc_in=1, chromaloc=0) cwarp = WarpFixChromaBlend(cshift, thresh=88, blur=3, depth=6) # Regular debanding + graining detail_mask = flt.detail_mask(cwarp, brz=(1800, 3500)) deband = vdf.deband.dumb3kdb(cwarp, threshold=32, grain=16) deband_masked = core.std.MaskedMerge(deband, cwarp, detail_mask) grain: vs.VideoNode = adptvgrnMod(deband_masked, 0.2, luma_scaling=10, size=1.35, static=True, grain_chroma=False) return grain
from vapoursynth import core import havsfunc as haf from rekt import rektlvls westbound = core.d2v.Source("Westbound/VTS_01_1.d2v") westbound = core.vivtc.VFM(westbound, 1) westbound = core.std.SelectEvery(westbound, cycle=5, offsets=[0, 1, 2, 3]) westbound = rektlvls(westbound, colnum=[719], colval=[20]) westbound = haf.Deblock_QED(westbound) westbound.set_output()
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """Main filterchain""" import lvsfunc as lvf import rekt import vardefunc as vdf from awsmfunc import bbmod from muvsfunc import SSIM_downsample from vsutil import depth, get_y src = JP_BD.clip_cut rkt = rekt.rektlvls(src, [0, -1], [17, 17], [0, -1], [17, 21]) bb_y = bbmod(rkt, top=2, left=2, right=1, u=False, v=False) bb_uv = bbmod(bb_y, left=2, right=2, y=False) bb = depth(bb_uv, 32) descale = lvf.kernels.Mitchell().descale(get_y(bb), 1280, 720) up_chr = vdf.scale.to_444(bb, 1920, 1080, True).resize.Bicubic(1280, 720) descale_merge = vdf.misc.merge_chroma(descale, up_chr) denoise_down = lvf.deblock.vsdpir(descale_merge, strength=5, mode='deblock', matrix=1, i444=True, cuda=True) supersample = vdf.scale.nnedi3_upscale(get_y(denoise_down)) downscaled = SSIM_downsample(supersample, bb.width, bb.height, smooth=((3 ** 2 - 1) / 12) ** 0.5, sigmoid=True, filter_param_a=0, filter_param_b=0) den_chr_up = core.resize.Bicubic(denoise_down, bb.width, bb.height, bb.format.id) den_chr_up_shift = core.resize.Bicubic(denoise_down, bb.width, bb.height, bb.format.id, src_left=-0.5) den_chr_up = lvf.rfs(den_chr_up, den_chr_up_shift, shift_chr) scaled = vdf.misc.merge_chroma(downscaled, den_chr_up) scaled = depth(scaled, 16) decs = vdf.noise.decsiz(scaled, sigmaS=4, min_in=208 << 8, max_in=232 << 8) deband = core.average.Mean([ flt.masked_f3kdb(decs, rad=17, thr=[20, 24], grain=[24, 12]), flt.masked_f3kdb(decs, rad=21, thr=[32, 24], grain=[24, 12]), flt.masked_placebo(decs, rad=6, thr=2.8, itr=2, grain=4) ]) grain = vdf.noise.Graigasm( thrs=[x << 8 for x in (32, 80, 128, 176)], strengths=[(0.25, 0.0), (0.20, 0.0), (0.15, 0.0), (0.0, 0.0)], sizes=(1.25, 1.20, 1.15, 1), sharps=(80, 70, 60, 50), grainers=[ vdf.noise.AddGrain(seed=69420, constant=False), vdf.noise.AddGrain(seed=69420, constant=False), vdf.noise.AddGrain(seed=69420, constant=True) ]).graining(deband) grain_str = vdf.noise.Graigasm( thrs=[x << 8 for x in (32, 80, 128, 176)], strengths=[(0.35, 0.0), (0.30, 0.0), (0.25, 0.0), (0.0, 0.0)], sizes=(1.25, 1.20, 1.15, 1), sharps=(80, 70, 60, 50), grainers=[ vdf.noise.AddGrain(seed=69420, constant=False), vdf.noise.AddGrain(seed=69420, constant=False), vdf.noise.AddGrain(seed=69420, constant=True) ]).graining(deband) grain = lvf.rfs(grain, grain_str, str_grain) return grain
import awsmfunc as awf import havsfunc 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)
from vapoursynth import core import awsmfunc as awf from rekt import rektlvls deliverance = core.ffms2.Source( "Deliverance.40th.Anniversary.Edition.1972.Bluray.Remux.1080p.VC-1.DTS-HD.MA.5.1-HiFi.mkv" ) deliverance = core.std.Crop(deliverance, top=140, bottom=140) deliverance = core.fb.FillBorders(deliverance, left=2) deliverance = rektlvls(deliverance, colnum=[1916, 1918], colval=[2, 26]) deliverance = awf.fb(deliverance, right=1) deliverance = awf.bbmod(deliverance, left=8, right=4, thresh=15, blur=20) deliverance.set_output()
from vapoursynth import core, YUV444P8, YUV420P8 from rekt import rektlvls import havsfunc as haf import awsmfunc as awf import lvsfunc as lvf import G41Fun guilstein = core.d2v.Source("Guilstein/VTS_01_1.d2v")[:163645] guilstein = guilstein.decross.DeCross().dedot.Dedot().resize.Bicubic(format=YUV444P8, matrix_s="170m") topline = guilstein.vinverse.Vinverse().std.Crop(top=63, bottom=70, left=6, right=6).std.CropAbs(top=1, width=guilstein.width-12, height=2) guilstein = core.std.MaskedMerge(guilstein.vinverse.Vinverse().std.Crop(top=66, left=6, right=6), guilstein.std.Crop(top=66, left=6, right=6).nnedi3.nnedi3(1), guilstein.std.Crop(top=66, left=6, right=6).comb.CombMask().morpho.Dilate()) guilstein = guilstein.std.Crop(bottom=70) guilstein = core.std.StackVertical([topline, guilstein]) guilstein = rektlvls(guilstein, rownum=[0, 1], rowval=[50, 10], colnum=[0, 1, 2, 3, 4], colval=[14, 10, 9, -3, -2], prot_val=[16, 235]) guilstein = awf.bbmod(guilstein, right=4, thresh=7, blur=16) guilstein = core.std.Expr([guilstein, awf.bbmod(guilstein, bottom=3, thresh=2, blur=16)], "x y > x y ?") guilstein = core.std.Expr([guilstein, awf.bbmod(guilstein, left=8, thresh=1, blur=8)], "x y > x y ?") guilstein = lvf.aa.upscaled_sraa(guilstein, rfactor=2.0) guilstein = guilstein.dfttest.DFTTest(sigma=2.0) guilstein = guilstein.f3kdb.Deband(range=30, grainy=2, grainc=2) guilstein = G41Fun.MaskedDHA(guilstein, rx=1.6, ry=1.6, darkstr=0.0, brightstr=0.6, lowsens=120, highsens=10) guilstein = haf.EdgeCleaner(guilstein, strength=10) guilstein = guilstein.resize.Bicubic(format=YUV420P8, matrix_s="170m") guilstein = guilstein.std.FreezeFrames(first=[110471], last=[110483], replacement=[110470]) guilstein.set_output()
from vapoursynth import core import awsmfunc as awf from rekt import rektlvls battle_of_the_bulge = core.ffms2.Source( "Battle.of.the.Bulge.1965.BluRay.Remux.1080p.VC-1.DD.5.1-decibeL.mkv") battle_of_the_bulge = core.std.Crop(battle_of_the_bulge, top=194, bottom=192, left=6, right=6) battle_of_the_bulge = awf.fb(battle_of_the_bulge, right=1) battle_of_the_bulge = rektlvls(battle_of_the_bulge, colnum=[0, 1, 1905, 1906, 1907], colval=[-14, -5, -5, -12, -15]) battle_of_the_bulge.set_output()
cunny = core.d2v.Source("Imouto Jiru/DISC1.d2v") cunny = cunny.vivtc.VFM(1) cunny = cunny.vivtc.VDecimate() cunny = cunny[:44972] cunny = cunny.std.Crop(left=6, right=4) cunny = awf.fb(cunny, top=1) cunny = cunny.resize.Bicubic(src_top=1) cunny = cunny.fb.FillBorders(top=1, bottom=1, mode="fixborders") cunny = cunny.vinverse.Vinverse() black = core.tcm.TColorMask(cunny.std.Minimum(), ["$000000"], tolerance=7, bt601=True, gray=False, lutthr=9) cunny = rektlvls(cunny, colnum=[1, 709], colval=[-9, 35]) aa = taa.TAAmbk(cunny, "Nnedi3") sangnom = taa.TAAmbk(cunny, "Nnedi3SangNom") mask = kgf.retinex_edgemask(cunny).std.Binarize(200).std.Deflate(threshold=250) cunny = cunny.placebo.Deband(threshold=6, radius=16, grain=4) cunny = awf.ReplaceFrames(core.std.MaskedMerge(cunny, aa, mask), core.std.MaskedMerge(cunny, sangnom, mask), "[4708 4850] [5290 5421] [5542 5698] [5770 5803]") no_bbmod = cunny censor = cunny.fb.FillBorders(top=2, mode="fixborders") censor = awf.bbmod(censor, top=4, thresh=200, blur=10) censor = awf.bbmod(censor, right=4, thresh=2, blur=5) censor = awf.bbmod(censor, left=4, thresh=6, blur=8) censor = awf.bbmod(censor, right=1) cunny = awf.bbmod(cunny, right=4, top=4, thresh=2, blur=5) cunny = awf.bbmod(cunny, left=4, thresh=6, blur=8)
expand=5) diffedge = vdf.mask.Difference().creditless(src_clip=ededge + ededge[0], credit_clip=ededge, nc_clip=nced, start_frame=0, thr=20, prefilter=True, expand=5) diff = core.std.StackVertical([ diffedge.std.CropAbs(width=diffedge.width, height=4), diff.std.Crop(top=4, bottom=4), diffedge.std.CropAbs(width=diffedge.width, height=4, top=360) ])[:-1] diff = diff.std.Deflate().std.Deflate().std.Deflate() merged = core.std.MaskedMerge(ed, merged, diff) #damage = core.std.MaskedMerge(ed, damage, diff) merged = merged.std.Crop(left=2, right=2) merged = core.resize.Bicubic(merged, format=YUV444P8) merged = merged.std.Crop(left=1, right=1) merged = rekt.rektlvls(merged, rownum=[0], rowval=[10]) merged = merged.fb.FillBorders(bottom=1, left=1, mode="fixborders") merged = awf.bbmod(merged, top=8, thresh=2, blur=4) merged = awf.bbmod(merged, left=6, right=6, thresh=2, blur=10) merged = awf.bbmod(merged, bottom=2, thresh=4, blur=4) merged = merged.std.AddBorders(top=56, bottom=60) set_output(ivtc(merged))
epfix = depth(ep, 16) epfix = epfix.std.Levels(min_in=0, max_in=235 << 8, min_out=16 << 8, max_out=235 << 8, planes=0) epfix = epfix.resize.Bicubic(format=YUV444P16, matrix_in_s="170m", range_in_s="limited", dither_type="error_diffusion") edgefix = core.std.ShufflePlanes([epfix, awf.fb(epfix, left=1)], [0, 1, 2], YUV) epfix = awf.bbmod(edgefix, left=2, blur=20, thresh=30).std.Merge(edgefix, weight=[0.6, 0.4]) epfix = rektlvls(epfix, colnum=[638], colval=[8], prot_val=[70, 191]) epfix = epfix.resize.Bicubic(format=RGBS, matrix_in_s="170m", range_in_s="limited") dpir = lvf.deblock.autodb_dpir(epfix, strs=[45, 55, 75], thrs=[(0.0, 0.0, 0.0), (1.0, 1.2, 1.5), (3.0, 3.8, 4.5)], cuda=False).resize.Bicubic( format=YUV444P16, matrix_s="170m", dither_type="error_diffusion") dpir = haf.FineDehalo(dpir, rx=2, ry=2, brightstr=1.8, darkstr=0.2) dpir = core.std.Merge(haf.FineDehalo(dpir,
def pre_filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """ Regular filtering to get the output images to stitch. This is preferable over handling it unfiltered, since it'll be faster than encoding it and reduces the amount of jitter caused by the upscale after. """ import lvsfunc as lvf import rekt import vardefunc as vdf from awsmfunc import bbmod from muvsfunc import SSIM_downsample from vsutil import depth, get_y, join, plane src = JP_BD.clip_cut # Fixing animation f**k-ups if freeze_ranges: src = core.std.FreezeFrames( src, [s[0] for s in freeze_ranges], [e[1] for e in freeze_ranges], [f[2] for f in freeze_ranges] ) # Edgefixing ef = rekt.rektlvls( src, prot_val=[16, 235], min=16, max=235, rownum=[0, src.height-1], rowval=[16, 16], colnum=[0, src.width-1], colval=[16, 16], ) bb_y = bbmod(ef, left=1, top=1, right=1, bottom=1, thresh=32, y=True, u=False, v=False) bb_uv = bbmod(bb_y, left=2, top=2, right=2, bottom=2, y=False, u=True, v=True) cshift = flt.shift_chroma(bb_uv, left=0.6) cshift = lvf.rfs(bb_uv, cshift, cshift_left_ranges) bb32 = depth(cshift, 32) bb32_y = get_y(bb32) # Descaling + DPIR while it's at a lower res (so I can actually run it because >memory issues xd) descale = lvf.kernels.Catrom().descale(bb32_y, 1280, 720) downscale = lvf.kernels.Catrom(format=vs.YUV444PS).scale(bb32, 1280, 720) descale_444 = join([descale, plane(downscale, 1), plane(downscale, 2)]) denoise_y = lvf.deblock.vsdpir(descale_444, strength=2.75, mode='deblock', matrix=1, i444=True, cuda=True) supersample = vdf.scale.fsrcnnx_upscale(get_y(denoise_y), shader_file=shader_file, downscaler=None) downscaled = SSIM_downsample(supersample, src.width, src.height, smooth=((3 ** 2 - 1) / 12) ** 0.5, sigmoid=True, filter_param_a=0, filter_param_b=0) # Create credit mask upscale = lvf.kernels.Catrom().scale(descale, src.width, src.height) credit_mask = lvf.scale.descale_detail_mask(bb32_y, upscale, threshold=0.055) \ .std.Deflate().std.Deflate().std.Minimum() # Merge early for additional accuracy with DPIR merged = core.std.MaskedMerge(downscaled, bb32_y, credit_mask) down_y = lvf.kernels.Catrom().scale(merged, src.width/2, src.height/2) down_i444 = join([down_y, plane(bb32, 1), plane(bb32, 2)]) deblock_down = lvf.deblock.vsdpir(down_i444, strength=3, mode='denoise', matrix=1, i444=True, cuda=True) scaled = depth(join([merged, plane(deblock_down, 1), plane(deblock_down, 2)]), 16) # Final bit of "denoising" dft = core.dfttest.DFTTest(scaled, sigma=2.0, tbsize=5, tosize=3, planes=[0]) decs = vdf.noise.decsiz(dft, sigmaS=4, min_in=208 << 8, max_in=232 << 8) # AA baa = lvf.aa.based_aa(decs, str(shader_file)) sraa = lvf.sraa(decs, rfactor=1.65) clmp = lvf.aa.clamp_aa(decs, baa, sraa, strength=1.3) dehalo = lvf.dehalo.masked_dha(clmp, rx=1.4, ry=1.4, brightstr=0.4) cwarp = core.warp.AWarpSharp2(dehalo, thresh=72, blur=3, type=1, depth=4, planes=[1, 2]) # Merge credits (if applicable) merged = core.std.MaskedMerge(cwarp, depth(bb32, 16), depth(credit_mask, 16)) deband = core.average.Mean([ flt.masked_f3kdb(merged, rad=16, thr=[20, 24], grain=[24, 12]), flt.masked_f3kdb(merged, rad=20, thr=[28, 24], grain=[24, 12]), flt.masked_placebo(merged, rad=6, thr=2.5, itr=2, grain=4) ]) no_flt = lvf.rfs(deband, depth(bb32, 16), no_filter) return no_flt
opfix = depth(op, 16) opfix = opfix.std.Levels(min_in=0, max_in=235 << 8, min_out=16 << 8, max_out=235 << 8, planes=0) opfix = opfix.resize.Bicubic(format=YUV444P16, matrix_in_s="170m", range_in_s="limited", dither_type="error_diffusion") edgefix = core.std.ShufflePlanes([opfix, awf.fb(opfix, left=1)], [0, 1, 2], YUV) opfix = awf.bbmod(edgefix, left=2, blur=20, thresh=30).std.Merge(edgefix, weight=[0.6, 0.4]) opfix = rektlvls(opfix, colnum=[638], colval=[8], prot_val=[60, 190]) # 692 957 805 opfix = opfix.resize.Bicubic(format=RGBS, matrix_in_s="170m", range_in_s="limited") dpir = lvf.deblock.autodb_dpir(opfix, strs=[55, 65, 115], thrs=[(0.0, 0.0, 0.0), (1.0, 1.2, 1.5), (3.0, 3.8, 4.5)], cuda=False).resize.Bicubic( format=YUV444P16, matrix_s="170m", dither_type="error_diffusion") dpir = haf.FineDehalo(dpir, rx=2, ry=2, brightstr=1.8, darkstr=0.2) #dpir = core.std.Merge(haf.FineDehalo(dpir, rx=1.8, ry=1.8, brightstr=1.8, darkstr=0), dpir, weight=[0.4, 0.6])
def main() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """Vapoursynth filtering""" # Don't worry, this script is barely readable anymore even for me import rekt from awsmfunc import bbmod from havsfunc import ContraSharpening from lvsfunc.aa import upscaled_sraa from lvsfunc.comparison import stack_compare from lvsfunc.mask import BoundingBox from lvsfunc.util import replace_ranges from vardefunc import dcm from vardefunc.deband import dumb3kdb from vardefunc.mask import FreyChen from vsutil import depth, get_y, insert_clip src = JP_BD.clip_cut b = core.std.BlankClip(src, length=1) if opstart is not False: src_NCOP = NCOP.clip_cut op_scomp = stack_compare( src[opstart:opstart + src_NCOP.num_frames - 1] + b, src_NCOP[:-op_offset] + b, make_diff=True) # noqa if edstart is not False: src_NCED = NCED.clip_cut #ed_scomp = stack_compare(src[edstart:edstart+src_NCED.num_frames-1]+b, src_NCED[:-ed_offset]+b, make_diff=True) # noqa # Masking credits op_mask = dcm( src, src[opstart:opstart+src_NCOP.num_frames], src_NCOP, start_frame=opstart, thr=25, prefilter=True) if opstart is not False \ else get_y(core.std.BlankClip(src)) ed_mask = dcm( src, src[edstart:edstart+src_NCED.num_frames], src_NCED, start_frame=edstart, thr=25, prefilter=True) if edstart is not False \ else get_y(core.std.BlankClip(src)) credit_mask = core.std.Expr([op_mask, ed_mask], expr='x y +') credit_mask = depth(credit_mask, 16).std.Binarize() # Fixing an animation f**k-up for f in op_replace: src = insert_clip(src, src[f], f - 1) # Edgefixing ef = rekt.rektlvls( src, prot_val=[16, 235], min=16, max=235, rownum=[0, src.height - 1], rowval=[16, 16], colnum=[0, src.width - 1], colval=[16, 16], ) bb_y = bbmod(ef, left=1, top=1, right=1, bottom=1, thresh=32, y=True, u=False, v=False) bb_uv = bbmod(bb_y, left=2, top=2, right=2, bottom=2, y=False, u=True, v=True) bb32 = depth(bb_uv, 32) # --- Very specific filtering that should probably be removed for future episodes entirely # Fading for some... well, fades. fade = flt.fader(bb32, start_frame=4437, end_frame=4452) fade = flt.fader(fade, start_frame=18660, end_frame=18697) # Different sport names rkt_aa_ranges: Union[Union[int, None, Tuple[Optional[int], Optional[int]]], List[Union[int, None, Tuple[Optional[int], Optional[int]]]], None] = [ # noqa (8824, 8907), (9828, 9911), (10995, 11078), (11904, 12010) ] rkt_aa = rekt.rekt_fast(fade, fun=lambda x: upscaled_sraa(x), top=854, left=422, bottom=60, right=422) rkt_aa = replace_ranges(fade, rkt_aa, rkt_aa_ranges) # QP GET! rkt_aa2_ranges: Union[Union[int, None, Tuple[Optional[int], Optional[int]]], List[Union[int, None, Tuple[Optional[int], Optional[int]]]], None] = [ # noqa (26333, 26333), (28291, 28344), (30271, 30364) ] rkt_aa2 = rekt.rekt_fast(rkt_aa, fun=lambda x: upscaled_sraa(x), top=714, left=354, bottom=224, right=354) rkt_aa2 = replace_ranges(fade, rkt_aa, rkt_aa2_ranges) # Table stuff rkt_aa3_ranges: Union[Union[int, None, Tuple[Optional[int], Optional[int]]], List[Union[int, None, Tuple[Optional[int], Optional[int]]]], None] = [ # noqa (32797, 32952) ] rkt_aa3 = rekt.rekt_fast(rkt_aa2, fun=lambda x: upscaled_sraa(x), top=488, left=312, bottom=390, right=850) rkt_aa3 = replace_ranges(fade, rkt_aa2, rkt_aa3_ranges) rkt_aa = rkt_aa3 # Clipping error Nyatalante/Achilles fixed_frame = source( JP_BD.workdir.to_str() + r"/assets/01/FGCBD_01_8970_fixed.png", rkt_aa) fix_error = replace_ranges(rkt_aa, fixed_frame, [(8968, 8970)]) sp_out32 = fix_error sp_out16 = depth(sp_out32, 16) # Rescaling l_mask = FreyChen().get_mask(get_y(sp_out16)).morpho.Close(size=6) l_mask = core.std.Binarize(l_mask, 24 << 8).std.Maximum().std.Maximum() scaled, credit_mask = flt.rescaler(sp_out32, height=720, shader_file=shader) scaled = core.std.MaskedMerge(sp_out16, scaled, l_mask) scaled = core.std.MaskedMerge(scaled, sp_out16, credit_mask) # Denoising denoise = flt.multi_denoise(scaled, l_mask) # Anti-aliasing aa_clamped = flt.clamp_aa(denoise, strength=3.0) aa_rfs = replace_ranges(denoise, aa_clamped, aa_ranges) # Fix edges because they get f****d during the denoising and AA stages box = BoundingBox((1, 1), (src.width - 2, src.height - 2)) fix_edges = core.std.MaskedMerge(scaled, aa_rfs, box.get_mask(scaled)) # Regular debanding, but then... deband = flt.multi_debander(fix_edges, sp_out16) # --- More very specific filtering that should almost definitely be removed for other episodes boxes = [ BoundingBox((0, 880), (1920, 200)), BoundingBox((1367, 0), (552, 1080)), BoundingBox((1143, 0), (466, 83)), BoundingBox((1233, 84), (237, 84)), ] boxed_deband = flt.placebo_debander(fix_edges, iterations=2, threshold=8, radius=14, grain=4) boxed_mask = core.std.BlankClip( boxed_deband.std.ShufflePlanes(planes=0, colorfamily=vs.GRAY)) for bx in boxes: # Gonna be awfully slow but OH WELLLLLL boxed_mask = core.std.Expr( [boxed_mask, bx.get_mask(boxed_mask)], "x y max") boxed_deband_merged = core.std.MaskedMerge(deband, boxed_deband, boxed_mask) boxed_deband_merged = replace_ranges(deband, boxed_deband_merged, [(20554, 20625)]) stronger_deband = dumb3kdb(fix_edges, radius=18, threshold=[48, 32]) stronger_deband = replace_ranges(boxed_deband_merged, stronger_deband, [(22547, 22912), (28615, 28846), (33499, 33708), (37223, 37572), (37636, 37791), (38047, 38102), (38411, 38733)]) deband_csharp = ContraSharpening(stronger_deband, scaled, 17) sp_out = deband_csharp # Back to regular graining grain = flt.grain(sp_out) return grain
from vapoursynth import core, GRAY, YUV, YUV444P16, YUV420P10 import awsmfunc as awf import lvsfunc as lvf import havsfunc as haf import vardefunc as vdf from rekt import rektlvls src = core.ffms2.Source("[SubsPlease] Nomad - Megalo Box 2 - 01 (1080p) [99D681F1].mkv") fb = rektlvls(src, colnum=[0, 1919], colval=[15, 15]) fb = rektlvls(fb, rownum=[0, 1079], rowval=[16, 16]) descale = lvf.scale.descale(fb, upscaler=None, height=720, kernel=lvf.kernels.Bicubic(b=0, c=1)) descale = lvf.scale.descale(descale, upscaler=None, height=405, kernel=lvf.kernels.Bicubic(b=0, c=1/2)) downscale = fb.resize.Spline36(width=descale.width, height=descale.height, format=YUV444P16) descale = descale.resize.Spline36(format=YUV444P16) u = core.std.ShufflePlanes(downscale, planes=[1], colorfamily=GRAY) v = core.std.ShufflePlanes(downscale, planes=[2], colorfamily=GRAY) descale = core.std.ShufflePlanes([descale, u, v], planes=[0, 0, 0], colorfamily=YUV) deband = descale.placebo.Deband(threshold=3, radius=8, grain=0) rescale = vdf.fsrcnnx_upscale(deband, 1920, 1080, shader_file="FSRCNNX_x2_56-16-4-1.glsl").resize.Spline36(1920, 1080) rescale = vdf.merge_chroma(rescale, deband.resize.Spline36(width=1920, height=1080)) rescale = awf.ReplaceFrames(rescale, haf.Deblock_QED(src).placebo.Deband(threshold=3, radius=8, grain=0).resize.Spline36(format=YUV444P16), "[0 167] [662 757] [806 901] [950 1045] [1130 1125] [1418 1513] [2514 2637] [32698 34694]") rescale = awf.ReplaceFrames(rescale, fb.placebo.Deband(threshold=3, radius=8, grain=0).resize.Spline36(format=YUV444P16), "[168 601] [25058 25185]") rescale = rescale.resize.Spline36(format=YUV420P10, dither_type="error_diffusion") rescale.set_output()
from vapoursynth import core import havsfunc as haf import awsmfunc as awf from rekt import rektlvls import mvsfunc executive_action_tv = core.lsmas.LWLibavSource("Executive Action.mkv") executive_action_tv = core.std.Crop(executive_action_tv, top=6, bottom=2) executive_action_tv = rektlvls(executive_action_tv, colnum=[2, 1917], colval=[20, 12]) executive_action_tv = core.fb.FillBorders(executive_action_tv, left=2, right=2) executive_action_tv = awf.fb(executive_action_tv, bottom=1) executive_action_tv = awf.bbmod(executive_action_tv, left=6, top=4, bottom=6, thresh=15, blur=20) executive_action_tv = awf.bbmod(executive_action_tv, right=6, thresh=5, blur=20) executive_action_tv = core.resize.Bicubic(executive_action_tv, format=YUV444P8) executive_action_ntsc = core.d2v.Source( "Executive.Action.1973.NTSC.DVD5/VTS_01_1.d2v")[83:] executive_action_ntsc = core.vivtc.VFM(executive_action_ntsc, 1) executive_action_ntsc = core.std.SelectEvery(executive_action_ntsc, cycle=5,
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """Main filterchain""" import havsfunc as haf import lvsfunc as lvf import rekt import vardefunc as vdf from adptvgrnMod import adptvgrnMod from awsmfunc import bbmod from ccd import ccd from vsutil import depth, get_y from xvs import WarpFixChromaBlend src = JP_BD.clip_cut src_NCOP, src_NCED = JP_BD_NCOP.clip_cut, JP_BD_NCED.clip_cut src_NCOP = src_NCOP + src_NCOP[-1] * 11 src_NCED = src_NCED + src_NCED[-1] src_03 = JP_BD_03.clip_cut # b = core.std.BlankClip(src, length=1) # Fixing an animation error in the NCOP sqmask_NCOP = lvf.mask.BoundingBox((419, 827), (1500, 68)) masked_NCOP = core.std.MaskedMerge(src_NCOP, src_03, sqmask_NCOP.get_mask(src_NCOP)) masked_NCOP = lvf.rfs(src_NCOP, masked_NCOP, [(opstart+2064, opstart+2107)]) # OP/ED stack comps to check that it lines up # op_scomp = lvf.scomp(src[opstart:opstart+src_NCOP.num_frames-1]+b, masked_NCOP[:-op_offset]+b) # noqa # ed_scomp = lvf.scomp(src[edstart:edstart+src_NCED.num_frames-1]+b, src_NCED[:-ed_offset]+b) # noqa # Masking credits op_mask = vdf.dcm( src, src[opstart:opstart+src_NCOP.num_frames-op_offset], masked_NCOP[:-op_offset], start_frame=opstart, thr=25, prefilter=True) if opstart is not False \ else get_y(core.std.BlankClip(src)) ed_mask = vdf.dcm( src, src[edstart:edstart+src_NCED.num_frames-ed_offset], src_NCED[:-ed_offset], start_frame=edstart, thr=25, prefilter=False) if edstart is not False \ else get_y(core.std.BlankClip(src)) credit_mask = core.std.Expr([op_mask, ed_mask], expr='x y +') credit_mask = depth(credit_mask, 16).std.Binarize() # Edgefixing rkt = rekt.rektlvls( src, [0, 1079], [17, 16], [0, 1, 2, 3] + [1917, 1918, 1919], [16, 4, -2, 2] + [-2, 5, 14] ) ef = bbmod(rkt, left=4, right=3, y=False) ef = depth(ef, 32) # Descaling + Rescaling src_y = get_y(ef) descaled = lvf.kernels.Bicubic().descale(src_y, 1280, 720) rescaled = vdf.scale.nnedi3_upscale(descaled) downscaled = lvf.kernels.Bicubic(-1/2, 1/4).scale(rescaled, 1920, 1080) l_mask = vdf.mask.FDOG().get_mask(src_y, lthr=0.065, hthr=0.065).std.Maximum().std.Minimum() l_mask = l_mask.std.Median().std.Convolution([1] * 9) rescaled_masked = core.std.MaskedMerge(src_y, downscaled, l_mask) scaled = depth(vdf.misc.merge_chroma(rescaled_masked, ef), 16) unwarp = flt.line_darkening(scaled, 0.145).warp.AWarpSharp2(depth=2) sharp = haf.LSFmod(unwarp, strength=65, Smode=3, Lmode=1, edgemode=1, edgemaskHQ=True) mask_sharp = core.std.MaskedMerge(scaled, sharp, depth(l_mask, 16)) upscaled = lvf.kernels.Bicubic().scale(descaled, 1920, 1080) descale_mask = lvf.scale.descale_detail_mask(src_y, upscaled) scale_restore_mask = core.std.Expr([credit_mask, descale_mask], "x y +") credits_merged = core.std.MaskedMerge(mask_sharp, depth(ef, 16), scale_restore_mask) # Denoising denoise_y = core.knlm.KNLMeansCL(credits_merged, d=1, a=3, s=4, h=0.15, channels='Y') denoise_uv = ccd(denoise_y, threshold=6, matrix='709') stab = haf.GSMC(denoise_uv, radius=2, planes=[0]) decs = vdf.noise.decsiz(stab, sigmaS=8, min_in=208 << 8, max_in=232 << 8) # Fixing chroma cshift = core.resize.Bicubic(decs, chromaloc_in=1, chromaloc=0) cwarp = WarpFixChromaBlend(cshift, thresh=88, blur=3, depth=6) # Regular debanding + graining detail_mask = flt.detail_mask(cwarp, brz=(1800, 3500)) deband = vdf.deband.dumb3kdb(cwarp, threshold=32, grain=16) deband_masked = core.std.MaskedMerge(deband, cwarp, detail_mask) grain: vs.VideoNode = adptvgrnMod(deband_masked, 0.2, luma_scaling=10, size=1.35, static=True, grain_chroma=False) return grain
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]: """Main VapourSynth filterchain""" import debandshit as dbs import havsfunc as haf import lvsfunc as lvf import rekt import vardefunc as vdf from awsmfunc import bbmod from ccd import ccd from muvsfunc import SSIM_downsample from vsutil import depth, get_w, get_y src = JP_BD.clip_cut src = depth(src, 16) rkt_a = rekt.rektlvls(src, [0, 1, -2, -1], [12, -12, -10, 11], [0, 1, -2, -1], [11, -12, -10, 11]) rkt_b = rekt.rektlvls(src, [0, -1], [15, 15], [0, 1, 2, 3, -4, -2, -1], [12, 3, -1, 1, 2, 4, 12]) rkt_c = rekt.rektlvls(src, [-2, -1], [6, 11], [0, -2, -1], [15, 10, 15]) bb_c = bbmod(rkt_c, bottom=2, blur=35, y=False) rkt = lvf.rfs(rkt_a, rkt_b, [(458, 522), (806, 919), (1148, 1179), (1321, 1442), (1989, 2129)]) rkt = lvf.rfs(rkt, bb_c, [(2130, None)]) ef = depth(rkt, 32) src_y = get_y(ef) pre_den = core.dfttest.DFTTest(src_y, sigma=3.0) l_mask = vdf.mask.FDOG().get_mask( pre_den, lthr=0.125, hthr=0.050).rgsf.RemoveGrain(4).rgsf.RemoveGrain(4) l_mask = l_mask.std.Minimum().std.Deflate().std.Median().std.Convolution( [1] * 9).std.Maximum() # Descaling. descaled = lvf.kernels.Catrom().descale( src_y, get_w(720, src_y.width / src_y.height), 720) descaled = core.resize.Bicubic(descaled, format=vs.YUV444P16) # Slight AA in an attempt to forcibly fix starved lineart. baa = lvf.aa.based_aa(descaled, shader_file) sraa = lvf.aa.upscaled_sraa(descaled, rfactor=1.45) clamp_aa = lvf.aa.clamp_aa(descaled, baa, sraa, strength=1.15) clamp_aa = depth(get_y(clamp_aa), 32) # Doing a mixed reupscale using nn3/fsrcnnx, grabbing the darkest parts of each rescaled_nn3 = vdf.scale.nnedi3cl_double(clamp_aa, use_znedi=True, pscrn=1) rescaled_fsrcnnx = vdf.scale.fsrcnnx_upscale(clamp_aa, rescaled_nn3.width, rescaled_nn3.height, shader_file) rescaled = core.std.Expr([rescaled_nn3, rescaled_fsrcnnx], "x y min") downscaled = SSIM_downsample(rescaled, src_y.width, src_y.height, smooth=((3**2 - 1) / 12)**0.5, sigmoid=True, filter_param_a=-1 / 2, filter_param_b=1 / 4) downscaled = core.std.MaskedMerge(src_y, downscaled, l_mask) scaled = depth(vdf.misc.merge_chroma(downscaled, ef), 16) # Chroma warping to forcibly wrap it a bit nicer around the lineart. Also fixing slight shift. 4:2:0 was a mistake. cwarp = scaled.warp.AWarpSharp2(thresh=72, blur=3, type=1, depth=6, planes=[1, 2]) # The textures and detail are very smeary, so gotta be careful not to make it even worse stab = haf.GSMC(cwarp, radius=3, planes=[0], thSAD=75) den_uv = ccd(stab, threshold=5, matrix='709') decs = vdf.noise.decsiz(den_uv, sigmaS=8.0, min_in=200 << 8, max_in=240 << 8) # Scenefiltered debanding. Not graining, since we kept most of the original grain anyway. deband_wk = dbs.debanders.dumb3kdb(decs, radius=16, threshold=[28, 0], grain=0) deband_wk = core.placebo.Deband(deband_wk, iterations=2, threshold=3.5, radius=12, grain=0, planes=2 | 4) # Strong denoising + debanding to hopefully deal with all the awful bands. Courtesy of :b:arde dft = core.dfttest.DFTTest(decs, sigma=4.0) ccd_uv = ccd(dft, threshold=10, matrix='709') f3k = dbs.debanders.dumb3kdb(ccd_uv, radius=8, threshold=[36, 24], grain=0) plac = flt.masked_placebo(f3k, rad=18, thr=5.5, itr=2, grain=3.0, mask_args={ 'detail_brz': 100, 'lines_brz': 450 }) dft_diff = core.std.MakeDiff(decs, dft) plac_diff = core.std.MergeDiff(plac, dft_diff) deband = lvf.rfs(deband_wk, plac_diff, strong_debanding) return deband