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, ...]]:
"""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 filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Main filterchain"""
import lvsfunc as lvf
import muvsfunc as muf
import vardefunc as vdf
from adptvgrnMod import adptvgrnMod
from ccd import ccd
from vsutil import depth, get_w, get_y, iterate
from xvs import WarpFixChromaBlend
# Can't mean this one out this time because of credit changes
src = JP_CR.clip_cut
src = depth(src, 32)
src_y = get_y(src)
descale = lvf.kernels.Lanczos(taps=5).descale(src_y, get_w(945), 945)
rescale = vdf.scale.nnedi3cl_double(descale, pscrn=1)
rescale = muf.SSIM_downsample(rescale, src_y.width, src_y.height)
scaled = vdf.misc.merge_chroma(rescale, src)
scaled = depth(scaled, 16)
# Having a hard time reliably catching the EDs. Oh well.
upscale = lvf.kernels.Lanczos(taps=5).scale(descale, src_y.width,
src_y.height)
credit_mask = depth(
lvf.scale.descale_detail_mask(src_y, upscale, threshold=0.08), 16)
credit_mask = iterate(credit_mask, core.std.Minimum, 5)
credit_mask = iterate(credit_mask, core.std.Maximum, 9)
credit_mask = core.morpho.Close(credit_mask, 9)
credits_merged = core.std.MaskedMerge(scaled, depth(src, 16), credit_mask)
denoise_y = core.knlm.KNLMeansCL(credits_merged,
d=1,
a=3,
s=4,
h=0.55,
channels='Y')
denoise_uv = ccd(denoise_y, threshold=6, matrix='709')
decs = vdf.noise.decsiz(denoise_uv,
sigmaS=8,
min_in=208 << 8,
max_in=232 << 8)
darken = flt.line_darkening(decs, strength=0.175)
deband = flt.masked_f3kdb(darken, thr=24, grain=[24, 12])
grain: vs.VideoNode = adptvgrnMod(deband,
seed=42069,
strength=0.45,
luma_scaling=10,
size=1.25,
sharp=100,
static=True,
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, 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 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
