def recreate_OP1E():
src_nc = OP1D.clip_cut
src_ep = EP13.clip_cut[6954:6954 + src_nc.num_frames]
op = lvf.rfs(src_nc, src_ep, [(2048, 2156)])
mask = vdf.dcm(op,
op[0:src_nc.num_frames - 1],
src_nc,
0,
thr=248,
prefilter=True)
merge = core.std.MaskedMerge(op, src_nc, mask[2075])
op = lvf.rfs(op, merge, [(2048, 2092)])
pause = src_ep.std.FreezeFrames(2111, src_ep.num_frames - 1, 2111)
fade = kgf.crossfade(pause[0:2159], core.std.BlankClip(pause),
32)[0:src_nc.num_frames]
merge = core.std.MaskedMerge(op, fade,
mask[2155].std.Minimum().std.Minimum())
op = lvf.rfs(op, merge, [(2112, 2156)])
pause = op.std.FreezeFrames(2121, op.num_frames - 1, 2121)
fade = kgf.crossfade(pause[0:2159], core.std.BlankClip(pause),
32)[0:src_nc.num_frames]
merge = core.std.MaskedMerge(op, fade,
mask[2155].std.Minimum().std.Minimum())
op = lvf.rfs(op, merge, [(2112, 2156)])
mask_img = core.imwri.Read(MASK).resize.Point(format=fade.format.id,
matrix_s="709")
mask = core.std.Binarize(mask_img, 128).std.Maximum().std.Deflate()
return core.std.MaskedMerge(fade, op, mask, [0, 1, 2])
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
src = depth(src, 16)
out = src
ref = hvf.SMDegrain(out, thSAD=300)
denoise = mvf.BM3D(out, [1.5, 1.25], radius1=1, ref=ref)
out = denoise
crop = core.std.Crop(out, left=12)
crop = awf.bbmod(crop, left=2, thresh=20 << 8)
resize = core.resize.Bicubic(crop, 1920)
out = lvf.rfs(out, resize, [(78, 89)])
y = get_y(out)
lineart = gf.EdgeDetect(y, 'scharr').morpho.Dilate(2, 2).std.Inflate()
fkrescale = fake_rescale(
y, 882, 0, 1,
deringer=lambda x: gf.MaskedDHA(x, rx=1.85, ry=1.85, darkstr=0.25, brightstr=1.0, maskpull=100, maskpush=200),
antialiser=lambda c: lvf.sraa(c, 2, 13, downscaler=core.resize.Bicubic)
)
merged = core.std.MaskedMerge(y, fkrescale, lineart)
out = vdf.merge_chroma(merged, out)
dering = hvf.EdgeCleaner(out, 17, smode=1, hot=True)
out = dering
out = lvf.rfs(
out, denoise,
[(0, 11), (38, 77), (115, 133), (316, 395), (441, 460), (606, 779), (825, 844), (990, 1127)]
)
detail_mask = lvf.mask.detail_mask(out, brz_a=2250, brz_b=1000)
deband = vdf.dumb3kdb(out, 15, threshold=17, grain=(24, 0))
deband = core.std.MaskedMerge(deband, out, detail_mask)
out = deband
grain = adptvgrnMod(out, 0.3, static=True, grain_chroma=False, hi=[128, 240], seed=333)
out = grain
decz = vdf.decsiz(out, min_in=128 << 8, max_in=200 << 8)
out = decz
return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2], [0, 1, 2])
def pre_corrections() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""
There were a couple animation 'fixes' in the BDs that I'm reverting here.
Alongside that, they also introduced a couple of errors occasionally which I also fix here.
Comments with examples of what I'm changing/fixing included if big enough.
"""
import lvsfunc as lvf
src_BD = JP_BD.clip_cut
src_WEB = JP_WEB.clip_cut
# Make sure the Waka rip matches up to the BD as much as it has to
src_WEB = src_WEB[:2421] + src_WEB[2420] + src_WEB[2421:]
# Fix mouth misplacement introduced on BDs — https://slow.pics/c/NE6vqUdq
sqmask = lvf.mask.BoundingBox(
(1084, 663), (225, 200)).get_mask(src_BD).bilateral.Gaussian(sigma=10)
fixed = lvf.rfs(src_BD, src_BD.std.MaskedMerge(src_WEB, sqmask),
[(1226, 1227)])
# Fix bit of rope they deleted on the BDs — https://slow.pics/c/JdVX7Chb
sqmask = lvf.mask.BoundingBox((1841, 458), (67, 17)).get_mask(fixed)
fixed = lvf.rfs(fixed, fixed.std.MaskedMerge(src_WEB, sqmask),
[(3330, 3365)])
return fixed
def pre_corrections() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""
There were a couple animation 'fixes' in the BDs that I'm reverting here.
Alongside that, they also introduced a couple of errors occasionally which I also fix here.
Comments with examples of what I'm changing/fixing included if big enough.
"""
import lvsfunc as lvf
src_BD = JP_BD.clip_cut
src_WEB = JP_WEB.clip_cut
# Make sure the Waka rip matches up to the BD as much as it has to
src_WEB = src_WEB[0] + src_WEB
# Undoing a Saya face redraw — https://slow.pics/c/zFGJBtNc
sqmask = lvf.mask.BoundingBox(
(1397, 370), (86, 74)).get_mask(src_BD).bilateral.Gaussian(sigma=10)
fixed = lvf.rfs(src_BD, src_BD.std.MaskedMerge(src_WEB, sqmask),
[(21248, 21310)])
# Another face redraw undo — https://slow.pics/c/QoxjoSeB
sqmask = lvf.mask.BoundingBox(
(1310, 356), (94, 80)).get_mask(src_BD).bilateral.Gaussian(sigma=10)
fixed = lvf.rfs(fixed, fixed.std.MaskedMerge(src_WEB, sqmask),
[(21447, 21493)])
# Very minor line f**k-up
sqmask = lvf.mask.BoundingBox((1320, 478), (8, 14)).get_mask(src_BD)
fixed = lvf.rfs(fixed, fixed.std.MaskedMerge(src_WEB, sqmask),
[(21452, 21454)])
return fixed
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 = 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
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() -> vs.VideoNode:
"""Vapoursynth filtering"""
src = JPBD.src_cut
out = src
luma = get_y(out)
rows = [
core.std.CropAbs(luma, out.width, 1, top=out.height - 1),
core.std.CropAbs(luma, out.width, 1, top=out.height - 2)
]
diff = core.std.Expr(rows, 'x y - abs').std.PlaneStats()
row_fix = vdf.merge_chroma(
luma.fb.FillBorders(bottom=1, mode="fillmargins"),
out.fb.FillBorders(bottom=2, mode="fillmargins"))
fixrow = core.std.FrameEval(out,
partial(_select_row, clip=out,
row_fix=row_fix),
prop_src=diff)
out = fixrow
fixedge_a = awf.bbmod(out, 1, 1, 1, 1, 20, blur=700, u=False, v=False)
fixedge = out
fixedge = lvf.rfs(fixedge, fixedge_a, [(EDSTART + 309, EDEND)])
out = fixedge
out = depth(out, 16)
dehalo = gf.MaskedDHA(out, rx=1.4, ry=1.4, darkstr=0.02, brightstr=1)
dehalo = lvf.rfs(out, dehalo, [(EDEND + 1, src.num_frames - 1)])
out = dehalo
resize = core.std.Crop(out, right=12, bottom=8).resize.Bicubic(1920, 1080)
resize = lvf.rfs(out, resize, [(27005, 27076)])
out = resize
# Denoising only the chroma
pre = hvf.SMDegrain(out, tr=2, thSADC=300, plane=3)
planes = split(out)
planes[1], planes[2] = [
mvf.BM3D(planes[i], 1.25, radius2=2, pre=plane(pre, i))
for i in range(1, 3)
]
out = join(planes)
preden = core.dfttest.DFTTest(out, sbsize=16, sosize=12, tbsize=1)
detail_mask = lvf.mask.detail_mask(preden, brz_a=2500, brz_b=1500)
deband = vdf.dumb3kdb(preden, 16, threshold=[17, 17], grain=[24, 0])
deband = core.std.MergeDiff(deband, out.std.MakeDiff(preden))
deband = core.std.MaskedMerge(deband, out, detail_mask)
out = deband
decz = vdf.decsiz(out, min_in=128 << 8, max_in=192 << 8)
out = decz
return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2], [0, 1, 2])
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Main filterchain"""
import EoEfunc as eoe
import havsfunc as haf
import lvsfunc as lvf
import vardefunc as vdf
from adptvgrnMod import adptvgrnMod
from ccd import ccd
from vsutil import depth
src = JP_BD.clip_cut
src = depth(src, 16)
# Native 855p OP.
scaled, descale_mask = flt.rescaler(src, height=855)
# Weak denoising for most of the clip to smoothen out the compression noise. Stronger over heavy grain scenes.
denoise_y_wk = core.knlm.KNLMeansCL(scaled, d=2, a=3, h=0.3)
denoise_y_str = eoe.dn.BM3D(scaled, sigma=[0.85, 0])
denoise_y = lvf.rfs(denoise_y_wk, denoise_y_str, [(273, 676),
(1303, 1428)])
denoise_uv = ccd(denoise_y, threshold=9, matrix='709')
# Grain stabilising and blurring away super bright areas to save more filesize by limiting intra-frame differences.
stab = haf.GSMC(denoise_uv, radius=1, thSAD=250, planes=[0])
decs = vdf.noise.decsiz(stab, sigmaS=8, min_in=200 << 8, max_in=232 << 8)
# Clamped AA to try and force ufo's meh lineart along and deal with some leftover lineart fuckery from rescaling.
aa_weak = lvf.aa.nneedi3_clamp(decs, strength=4)
aa_strong = lvf.sraa(decs, rfactor=1.6)
aa_clamp = lvf.aa.clamp_aa(decs, aa_weak, aa_strong, strength=2)
# AA has a tendency to slightly brighten lines, so we perform pretty weak line darkening here
halo_mask = lvf.mask.halo_mask(aa_clamp)
darken = flt.line_darkening(aa_clamp, strength=0.35)
dehalo = core.std.MaskedMerge(
darken, lvf.dehalo.bidehalo(darken, sigmaS_final=1.2, sigmaR=11 / 255),
halo_mask)
# But the dehaloing also destroys select scenes too much, so we undo that here.
no_dehalo_aa = lvf.rfs(dehalo, decs, [(2967, 3031)])
merged_credits = core.std.MaskedMerge(no_dehalo_aa, src, descale_mask)
# Medium debanding. Smears the darker backgrounds a tiny bit, but the added grain should help hide that.
deband = flt.masked_f3kdb(merged_credits,
rad=21,
thr=[28, 24],
grain=[32, 16])
grain: vs.VideoNode = adptvgrnMod(deband,
seed=42069,
strength=0.25,
luma_scaling=10,
size=1.35,
sharp=80,
grain_chroma=False)
return grain
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Main filterchain"""
import havsfunc as haf
import lvsfunc as lvf
import vardefunc as vdf
from adptvgrnMod import adptvgrnMod
from ccd import ccd
from vsutil import depth
src = JP_BD.clip_cut
src = depth(src, 16)
scaled, descale_mask = flt.rescaler(src, height=855)
denoise_y = core.knlm.KNLMeansCL(scaled, d=2, a=3, h=0.15)
denoise_uv = ccd(denoise_y, threshold=7, matrix='709')
denoise_uv_str = ccd(denoise_y, threshold=15, matrix='709')
denoise_uv = lvf.rfs(denoise_uv, denoise_uv_str, [(1999, 2041)])
stab = haf.GSMC(denoise_uv, radius=1, thSAD=200, planes=[0])
decs = vdf.noise.decsiz(stab, sigmaS=8, min_in=200 << 8, max_in=232 << 8)
aa_weak = lvf.aa.nneedi3_clamp(decs, strength=4)
aa_strong = lvf.sraa(decs, rfactor=1.6)
aa_clamp = lvf.aa.clamp_aa(decs, aa_weak, aa_strong, strength=2)
halo_mask = lvf.mask.halo_mask(aa_clamp)
darken = flt.line_darkening(aa_clamp, strength=0.35)
dehalo = core.std.MaskedMerge(
darken, lvf.dehalo.bidehalo(darken, sigmaS_final=1.2, sigmaR=11 / 255),
halo_mask)
# ufo w h y y y y y this is why I hate working on your shows
halo_mask_str = lvf.mask.halo_mask(aa_clamp, rad=1, brz=0.9, thlima=0.55)
dehalo_str = core.std.MaskedMerge(
darken,
lvf.dehalo.bidehalo(darken,
sigmaS=4.0,
sigmaS_final=3.6,
sigmaR=22 / 255), halo_mask_str)
dehalo = lvf.rfs(dehalo, dehalo_str, [(2042, 2077)])
merged_credits = core.std.MaskedMerge(dehalo, src, descale_mask)
deband = flt.masked_f3kdb(merged_credits,
rad=21,
thr=[28, 24],
grain=[32, 16])
grain: vs.VideoNode = adptvgrnMod(deband,
seed=42069,
strength=0.25,
luma_scaling=10,
size=1.35,
sharp=80,
grain_chroma=False)
return grain
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
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"""
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"""
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 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"""
src = JPBD.src_cut
src = depth(src, 32)
edstart, edend = 14969, src.num_frames - 1
denoise = mvf.BM3D(src, 1.1, radius1=1, depth=16)
out = denoise
antialias = lvf.sraa(out,
2,
13,
downscaler=core.resize.Bicubic,
gamma=500,
nrad=2,
mdis=16)
out = antialias
deband_mask = lvf.denoise.detail_mask(out, brz_a=2250,
brz_b=1600).std.Median()
deband = dbs.f3kbilateral(out, 17, 48, 48)
deband_a = dbs.f3kbilateral(out, 22, 96, 96)
deband = lvf.rfs(deband, deband_a, [(edstart, edend)])
deband = core.std.MaskedMerge(deband, out, deband_mask)
out = deband
grain = core.grain.Add(out, 0.3, constant=True)
out = grain
endcard = endcard_source(
r'endcards\yande.re 611483 isekai_quartet iwamoto_tatsurou maid ram_(re_zero) rem_(re_zero) sketch tanya_degurechaff tate_no_yuusha_no_nariagari uniform youjo_senki.jpg',
src)
endcard_ar = endcard.width / endcard.height
endcard_ev = bool(endcard.format.name == 'YUV420P8')
if endcard_ar > 16 / 9:
w, h = get_w(src.height, endcard_ar, only_even=endcard_ev), src.height
elif endcard_ar < 16 / 9:
w, h = src.width, get_h(src.width, endcard_ar, only_even=endcard_ev)
else:
w, h = src.width, src.height
endcard = core.resize.Bicubic(endcard,
w,
h,
vs.YUV444PS,
range_in=1,
range=0,
dither_type='error_diffusion')
endcard = mvf.BM3D(endcard, 0.5)
endcard = core.std.CropAbs(endcard,
1920,
1080,
top=round((endcard.height - 1080) / 2 / 2) * 2)
final = core.std.Splice([out, endcard * (17263 - src.num_frames)],
mismatch=True)
return core.resize.Bicubic(final,
format=vs.YUV420P10,
dither_type='error_diffusion')
def do_filter():
"""Vapoursynth filtering"""
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 antialias(
clip: vs.VideoNode,
heavy: Optional[Union[int, Tuple[int, int]]] = None) -> vs.VideoNode:
aa_lo = lvf.aa.taa(clip, lvf.aa.nnedi3())
aa_hi = lvf.aa.upscaled_sraa(clip, 1.5)
aa_clamp = lvf.aa.clamp_aa(clip, aa_lo, aa_hi, strength=2)
aa = lvf.rfs(aa_clamp, aa_hi, ranges=heavy)
return aa
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 vsutil import depth
src = JP_BD.clip_cut
cloc = core.resize.Bicubic(src, chromaloc_in=2, chromaloc=0)
src = depth(cloc, 16)
halo_mask = lvf.mask.halo_mask(src, rad=1, brz=0.85, thmi=0.35, thma=0.95)
halo_mask = halo_mask.std.Maximum().std.Inflate()
bidehalo = lvf.dehalo.bidehalo(src,
sigmaR=8 / 255,
sigmaS=2.0,
sigmaS_final=1.5)
dehalo_den = core.dfttest.DFTTest(bidehalo, sigma=8.0)
dehalo_clean = haf.EdgeCleaner(dehalo_den, strength=8, smode=1, hot=True)
dehalo = core.std.MaskedMerge(src, dehalo_clean, halo_mask)
# Certain cuts have a strong camera effect that amplifies haloing, and is likely intentional
dehalo = lvf.rfs(dehalo, src, [(773, 786), (867, 886)])
denoise = core.dfttest.DFTTest(dehalo, sigma=1.75)
cdenoise = ccd(denoise, threshold=4, matrix='709')
decs = vdf.noise.decsiz(cdenoise,
sigmaS=8.0,
min_in=208 << 8,
max_in=232 << 8)
baa = lvf.aa.based_aa(decs, str(shader_file))
sraa = lvf.sraa(decs, rfactor=1.45)
clmp = lvf.aa.clamp_aa(decs, baa, sraa, strength=1.45)
darken = haf.FastLineDarkenMOD(clmp, strength=12)
# Debanding and graining
deband = flt.masked_f3kdb(darken, rad=18, thr=[24, 20])
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=(70, 60, 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 filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Regular VapourSynth filterchain"""
import EoEfunc as eoe
import havsfunc as haf
import lvsfunc as lvf
import vardefunc as vdf
from adptvgrnMod import adptvgrnMod
from ccd import ccd
from muvsfunc import SSIM_downsample
from vsutil import depth, get_y, iterate
src = pre_freeze().std.AssumeFPS(fpsnum=24000, fpsden=1001)
src = depth(src, 16)
# TO-DO: Figure out how they post-sharpened it. Probably some form of unsharpening?
src_y = depth(get_y(src), 32)
descale = lvf.kernels.Bicubic(b=0, c=3 / 4).descale(src_y, 1440, 810)
double = vdf.scale.nnedi3cl_double(descale, pscrn=1)
rescale = depth(SSIM_downsample(double, 1920, 1080), 16)
scaled = vdf.misc.merge_chroma(rescale, src)
denoise = core.knlm.KNLMeansCL(scaled, d=1, a=3, s=4, h=0.4, channels='Y')
stab = haf.GSMC(denoise, radius=2, planes=[0])
cdenoise = ccd(stab, threshold=5, matrix='709')
decs = vdf.noise.decsiz(cdenoise,
sigmaS=4,
min_in=208 << 8,
max_in=232 << 8)
dehalo = haf.YAHR(decs, blur=2, depth=32)
halo_mask = lvf.mask.halo_mask(decs, rad=3, brz=0.3, thma=0.42)
dehalo_masked = core.std.MaskedMerge(decs, dehalo, halo_mask)
dehalo_min = core.std.Expr([dehalo_masked, decs], "x y min")
aa = lvf.aa.nneedi3_clamp(dehalo_min, strength=1.5)
# Some scenes have super strong aliasing that I really don't wanna scenefilter until BDs. Thanks, Silver Link!
aa_strong = lvf.sraa(dehalo_min, rfactor=1.35)
aa_spliced = lvf.rfs(aa, aa_strong, [])
upscale = lvf.kernels.Bicubic(b=0, c=3 / 4).scale(descale, 1920, 1080)
credit_mask = lvf.scale.descale_detail_mask(src_y, upscale, threshold=0.08)
credit_mask = iterate(credit_mask, core.std.Deflate, 3)
credit_mask = iterate(credit_mask, core.std.Inflate, 3)
credit_mask = iterate(credit_mask, core.std.Maximum, 2)
merge_credits = core.std.MaskedMerge(aa_spliced, src,
depth(credit_mask, 16))
deband = flt.masked_f3kdb(merge_credits, rad=18, thr=32, grain=[24, 0])
grain: vs.VideoNode = adptvgrnMod(deband,
seed=42069,
strength=0.15,
luma_scaling=10,
size=1.25,
sharp=80,
static=True,
grain_chroma=False)
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, 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"""
opstart_ep10 = 768
ncop = JPBD_NCOP.src_cut
ep10 = JPBD_10.src_cut
ncop = lvf.rfs(ncop, ep10[opstart_ep10:], [(0, 79), (1035, 1037)])
return ncop
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
src = depth(src, 16)
out = src
opstart, opend = 1080, 3236
edstart, edend = 30593, 32751
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.25, 3, downscaler=core.resize.Bicubic)
antialias = lvf.rfs(antialias, antialias_b, [(12113, 12157), (12760, 12826), (14023, 14079),
(23982, 24031), (27733, 27803)])
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 filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Main filterchain"""
import debandshit as dbs
import havsfunc as haf
import lvsfunc as lvf
import vardefunc as vdf
from adptvgrnMod import adptvgrnMod
from vsutil import depth
src = JP_BD.clip_cut
src = depth(src, 16)
up = vdf.scale.to_444(src, src.width, src.height, join_planes=True)
cbl = haf.FixChromaBleedingMod(up,
cx=-0.35,
cy=0,
thr=4,
strength=1,
blur=False)
debl = lvf.deblock.vsdpir(cbl,
matrix=1,
strength=25,
mode='deblock',
i444=True)
aa = lvf.aa.nneedi3_clamp(debl, strength=1.5)
aa = lvf.rfs(debl, aa, aliasing_ranges)
aa = depth(aa, 16).std.Limiter(16 >> 8, [235 << 8, 240 << 8], [0, 1, 2])
dehalo = lvf.dehalo.masked_dha(aa, brightstr=0.35)
dehalo = lvf.rfs(aa, dehalo, haloing_ranges)
deband = dbs.dumb3kdb(dehalo, threshold=[16, 12])
grain: vs.VideoNode = adptvgrnMod(deband,
strength=0.15,
size=1.15,
sharp=70,
grain_chroma=False,
static=False,
seed=42069,
luma_scaling=10)
return grain
def deband(
clip: vs.VideoNode,
lineart: vs.VideoNode,
heavy: Optional[Union[int, Tuple[int, int]]] = None) -> vs.VideoNode:
detail_mask = lvf.mask.detail_mask(clip, brz_a=0.03)
deband_lo = dumb3kdb(clip, radius=16, threshold=36)
deband_hi = dumb3kdb(clip, radius=18, threshold=72)
deband_replace = lvf.rfs(deband_lo, deband_hi, ranges=heavy)
deband = core.std.MaskedMerge(deband_replace, lineart, detail_mask)
return deband
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
src = depth(src, 32)
edstart, edend = 14313, 16383
denoise = mvf.BM3D(src, 1.1, radius1=1, depth=16)
out = denoise
antialias = lvf.sraa(out,
2,
13,
downscaler=core.resize.Bicubic,
gamma=500,
nrad=2,
mdis=16)
out = antialias
deband_mask = lvf.denoise.detail_mask(out, brz_a=2250,
brz_b=1600).std.Median()
deband = dbs.f3kbilateral(out, 17, 48, 48)
deband_a = dbs.f3kbilateral(out, 22, 96, 96)
deband = lvf.rfs(deband, deband_a, [(edstart, edend)])
deband = core.std.MaskedMerge(deband, out, deband_mask)
out = deband
grain = core.grain.Add(out, 0.3, constant=True)
out = grain
endcard = endcard_source(
r'endcards\yande.re 607473 cheerleader isekai_quartet pointy_ears ram_(re_zero) rem_(re_zero) satou_kazuma seifuku tagme tanya_degurechaff trap youjo_senki.jpg',
src)
endcard_ar = endcard.width / endcard.height
endcard_ev = bool(endcard.format.name == 'YUV420P8')
if endcard_ar > 16 / 9:
w, h = get_w(src.height, endcard_ar, only_even=endcard_ev), src.height
elif endcard_ar < 16 / 9:
w, h = src.width, get_h(src.width, endcard_ar, only_even=endcard_ev)
else:
w, h = src.width, src.height
endcard = core.resize.Bicubic(endcard,
w,
h,
range_in=1,
range=0,
dither_type='error_diffusion')
endcard = lvf.sraa(depth(endcard, 16), 1.5, 7)
final = core.std.Splice([out, endcard * (17263 - src.num_frames)],
mismatch=True)
return core.resize.Bicubic(final,
format=vs.YUV420P10,
dither_type='error_diffusion')
def 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 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 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, ...]]:
"""Regular VapourSynth filterchain"""
import havsfunc as haf
import lvsfunc as lvf
import vardefunc as vdf
from adptvgrnMod import adptvgrnMod
from muvsfunc import SSIM_downsample
from vsutil import depth, get_y, iterate
src = pre_freeze()
src = depth(src, 16)
src_y = depth(get_y(src), 32)
descale = lvf.kernels.Bicubic(b=0, c=3 / 4).descale(src_y, 1440, 810)
double = vdf.scale.nnedi3cl_double(descale, pscrn=1)
rescale = depth(SSIM_downsample(double, 1920, 1080), 16)
scaled = vdf.misc.merge_chroma(rescale, src)
denoise = core.knlm.KNLMeansCL(scaled, d=1, a=3, s=4, h=0.3, channels='Y')
decs = vdf.noise.decsiz(denoise,
sigmaS=4,
min_in=208 << 8,
max_in=232 << 8)
dehalo = haf.YAHR(decs, blur=2, depth=28)
halo_mask = lvf.mask.halo_mask(decs, rad=3, brz=0.3, thma=0.42)
dehalo_masked = core.std.MaskedMerge(decs, dehalo, halo_mask)
aa = lvf.aa.nneedi3_clamp(dehalo_masked, strength=1.5)
# Strong aliasing on the transformation scene (and probably elsewhere that I missed). Thanks, Silver Link!
aa_strong = lvf.sraa(dehalo_masked, rfactor=1.35)
aa_spliced = lvf.rfs(aa, aa_strong, [(7056, 7322)])
upscale = lvf.kernels.Bicubic(b=0, c=3 / 4).scale(descale, 1920, 1080)
credit_mask = lvf.scale.descale_detail_mask(src_y, upscale, threshold=0.08)
credit_mask = iterate(credit_mask, core.std.Deflate, 3)
credit_mask = iterate(credit_mask, core.std.Inflate, 3)
credit_mask = iterate(credit_mask, core.std.Maximum, 2)
merge_credits = core.std.MaskedMerge(aa_spliced, src,
depth(credit_mask, 16))
deband = flt.masked_f3kdb(merge_credits, rad=18, thr=32, grain=[24, 0])
grain: vs.VideoNode = adptvgrnMod(deband,
seed=42069,
strength=0.15,
luma_scaling=10,
size=1.25,
sharp=80,
static=True,
grain_chroma=False)
return grain
