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 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 vapoursynthFilter(self):
if VSCORE_MEM_CACHE_MAX is not None:
core.max_cache_size = VSCORE_MEM_CACHE_MAX
video = core.ffms2.Source(source=self.sourcefile)
video = core.std.CropRel(video, top=140, bottom=140)
video = haf.GSMC(video, thSAD=150, radius=2)
video = core.f3kdb.Deband(video, dynamic_grain=True, preset='Low')
video = core.std.AddBorders(video, top=140, bottom=140)
return video
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 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 do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
src = depth(src, 16)
denoise_chroma = core.knlm.KNLMeansCL(src,
a=2,
h=0.55,
d=3,
device_type='gpu',
channels='UV')
stabilize = hvf.GSMC(denoise_chroma, radius=2, planes=0)
return depth(stabilize, 10)
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, insert_clip
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.35)
denoise_uv = ccd(denoise_y, threshold=7, matrix='709')
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)
aa_rfs = lvf.rfs(aa_clamp, aa_strong, [(434, 592)])
halo_mask = lvf.mask.halo_mask(aa_rfs)
darken = flt.line_darkening(aa_rfs, strength=0.35)
dehalo = core.std.MaskedMerge(
darken, lvf.dehalo.bidehalo(darken, sigmaS_final=1.2, sigmaR=11 / 255),
halo_mask)
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)
# Making sure there's no weird dynamic noise on the titlecard
final = insert_clip(grain, grain[869] * (903 - 869), 869)
return final
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
ef = bbmod(src, left=1, right=1, top=1, bottom=1, u=False, v=False)
ef = bbmod(ef, left=2, right=2, top=2, bottom=2, y=False)
ef = depth(ef, 32)
# Descaling + Rescaling
src_y = get_y(ef)
descaled = lvf.kernels.Lanczos(taps=5).descale(src_y, 1280, 720)
rescaled = vdf.scale.nnedi3_upscale(descaled)
downscaled = lvf.kernels.BicubicDidee().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 do_filter():
"""Vapoursynth filtering"""
def _sraa(clip: vs.VideoNode, nnargs: dict, eeargs: dict) -> vs.VideoNode:
def _nnedi3(clip):
return clip.nnedi3.nnedi3(0, False, **nnargs)
def _eedi3(clip, sclip):
return clip.eedi3m.EEDI3(0, False, **eeargs, sclip=sclip)
clip = _eedi3(clip, _nnedi3(clip)).std.Transpose()
clip = _eedi3(clip, _nnedi3(clip)).std.Transpose()
return clip
def _nnedi3(clip: vs.VideoNode, factor: float, args: dict) -> vs.VideoNode:
upscale = clip.std.Transpose().nnedi3.nnedi3(0, True, **args) \
.std.Transpose().nnedi3.nnedi3(0, True, **args)
return core.resize.Spline36(upscale,
clip.width * factor,
clip.height * factor,
src_top=.5,
src_left=.5)
def _line_mask(clip: vs.VideoNode, thr: int) -> vs.VideoNode:
mask = core.std.Prewitt(clip)
mask = core.std.Expr(mask, 'x 2 *').std.Median()
mask = core.std.Expr(mask, f'x {thr} < x x 3 * ?')
return mask.std.Inflate().std.Deflate()
def _ssharp(clip: vs.VideoNode,
strength: float,
width: int,
height: int,
factor: float = 2,
b: float = -1,
c: float = 6) -> vs.VideoNode:
source = clip
sharp = core.resize.Bicubic(clip, clip.width*factor, clip.height*factor, \
filter_param_a=b, filter_param_b=c).resize.Lanczos(width, height)
source = core.resize.Spline64(source, sharp.width, sharp.height)
sharp = core.rgvs.Repair(sharp, source, 13)
sharp = mvf.LimitFilter(source,
sharp,
thrc=0.5,
elast=6,
brighten_thr=0.5,
planes=0)
final = core.std.Expr([sharp, source],
f'x {strength} * y 1 {strength} - * +')
return final
def to_gray(clip: vs.VideoNode, ref: vs.VideoNode) -> vs.VideoNode:
clip = core.std.AssumeFPS(clip, ref)
return core.resize.Point(clip,
format=vs.GRAY16,
matrix_s=mvf.GetMatrix(ref))
def _perform_masks_credit(path: Path) -> List[MaskCredit]:
return [
MaskCredit(lvf.src(str(mask)), int(str(mask.stem).split('_')[2]),
int(str(mask.stem).split('_')[3]))
for mask in path.glob('*')
]
# pylint: disable=unused-argument
def _diff(n: int, f: vs.VideoFrame, new: vs.VideoNode,
adapt: vs.VideoNode) -> vs.VideoNode:
psa = f.props['PlaneStatsAverage']
if psa > 0.5:
clip = new
elif psa < 0.4:
clip = adapt
else:
weight = (psa - 0.4) * 10
clip = core.std.Merge(adapt, new, weight)
return clip
def _ret_mask(clip: vs.VideoNode, thr: int) -> vs.VideoNode:
mask = kgf.retinex_edgemask(clip)
mask = core.std.Median(mask).std.Binarize(thr)
mask = iterate(mask, core.std.Median, 2)
mask = iterate(mask, core.std.Maximum, 3)
mask = iterate(mask, core.std.Minimum, 2)
return mask
opstart, opend = 1774, 3944
edstart, edend = 31781, 33938
src = JPBD.src_cut
src = depth(src, 16)
denoise_a = mdf.hybriddenoise_mod(src, 0.55, 2.25)
denoise_b = mdf.hybriddenoise_mod(src, 0.55, 10)
denoise = lvf.rfs(denoise_a, denoise_b, [(opstart, opstart + 44)])
diff = core.std.MakeDiff(src, denoise, [0, 1, 2])
luma = get_y(denoise)
upscale = _nnedi3(luma, 1.5, dict(nsize=0, nns=3, qual=1, pscrn=1))
sraa = _sraa(upscale, dict(nsize=0, nns=3, qual=1, pscrn=1),
dict(alpha=0.2, beta=0.5, gamma=80, nrad=3, mdis=18))
sraa = core.rgvs.Repair(sraa, upscale, 3)
rescale = _ssharp(sraa, 0.55, src.width, src.height, 2)
artefacts_mask = core.std.BlankClip(rescale, color=(256 << 8) - 1)
artefacts_mask = vdf.region_mask(artefacts_mask, 2, 2, 2, 2).std.Inflate()
rescale = core.std.MaskedMerge(luma, rescale, artefacts_mask)
lineart_mask = _line_mask(luma, 8000)
antialias = core.std.MaskedMerge(luma, rescale, lineart_mask)
antialias_merged = vdf.merge_chroma(antialias, denoise)
src_c, src_ncop = [
c.knlm.KNLMeansCL(a=6, h=20, d=0, device_type='gpu')
for c in [src, JPBD_NCOP.src_cut[:opend - opstart + 1]]
]
credit_mask = vdf.dcm(src, src_c[opstart:opend + 1], src_ncop, opstart,
opend, 2, 2).std.Deflate()
credit = core.std.MaskedMerge(antialias_merged, denoise, credit_mask)
masks_credit_ = _perform_masks_credit(Path('masks_' + JPBD.name[-2:] +
'/'))
for mask in masks_credit_:
credit = lvf.rfs(
credit,
core.std.MaskedMerge(credit, denoise,
to_gray(mask.mask, src).std.Deflate()),
[(mask.start_frame, mask.end_frame)])
deband_mask = lvf.denoise.detail_mask(credit, brz_a=3000, brz_b=1500)
dark_mask = core.std.Expr([deband_mask, _ret_mask(credit, 12500)], 'x y +')
deband_a = dbs.f3kpf(credit, 18, 36, 36)
deband_b = dbs.f3kpf(credit, 18, 42, 42)
deband_c = placebo.Deband(credit,
radius=12,
threshold=20,
iterations=3,
grain=0)
deband_d = placebo.Deband(credit,
radius=10,
threshold=8,
iterations=2,
grain=0)
deband = lvf.rfs(deband_a, deband_b, [(opstart + 483, opstart + 554)])
deband = lvf.rfs(deband, deband_c, [(opstart, opstart + 44)])
deband = lvf.rfs(deband, core.std.MaskedMerge(deband_d, credit, dark_mask),
[(opstart + 1070, opstart + 1103)])
deband = lvf.rfs(deband, deband_d, [(opstart + 1104, opstart + 1124)])
deband = core.std.MaskedMerge(deband, credit, deband_mask)
grain_original = core.std.MergeDiff(deband, diff, [0, 1, 2])
grain_original_nochroma = core.std.MergeDiff(deband, diff, [0])
grain_new = core.neo_f3kdb.Deband(deband,
preset='depth',
grainy=32,
grainc=32)
grain_new_nochroma = vdf.merge_chroma(grain_new, deband)
avg = core.std.PlaneStats(deband)
adapt_mask = core.adg.Mask(get_y(avg), 28)
grain_adapt = core.std.MaskedMerge(grain_new, grain_original, adapt_mask)
gf3_args = dict(g1str=5,
g2str=3.85,
g3str=3.5,
g1shrp=50,
g2shrp=60,
g3shrp=60,
g1size=1.65,
g2size=1.60,
g3size=1.25)
grain_a = hvf.GrainFactory3(deband, **gf3_args)
grain_b = mdf.adptvgrnMod_mod(deband,
2,
size=1.5,
sharp=60,
static=False,
luma_scaling=14)
grain = core.std.FrameEval(
deband, partial(_diff, new=grain_new, adapt=grain_adapt), avg)
grain = lvf.rfs(grain, grain_original, [(5058, 5253), (7871, 7989)])
grain = lvf.rfs(grain, grain_new_nochroma,
[(opstart + 117, opstart + 873),
(opstart + 921, opstart + 993)])
grain = lvf.rfs(grain, grain_original_nochroma,
[(opstart + 874, opstart + 920),
(opstart + 994, opstart + 1069),
(opstart + 1125, opstart + 1202)])
grain = lvf.rfs(grain, grain_a, [(opstart, opstart + 44)])
grain = lvf.rfs(grain, grain_b, [(opstart + 1070, opstart + 1124)])
stabilize = hvf.GSMC(src, radius=2, planes=0)
ending = vdf.merge_chroma(stabilize, denoise)
final = lvf.rfs(grain, ending, [(edstart, edend)])
final = final[:opstart] + final[opstart + 2:opstart + 2160] + final[opend +
1:]
return depth(final, 10), opstart, opend
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
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 filterchain"""
import EoEfunc as eoe
import havsfunc as haf
import kagefunc as kgf
import lvsfunc as lvf
import vardefunc as vdf
from adptvgrnMod import adptvgrnMod
from ccd import ccd
from vsdpir import DPIR
from vsutil import depth
src = pre_filter()
src = depth(src, 16)
# Fix slight green tint present throughout parts of the OP
src_g = core.std.Expr(src, ["", "", "x 32768 = x x 96 + ?"])
src_g = lvf.rfs(src, src_g, [(None, 873)])
scaled, descale_mask = flt.rescaler(src_g,
height=854,
shader_file=shader_file)
# Denoising this is rough. Lots of fine detail that's easy to destroy.
detail_mask = flt.detail_mask(scaled,
pf_sigma=1.5,
rxsigma=[50, 150, 200, 300],
rad=2,
brz=[2250, 3500])
denoise_y = eoe.dn.BM3D(scaled, sigma=[0.3, 0])
denoise_y_str = flt.to_yuvps(
DPIR(flt.to_rgbs(scaled),
strength=40,
task='deblock',
device_type='cpu'))
denoise_y = lvf.rfs(denoise_y, denoise_y_str, [(1384, 1398)])
denoise_uv = ccd(denoise_y, threshold=7, matrix='709')
denoise_uv_rep = core.std.MaskedMerge(denoise_uv, denoise_y, detail_mask)
stab = haf.GSMC(denoise_uv_rep, radius=1, thSAD=200, planes=[0])
stab = lvf.rfs(
stab, scaled,
[(1399, 1400),
(1408, 1416)]) # Undo denoising because it eats lines on these scenes
decs = vdf.noise.decsiz(stab, sigmaS=8, min_in=200 << 8, max_in=232 << 8)
# F**k ufo lines
eed = lvf.aa.nneedi3_clamp(decs, strength=1.6)
sraa = lvf.sraa(decs, rfactor=1.5, aafun=flt.eedi3_singlerate_custom)
clamp_aa = lvf.aa.clamp_aa(decs, eed, sraa, strength=1.6)
# Certain frames have truly godawful aliasing. We attempt to fix those here
tsraa = flt.transpose_sraa(decs,
rfactor=1.5,
aafun=flt.eedi3_singlerate_custom)
tsraa_rep = core.rgvs.Repair(tsraa, clamp_aa, 13)
aa_rfs = lvf.rfs(clamp_aa, tsraa_rep, strong_aa)
# F**k ufo lines
ec = haf.EdgeCleaner(aa_rfs, strength=4)
# This fixes up all the super red scenes fairly well
crecon = lvf.recon.chroma_reconstruct(ec)
deband_a = flt.masked_f3kdb(crecon,
rad=18,
thr=24,
grain=[24, 16],
mask_args={'brz': (1250, 2250)})
deband_b = flt.masked_f3kdb(crecon,
rad=24,
thr=40,
grain=[32, 24],
mask_args={'brz': (1000, 1750)})
deband_c = flt.placebo_debander(crecon,
grain=2,
iterations=2,
threshold=8,
radius=16)
deband = lvf.rfs(deband_a, deband_b, [])
deband = kgf.crossfade(deband[:2246 + 48], deband_c[2246:], 47)
deband = lvf.rfs(deband, crecon, [(1399, 1400)])
sqmask = lvf.mask.BoundingBox((699, 50), (526, 870)).get_mask(deband)
sqmask = core.bilateral.Gaussian(sqmask, sigma=4)
blur = core.bilateral.Gaussian(deband,
sigma=25).bilateral.Gaussian(sigma=25)
blur_mask = core.std.MaskedMerge(blur, deband, sqmask)
blurred = kgf.crossfade(deband[:2412 + 48], blur_mask[2411:], 48)
blurred_del = core.std.DeleteFrames(blurred, [2293])
grain_a = adptvgrnMod(blurred_del,
seed=42069,
strength=0.15,
static=True,
size=1.15,
sharp=80,
grain_chroma=False)
grain_b = adptvgrnMod(blurred_del,
seed=42069,
strength=0.25,
static=True,
size=1.15,
sharp=100,
grain_chroma=False)
grain_c = adptvgrnMod(blurred_del,
seed=42069,
strength=0.2,
static=False,
size=1.15,
sharp=100,
grain_chroma=False)
grain = lvf.rfs(grain_a, grain_b, [(2390, None)])
grain = lvf.rfs(grain, grain_c, [(885, 1149), (1324, 1345), (1489, 1506),
(1603, 1810), (1981, 1996)])
# Accidentally a frame during one of the previous processes. Easy to fix, though.
oopsie = core.std.DeleteFrames(grain, [grain.num_frames - 1])
out = enc.dither_down(oopsie)
return out
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Main filterchain"""
import havsfunc as haf
import lvsfunc as lvf
import muvsfunc as muf
import debandshit as dbs
import vardefunc as vdf
from vsutil import depth, get_y, insert_clip, join, plane
src = JP_DVD.clip_cut.std.AssumeFPS(fpsnum=24000, fpsden=1001)
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
src_ncop = flt.rekt(src_ncop)
src_nced = flt.rekt(src_nced)
src_03 = flt.rekt(src_03)
# 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_mask = vdf.dcm(
src_03, src_03[opstart:opstart+masked_ncop.num_frames-op_offset], masked_ncop[:-op_offset],
start_frame=opstart, thr=85, prefilter=True) if opstart is not False \
else get_y(core.std.BlankClip(src))
op_mask = depth(core.resize.Bicubic(op_mask, 1296, 728).std.Crop(top=4, bottom=4), 16)
# Stick credits ontop of NC because it looks way better
masked_ncop = src_ncop.resize.Bicubic(chromaloc_in=1, chromaloc=0)
cwarp_ncop = masked_ncop.warp.AWarpSharp2(thresh=88, blur=3, type=1, depth=6, planes=[1, 2])
descale_ncop = lvf.kernels.Bicubic().descale(plane(depth(src_ncop, 16), 0), 1280, 720)
chroma_down_ncop = core.resize.Bicubic(cwarp_ncop, 1280, 720, vs.YUV444P16)
scaled_ncop = join([descale_ncop, plane(chroma_down_ncop, 1), plane(chroma_down_ncop, 2)])
scaled_ncop = scaled_ncop.resize.Bicubic(1296, 728).std.Crop(top=4, bottom=4)
downscale_03 = src_03.resize.Bicubic(1296, 728, vs.YUV444P16).std.Crop(top=4, bottom=4)
merge_credits_03 = core.std.MaskedMerge(scaled_ncop, downscale_03, op_mask)
for prop, val in PROPS_DVD:
src = src.std.SetFrameProp(prop, intval=val)
dvd_i444 = vdf.scale.to_444(depth(src, 32), src.width, src.height, join_planes=True)
dvd_rgb = dvd_i444.resize.Bicubic(format=vs.RGB24, dither_type='error_diffusion', matrix_in=6)
upscale = vsgan.run(dvd_rgb)
conv = core.resize.Bicubic(upscale, format=vs.YUV444P16, matrix=1)
scaled = depth(muf.SSIM_downsample(conv, 1296, 720), 16)
splice_op = lvf.rfs(scaled, merge_credits_03, [(0, 203), (263, 1740), (1836, 2018)])
# Splicing for the ED. Halves of the ED have visuals, others are credits
masked_nced = src_nced.resize.Bicubic(chromaloc_in=1, chromaloc=0)
cwarp_nced = masked_nced.warp.AWarpSharp2(thresh=88, blur=3, type=1, depth=6, planes=[1, 2])
descale_nced = lvf.kernels.Bicubic().descale(plane(depth(src_nced, 16), 0), 1280, 720)
chroma_down_nced = core.resize.Bicubic(cwarp_nced, 1280, 720, vs.YUV444P16)
scaled_nced = join([descale_nced, plane(chroma_down_nced, 1), plane(chroma_down_nced, 2)])
scaled_nced = scaled_nced.resize.Bicubic(1296, 728).std.Crop(top=4, bottom=4)
ed_nc = scaled_nced
ed_dvd = splice_op[31888:]
sq_top = lvf.mask.BoundingBox((0, 0), (ed_nc.width, ed_nc.height/2)).get_mask(ed_nc)
sq_left = lvf.mask.BoundingBox((0, 0), (ed_nc.width/2, ed_nc.height)).get_mask(ed_nc)
sq_right = sq_left.std.Invert()
mask_top = core.std.MaskedMerge(ed_dvd, ed_nc, sq_top)
mask_left = core.std.MaskedMerge(ed_dvd, ed_nc, sq_left)
mask_right = core.std.MaskedMerge(ed_dvd, ed_nc, sq_right)
ed_splice = lvf.rfs(ed_dvd, mask_top, [(0, 1213), (1613, 1673), (1794, None)])
ed_splice = lvf.rfs(ed_splice, mask_left, [(1390, 1503)])
ed_splice = lvf.rfs(ed_splice, mask_right, [(1214, 1389), (1504, 1612), (1674, 1793)])
splice_ed = insert_clip(splice_op, ed_splice, edstart)
# Back to more regular filtering
stab = haf.GSMC(splice_ed, radius=2, planes=[0])
decs = vdf.noise.decsiz(stab, sigmaS=8, min_in=208 << 8, max_in=232 << 8)
detail_mask = flt.detail_mask(decs, brz=(1800, 3500))
deband = dbs.debanders.dumb3kdb(decs, threshold=32, grain=16)
deband_masked = core.std.MaskedMerge(deband, decs, detail_mask)
grain = vdf.noise.Graigasm( # Mostly stolen from Varde tbh
thrs=[x << 8 for x in (32, 80, 128, 176)],
strengths=[(0.25, 0.0), (0.2, 0.0), (0.15, 0.0), (0.0, 0.0)],
sizes=(1.2, 1.15, 1.05, 1),
sharps=(65, 50, 40, 40),
grainers=[
vdf.noise.AddGrain(seed=69420, constant=True),
vdf.noise.AddGrain(seed=69420, constant=False),
vdf.noise.AddGrain(seed=69420, constant=False)
]).graining(deband_masked)
return grain
def do_filter():
"""Vapoursynth filtering"""
def _sraa(clip: vs.VideoNode, nnargs: dict, eeargs: dict) -> vs.VideoNode:
def _nnedi3(clip):
return clip.nnedi3.nnedi3(0, False, **nnargs)
def _eedi3(clip, sclip):
return clip.eedi3m.EEDI3(0, False, **eeargs, sclip=sclip)
clip = _eedi3(clip, _nnedi3(clip)).std.Transpose()
clip = _eedi3(clip, _nnedi3(clip)).std.Transpose()
return clip
def _nnedi3(clip: vs.VideoNode, factor: float, args: dict) -> vs.VideoNode:
upscale = clip.std.Transpose().nnedi3.nnedi3(0, True, **args) \
.std.Transpose().nnedi3.nnedi3(0, True, **args)
return core.resize.Spline36(upscale,
clip.width * factor,
clip.height * factor,
src_top=.5,
src_left=.5)
def _line_mask(clip: vs.VideoNode, thr: int) -> vs.VideoNode:
mask = core.std.Prewitt(clip)
mask = core.std.Expr(mask, 'x 2 *').std.Median()
mask = core.std.Expr(mask, f'x {thr} < x x 3 * ?')
return mask.std.Inflate().std.Deflate()
def _ssharp(clip: vs.VideoNode,
strength: float,
width: int,
height: int,
factor: float = 2,
b: float = -1,
c: float = 6) -> vs.VideoNode:
source = clip
sharp = core.resize.Bicubic(clip, clip.width*factor, clip.height*factor, \
filter_param_a=b, filter_param_b=c).resize.Lanczos(width, height)
source = core.resize.Spline64(source, sharp.width, sharp.height)
sharp = core.rgvs.Repair(sharp, source, 13)
sharp = mvf.LimitFilter(source,
sharp,
thrc=0.5,
elast=6,
brighten_thr=0.5,
planes=0)
final = core.std.Expr([sharp, source],
f'x {strength} * y 1 {strength} - * +')
return final
def to_gray(clip: vs.VideoNode, ref: vs.VideoNode) -> vs.VideoNode:
clip = core.std.AssumeFPS(clip, ref)
return core.resize.Point(clip,
format=vs.GRAY16,
matrix_s=mvf.GetMatrix(ref))
def _perform_masks_credit(path: Path) -> List[MaskCredit]:
return [
MaskCredit(lvf.src(str(mask)), int(str(mask.stem).split('_')[2]),
int(str(mask.stem).split('_')[3]))
for mask in path.glob('*')
]
# pylint: disable=unused-argument
def _diff(n: int, f: vs.VideoFrame, new: vs.VideoNode,
adapt: vs.VideoNode) -> vs.VideoNode:
psa = f.props['PlaneStatsAverage']
if psa > 0.5:
clip = new
elif psa < 0.4:
clip = adapt
else:
weight = (psa - 0.4) * 10
clip = core.std.Merge(adapt, new, weight)
return clip
edstart, edend = 31782, 33939
src = JPBD.src_cut
src = depth(src, 16)
denoise = mdf.hybriddenoise_mod(src, 0.55, 2.25)
diff = core.std.MakeDiff(src, denoise, [0, 1, 2])
luma = get_y(denoise)
upscale = _nnedi3(luma, 1.5, dict(nsize=0, nns=3, qual=1, pscrn=1))
sraa = _sraa(upscale, dict(nsize=0, nns=3, qual=1, pscrn=1),
dict(alpha=0.2, beta=0.5, gamma=80, nrad=3, mdis=18))
sraa = core.rgvs.Repair(sraa, upscale, 3)
rescale = _ssharp(sraa, 0.55, src.width, src.height, 2)
artefacts_mask = core.std.BlankClip(rescale, color=(256 << 8) - 1)
artefacts_mask = vdf.region_mask(artefacts_mask, 2, 2, 2, 2).std.Inflate()
rescale = core.std.MaskedMerge(luma, rescale, artefacts_mask)
lineart_mask = _line_mask(luma, 8000)
antialias = core.std.MaskedMerge(luma, rescale, lineart_mask)
antialias_merged = vdf.merge_chroma(antialias, denoise)
antialias_merged = lvf.rfs(antialias_merged, denoise, [(1894, 2013)])
credit = antialias_merged
masks_credit_ = _perform_masks_credit(Path('masks_' + JPBD.name[-2:] +
'/'))
for mask in masks_credit_:
credit = lvf.rfs(
credit,
core.std.MaskedMerge(credit, denoise,
to_gray(mask.mask, src).std.Deflate()),
[(mask.start_frame, mask.end_frame)])
deband_mask = lvf.denoise.detail_mask(credit, brz_a=3000, brz_b=1500)
deband_a = dbs.f3kpf(credit, 18, 36, 36)
deband_b = dbs.f3kpf(credit, 18, 56, 56)
deband = lvf.rfs(deband_a, deband_b, [(9380, 9444)])
deband = core.std.MaskedMerge(deband, credit, deband_mask)
grain_original = core.std.MergeDiff(deband, diff, [0, 1, 2])
grain_new = core.neo_f3kdb.Deband(deband,
preset='depth',
grainy=32,
grainc=32)
avg = core.std.PlaneStats(deband)
adapt_mask = core.adg.Mask(get_y(avg), 28)
grain_adapt = core.std.MaskedMerge(grain_new, grain_original, adapt_mask)
grain = core.std.FrameEval(
deband, partial(_diff, new=grain_new, adapt=grain_adapt), avg)
grain = lvf.rfs(grain, grain_original, [(8405, 8548)])
stabilize = hvf.GSMC(src, radius=2, planes=0)
ending = vdf.merge_chroma(stabilize, denoise)
final = lvf.rfs(grain, ending, [(edstart, edend)])
return depth(final, 10)
