def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Main VapourSynth filterchain"""
import EoEfunc as eoe
import havsfunc as haf
import lvsfunc as lvf
import vardefunc as vdf
from vsutil import depth
src = JP_BD.clip_cut
yt = lvf.src(r"src/『魔法使いの夜』ティザーPV-NHIgc-seeSo.mkv", ref=src) \
.std.AssumeFPS(fpsnum=24000, fpsden=1001)
src = core.std.SetFrameProp(src, '_FieldBased', intval=0)
se = core.tivtc.TDecimate(src)
# Fix range compression and missing frame in TV release
csp = core.resize.Bicubic(se,
range_in=0,
range=1,
dither_type="error_diffusion")
csp = csp.std.SetFrameProp(prop="_ColorRange", intval=1)
merge = csp[:400] + yt[400] + csp[400:]
# "Delogoing" and "Edgefixing"
sqmask = lvf.mask.BoundingBox(
(1753, 27),
(118, 50)).get_mask(merge).std.Inflate().std.Inflate().std.Maximum()
sqmask = sqmask.std.Maximum().std.Maximum().std.Median().std.Convolution(
[1] * 9).std.Convolution([1] * 9)
mask_merge = core.std.MaskedMerge(merge, yt[:merge.num_frames], sqmask)
sqmask_ef = lvf.mask.BoundingBox(
(3, 3), (src.width - 3, src.height - 3)).get_mask(mask_merge)
ef = core.std.MaskedMerge(yt, mask_merge, sqmask_ef)
ef = depth(ef, 16)
debl = lvf.deblock.vsdpir(ef, strength=35, cuda=use_cuda)
csharp = eoe.misc.ContraSharpening(debl, ef, radius=2, rep=13)
darken = haf.FastLineDarkenMOD(csharp, strength=24)
deband = core.average.Mean([
flt.masked_f3kdb(darken, rad=16, thr=[28, 20], grain=[16, 6]),
flt.masked_placebo(darken, rad=14, thr=4.5, itr=2, grain=2)
])
grain = vdf.noise.Graigasm(thrs=[x << 8 for x in (32, 80, 128, 176)],
strengths=[(0.15, 0.0), (0.10, 0.0),
(0.05, 0.0), (0.0, 0.0)],
sizes=(1.15, 1.10, 1.05, 1),
sharps=(100, 90, 80, 50),
grainers=[
vdf.noise.AddGrain(seed=69420,
constant=True),
vdf.noise.AddGrain(seed=69420,
constant=False),
vdf.noise.AddGrain(seed=69420,
constant=False)
]).graining(deband)
return grain
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Main VapourSynth filterchain"""
import EoEfunc as eoe
import lvsfunc as lvf
import vardefunc as vdf
from ccd import ccd
from finedehalo import fine_dehalo
from vsutil import depth, get_y
src, ep = JP_BD.clip_cut, JP_EP.clip_cut
ep_ext = ep[0] * 16 + ep # F**K THIS STUDIO HOLY SHIT
src = lvf.rfs(src, ep_ext, [(811, 859)])
src = depth(src, 16)
# This noise can burn in hell.
denoise_pre = get_y(src.dfttest.DFTTest(sigma=1.0))
denoise_ret = core.retinex.MSRCP(denoise_pre, sigma=[50, 200, 350], upper_thr=0.005)
denoise_mask = flt.detail_mask(denoise_ret, sigma=2.0, lines_brz=3000).rgvs.RemoveGrain(4)
denoise_pre = core.dfttest.DFTTest(src, sigma=4.0)
denoise_smd = eoe.dn.CMDegrain(src, tr=5, thSAD=275, freq_merge=True, prefilter=denoise_pre)
denoise_masked = core.std.MaskedMerge(denoise_smd, src, denoise_mask)
denoise_uv = ccd(denoise_masked, threshold=6)
decs = vdf.noise.decsiz(denoise_uv, sigmaS=8, min_in=200 << 8, max_in=235 << 8)
# F**K THIS SHOW'S LINEART HOLY SHIT
baa = lvf.aa.based_aa(decs.std.Transpose(), str(shader_file), gamma=120)
baa = lvf.aa.based_aa(baa.std.Transpose(), str(shader_file), gamma=120)
sraa = lvf.sraa(decs, rfactor=1.4)
clmp_aa = lvf.aa.clamp_aa(decs, baa, sraa, strength=1.65)
# AAing introduces some haloing (zzzzzz)
restr_edges = fine_dehalo(clmp_aa, decs)
restr_dark = core.std.Expr([clmp_aa, restr_edges], "x y min")
deband = core.average.Mean([
flt.masked_f3kdb(restr_dark, rad=17, thr=[28, 20], grain=[12, 8]),
flt.masked_f3kdb(restr_dark, rad=21, thr=[36, 32], grain=[24, 12]),
flt.masked_placebo(restr_dark, rad=6.5, thr=2.5, itr=2, grain=4)
])
grain = vdf.noise.Graigasm(
thrs=[x << 8 for x in (32, 80, 128, 176)],
strengths=[(0.25, 0.0), (0.20, 0.0), (0.15, 0.0), (0.0, 0.0)],
sizes=(1.20, 1.15, 1.10, 1),
sharps=(80, 70, 60, 50),
grainers=[
vdf.noise.AddGrain(seed=69420, constant=True),
vdf.noise.AddGrain(seed=69420, constant=False),
vdf.noise.AddGrain(seed=69420, constant=False)
]).graining(deband)
return grain
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Main VapourSynth filterchain"""
import EoEfunc as eoe
import lvsfunc as lvf
import vardefunc as vdf
from ccd import ccd
from finedehalo import fine_dehalo
from vsutil import depth, get_y, insert_clip
src = JP_BD.clip_cut
src_c = src
src_ncop, src_nced = JP_NCOP.clip_cut, JP_NCED.clip_cut
b = core.std.BlankClip(src, length=1)
# OP/ED stack comps to check if they line up
if opstart is not False:
op_scomp = lvf.scomp(src[opstart:opstart+src_ncop.num_frames-1]+b, src_ncop[:-op_offset]+b) \
.text.Text('src', 7).text.Text('op', 9)
if edstart is not False:
ed_scomp = lvf.scomp(src[edstart:edstart+src_nced.num_frames-1]+b, src_nced[:-ed_offset]+b) \
.text.Text('src', 7).text.Text('ed', 9)
# Splicing in NCs and diff'ing back the credits
if opstart is not False:
src = insert_clip(src, src_ncop[:-op_offset], opstart)
src = lvf.rfs(src, src_c, [(opstart + 811, opstart + 859)])
if edstart is not False:
src = insert_clip(src, src_nced[:-ed_offset], edstart)
den_src, den_ncs = map(partial(core.dfttest.DFTTest, sigma=10),
[src_c, src])
den_src, den_ncs = depth(den_src, 32), depth(den_ncs, 32)
diff = core.std.MakeDiff(den_src, den_ncs).dfttest.DFTTest(sigma=50.0)
# For some reason there's noise from previous credits remaining? Removing that here
diff_brz = vdf.misc.merge_chroma(diff.std.Binarize(0.03), diff)
diff = core.std.Expr([diff, diff_brz], "x y min")
src = depth(src, 16)
# This noise can burn in hell.
denoise_pre = get_y(src.dfttest.DFTTest(sigma=1.0))
denoise_ret = core.retinex.MSRCP(denoise_pre,
sigma=[50, 200, 350],
upper_thr=0.005)
denoise_mask = flt.detail_mask(denoise_ret, sigma=2.0,
lines_brz=3000).rgvs.RemoveGrain(4)
denoise_pre = core.dfttest.DFTTest(src, sigma=4.0)
denoise_smd = eoe.dn.CMDegrain(src,
tr=5,
thSAD=275,
freq_merge=True,
prefilter=denoise_pre)
denoise_masked = core.std.MaskedMerge(denoise_smd, src, denoise_mask)
denoise_uv = ccd(denoise_masked, threshold=6)
decs = vdf.noise.decsiz(denoise_uv,
sigmaS=8,
min_in=200 << 8,
max_in=235 << 8)
# F**K THIS SHOW'S LINEART HOLY SHIT
baa = lvf.aa.based_aa(decs.std.Transpose(), str(shader_file), gamma=120)
baa = lvf.aa.based_aa(baa.std.Transpose(), str(shader_file), gamma=120)
sraa = lvf.sraa(decs, rfactor=1.4)
clmp_aa = lvf.aa.clamp_aa(decs, baa, sraa, strength=1.65)
# AAing introduces some haloing (zzzzzz)
restr_edges = fine_dehalo(clmp_aa, decs)
restr_dark = core.std.Expr([clmp_aa, restr_edges], "x y min")
# Masking credits at the end if there's no NCED
get_max = core.std.Expr([restr_dark, decs], "x y max")
if opstart is False:
restr_dark = lvf.rfs(restr_dark, get_max, [(None, 3500)])
if edstart is False:
restr_dark = lvf.rfs(restr_dark, get_max, [(-5000, None)])
deband = core.average.Mean([
flt.masked_f3kdb(restr_dark, rad=17, thr=[28, 20], grain=[12, 8]),
flt.masked_f3kdb(restr_dark, rad=21, thr=[36, 32], grain=[24, 12]),
flt.masked_placebo(restr_dark, rad=6.5, thr=2.5, itr=2, grain=4)
])
grain = vdf.noise.Graigasm(thrs=[x << 8 for x in (32, 80, 128, 176)],
strengths=[(0.25, 0.0), (0.20, 0.0),
(0.15, 0.0), (0.0, 0.0)],
sizes=(1.20, 1.15, 1.10, 1),
sharps=(80, 70, 60, 50),
grainers=[
vdf.noise.AddGrain(seed=69420,
constant=True),
vdf.noise.AddGrain(seed=69420,
constant=False),
vdf.noise.AddGrain(seed=69420,
constant=False)
]).graining(deband)
merge_creds = core.std.MergeDiff(depth(grain, 32), diff)
return merge_creds
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Main VapourSynth filterchain"""
import havsfunc as haf
import lvsfunc as lvf
import vardefunc as vdf
from ccd import ccd
from muvsfunc import SSIM_downsample
from vsutil import depth, get_y
src = JP_BD.clip_cut
src = depth(src, 32)
src_y = get_y(src)
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)
# Rescaling
descale = flt.auto_descale(src_y)
desc_i = flt.descale_fields(src_y, kernel=lvf.kernels.BicubicSharp)
descale = lvf.rfs(descale, desc_i, [(1555, 1685)])
supersample = vdf.scale.nnedi3cl_double(descale, use_znedi=True, pscrn=1)
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_mask = core.std.MaskedMerge(src_y, downscaled, l_mask)
scaled = depth(vdf.misc.merge_chroma(scaled_mask, src), 16)
# Denoising
l_mask_16 = depth(l_mask, 16).std.Minimum()
dft = core.dfttest.DFTTest(scaled, sigma=1.25, tbsize=3, tosize=1)
dft_masked = core.std.MaskedMerge(dft, scaled, l_mask_16)
ccd_uv = ccd(dft, threshold=4, matrix='709')
ccd_uv = core.std.MaskedMerge(ccd_uv, dft_masked, l_mask_16, planes=[1, 2])
decs = vdf.noise.decsiz(ccd_uv, sigmaS=4, min_in=212 << 8, max_in=240 << 8)
# AA and slight lineart enhancement
baa = lvf.aa.based_aa(decs, shader_file)
sraa = lvf.sraa(decs, rfactor=1.5, downscaler=lvf.kernels.Bicubic(b=-1/2, c=1/4).scale)
clmp = lvf.aa.clamp_aa(decs, baa, sraa, strength=1.5)
sraa_strong = flt.transpose_sraa(decs, rfactor=1.2, downscaler=lvf.kernels.Bicubic(b=-1/2, c=1/4).scale)
clmp = lvf.rfs(clmp, sraa_strong, [])
darken = haf.FastLineDarkenMOD(clmp, strength=36)
# Debanding and graining
deband = core.average.Mean([
flt.masked_f3kdb(darken, rad=18, thr=[28, 24]),
flt.masked_placebo(darken, rad=15, thr=4)
])
grain = vdf.noise.Graigasm(
thrs=[x << 8 for x in (32, 80, 128, 176)],
strengths=[(0.15, 0.0), (0.10, 0.0), (0.10, 0.0), (0.0, 0.0)],
sizes=(1.15, 1.10, 1.05, 1),
sharps=(60, 50, 50, 50),
grainers=[
vdf.noise.AddGrain(seed=69420, constant=True),
vdf.noise.AddGrain(seed=69420, constant=True),
vdf.noise.AddGrain(seed=69420, constant=True)
]).graining(deband)
return grain
def 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
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
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
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Main VapourSynth filterchain"""
import EoEfunc as eoe
import lvsfunc as lvf
import vardefunc as vdf
from ccd import ccd
from finedehalo import fine_dehalo
from vsutil import depth, get_y
src = JP_BD.clip_cut
src = depth(src, 16)
# This noise can burn in hell.
denoise_pre = get_y(src.dfttest.DFTTest(sigma=1.0))
denoise_ret = core.retinex.MSRCP(denoise_pre, sigma=[50, 200, 350], upper_thr=0.005)
denoise_mask = flt.detail_mask(denoise_ret, sigma=2.0, lines_brz=3000).rgvs.RemoveGrain(4)
denoise_pre = core.dfttest.DFTTest(src, sigma=4.0)
denoise_smd = eoe.dn.CMDegrain(src, tr=5, thSAD=275, freq_merge=True, prefilter=denoise_pre)
denoise_masked = core.std.MaskedMerge(denoise_smd, src, denoise_mask)
denoise_uv = ccd(denoise_masked, threshold=6)
decs = vdf.noise.decsiz(denoise_uv, sigmaS=8, min_in=200 << 8, max_in=235 << 8)
# F**K THIS SHOW'S LINEART HOLY SHIT
baa = lvf.aa.based_aa(decs.std.Transpose(), str(shader_file), gamma=120)
baa = lvf.aa.based_aa(baa.std.Transpose(), str(shader_file), gamma=120)
sraa = lvf.sraa(decs, rfactor=1.4)
clmp_aa = lvf.aa.clamp_aa(decs, baa, sraa, strength=1.65)
# AAing introduces some haloing (zzzzzz)
restr_edges = fine_dehalo(clmp_aa, decs)
restr_dark = core.std.Expr([clmp_aa, restr_edges], "x y min")
deband = core.average.Mean([
flt.masked_f3kdb(restr_dark, rad=17, thr=[28, 20], grain=[12, 8]),
flt.masked_f3kdb(restr_dark, rad=21, thr=[36, 32], grain=[24, 12]),
flt.masked_placebo(restr_dark, rad=6.5, thr=2.5, itr=2, grain=4)
])
grain = vdf.noise.Graigasm(
thrs=[x << 8 for x in (32, 80, 128, 176)],
strengths=[(0.25, 0.0), (0.20, 0.0), (0.15, 0.0), (0.0, 0.0)],
sizes=(1.20, 1.15, 1.10, 1),
sharps=(80, 70, 60, 50),
grainers=[
vdf.noise.AddGrain(seed=69420, constant=True),
vdf.noise.AddGrain(seed=69420, constant=False),
vdf.noise.AddGrain(seed=69420, constant=False)
]).graining(deband)
# Masking credits at the end
get_max = core.std.Expr([grain, decs], "x y max")
sq_mask = [
lvf.mask.BoundingBox((782, 603), (507, 389)),
lvf.mask.BoundingBox((0, 957), (1920, 123)),
lvf.mask.BoundingBox((1139, 835), (478, 142))
]
sqmask = core.std.BlankClip(get_y(src))
for sq in sq_mask:
mask = sq.get_mask(src).std.BoxBlur(hpasses=20, vpasses=20)
sqmask = core.std.Expr([mask, sqmask], "x y +")
max_masked = core.std.MaskedMerge(get_max, grain, sqmask)
max_ed = lvf.rfs(grain, max_masked, (5467, None))
return max_ed
