def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Main filterchain"""
import debandshit as dbs
import lvsfunc as lvf
from adptvgrnMod import adptvgrnMod
from vsutil import depth
src = JP_TV.clip_cut
vfm = core.vivtc.VFM(src, order=1)
vdec = core.vivtc.VDecimate(vfm)
src = depth(vdec, 16)
stretch = lvf.kernels.Catrom().scale(src, 1920, 1080)
debl = lvf.deblock.autodb_dpir(stretch,
strs=[15, 20, 35],
matrix=1,
cuda=True)
deband = dbs.dumb3kdb(debl, radius=18, threshold=[24, 16])
grain: vs.VideoNode = adptvgrnMod(deband,
strength=0.3,
size=1.3,
sharp=80,
grain_chroma=False,
static=False,
seed=42069,
luma_scaling=8)
return grain
def main() -> vs.VideoNode:
"""Vapoursynth filtering"""
import rekt
from adptvgrnMod import adptvgrnMod
from havsfunc import FastLineDarkenMOD
from vsutil import depth
from xvs import WarpFixChromaBlend
src_ep = JPBD_EP.clip_cut
src_NCOP1 = JPBD_NCOP1.clip_cut
src_NCOP2 = JPBD_NCOP2.clip_cut
src_NCOP = replace_ranges(src_NCOP2, src_NCOP1, replace_op)
src_NCOP = replace_ranges(src_NCOP, src_ep, replace_ep)
rkt = rekt.rektlvls(src_NCOP,
rownum=[0, 1079], rowval=[15, 15],
colnum=[0, 1919], colval=[15, 15]
)
no_rkt = replace_ranges(rkt, src_NCOP, [(526, 597), (1350, 1575), (1613, 1673), (1735, 1933)])
scaled = flt.rescaler(no_rkt, 720)
denoised = flt.denoiser(scaled, bm3d_sigma=[0.8, 0.6], bm3d_rad=1)
aa_rep = flt.clamped_aa(denoised)
trans_sraa = flt.transpose_sraa(denoised)
aa_ranges = replace_ranges(aa_rep, trans_sraa, red_circle)
darken = FastLineDarkenMOD(aa_ranges, strength=48, protection=6, luma_cap=255, threshold=2)
deband = flt.masked_deband(darken, denoised=True, deband_args={'iterations': 2, 'threshold': 5.0, 'radius': 8, 'grain': 6})
grain = adptvgrnMod(deband, strength=0.3, luma_scaling=10, size=1.25, sharp=80, grain_chroma=False, seed=42069)
return depth(grain, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2], [0, 1, 2])
def main() -> vs.VideoNode:
"""Vapoursynth filtering"""
from adptvgrnMod import adptvgrnMod
from havsfunc import FastLineDarkenMOD
from vsutil import depth
src_op = JPBD_NCOP.clip_cut
src_ep = JPBD_EP.clip_cut
src = replace_ranges(src_op, src_ep, replace_op)
scaled = flt.rescaler(src, 720)
denoised = flt.denoiser(scaled, bm3d_sigma=[0.8, 0.6], bm3d_rad=1)
aa_rep = flt.clamped_aa(denoised)
trans_sraa = flt.transpose_sraa(denoised)
aa_ranges = replace_ranges(aa_rep, trans_sraa, red_circle)
darken = FastLineDarkenMOD(aa_ranges, strength=48, protection=6, luma_cap=255, threshold=2)
deband = flt.masked_deband(darken, denoised=True, deband_args={'iterations': 2, 'threshold': 5.0, 'radius': 8, 'grain': 6})
pdeband = flt.placebo_debander(darken, grain=4, deband_args={'iterations': 2, 'threshold': 8.0, 'radius': 10})
deband = replace_ranges(deband, pdeband, op_aisle)
grain = adptvgrnMod(deband, strength=0.3, luma_scaling=10, size=1.25, sharp=80, grain_chroma=False, seed=42069)
return depth(grain, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2], [0, 1, 2])
def DebandReader(clip, csvfile, range=30, delimiter=' ', mask=None, luma_scaling=15):
"""
DebandReader, read a csv file to apply a f3kdb filter for given strengths and frames. From awsmfunc.
> Usage: DebandReader(clip, csvfile, grain, range)
* csvfile is the path to a csv file containing in each row: <startframe> <endframe> <<strength_y>,**<strength_b>,**<strength_r>> <grain strength> <mask>
* mask is the mask list you want to apply. it should be in a list
* range is passed as range in the f3kdb filter
"""
import csv
filtered = clip if get_depth(clip) <= 16 else Depth(clip, 16)
depth = get_depth(clip)
with open(csvfile) as debandcsv:
csvzones = csv.reader(debandcsv, delimiter=delimiter)
for row in csvzones:
clip_mask = int(row[4])
strength = row[2].split(',')
while len(strength) < 3:
strength.append(strength[-1])
grain_strength = float(row[3])
db = core.f3kdb.Deband(clip, y=strength[0], cb=strength[1], cr=strength[2], grainy=0, grainc=0,
range=range, output_depth=depth)
db = agm.adptvgrnMod(db, luma_scaling=luma_scaling, strength=grain_strength)
filtered = awf.ReplaceFrames(filtered, db, mappings="[" + row[0] + " " + row[1] + "]")
if mask:
filtered = core.std.MaskedMerge(filtered, clip, mask[clip_mask])
return filtered
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 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 default_grain(clip: vs.VideoNode, grain_args: Dict[str, Any] = {}) -> Any:
"""Consistent grainer across episodes"""
from adptvgrnMod import adptvgrnMod
g_args: Dict[str, Any] = dict(strength=0.2, luma_scaling=10, size=1.25, sharp=80, grain_chroma=False)
g_args |= grain_args
return adptvgrnMod(clip, seed=42069, **g_args)
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
out = depth(src, 16)
denoise = hvf.SMDegrain(out, thSAD=150, thSADC=75)
out = denoise
y = get_y(out)
lineart = core.std.Sobel(y).std.Binarize(
75 << 8).std.Maximum().std.Inflate()
antialias = lvf.sraa(y,
1.5,
9,
downscaler=core.resize.Spline36,
gamma=200,
mdis=18)
sharp = hvf.LSFmod(antialias,
strength=95,
Smode=3,
Lmode=1,
edgemode=1,
edgemaskHQ=True)
minmax = core.std.Expr([y, sharp, antialias], 'x y z min max y z max min')
merge = core.std.MaskedMerge(y, minmax, lineart)
out = vdf.merge_chroma(merge, out)
y = get_y(out)
detail_dark_mask = detail_dark_mask_func(y, brz_a=10000, brz_b=9000)
detail_light_mask = lvf.denoise.detail_mask(y, brz_a=2500, brz_b=1200)
detail_mask = core.std.Expr([detail_dark_mask, detail_light_mask],
'x y +').std.Median()
detail_mask_grow = iterate(detail_mask, core.std.Maximum, 2)
detail_mask_grow = iterate(detail_mask_grow, core.std.Inflate,
2).std.Convolution([1, 1, 1, 1, 1, 1, 1, 1, 1])
detail_mask = core.std.Expr([y, detail_mask_grow, detail_mask],
f'x {28<<8} < y z ?')
deband = dbs.f3kpf(out, 17, 24, 24)
deband = core.std.MaskedMerge(deband, out, detail_mask)
out = deband
grain = adptvgrnMod(out,
0.2,
0.1,
1.25,
luma_scaling=14,
sharp=80,
static=False,
lo=19,
hi=[192, 240])
out = grain
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 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 grain(clip: vs.VideoNode) -> vs.VideoNode:
grain = adptvgrnMod(clip,
strength=0.25,
cstrength=0.05,
size=1.1,
sharp=70,
luma_scaling=10,
static=True)
return grain
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
h = 720
w = get_w(h)
edgesfix = awf.bbmod(src, 1, 1, 1, 1, 48, 500)
out = edgesfix
clip = depth(out, 32)
denoise = hybrid_denoise(clip, 0.45, 1.5)
out = denoise
luma = get_y(out)
line_mask = line_mask_func(luma)
descale = core.descale.Debilinear(luma, w, h)
upscale = vdf.nnedi3_upscale(descale, pscrn=1)
antialias = single_rate_antialiasing(upscale, 13, alpha=0.2, beta=0.5, gamma=600, mdis=15)
scaled = core.resize.Bicubic(antialias, src.width, src.height)
rescale = core.std.MaskedMerge(luma, scaled, depth(line_mask, 32))
merged = vdf.merge_chroma(rescale, out)
out = depth(merged, 16)
preden = core.knlm.KNLMeansCL(get_y(out), h=0.75, a=2, d=3, device_type='gpu', device_id=0)
detail_dark_mask = detail_dark_mask_func(preden, brz_a=8000, brz_b=6000)
detail_light_mask = lvf.denoise.detail_mask(preden, brz_a=2500, brz_b=1200)
detail_mask = core.std.Expr([detail_dark_mask, detail_light_mask], 'x y +').std.Median()
detail_mask_grow = iterate(detail_mask, core.std.Maximum, 2)
detail_mask_grow = iterate(detail_mask_grow, core.std.Inflate, 2).std.Convolution([1, 1, 1, 1, 1, 1, 1, 1, 1])
detail_mask = core.std.Expr([preden, detail_mask_grow, detail_mask], f'x {32<<8} < y z ?')
deband_a = dbs.f3kpf(out, 16, 30, 42, thr=0.5, elast=2, thrc=0.2)
deband_b = placebo.deband(out, 18, 5.5, 2, 4)
deband = core.std.MaskedMerge(deband_a, deband_b, preden)
deband = core.std.MaskedMerge(deband_a, out, detail_mask)
deband = core.neo_f3kdb.Deband(deband, preset='depth', grainy=24, grainc=24)
out = deband
grain = adptvgrnMod(out, 0.4, 0.3, 1.25, luma_scaling=8, sharp=80, static=False, lo=19)
out = grain
return depth(out, 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 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
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 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 do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
src = depth(src, 16)
out = src
h = 846
degrain = hybrid_denoise(out, 0.35, 1.2, dict(a=2, d=1))
out = degrain
ref = out
pfed = ref.std.Median().std.Convolution([1] * 9, planes=0)
diff_ed = core.std.MakeDiff(ref, pfed)
deband_ed = core.f3kdb.Deband(pfed,
22,
30,
30,
30,
32,
32,
2,
keep_tv_range=True,
output_depth=16)
deband_ed = core.std.MergeDiff(deband_ed, diff_ed)
out = deband_ed
grain = adptvgrnMod(out,
0.25,
0.15,
size=out.height / h,
sharp=80,
luma_scaling=10,
static=True)
out = grain
return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2])
def filterchain(clip: vs.VideoNode) -> vs.VideoNode:
from adptvgrnMod import adptvgrnMod
from vsutil import depth
clip16 = depth(clip, 16)
scaled, credit_mask = rescaler(clip16, height=844)
denoise = denoising(scaled)
aa_clamped = antialiasing(denoise)
credits_merged = core.std.MaskedMerge(aa_clamped, depth(clip16, 16),
credit_mask)
deband = debanding(credits_merged)
grain = adptvgrnMod(deband,
strength=0.3,
luma_scaling=10,
size=1.25,
sharp=100,
grain_chroma=False,
static=False,
seed=42069)
return depth(grain, 10)
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
dering = hvf.EdgeCleaner(out, 17, smode=1, hot=True)
out = dering
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 do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
src += src[-1] * 2
h = 720
w = get_w(h)
edgesfix = awf.bbmod(src, 1, 1, 1, 1, 48, 500)
out = edgesfix
clip = depth(out, 32)
denoise = hybrid_denoise(clip, 0.45, 1.5)
out = denoise
luma = get_y(out)
line_mask = line_mask_func(luma)
descale = core.descale.Debilinear(luma, w, h)
upscale = vdf.nnedi3_upscale(descale, pscrn=1)
antialias = single_rate_antialiasing(upscale,
13,
alpha=0.4,
beta=0.3,
gamma=400,
mdis=15).resize.Bilinear(
src.width, src.height)
rescale = core.std.MaskedMerge(luma, antialias, depth(line_mask, 32))
merged = vdf.merge_chroma(rescale, out)
out = depth(merged, 16)
preden = core.knlm.KNLMeansCL(get_y(out),
h=0.75,
a=2,
d=3,
device_type='gpu',
device_id=0)
detail_dark_mask = detail_dark_mask_func(preden, brz_a=8000, brz_b=6000)
detail_light_mask = lvf.denoise.detail_mask(preden, brz_a=2500, brz_b=1200)
detail_mask = core.std.Expr([detail_dark_mask, detail_light_mask],
'x y +').std.Median()
detail_mask_grow = iterate(detail_mask, core.std.Maximum, 2)
detail_mask_grow = iterate(detail_mask_grow, core.std.Inflate,
2).std.Convolution([1, 1, 1, 1, 1, 1, 1, 1, 1])
detail_mask = core.std.Expr([preden, detail_mask_grow, detail_mask],
f'x {32<<8} < y z ?')
deband_a = dbs.f3kpf(out, 17, 36, 42, thr=0.5, elast=2, thrc=0.2)
deband_b = placebo.deband(out, 18, 5.5, 2, 0)
deband = core.std.MaskedMerge(deband_a, deband_b, preden)
deband = core.std.MaskedMerge(deband, out, detail_mask)
deband = core.neo_f3kdb.Deband(deband,
preset='depth',
grainy=24,
grainc=24)
out = deband
ref, src = [depth(x, 16) for x in [denoise, src]]
credit_mask = vdf.drm(ref, kernel='bilinear', mthr=65)
credit = out
credit = lvf.rfs(credit, core.std.MaskedMerge(credit, ref, credit_mask, 0),
[(0, 1380), (36437, 38719)])
credit = lvf.rfs(credit, ref, [(20810, 20881),
(38720, src.num_frames - 1)])
out = credit
grain = adptvgrnMod(out,
0.3,
0.15,
1.25,
luma_scaling=8,
sharp=80,
static=False,
lo=19)
out = grain
return depth(out, 10)
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"""
src = JPBD.src_cut
src = depth(src, 16)
out = src
opstart, opend = 59, 1630
edstart, edend = 30776, src.num_frames-1
h = 846
w = get_w(h)
cubic_filters = ['catrom', 'mitchell', 'robidoux', 'robidoux sharp']
cubic_filters = [vdf.get_bicubic_params(cf) for cf in cubic_filters]
degrain = hybrid_denoise(out, 0.35, 1.2, dict(a=2, d=1))
out = degrain
y = get_y(out)
y32 = depth(y, 32)
lineart = vdf.edge_detect(y32, 'kirsch', 0.055, (1, 1)).std.Median().std.Inflate()
descale_clips = [core.descale.Debicubic(y32, w, h, b, c) for b, c in cubic_filters]
descale = core.std.Expr(descale_clips, 'x y z a min min min x y z max max min')
conv = core.std.Convolution(descale, [1, 2, 1, 2, 0, 2, 1, 2, 1])
thr, coef = 0.013, 3
descale_fix = core.std.Expr([descale, conv], f'x y - abs {thr} < y x ?').std.PlaneStats()
adapt_mask = core.adg.Mask(descale_fix, 12).std.Invert().std.Expr(f'x 0.5 - {coef} * 0.5 + 0 max 1 min')
descale = core.std.MaskedMerge(descale, descale_fix, adapt_mask)
upscale = vdf.fsrcnnx_upscale(descale, w*2, h*2, r'shaders\FSRCNNX_x2_56-16-4-1.glsl', upscaler_smooth=eedi3_upscale,
profile='zastin', sharpener=partial(gf.DetailSharpen, sstr=1.25, power=4))
aa_strong = sraa_eedi3(upscale, 13, alpha=0.3, beta=0.5, gamma=40)
aa = aa_strong
down = muvf.SSIM_downsample(aa, src.width, src.height, filter_param_a=0, filter_param_b=0)
upscale = depth(
core.std.MaskedMerge(y32, down, lineart), 16
)
merged = vdf.merge_chroma(upscale, out)
out = merged
y = get_y(out)
detail_light_mask = lvf.denoise.detail_mask(y, brz_a=2500, brz_b=1200)
pf = iterate(out, core.std.Maximum, 2).std.Convolution([10] * 9, planes=0)
diff = core.std.MakeDiff(out, pf)
deband = core.f3kdb.Deband(pf, 17, 36, 36, 36, 12, 12, 2, keep_tv_range=True, output_depth=16)
deband = core.std.MergeDiff(deband, diff)
deband = core.std.MaskedMerge(deband, out, detail_light_mask)
out = deband
grain = adptvgrnMod(out, 0.25, 0.15, size=out.height/h, sharp=80, luma_scaling=10, static=True)
out = grain
# # Restore 1080p stuff
ref = src
rescale_mask = vdf.drm(ref, h, mthr=65, sw=4, sh=4)
credit = out
credit = lvf.rfs(credit, core.std.MaskedMerge(credit, ref, rescale_mask, 0),
[(opstart, opend), (1634, 1728), (edstart, edend)])
credit = lvf.rfs(credit, ref, [(15200, 15271)])
out = credit
return depth(out, 10).std.Limiter(16<<2, [235<<2, 240<<2])
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 vsutil import depth, get_w, get_y
from xvs import WarpFixChromaBlend
src_path = [
r"websrc/CHRONOS RULER E05 [1080p][AAC][JapDub][GerEngSub][Web-DL].mkv",
r"websrc/CHRONOS RULER E06 [1080p][AAC][JapDub][GerEngSub][Web-DL].mkv",
r"websrc/CHRONOS RULER E07 [1080p][AAC][JapDub][GerEngSub][Web-DL].mkv",
r"websrc/CHRONOS RULER E08 [1080p][AAC][JapDub][GerEngSub][Web-DL].mkv",
r"websrc/CHRONOS RULER E09 [1080p][AAC][JapDub][GerEngSub][Web-DL].mkv",
r"websrc/CHRONOS RULER E10 [1080p][AAC][JapDub][GerEngSub][Web-DL].mkv",
r"websrc/CHRONOS RULER E11 [1080p][AAC][JapDub][GerEngSub][Web-DL].mkv",
r"websrc/CHRONOS RULER E12 [1080p][AAC][JapDub][GerEngSub][Web-DL].mkv",
r"websrc/CHRONOS RULER E13 [1080p][AAC][JapDub][GerEngSub][Web-DL].mkv"
]
base = JP_CR.clip_cut
src = [lvf.src(c, force_lsmas=True, cachedir='') for c in src_path]
src_c = lvf.src(src_path[-3], force_lsmas=True, cachedir='')
# Trimming clips to get just the OP
src[0] = src[0][2182] * 11 + src[0][2182:2182 + base.num_frames - 11]
src[1] = src[1][936:936 + base.num_frames]
src[2] = src[2][1104:1104 + base.num_frames]
src[3] = src[3][6378:6378 + base.num_frames]
src[4] = src[4][5179:5179 + base.num_frames]
src[5] = src[5][1200:1200 + base.num_frames]
src[6] = src[6][1822:1822 + base.num_frames]
src[7] = src[7][1558:1558 + base.num_frames]
src[8] = src[8][1224:1224 + base.num_frames]
mean = core.average.Mean(src) # type:ignore[attr-defined]
mean = mean[:-1] + src_c[1822:3980][-2:]
mean = depth(mean, 32)
mean_y = get_y(mean)
descale = lvf.kernels.Lanczos(taps=5).descale(mean_y, get_w(945), 945)
rescale = vdf.scale.nnedi3cl_double(descale, pscrn=1)
rescale = muf.SSIM_downsample(rescale, mean_y.width, mean_y.height)
scaled = vdf.misc.merge_chroma(rescale, mean)
scaled = depth(scaled, 16)
decs = vdf.noise.decsiz(scaled, sigmaS=8, min_in=208 << 8, max_in=232 << 8)
deband_reg = flt.masked_f3kdb(decs, thr=24, grain=[24, 12])
detail_mask = flt.detail_mask(decs, brz=(1200, 3000))
den_ref = core.knlm.KNLMeansCL(decs, d=1, a=3, s=4, h=0.5, channels='Y')
deband_str = flt.placebo_debander(den_ref, placebo_args={'threshold': 4})
deband_str = core.std.MaskedMerge(deband_str, deband_reg, detail_mask)
deband = lvf.rfs(deband_reg, deband_str, [(1162, 1193), (1210, 1216)])
grain: vs.VideoNode = adptvgrnMod(deband,
seed=42069,
strength=0.3,
luma_scaling=8,
size=1.35,
sharp=100,
grain_chroma=False)
return grain
def do_filter():
"""Vapoursynth filtering"""
# Source and dithering
src = JPBD.src_cut
src = depth(src, 16)
out = src
# Variables
h = 846
w = get_w(h)
cubic_filters = ['catrom', 'mitchell', 'robidoux', 'robidoux sharp']
cubic_filters = [vdf.get_bicubic_params(cf) for cf in cubic_filters]
# Remove the dynamic grain
degrain = hybrid_denoise(out, 0.35, 1.2, dict(a=2, d=1))
out = degrain
y = get_y(out)
y32 = depth(y, 32)
lineart = vdf.edge_detect(y32, 'kirsch', 0.055,
(1, 1)).std.Median().std.Inflate()
# Use multiple descaling kernel for a sharper result
descale_clips = [
core.descale.Debicubic(y32, w, h, b, c) for b, c in cubic_filters
]
descale = core.std.Expr(descale_clips,
'x y z a min min min x y z max max min')
# Fix descaling artifacts (yes even for catrom there's still artifacts)
conv = core.std.Convolution(descale, [1, 2, 1, 2, 0, 2, 1, 2, 1])
thr, coef = 0.013, 3.2
descale_fix = core.std.Expr([descale, conv],
f'x y - abs {thr} < y x ?').std.PlaneStats()
adapt_mask = core.adg.Mask(
descale_fix,
12).std.Invert().std.Expr(f'x 0.80 - {coef} * 0.20 + 0 max 1 min')
descale = core.std.MaskedMerge(descale, descale_fix, adapt_mask)
# Double using eedi3+nnedi, fsrcnnx and a sharpener
upscale = vdf.fsrcnnx_upscale(descale,
w * 2,
h * 2,
r'shaders\FSRCNNX_x2_56-16-4-1.glsl',
upscaler_smooth=eedi3_upscale,
profile='zastin',
sharpener=partial(gf.DetailSharpen,
sstr=1.25,
power=4))
# Antialiasing by eedi3
aa_strong = sraa_eedi3(upscale, 13, alpha=0.3, beta=0.5, gamma=40)
aa = aa_strong
# Rescale to 1080p with Bicubic b=0, c=0 AKA Hermite
down = muvf.SSIM_downsample(aa,
src.width,
src.height,
filter_param_a=0,
filter_param_b=0)
upscale = depth(core.std.MaskedMerge(y32, down, lineart), 16)
merged = vdf.merge_chroma(upscale, out)
out = merged
# Deband with prefilter
y = get_y(out)
detail_light_mask = lvf.denoise.detail_mask(y, brz_a=2500, brz_b=1200)
pf = iterate(out, core.std.Maximum, 2).std.Convolution([10] * 9, planes=0)
diff = core.std.MakeDiff(out, pf)
deband = core.f3kdb.Deband(pf,
17,
36,
36,
36,
12,
12,
2,
keep_tv_range=True,
output_depth=16)
deband = core.std.MergeDiff(deband, diff)
deband = core.std.MaskedMerge(deband, out, detail_light_mask)
out = deband
# Regraining
grain = adptvgrnMod(out,
0.25,
0.15,
size=out.height / h,
sharp=80,
luma_scaling=10,
static=True)
out = grain
return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2])
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Main filterchain"""
import havsfunc as haf
import lvsfunc as lvf
import rekt
import vardefunc as vdf
from adptvgrnMod import adptvgrnMod
from 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 do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
h = 720
w = get_w(h)
edgesfix = awf.bbmod(src, 1, 1, 1, 1, 48, 500)
out = edgesfix
clip = depth(out, 32)
denoise = hybrid_denoise(clip, 0.45, 1.5)
out = denoise
luma = get_y(out)
line_mask = line_mask_func(luma)
descale = core.descale.Debilinear(luma, w, h)
upscale = vdf.nnedi3_upscale(descale, pscrn=1)
antialias = single_rate_antialiasing(upscale,
13,
alpha=0.2,
beta=0.5,
gamma=600,
mdis=15)
scaled = core.resize.Bicubic(antialias, src.width, src.height)
rescale = core.std.MaskedMerge(luma, scaled, depth(line_mask, 32))
merged = vdf.merge_chroma(rescale, out)
out = depth(merged, 16)
preden = core.knlm.KNLMeansCL(get_y(out),
h=0.75,
a=2,
d=3,
device_type='gpu',
device_id=0)
detail_dark_mask = detail_dark_mask_func(preden, brz_a=8000, brz_b=6000)
detail_light_mask = lvf.denoise.detail_mask(preden, brz_a=2500, brz_b=1200)
detail_mask = core.std.Expr([detail_dark_mask, detail_light_mask],
'x y +').std.Median()
detail_mask_grow = iterate(detail_mask, core.std.Maximum, 2)
detail_mask_grow = iterate(detail_mask_grow, core.std.Inflate,
2).std.Convolution([1, 1, 1, 1, 1, 1, 1, 1, 1])
detail_mask = core.std.Expr([preden, detail_mask_grow, detail_mask],
f'x {32<<8} < y z ?')
op_mask = mask_opening(out)
op_mask = iterate(op_mask, core.std.Deflate, 2)
deband_a = dbs.f3kpf(out, 17, 36, 42, thr=0.5, elast=2, thrc=0.2)
deband_b = placebo.deband(out, 18, 5.5, 2, 0)
deband_c = placebo.deband(out, 22, 10, 3, 0)
deband = core.std.MaskedMerge(deband_a, deband_b, preden)
deband = core.std.MaskedMerge(deband, out, detail_mask)
deband = lvf.rfs(deband, core.std.MaskedMerge(deband_c, deband, op_mask),
[(OPSTART + 0, OPSTART + 38)])
deband = lvf.rfs(deband, deband_b, [(OPSTART + 236, OPSTART + 284)])
deband = lvf.rfs(deband, deband_c, [(OPSTART + 1934, OPSTART + 1944)])
deband = core.neo_f3kdb.Deband(deband,
preset='depth',
grainy=24,
grainc=24)
out = deband
ref, src, src_ncop = [
depth(x, 16) for x in [denoise, src, JPBD_NCOP.src_cut]
]
credit_mask = vdf.drm(ref, kernel='bilinear', mthr=65)
credit = lvf.rfs(out, core.std.MaskedMerge(out, ref, credit_mask, 0),
[(0, 3164)])
credit = lvf.rfs(credit, ref, [(34693, 34764)])
out = credit
src_c, src_ncop = [
c.knlm.KNLMeansCL(a=7, h=35, d=0, device_type='gpu')
for c in [src, src_ncop]
]
opening_mask = vdf.dcm(out, src_c[OPSTART:OPEND + 1],
src_ncop[:OPEND - OPSTART + 1], OPSTART, OPEND, 4,
4).std.Inflate()
credit = lvf.rfs(out, core.std.MaskedMerge(out, ref, opening_mask),
[(OPSTART, OPEND)])
out = credit
grain = adptvgrnMod(out,
0.3,
0.15,
1.25,
luma_scaling=8,
sharp=80,
static=False,
lo=19)
out = grain
return depth(out, 10)
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
src = depth(src, 16)
out = src
if out.num_frames < 34046:
while out.num_frames != 34046:
out += out[-1]
opstart, opend = 0, 2157
h = 720
w = get_w(h)
fixedges = awf.bbmod(out, 2, 2, 2, 2, 64<<8, 999)
out = fixedges
decomb = hvf.Vinverse(out)
decomb = lvf.rfs(out, decomb, [(2187, 2195)])
ref = decomb
out = decomb
from adptvgrnMod import adptvgrnMod
first_denoise = hybrid_denoise(out, 0.35, 1.5)
regrain = adptvgrnMod(first_denoise, 0.275, 0.175, 1.25, 45)
regrain = lvf.rfs(out, regrain, [(28691, 28818)])
out = regrain
clean = core.knlm.KNLMeansCL(out, h=0.55, a=2, d=3, device_type='gpu', device_id=0, channels='UV')
clean = core.knlm.KNLMeansCL(clean, h=0.55, a=2, d=3, device_type='gpu', device_id=0, channels='Y')
diff_den = core.std.MakeDiff(out, clean)
out = depth(clean, 32)
luma = get_y(out)
line_mask = vdf.edge_detect(luma, 'FDOG', 0.05, (1, 1))
descale = core.descale.Debilinear(luma, w, h)
upscale = vdf.nnedi3_upscale(descale, correct_shift=False, pscrn=1).resize.Bicubic(src.width, src.height, src_left=.5, src_top=.5)
rescale = core.std.MaskedMerge(luma, upscale, line_mask)
merged = vdf.merge_chroma(rescale, out)
out = depth(merged, 16)
moozzi = warping(out, 0.4, 4)
sharp = hvf.LSFmod(moozzi, strength=95, 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, 30, 30)
deband = core.std.MaskedMerge(deband, out, deband_mask)
out = deband
grain_org = core.std.MergeDiff(out, diff_den)
out = grain_org
credit_mask = vdf.diff_rescale_mask(ref, mthr=40, sw=5, sh=5)
credit_mask = vdf.region_mask(credit_mask, 10, 10, 10, 10).std.Inflate().std.Inflate()
antialias = lvf.sraa(ref, 2, 13, downscaler=core.resize.Bicubic)
credit = lvf.rfs(out, core.std.MaskedMerge(out, antialias, credit_mask),
[(2188, 2305), (33926, src.num_frames-1)])
credit = lvf.rfs(credit, core.std.MaskedMerge(out, ref, credit_mask), [(31684, 33925)])
out = credit
src_c, ncop = [clip.std.Median() for clip in [src, JPBD_NCOP.src_cut]]
opening_mask = vdf.dcm(out, src_c[opstart:opend+1], ncop[:opend-opstart+1], opstart, opend, 3, 3)
credit_mask = opening_mask.std.Convolution([1]*9)
credit = lvf.rfs(out, core.std.MaskedMerge(out, src, credit_mask), [(opstart, opend)])
out = credit
return depth(out, 10)
def denoise(clip: vs.VideoNode) -> vs.VideoNode:
adaptive_mask = adptvgrnMod(clip, luma_scaling=8, show_mask=True)
denoise = CoolDegrain(clip, thsad=48, blksize=8, overlap=4)
merge = core.std.MaskedMerge(denoise, clip, adaptive_mask)
return merge
