def MQTGMC(src, EZDenoise=None, lsb=None, TFF=True, half=False, fast=False):
core = vs.get_core()
if lsb is None:
if fast is True:
lsb = False
else:
lsb = True
src16 = Up16(src, lsb)
FPSDivisor = 2 if half else 1
# Controllare MatchEnhance e/o Sharpness in quanto con SourceMatch il risultato sembra essere meno sharposo
# has.QTGMC(src16, Preset="Very Slow", SourceMatch=3, MatchPreset="Slow", MatchPreset2="Ultra Fast", Lossless=2, NoisePreset="Slow", TFF=TFF, EZDenoise=EZDenoise, FPSDivisor=FPSDivisor)
# has.QTGMC(src16, Preset="Medium", SourceMatch=3, MatchPreset="Fast", MatchPreset2="Ultra Fast", Lossless=2, NoisePreset="Medium", TFF=TFF, EZDenoise=EZDenoise, FPSDivisor=FPSDivisor)
if fast:
result = has.QTGMC(src16,
Preset="Medium",
SourceMatch=3,
MatchPreset="Fast",
Lossless=2,
NoisePreset="Medium",
TFF=TFF,
EZDenoise=EZDenoise,
FPSDivisor=FPSDivisor)
else:
result = has.QTGMC(src16,
Preset="Very Slow",
SourceMatch=3,
MatchPreset2="Slow",
Lossless=2,
NoisePreset="Slow",
TFF=TFF,
EZDenoise=EZDenoise,
FPSDivisor=FPSDivisor)
return result
def decomb(src: vs.VideoNode,
TFF: bool = None,
decimate: bool = True,
vinv: bool = True,
rep: int = None):
funcname = "decomb"
"""
Function written by Midlifecrisis from the WEEB AUTISM server, and slightly modified by me.
This function does some aggressive filtering to get rid of the combing on a interlaced/telecined source.
You can also allow it to decimate the clip, or keep it disabled if you wish to handle the decimating yourself.
Vinverse can also be disabled, allowing for less aggressive decombing. Note that this means far more combing will be left over!
:param TFF: bool: Top-Field-First. Mandatory to set. Set to either "True" or False"
:param decimate: bool: Decimate the video after deinterlacing
:param vinv: bool: Use vinverse to get rid of additional combing
:param rep: int: Repair mode for repairing the decombed frame using the original src frame
"""
if TFF is None:
return error(funcname, 'TFF has to be set to either "True" or "False"!')
VFM_TFF = int(TFF)
def pp(n, f, clip, pp):
return pp if f.props._Combed == 1 else clip
src = core.vivtc.VFM(src, order=VFM_TFF, mode=1)
combmask = core.comb.CombMask(src, cthresh=1, mthresh=3)
combmask = core.std.Maximum(combmask, threshold=250).std.Maximum(threshold=250).std.Maximum(threshold=250).std.Maximum(threshold=250)
combmask = core.std.BoxBlur(combmask, hradius=2, vradius=2)
qtgmc = haf.QTGMC(src, TFF=TFF, SourceMatch=3, Lossless=2, TR0=1, TR1=2, TR2=3, FPSDivisor=2)
qtgmc_merged = core.std.MaskedMerge(src, qtgmc, combmask, first_plane=True)
decombed = core.std.FrameEval(src, partial(pp, clip=src, pp=qtgmc_merged), src)
if vinv:
decombed = decombed.vinverse.Vinverse()
if rep:
decombed = core.rgvs.Repair(decombed, src, rep)
if decimate:
return core.vivtc.VDecimate(decombed)
return decombed
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
# Variables
opstart, opend = 2111, 4268
edstart, edend = 31650, 33809
full_zone = [(18727, 18774), (31590, 31649), (33990, src.num_frames - 1)
] # eyecatch, episode name and next episode
shabc_zone = [(edstart + 15, edstart + 1215),
(edstart + 1882, edstart + 2126)]
h = 720
w = get_w(h)
# Bicubic sharp parts don't have bad edges
edges_a = core.edgefixer.ContinuityFixer(src, *[[2, 1, 1]] * 4)
edges_b = awf.bbmod(src, left=6, thresh=32, blur=200)
edges = lvf.rfs(edges_a, edges_b, [(edstart + 1275, edstart + 1757)])
edges = lvf.rfs(edges, src, [(opstart, opend)] + full_zone)
out = depth(edges, 32)
# Denoise
ref = hvf.SMDegrain(depth(get_y(out), 16), thSAD=450)
denoise = hybrid_denoise(out, 0.35, 1.4, dict(a=2, d=1),
dict(ref=depth(ref, 32)))
out = denoise
# denoise = out
# Descale
luma = get_y(out)
lineart = vdf.edge_detect(luma, 'FDOG', 0.055,
(1, 1)).std.Median().std.BoxBlur(0, 1, 1, 1, 1)
descale_a = core.descale.Despline36(luma, w,
h).std.SetFrameProp('descaleKernel',
data='spline36')
descale_b = core.descale.Debicubic(luma, w, h, 0, 1).std.SetFrameProp(
'descaleKernel', data='sharp_bicubic')
descale = lvf.rfs(descale_a, descale_b, shabc_zone)
# Chroma reconstruction
# y_m is the assumed mangled luma.
# Descale 1080p -> Bad conversion in 422 720p -> Regular 1080p 420
radius = 2
y, u, v = descale, plane(out, 1), plane(out, 2)
y_m = core.resize.Point(y, 640, 720,
src_left=-1).resize.Bicubic(960,
540,
filter_param_a=1 / 3,
filter_param_b=1 / 3)
# 0.25 for 444 and 0.25 for right shifting
y_m, u, v = [
c.resize.Bicubic(w,
h,
src_left=0.25 + 0.25,
filter_param_a=0,
filter_param_b=.5) for c in [y_m, u, v]
]
y_fixup = core.std.MakeDiff(y, y_m)
yu, yv = Regress(y_m, u, v, radius=radius, eps=1e-7)
u_fixup = ReconstructMulti(y_fixup, yu, radius=radius)
u_r = core.std.MergeDiff(u, u_fixup)
v_fixup = ReconstructMulti(y_fixup, yv, radius=radius)
v_r = core.std.MergeDiff(v, v_fixup)
# -0.5 * 720/1080 = -1/3
# -1/3 for the right shift
# https://forum.doom9.org/showthread.php?p=1802716#post1802716
u_r, v_r = [
c.resize.Bicubic(960,
540,
src_left=-1 / 3,
filter_param_a=-.5,
filter_param_b=.25) for c in [u_r, v_r]
]
upscale = vdf.fsrcnnx_upscale(
descale,
height=h * 2,
shader_file=r'shaders\FSRCNNX_x2_56-16-4-1.glsl',
upscaler_smooth=eedi3_upscale,
profile='zastin')
antialias = sraa_eedi3(upscale,
3,
alpha=0.2,
beta=0.4,
gamma=40,
nrad=3,
mdis=20)
downscale = muvf.SSIM_downsample(antialias,
src.width,
src.height,
filter_param_a=0,
filter_param_b=0)
downscale = core.std.MaskedMerge(luma, downscale, lineart)
merged_a = join([downscale, u_r, v_r])
merged_b = vdf.merge_chroma(downscale, denoise)
merged = lvf.rfs(merged_a, merged_b, shabc_zone)
out = depth(merged, 16)
warp = xvs.WarpFixChromaBlend(out, 80, 2, depth=8)
out = warp
dering = gf.MaskedDHA(out,
rx=1.25,
ry=1.25,
darkstr=0.05,
brightstr=1.0,
maskpull=48,
maskpush=140)
out = dering
qtgmc = hvf.QTGMC(out, Preset="Slower", InputType=1, ProgSADMask=2.0)
qtgmc = vdf.fade_filter(out, out, qtgmc, edstart + 1522,
edstart + 1522 + 24)
qtgmc = lvf.rfs(out, qtgmc, [(edstart + 1522 + 25, edstart + 1757)])
out = qtgmc
out = lvf.rfs(out, depth(denoise, 16), [(opstart, opend)])
detail_dark_mask = detail_dark_mask_func(get_y(out),
brz_a=8000,
brz_b=6000)
detail_light_mask = lvf.denoise.detail_mask(out, 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.BoxBlur(0, 1, 1, 1, 1)
detail_mask = core.std.Expr([get_y(out), detail_mask_grow, detail_mask],
f'x {32<<8} < y z ?')
deband = dumb3kdb(out, 22, 30)
deband = core.std.MaskedMerge(deband, out, detail_mask)
out = deband
ref = get_y(out).std.PlaneStats()
adgmask_a = core.adg.Mask(ref, 30)
adgmask_b = core.adg.Mask(ref, 12)
stgrain = sizedgrn(out, 0.1, 0.05, 1.05, sharp=80)
stgrain = core.std.MaskedMerge(out, stgrain, adgmask_b)
stgrain = core.std.MaskedMerge(out, stgrain, adgmask_a.std.Invert())
dygrain = sizedgrn(out, 0.2, 0.05, 1.15, sharp=80, static=False)
dygrain = core.std.MaskedMerge(out, dygrain, adgmask_a)
grain = core.std.MergeDiff(dygrain, out.std.MakeDiff(stgrain))
out = grain
ref = depth(edges, 16)
credit = out
rescale_mask = vdf.diff_rescale_mask(ref, h, b=0, c=1, mthr=40, sw=0, sh=0)
rescale_mask = vdf.region_mask(rescale_mask, *[10] * 4)
rescale_mask = hvf.mt_expand_multi(rescale_mask,
mode='ellipse',
sw=4,
sh=4).std.BoxBlur(0, 1, 1, 1, 1)
credit = lvf.rfs(credit, ref, full_zone)
credit = lvf.rfs(credit, core.std.MaskedMerge(credit, ref, rescale_mask),
[(edstart, edend)])
out = credit
return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2])