def fix_edges(clip, rownum, rowval, colnum, colval, **kwargs):
import rekt
import awsmfunc as awsm
bbmod_args = dict(top=3, bottom=3, left=3, right=3, thresh=None, blur=20)
bbmod_args |= kwargs
fix = rekt.rektlvls(clip, rownum, rowval, colnum, colval)
return fix.std.MaskedMerge(
awsm.bbmod(clip, **bbmod_args),
core.std.Expr([
fix,
rekt.rektlvls(clip, rownum, rowval, colnum, colval, [16, 256])
], 'x y - abs 0 > 65535 0 ?'), 0, True)
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 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 rekt(clip: vs.VideoNode) -> vs.VideoNode:
"""Apply rekt consistently across multiple clips"""
import rekt
from awsmfunc import bbmod
rkt = rekt.rektlvls(clip, [0, 1079], [17, 16],
[0, 1, 2, 3] + [1917, 1918, 1919],
[16, 4, -2, 2] + [-2, 5, 14])
return bbmod(rkt, left=4, right=3, y=False)
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Main filterchain"""
import lvsfunc as lvf
import rekt
import vardefunc as vdf
from awsmfunc import bbmod
from ccd import ccd
from muvsfunc import SSIM_downsample
from vsutil import depth, get_y
src = JP_BD.clip_cut
rkt = rekt.rektlvls(src, [0, -1], [30, 17], [0], [17])
bb_y = bbmod(rkt, top=2, left=2, right=2, bottom=2, u=False, v=False, blur=9999)
bb_uv = bbmod(bb_y, left=2, right=2, y=False)
bb = depth(bb_uv, 32)
descale = lvf.kernels.Spline36().descale(get_y(bb), 1280, 720)
up_chr = vdf.scale.to_444(bb, 1920, 1080, True).resize.Bicubic(1280, 720)
descale_merge = vdf.misc.merge_chroma(descale, up_chr)
denoise_down = lvf.deblock.vsdpir(descale_merge, strength=0.5, mode='deblock', matrix=1, i444=True, cuda=True)
supersample = vdf.scale.nnedi3_upscale(get_y(denoise_down))
downscaled = SSIM_downsample(supersample, bb.width, bb.height, smooth=((3 ** 2 - 1) / 12) ** 0.5,
sigmoid=True, filter_param_a=0, filter_param_b=0)
scaled = vdf.misc.merge_chroma(downscaled, bb)
scaled = depth(scaled, 16)
den_uv = ccd(scaled, matrix='709')
decs = vdf.noise.decsiz(den_uv, sigmaS=8, min_in=200 << 8, max_in=232 << 8)
nn_aa = lvf.aa.nnedi3(opencl=True, dh=False)(decs)
sraa = lvf.sraa(decs, rfactor=1.75)
clmp = lvf.aa.clamp_aa(decs, nn_aa, sraa)
dehalo = lvf.dehalo.masked_dha(clmp, brightstr=0.65)
deband = flt.masked_f3kdb(dehalo, rad=17, thr=[24, 16], grain=[24, 12])
grain = vdf.noise.Graigasm(
thrs=[x << 8 for x in (32, 80, 128, 176)],
strengths=[(0.20, 0.0), (0.15, 0.0), (0.10, 0.0), (0.0, 0.0)],
sizes=(1.20, 1.15, 1.10, 1),
sharps=(100, 80, 60, 20),
grainers=[
vdf.noise.AddGrain(seed=69420, constant=False),
vdf.noise.AddGrain(seed=69420, constant=False),
vdf.noise.AddGrain(seed=69420, constant=True)
]).graining(deband)
no_flt = lvf.rfs(grain, depth(bb, 16), no_filter)
return no_flt
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Main filterchain"""
import lvsfunc as lvf
import rekt
import vardefunc as vdf
from muvsfunc import SSIM_downsample
from vsutil import depth, get_y
src = JP_BD.clip_cut
rkt = rekt.rektlvls(src, [0, -1], [15, 15], [0, -1], [15, 15])
cloc = depth(rkt, 32).resize.Bicubic(chromaloc_in=1, chromaloc=0)
descale = lvf.kernels.Bilinear().descale(get_y(cloc), 1280, 720)
supersample = vdf.scale.nnedi3_upscale(descale)
downscaled = SSIM_downsample(supersample,
src.width,
src.height,
smooth=((3**2 - 1) / 12)**0.5,
sigmoid=True,
filter_param_a=0,
filter_param_b=0)
scaled = vdf.misc.merge_chroma(downscaled, cloc)
scaled = depth(scaled, 16)
dft = core.dfttest.DFTTest(scaled,
sigma=0.6,
sbsize=8,
sosize=6,
tbsize=3,
tosize=1)
decs = vdf.noise.decsiz(dft, sigmaS=4, min_in=200 << 8, max_in=232 << 8)
baa = lvf.aa.based_aa(decs, str(shader_file))
sraa = lvf.sraa(decs, rfactor=1.5)
clmp = lvf.aa.clamp_aa(decs, baa, sraa, strength=1.5)
deband = flt.masked_f3kdb(clmp, rad=16, thr=[20, 16])
grain = vdf.noise.Graigasm(thrs=[x << 8 for x in (32, 80, 128, 176)],
strengths=[(0.25, 0.0), (0.20, 0.0),
(0.15, 0.0), (0.0, 0.0)],
sizes=(1.20, 1.15, 1.10, 1),
sharps=(80, 70, 60, 50),
grainers=[
vdf.noise.AddGrain(seed=69420,
constant=False),
vdf.noise.AddGrain(seed=69420,
constant=False),
vdf.noise.AddGrain(seed=69420,
constant=True)
]).graining(deband)
return grain
def prepare_hr(self, clip: vs.VideoNode,
dvd_clip: vs.VideoNode) -> vs.VideoNode:
"""
Match with the DVD @640x480:
bd.resize.Bicubic(720, 486, src_left=-0.75).std.Crop(top=3, bottom=3)
"""
import havsfunc as haf
import lvsfunc as lvf
import muvsfunc as muf
import rekt
import vardefunc as vdf
from awsmfunc import bbmod
from vsutil import depth, join, plane
from xvs import WarpFixChromaBlend
rkt = rekt.rektlvls(clip, [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)
clip = depth(ef, 32).std.AssumeFPS(fpsnum=24, fpsden=1)
bd_descale = lvf.kernels.Bicubic().descale(plane(clip, 0), 1280, 720)
bd_doubled = vdf.scale.nnedi3_upscale(bd_descale)
bd_down = muf.SSIM_downsample(bd_doubled, dvd_clip.width * 2, 486 * 2)
# Need to do some fuckery to make sure the chroma matches up perfectly
bd_cshift = clip.resize.Bicubic(chromaloc_in=1,
chromaloc=0,
format=vs.YUV420P16)
bd_cwarp = bd_cshift.warp.AWarpSharp2(thresh=88,
blur=3,
type=1,
depth=6,
planes=[1, 2])
bd_chroma = bd_cwarp.resize.Bicubic(format=vs.YUV444P16,
width=bd_down.width,
height=bd_down.height)
bd_i444 = core.std.ShufflePlanes([depth(bd_down, 16), bd_chroma])
bd_shift = bd_i444.resize.Bicubic(src_left=-0.75).std.Crop(top=6,
bottom=6)
return bd_shift.resize.Bicubic(format=vs.RGB24, dither_type='error_diffusion') \
.std.ShufflePlanes([1, 2, 0], vs.RGB)
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Main filterchain"""
import lvsfunc as lvf
import rekt
import vardefunc as vdf
from awsmfunc import bbmod
from ccd import ccd
from vsutil import depth
src = JP_BD.clip_cut
rkt = rekt.rektlvls(src, [0, -1], [30, 17], [0], [17])
bb_y = bbmod(rkt, top=2, left=2, right=2, bottom=2, blur=9999, u=False, v=False)
bb_uv = bbmod(bb_y, left=2, right=2, y=False)
bb = depth(bb_uv, 16)
den = core.dfttest.DFTTest(bb, sigma=3.6, tbsize=5, tosize=3)
den_uv = ccd(den, matrix='709')
decs = vdf.noise.decsiz(den_uv, sigmaS=8, min_in=200 << 8, max_in=232 << 8)
cwarp = core.warp.AWarpSharp2(decs, thresh=72, blur=3, type=1, depth=4, planes=[1, 2])
deband = flt.masked_f3kdb(cwarp, rad=17, thr=[24, 16], grain=[24, 12])
grain = vdf.noise.Graigasm(
thrs=[x << 8 for x in (32, 80, 128, 176)],
strengths=[(0.20, 0.0), (0.15, 0.0), (0.10, 0.0), (0.0, 0.0)],
sizes=(1.20, 1.15, 1.10, 1),
sharps=(100, 80, 60, 20),
grainers=[
vdf.noise.AddGrain(seed=69420, constant=True),
vdf.noise.AddGrain(seed=69420, constant=True),
vdf.noise.AddGrain(seed=69420, constant=True)
]).graining(deband)
no_flt = lvf.rfs(grain, depth(bb, 16), no_filter)
return no_flt
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""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
from vapoursynth import core
import havsfunc as haf
from rekt import rektlvls
westbound = core.d2v.Source("Westbound/VTS_01_1.d2v")
westbound = core.vivtc.VFM(westbound, 1)
westbound = core.std.SelectEvery(westbound, cycle=5, offsets=[0, 1, 2, 3])
westbound = rektlvls(westbound, colnum=[719], colval=[20])
westbound = haf.Deblock_QED(westbound)
westbound.set_output()
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Main filterchain"""
import lvsfunc as lvf
import rekt
import vardefunc as vdf
from awsmfunc import bbmod
from muvsfunc import SSIM_downsample
from vsutil import depth, get_y
src = JP_BD.clip_cut
rkt = rekt.rektlvls(src, [0, -1], [17, 17], [0, -1], [17, 21])
bb_y = bbmod(rkt, top=2, left=2, right=1, u=False, v=False)
bb_uv = bbmod(bb_y, left=2, right=2, y=False)
bb = depth(bb_uv, 32)
descale = lvf.kernels.Mitchell().descale(get_y(bb), 1280, 720)
up_chr = vdf.scale.to_444(bb, 1920, 1080, True).resize.Bicubic(1280, 720)
descale_merge = vdf.misc.merge_chroma(descale, up_chr)
denoise_down = lvf.deblock.vsdpir(descale_merge, strength=5, mode='deblock', matrix=1, i444=True, cuda=True)
supersample = vdf.scale.nnedi3_upscale(get_y(denoise_down))
downscaled = SSIM_downsample(supersample, bb.width, bb.height, smooth=((3 ** 2 - 1) / 12) ** 0.5,
sigmoid=True, filter_param_a=0, filter_param_b=0)
den_chr_up = core.resize.Bicubic(denoise_down, bb.width, bb.height, bb.format.id)
den_chr_up_shift = core.resize.Bicubic(denoise_down, bb.width, bb.height, bb.format.id, src_left=-0.5)
den_chr_up = lvf.rfs(den_chr_up, den_chr_up_shift, shift_chr)
scaled = vdf.misc.merge_chroma(downscaled, den_chr_up)
scaled = depth(scaled, 16)
decs = vdf.noise.decsiz(scaled, sigmaS=4, min_in=208 << 8, max_in=232 << 8)
deband = core.average.Mean([
flt.masked_f3kdb(decs, rad=17, thr=[20, 24], grain=[24, 12]),
flt.masked_f3kdb(decs, rad=21, thr=[32, 24], grain=[24, 12]),
flt.masked_placebo(decs, rad=6, thr=2.8, itr=2, grain=4)
])
grain = vdf.noise.Graigasm(
thrs=[x << 8 for x in (32, 80, 128, 176)],
strengths=[(0.25, 0.0), (0.20, 0.0), (0.15, 0.0), (0.0, 0.0)],
sizes=(1.25, 1.20, 1.15, 1),
sharps=(80, 70, 60, 50),
grainers=[
vdf.noise.AddGrain(seed=69420, constant=False),
vdf.noise.AddGrain(seed=69420, constant=False),
vdf.noise.AddGrain(seed=69420, constant=True)
]).graining(deband)
grain_str = vdf.noise.Graigasm(
thrs=[x << 8 for x in (32, 80, 128, 176)],
strengths=[(0.35, 0.0), (0.30, 0.0), (0.25, 0.0), (0.0, 0.0)],
sizes=(1.25, 1.20, 1.15, 1),
sharps=(80, 70, 60, 50),
grainers=[
vdf.noise.AddGrain(seed=69420, constant=False),
vdf.noise.AddGrain(seed=69420, constant=False),
vdf.noise.AddGrain(seed=69420, constant=True)
]).graining(deband)
grain = lvf.rfs(grain, grain_str, str_grain)
return grain
import awsmfunc as awf
import havsfunc
import fvsfunc as fvf
import kagefunc as kgf
import lvsfunc
#from acsuite import eztrim
ep1 = core.ffms2.Source("Sukeban.Deka.S01.480p.AMZN.WEB-DL.DDP2.0.H.264-ARiN/Sukeban.Deka.S01E01.480p.AMZN.WEB-DL.DDP2.0.H.264-ARiN.mkv")
#eztrim(ep1, [(24,36876)], 'Sukeban.Deka.S01E01.480p.AMZN.WEB-DL.DDP2.0.H.264-ARiN.track_2.ac3')
ep1 = ep1[24:36876]
ep1 = havsfunc.Deblock_QED(ep1)
ep1 = awf.bbmod(ep1, left=3, thresh=5, blur=4)
ep1 = core.fb.FillBorders(ep1, right=2)
ep1 = rektlvls(ep1, colnum=[2,638], colval=[-20,-17])
ep1 = awf.bbmod(ep1, right=4, thresh=40, blur=40)
ep1 = core.resize.Bicubic(ep1, src_left=-1)
ep1 = rektlvls(ep1, colnum=[0,4,5], colval=[-40,-30,-10])
ep1 = rektlvls(ep1, colnum=[0,1,3,4,5], colval=[20,-10,20,30,10])
ep1 = awf.bbmod(ep1, right=6, thresh=10, blur=10)
ep1 = awf.bbmod(ep1, left=7, thresh=10, blur=90)
ep1 = lvsfunc.misc.fix_cr_tint(ep1)
ep1 = fvf.GradFun3(ep1, thr=0.35, radius=12, elast=8.0, mode=3, ampo=1, ampn=0, pat=32, dyn=False, staticnoise=False, thr_det=2 + round(max(1 - 0.35, 0) / 0.3), debug=False, thrc=1, radiusc=12, planes=list(range(ep1.format.num_planes)), ref=ep1, bits=ep1.format.bits_per_sample)
ep1 = kgf.adaptive_grain(ep1, strength=.25, static=True, luma_scaling=12, show_mask=False)
ep1 = havsfunc.FineDehalo(ep1)
from vapoursynth import core
import awsmfunc as awf
from rekt import rektlvls
deliverance = core.ffms2.Source(
"Deliverance.40th.Anniversary.Edition.1972.Bluray.Remux.1080p.VC-1.DTS-HD.MA.5.1-HiFi.mkv"
)
deliverance = core.std.Crop(deliverance, top=140, bottom=140)
deliverance = core.fb.FillBorders(deliverance, left=2)
deliverance = rektlvls(deliverance, colnum=[1916, 1918], colval=[2, 26])
deliverance = awf.fb(deliverance, right=1)
deliverance = awf.bbmod(deliverance, left=8, right=4, thresh=15, blur=20)
deliverance.set_output()
from vapoursynth import core, YUV444P8, YUV420P8
from rekt import rektlvls
import havsfunc as haf
import awsmfunc as awf
import lvsfunc as lvf
import G41Fun
guilstein = core.d2v.Source("Guilstein/VTS_01_1.d2v")[:163645]
guilstein = guilstein.decross.DeCross().dedot.Dedot().resize.Bicubic(format=YUV444P8, matrix_s="170m")
topline = guilstein.vinverse.Vinverse().std.Crop(top=63, bottom=70, left=6, right=6).std.CropAbs(top=1, width=guilstein.width-12, height=2)
guilstein = core.std.MaskedMerge(guilstein.vinverse.Vinverse().std.Crop(top=66, left=6, right=6), guilstein.std.Crop(top=66, left=6, right=6).nnedi3.nnedi3(1), guilstein.std.Crop(top=66, left=6, right=6).comb.CombMask().morpho.Dilate())
guilstein = guilstein.std.Crop(bottom=70)
guilstein = core.std.StackVertical([topline, guilstein])
guilstein = rektlvls(guilstein, rownum=[0, 1], rowval=[50, 10], colnum=[0, 1, 2, 3, 4], colval=[14, 10, 9, -3, -2], prot_val=[16, 235])
guilstein = awf.bbmod(guilstein, right=4, thresh=7, blur=16)
guilstein = core.std.Expr([guilstein, awf.bbmod(guilstein, bottom=3, thresh=2, blur=16)], "x y > x y ?")
guilstein = core.std.Expr([guilstein, awf.bbmod(guilstein, left=8, thresh=1, blur=8)], "x y > x y ?")
guilstein = lvf.aa.upscaled_sraa(guilstein, rfactor=2.0)
guilstein = guilstein.dfttest.DFTTest(sigma=2.0)
guilstein = guilstein.f3kdb.Deband(range=30, grainy=2, grainc=2)
guilstein = G41Fun.MaskedDHA(guilstein, rx=1.6, ry=1.6, darkstr=0.0, brightstr=0.6, lowsens=120, highsens=10)
guilstein = haf.EdgeCleaner(guilstein, strength=10)
guilstein = guilstein.resize.Bicubic(format=YUV420P8, matrix_s="170m")
guilstein = guilstein.std.FreezeFrames(first=[110471], last=[110483], replacement=[110470])
guilstein.set_output()
from vapoursynth import core
import awsmfunc as awf
from rekt import rektlvls
battle_of_the_bulge = core.ffms2.Source(
"Battle.of.the.Bulge.1965.BluRay.Remux.1080p.VC-1.DD.5.1-decibeL.mkv")
battle_of_the_bulge = core.std.Crop(battle_of_the_bulge,
top=194,
bottom=192,
left=6,
right=6)
battle_of_the_bulge = awf.fb(battle_of_the_bulge, right=1)
battle_of_the_bulge = rektlvls(battle_of_the_bulge,
colnum=[0, 1, 1905, 1906, 1907],
colval=[-14, -5, -5, -12, -15])
battle_of_the_bulge.set_output()
cunny = core.d2v.Source("Imouto Jiru/DISC1.d2v")
cunny = cunny.vivtc.VFM(1)
cunny = cunny.vivtc.VDecimate()
cunny = cunny[:44972]
cunny = cunny.std.Crop(left=6, right=4)
cunny = awf.fb(cunny, top=1)
cunny = cunny.resize.Bicubic(src_top=1)
cunny = cunny.fb.FillBorders(top=1, bottom=1, mode="fixborders")
cunny = cunny.vinverse.Vinverse()
black = core.tcm.TColorMask(cunny.std.Minimum(), ["$000000"],
tolerance=7,
bt601=True,
gray=False,
lutthr=9)
cunny = rektlvls(cunny, colnum=[1, 709], colval=[-9, 35])
aa = taa.TAAmbk(cunny, "Nnedi3")
sangnom = taa.TAAmbk(cunny, "Nnedi3SangNom")
mask = kgf.retinex_edgemask(cunny).std.Binarize(200).std.Deflate(threshold=250)
cunny = cunny.placebo.Deband(threshold=6, radius=16, grain=4)
cunny = awf.ReplaceFrames(core.std.MaskedMerge(cunny, aa, mask),
core.std.MaskedMerge(cunny, sangnom, mask),
"[4708 4850] [5290 5421] [5542 5698] [5770 5803]")
no_bbmod = cunny
censor = cunny.fb.FillBorders(top=2, mode="fixborders")
censor = awf.bbmod(censor, top=4, thresh=200, blur=10)
censor = awf.bbmod(censor, right=4, thresh=2, blur=5)
censor = awf.bbmod(censor, left=4, thresh=6, blur=8)
censor = awf.bbmod(censor, right=1)
cunny = awf.bbmod(cunny, right=4, top=4, thresh=2, blur=5)
cunny = awf.bbmod(cunny, left=4, thresh=6, blur=8)
expand=5)
diffedge = vdf.mask.Difference().creditless(src_clip=ededge + ededge[0],
credit_clip=ededge,
nc_clip=nced,
start_frame=0,
thr=20,
prefilter=True,
expand=5)
diff = core.std.StackVertical([
diffedge.std.CropAbs(width=diffedge.width, height=4),
diff.std.Crop(top=4, bottom=4),
diffedge.std.CropAbs(width=diffedge.width, height=4, top=360)
])[:-1]
diff = diff.std.Deflate().std.Deflate().std.Deflate()
merged = core.std.MaskedMerge(ed, merged, diff)
#damage = core.std.MaskedMerge(ed, damage, diff)
merged = merged.std.Crop(left=2, right=2)
merged = core.resize.Bicubic(merged, format=YUV444P8)
merged = merged.std.Crop(left=1, right=1)
merged = rekt.rektlvls(merged, rownum=[0], rowval=[10])
merged = merged.fb.FillBorders(bottom=1, left=1, mode="fixborders")
merged = awf.bbmod(merged, top=8, thresh=2, blur=4)
merged = awf.bbmod(merged, left=6, right=6, thresh=2, blur=10)
merged = awf.bbmod(merged, bottom=2, thresh=4, blur=4)
merged = merged.std.AddBorders(top=56, bottom=60)
set_output(ivtc(merged))
epfix = depth(ep, 16)
epfix = epfix.std.Levels(min_in=0,
max_in=235 << 8,
min_out=16 << 8,
max_out=235 << 8,
planes=0)
epfix = epfix.resize.Bicubic(format=YUV444P16,
matrix_in_s="170m",
range_in_s="limited",
dither_type="error_diffusion")
edgefix = core.std.ShufflePlanes([epfix, awf.fb(epfix, left=1)], [0, 1, 2],
YUV)
epfix = awf.bbmod(edgefix, left=2, blur=20,
thresh=30).std.Merge(edgefix, weight=[0.6, 0.4])
epfix = rektlvls(epfix, colnum=[638], colval=[8], prot_val=[70, 191])
epfix = epfix.resize.Bicubic(format=RGBS,
matrix_in_s="170m",
range_in_s="limited")
dpir = lvf.deblock.autodb_dpir(epfix,
strs=[45, 55, 75],
thrs=[(0.0, 0.0, 0.0), (1.0, 1.2, 1.5),
(3.0, 3.8, 4.5)],
cuda=False).resize.Bicubic(
format=YUV444P16,
matrix_s="170m",
dither_type="error_diffusion")
dpir = haf.FineDehalo(dpir, rx=2, ry=2, brightstr=1.8, darkstr=0.2)
dpir = core.std.Merge(haf.FineDehalo(dpir,
def pre_filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""
Regular filtering to get the output images to stitch.
This is preferable over handling it unfiltered, since it'll be faster than encoding it
and reduces the amount of jitter caused by the upscale after.
"""
import lvsfunc as lvf
import rekt
import vardefunc as vdf
from awsmfunc import bbmod
from muvsfunc import SSIM_downsample
from vsutil import depth, get_y, join, plane
src = JP_BD.clip_cut
# Fixing animation f**k-ups
if freeze_ranges:
src = core.std.FreezeFrames(
src,
[s[0] for s in freeze_ranges],
[e[1] for e in freeze_ranges],
[f[2] for f in freeze_ranges]
)
# Edgefixing
ef = rekt.rektlvls(
src, prot_val=[16, 235], min=16, max=235,
rownum=[0, src.height-1], rowval=[16, 16],
colnum=[0, src.width-1], colval=[16, 16],
)
bb_y = bbmod(ef, left=1, top=1, right=1, bottom=1, thresh=32, y=True, u=False, v=False)
bb_uv = bbmod(bb_y, left=2, top=2, right=2, bottom=2, y=False, u=True, v=True)
cshift = flt.shift_chroma(bb_uv, left=0.6)
cshift = lvf.rfs(bb_uv, cshift, cshift_left_ranges)
bb32 = depth(cshift, 32)
bb32_y = get_y(bb32)
# Descaling + DPIR while it's at a lower res (so I can actually run it because >memory issues xd)
descale = lvf.kernels.Catrom().descale(bb32_y, 1280, 720)
downscale = lvf.kernels.Catrom(format=vs.YUV444PS).scale(bb32, 1280, 720)
descale_444 = join([descale, plane(downscale, 1), plane(downscale, 2)])
denoise_y = lvf.deblock.vsdpir(descale_444, strength=2.75, mode='deblock', matrix=1, i444=True, cuda=True)
supersample = vdf.scale.fsrcnnx_upscale(get_y(denoise_y), shader_file=shader_file, downscaler=None)
downscaled = SSIM_downsample(supersample, src.width, src.height, smooth=((3 ** 2 - 1) / 12) ** 0.5,
sigmoid=True, filter_param_a=0, filter_param_b=0)
# Create credit mask
upscale = lvf.kernels.Catrom().scale(descale, src.width, src.height)
credit_mask = lvf.scale.descale_detail_mask(bb32_y, upscale, threshold=0.055) \
.std.Deflate().std.Deflate().std.Minimum()
# Merge early for additional accuracy with DPIR
merged = core.std.MaskedMerge(downscaled, bb32_y, credit_mask)
down_y = lvf.kernels.Catrom().scale(merged, src.width/2, src.height/2)
down_i444 = join([down_y, plane(bb32, 1), plane(bb32, 2)])
deblock_down = lvf.deblock.vsdpir(down_i444, strength=3, mode='denoise', matrix=1, i444=True, cuda=True)
scaled = depth(join([merged, plane(deblock_down, 1), plane(deblock_down, 2)]), 16)
# Final bit of "denoising"
dft = core.dfttest.DFTTest(scaled, sigma=2.0, tbsize=5, tosize=3, planes=[0])
decs = vdf.noise.decsiz(dft, sigmaS=4, min_in=208 << 8, max_in=232 << 8)
# AA
baa = lvf.aa.based_aa(decs, str(shader_file))
sraa = lvf.sraa(decs, rfactor=1.65)
clmp = lvf.aa.clamp_aa(decs, baa, sraa, strength=1.3)
dehalo = lvf.dehalo.masked_dha(clmp, rx=1.4, ry=1.4, brightstr=0.4)
cwarp = core.warp.AWarpSharp2(dehalo, thresh=72, blur=3, type=1, depth=4, planes=[1, 2])
# Merge credits (if applicable)
merged = core.std.MaskedMerge(cwarp, depth(bb32, 16), depth(credit_mask, 16))
deband = core.average.Mean([
flt.masked_f3kdb(merged, rad=16, thr=[20, 24], grain=[24, 12]),
flt.masked_f3kdb(merged, rad=20, thr=[28, 24], grain=[24, 12]),
flt.masked_placebo(merged, rad=6, thr=2.5, itr=2, grain=4)
])
no_flt = lvf.rfs(deband, depth(bb32, 16), no_filter)
return no_flt
opfix = depth(op, 16)
opfix = opfix.std.Levels(min_in=0,
max_in=235 << 8,
min_out=16 << 8,
max_out=235 << 8,
planes=0)
opfix = opfix.resize.Bicubic(format=YUV444P16,
matrix_in_s="170m",
range_in_s="limited",
dither_type="error_diffusion")
edgefix = core.std.ShufflePlanes([opfix, awf.fb(opfix, left=1)], [0, 1, 2],
YUV)
opfix = awf.bbmod(edgefix, left=2, blur=20,
thresh=30).std.Merge(edgefix, weight=[0.6, 0.4])
opfix = rektlvls(opfix, colnum=[638], colval=[8],
prot_val=[60, 190]) # 692 957 805
opfix = opfix.resize.Bicubic(format=RGBS,
matrix_in_s="170m",
range_in_s="limited")
dpir = lvf.deblock.autodb_dpir(opfix,
strs=[55, 65, 115],
thrs=[(0.0, 0.0, 0.0), (1.0, 1.2, 1.5),
(3.0, 3.8, 4.5)],
cuda=False).resize.Bicubic(
format=YUV444P16,
matrix_s="170m",
dither_type="error_diffusion")
dpir = haf.FineDehalo(dpir, rx=2, ry=2, brightstr=1.8, darkstr=0.2)
#dpir = core.std.Merge(haf.FineDehalo(dpir, rx=1.8, ry=1.8, brightstr=1.8, darkstr=0), dpir, weight=[0.4, 0.6])
def main() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Vapoursynth filtering"""
# Don't worry, this script is barely readable anymore even for me
import rekt
from awsmfunc import bbmod
from havsfunc import ContraSharpening
from lvsfunc.aa import upscaled_sraa
from lvsfunc.comparison import stack_compare
from lvsfunc.mask import BoundingBox
from lvsfunc.util import replace_ranges
from vardefunc import dcm
from vardefunc.deband import dumb3kdb
from vardefunc.mask import FreyChen
from vsutil import depth, get_y, insert_clip
src = JP_BD.clip_cut
b = core.std.BlankClip(src, length=1)
if opstart is not False:
src_NCOP = NCOP.clip_cut
op_scomp = stack_compare(
src[opstart:opstart + src_NCOP.num_frames - 1] + b,
src_NCOP[:-op_offset] + b,
make_diff=True) # noqa
if edstart is not False:
src_NCED = NCED.clip_cut
#ed_scomp = stack_compare(src[edstart:edstart+src_NCED.num_frames-1]+b, src_NCED[:-ed_offset]+b, make_diff=True) # noqa
# Masking credits
op_mask = dcm(
src, src[opstart:opstart+src_NCOP.num_frames], src_NCOP,
start_frame=opstart, thr=25, prefilter=True) if opstart is not False \
else get_y(core.std.BlankClip(src))
ed_mask = dcm(
src, src[edstart:edstart+src_NCED.num_frames], src_NCED,
start_frame=edstart, thr=25, prefilter=True) 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()
# Fixing an animation f**k-up
for f in op_replace:
src = insert_clip(src, src[f], f - 1)
# Edgefixing
ef = rekt.rektlvls(
src,
prot_val=[16, 235],
min=16,
max=235,
rownum=[0, src.height - 1],
rowval=[16, 16],
colnum=[0, src.width - 1],
colval=[16, 16],
)
bb_y = bbmod(ef,
left=1,
top=1,
right=1,
bottom=1,
thresh=32,
y=True,
u=False,
v=False)
bb_uv = bbmod(bb_y,
left=2,
top=2,
right=2,
bottom=2,
y=False,
u=True,
v=True)
bb32 = depth(bb_uv, 32)
# --- Very specific filtering that should probably be removed for future episodes entirely
# Fading for some... well, fades.
fade = flt.fader(bb32, start_frame=4437, end_frame=4452)
fade = flt.fader(fade, start_frame=18660, end_frame=18697)
# Different sport names
rkt_aa_ranges: Union[Union[int, None, Tuple[Optional[int], Optional[int]]],
List[Union[int, None,
Tuple[Optional[int],
Optional[int]]]], None] = [ # noqa
(8824, 8907), (9828, 9911),
(10995, 11078), (11904, 12010)
]
rkt_aa = rekt.rekt_fast(fade,
fun=lambda x: upscaled_sraa(x),
top=854,
left=422,
bottom=60,
right=422)
rkt_aa = replace_ranges(fade, rkt_aa, rkt_aa_ranges)
# QP GET!
rkt_aa2_ranges: Union[Union[int, None, Tuple[Optional[int],
Optional[int]]],
List[Union[int, None,
Tuple[Optional[int],
Optional[int]]]], None] = [ # noqa
(26333, 26333), (28291, 28344),
(30271, 30364)
]
rkt_aa2 = rekt.rekt_fast(rkt_aa,
fun=lambda x: upscaled_sraa(x),
top=714,
left=354,
bottom=224,
right=354)
rkt_aa2 = replace_ranges(fade, rkt_aa, rkt_aa2_ranges)
# Table stuff
rkt_aa3_ranges: Union[Union[int, None, Tuple[Optional[int],
Optional[int]]],
List[Union[int, None,
Tuple[Optional[int],
Optional[int]]]], None] = [ # noqa
(32797, 32952)
]
rkt_aa3 = rekt.rekt_fast(rkt_aa2,
fun=lambda x: upscaled_sraa(x),
top=488,
left=312,
bottom=390,
right=850)
rkt_aa3 = replace_ranges(fade, rkt_aa2, rkt_aa3_ranges)
rkt_aa = rkt_aa3
# Clipping error Nyatalante/Achilles
fixed_frame = source(
JP_BD.workdir.to_str() + r"/assets/01/FGCBD_01_8970_fixed.png", rkt_aa)
fix_error = replace_ranges(rkt_aa, fixed_frame, [(8968, 8970)])
sp_out32 = fix_error
sp_out16 = depth(sp_out32, 16)
# Rescaling
l_mask = FreyChen().get_mask(get_y(sp_out16)).morpho.Close(size=6)
l_mask = core.std.Binarize(l_mask, 24 << 8).std.Maximum().std.Maximum()
scaled, credit_mask = flt.rescaler(sp_out32,
height=720,
shader_file=shader)
scaled = core.std.MaskedMerge(sp_out16, scaled, l_mask)
scaled = core.std.MaskedMerge(scaled, sp_out16, credit_mask)
# Denoising
denoise = flt.multi_denoise(scaled, l_mask)
# Anti-aliasing
aa_clamped = flt.clamp_aa(denoise, strength=3.0)
aa_rfs = replace_ranges(denoise, aa_clamped, aa_ranges)
# Fix edges because they get f****d during the denoising and AA stages
box = BoundingBox((1, 1), (src.width - 2, src.height - 2))
fix_edges = core.std.MaskedMerge(scaled, aa_rfs, box.get_mask(scaled))
# Regular debanding, but then...
deband = flt.multi_debander(fix_edges, sp_out16)
# --- More very specific filtering that should almost definitely be removed for other episodes
boxes = [
BoundingBox((0, 880), (1920, 200)),
BoundingBox((1367, 0), (552, 1080)),
BoundingBox((1143, 0), (466, 83)),
BoundingBox((1233, 84), (237, 84)),
]
boxed_deband = flt.placebo_debander(fix_edges,
iterations=2,
threshold=8,
radius=14,
grain=4)
boxed_mask = core.std.BlankClip(
boxed_deband.std.ShufflePlanes(planes=0, colorfamily=vs.GRAY))
for bx in boxes: # Gonna be awfully slow but OH WELLLLLL
boxed_mask = core.std.Expr(
[boxed_mask, bx.get_mask(boxed_mask)], "x y max")
boxed_deband_merged = core.std.MaskedMerge(deband, boxed_deband,
boxed_mask)
boxed_deband_merged = replace_ranges(deband, boxed_deband_merged,
[(20554, 20625)])
stronger_deband = dumb3kdb(fix_edges, radius=18, threshold=[48, 32])
stronger_deband = replace_ranges(boxed_deband_merged, stronger_deband,
[(22547, 22912), (28615, 28846),
(33499, 33708), (37223, 37572),
(37636, 37791), (38047, 38102),
(38411, 38733)])
deband_csharp = ContraSharpening(stronger_deband, scaled, 17)
sp_out = deband_csharp
# Back to regular graining
grain = flt.grain(sp_out)
return grain
from vapoursynth import core, GRAY, YUV, YUV444P16, YUV420P10
import awsmfunc as awf
import lvsfunc as lvf
import havsfunc as haf
import vardefunc as vdf
from rekt import rektlvls
src = core.ffms2.Source("[SubsPlease] Nomad - Megalo Box 2 - 01 (1080p) [99D681F1].mkv")
fb = rektlvls(src, colnum=[0, 1919], colval=[15, 15])
fb = rektlvls(fb, rownum=[0, 1079], rowval=[16, 16])
descale = lvf.scale.descale(fb, upscaler=None, height=720, kernel=lvf.kernels.Bicubic(b=0, c=1))
descale = lvf.scale.descale(descale, upscaler=None, height=405, kernel=lvf.kernels.Bicubic(b=0, c=1/2))
downscale = fb.resize.Spline36(width=descale.width, height=descale.height, format=YUV444P16)
descale = descale.resize.Spline36(format=YUV444P16)
u = core.std.ShufflePlanes(downscale, planes=[1], colorfamily=GRAY)
v = core.std.ShufflePlanes(downscale, planes=[2], colorfamily=GRAY)
descale = core.std.ShufflePlanes([descale, u, v], planes=[0, 0, 0], colorfamily=YUV)
deband = descale.placebo.Deband(threshold=3, radius=8, grain=0)
rescale = vdf.fsrcnnx_upscale(deband, 1920, 1080, shader_file="FSRCNNX_x2_56-16-4-1.glsl").resize.Spline36(1920, 1080)
rescale = vdf.merge_chroma(rescale, deband.resize.Spline36(width=1920, height=1080))
rescale = awf.ReplaceFrames(rescale, haf.Deblock_QED(src).placebo.Deband(threshold=3, radius=8, grain=0).resize.Spline36(format=YUV444P16), "[0 167] [662 757] [806 901] [950 1045] [1130 1125] [1418 1513] [2514 2637] [32698 34694]")
rescale = awf.ReplaceFrames(rescale, fb.placebo.Deband(threshold=3, radius=8, grain=0).resize.Spline36(format=YUV444P16), "[168 601] [25058 25185]")
rescale = rescale.resize.Spline36(format=YUV420P10, dither_type="error_diffusion")
rescale.set_output()
from vapoursynth import core
import havsfunc as haf
import awsmfunc as awf
from rekt import rektlvls
import mvsfunc
executive_action_tv = core.lsmas.LWLibavSource("Executive Action.mkv")
executive_action_tv = core.std.Crop(executive_action_tv, top=6, bottom=2)
executive_action_tv = rektlvls(executive_action_tv,
colnum=[2, 1917],
colval=[20, 12])
executive_action_tv = core.fb.FillBorders(executive_action_tv, left=2, right=2)
executive_action_tv = awf.fb(executive_action_tv, bottom=1)
executive_action_tv = awf.bbmod(executive_action_tv,
left=6,
top=4,
bottom=6,
thresh=15,
blur=20)
executive_action_tv = awf.bbmod(executive_action_tv,
right=6,
thresh=5,
blur=20)
executive_action_tv = core.resize.Bicubic(executive_action_tv, format=YUV444P8)
executive_action_ntsc = core.d2v.Source(
"Executive.Action.1973.NTSC.DVD5/VTS_01_1.d2v")[83:]
executive_action_ntsc = core.vivtc.VFM(executive_action_ntsc, 1)
executive_action_ntsc = core.std.SelectEvery(executive_action_ntsc,
cycle=5,
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
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)
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 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
