def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
src = depth(src, 16)
out = src
h = 720
w = get_w(h)
fixedges = awf.bbmod(out, 2, 2, 2, 2, 64 << 8, 999)
out = fixedges
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
return depth(out, 10)
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
src = depth(src, 16)
denoise = CoolDegrain(src, tr=1, thsad=24, blksize=8, overlap=4, plane=4)
out = denoise
luma = get_y(out)
antialias = vdf.nnedi3_upscale(luma, correct_shift=False, pscrn=4) \
.resize.Bicubic(src.width, src.height, src_left=.5, src_top=.5,
filter_param_a=0, filter_param_b=1/2)
out = vdf.merge_chroma(antialias, out)
deband_mask = lvf.denoise.detail_mask(out, brz_a=2000, brz_b=1000)
deband = dbs.f3kpf(out, 17, 24, 24)
deband = core.std.MaskedMerge(deband, out, deband_mask)
out = deband
grain = kgf.adaptive_grain(out, 0.2, luma_scaling=14)
out = grain
return depth(out, 10)
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 _zoom_prog(n: int, clip: vs.VideoNode) -> vs.VideoNode:
step_x = round(86 / clip.num_frames)
step_y = round(46 / clip.num_frames)
while step_x % 2:
step_x += 1
while step_y % 2:
step_y += 1
crop = core.std.Crop(clip, step_x * n, step_x * n, step_y * n, step_y * n)
return vdf.nnedi3_upscale(crop, correct_shift=False) \
.resize.Spline36(clip.width, clip.height, src_left=.5, src_top=.5)
def demangle(clip):
return vdf.nnedi3_upscale(clip, pscrn=0,
correct_shift=False).resize.Spline16(
src_left=0.5 + 0.25, src_top=.5)
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
src = depth(src, 16)
out = src
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, [(828, 836)])
out = decomb
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
ref = decomb
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()
credit = lvf.rfs(out, core.std.MaskedMerge(out, ref, credit_mask),
[(0, 725), (31741, 33864)])
antialias = lvf.sraa(ref, 2, 13, downscaler=core.resize.Bicubic)
credit = lvf.rfs(credit, core.std.MaskedMerge(out, antialias, credit_mask),
[(833, 933), (1060, 1229), (1716, 1887), (2665, 2830),
(4813, 4947), (8179, 8272), (13757, 13810),
(20630, 20737), (20866, 20951), (21338, 21409),
(21480, 21520), (24719, 24786), (24829, 24869),
(28206, 28298), (28299, 28426), (33927, 34046)])
out = credit
return depth(out, 10)
def demangle(clip):
return vdf.nnedi3_upscale(clip, core.resize.Bicubic, True, pscrn=0)
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 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 = WEB.src_cut
src = src.std.AssumeFPS(src)
src = depth(src, 16)
out = src
denoise = hvf.SMDegrain(out, tr=3, thSAD=150, thSADC=150)
out = denoise
dering = hvf.EdgeCleaner(out, 20, smode=1, hot=True)
out = dering
y = get_y(out)
taps = 5
w, h = 1600, 900
descale = core.descale.Delanczos(depth(y, 32), w, h, taps)
upscale = vdf.nnedi3_upscale(descale, pscrn=1, correct_shift=False)
rescale = core.resize.Bicubic(upscale,
1920,
1080,
src_left=.5,
src_top=.5,
filter_param_a=-.5,
filter_param_b=.25)
out = depth(rescale, 16)
sharp = hvf.LSFmod(out,
strength=90,
Smode=3,
edgemode=0,
source=get_y(denoise))
out = sharp
merge = vdf.merge_chroma(out, denoise)
out = merge
detail_mask = lvf.mask.detail_mask(out, brz_a=2250, brz_b=1200)
pref = out.std.Convolution([1, 2, 1, 2, 4, 2, 1, 2,
1]).std.Convolution([1] * 9)
deband1 = vdf.dumb3kdb(pref, 17, 45, grain=16, seed=333)
deband2 = vdf.dumb3kdb(pref,
15,
49,
grain=16,
sample_mode=4,
use_neo=True,
blur_first=False,
seed=333)
th_lo, th_hi = 20 << 8, 26 << 8
strength = '{1} x - {1} {0} - /'.format(th_lo, th_hi)
deband = core.std.Expr([pref, deband1, deband2], [
f'x {th_lo} > x {th_hi} < and z ' + strength + ' * y 1 ' + strength +
f' - * + x {th_lo} <= z y ? ?', 'y'
])
deband = core.std.MergeDiff(deband, out.std.MakeDiff(pref))
deband = core.std.MaskedMerge(deband, out, detail_mask)
out = deband
grain = adptvgrnMod(out,
0.3,
0.15,
size=1.2,
luma_scaling=16,
hi=[128, 240],
protect_neutral=False,
seed=333)
out = grain
ref = denoise
rescale_mask = vdf.drm(src, h, 'spline36', mthr=80).std.Maximum()
credit = out
credit = lvf.rfs(credit, core.std.MaskedMerge(credit, ref, rescale_mask),
[(2374, 4530), (4544, 4648), (4701, 4762), (30070, 30210),
(31266, 33422)])
credit = lvf.rfs(credit, ref, [(33423, src.num_frames - 1)])
out = credit
return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2], [0, 1, 2])
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
ep10 = JPBD_10.src_cut
h = 720
w = get_w(h)
b, c = vdf.get_bicubic_params('robidoux')
opstart, opend = 672, 3068
edstart, edend = 31888, src.num_frames - 1
opstart_ep10, opend_ep10 = 768, 3164
full_stuff = [(3853, 3984), (16130, 16279)]
# Fix borders of the henshin
start, end = 26596, 27387
white_clip = core.std.BlankClip(src, color=[235, 128, 128])
# Good length for the three henshins
hibiki = TRANSFOS.src_cut[912:1716]
hibiki = core.std.DeleteFrames(hibiki, [203, 204])
hibiki = core.std.DeleteFrames(hibiki, range(316, 320))
hibiki = core.std.DeleteFrames(hibiki, range(391, 394))
tsubasa = TRANSFOS.src_cut[2178:2738]
tsubasa = core.std.DuplicateFrames(white_clip[:8] + tsubasa, range(10, 20))
tsubasa = core.std.DuplicateFrames(tsubasa, range(196, 203))
tsubasa = core.std.DuplicateFrames(tsubasa, [443, 443, 443])
yukine = TRANSFOS.src_cut[3240:3828]
# The intro
intro = 203
new_tranfos = hibiki[:intro]
# Adjust croppings
hibiki_crop_a = core.std.Crop(hibiki[intro:], src.width / 3, src.width / 3,
0, 0)
dev = -150
hibiki_crop_b = core.std.Crop(hibiki[intro:], src.width / 3 + dev,
src.width / 3 - dev, 0, 0)
dev = -270
hibiki_crop_c = core.std.Crop(hibiki[intro:], src.width / 3 + dev,
src.width / 3 - dev, 0, 0)
hibiki_crop = lvf.rfs(hibiki_crop_a, hibiki_crop_b,
[(391 - intro, 471 - intro)])
hibiki_crop = lvf.rfs(hibiki_crop, hibiki_crop_c,
[(472 - intro, 552 - intro)])
tsubasa_crop_a = core.std.Crop(tsubasa, src.width / 3, src.width / 3, 0, 0)
dev = -400
tsubasa_crop_b = core.std.Crop(tsubasa, src.width / 3 + dev,
src.width / 3 - dev, 0, 0)
tsubasa_crop = lvf.rfs(tsubasa_crop_a, tsubasa_crop_b,
[(445 - intro, 460 - intro)])
tsubasa_crop = (tsubasa_crop[:461 - intro] + core.std.FrameEval(
tsubasa_crop[461 - intro:478 - intro],
partial(_prog_crop, clip=tsubasa[461 - intro:478 - intro], dev=dev)) +
tsubasa_crop[478 - intro:])
yukine_crop = core.std.Crop(yukine, src.width / 3, src.width / 3, 0, 0)
# Stack & merge
new_tranfos += core.std.StackHorizontal(
[tsubasa_crop, hibiki_crop, yukine_crop])
src = insert_clip(src, new_tranfos[:end - start], start)
# Fix compositing error in the OP
op_src, op_10 = src[opstart:opend + 1], ep10[opstart_ep10:opend_ep10 + 1]
fix = lvf.rfs(op_src, op_10, [(0, 79), (1035, 1037)])
fix_src = insert_clip(src, fix, opstart)
src = depth(fix_src, 32)
denoise = hybrid_denoise(src, 0.5, 2)
out = denoise
luma = get_y(out)
line_mask = vdf.edge_detect(luma, 'FDOG', 0.05, (1, 1))
descale = core.descale.Debicubic(luma, w, h, b, c)
upscale = vdf.fsrcnnx_upscale(descale, None, descale.height * 2,
'_shaders/FSRCNNX_x2_56-16-4-1.glsl',
core.resize.Point)
upscale_smooth = vdf.nnedi3_upscale(descale, pscrn=1)
upscale = vdf.fade_filter(upscale, upscale, upscale_smooth, 18018, 18068)
upscale = lvf.rfs(upscale, upscale_smooth, [(18068, 18134)])
antialias = single_rate_antialiasing(upscale,
13,
alpha=0.3,
beta=0.45,
gamma=320,
mdis=18)
scaled = muvf.SSIM_downsample(antialias,
src.width,
src.height,
kernel='Bicubic')
rescale = core.std.MaskedMerge(luma, scaled, line_mask)
merged = vdf.merge_chroma(rescale, out)
out = depth(merged, 16)
antialias = lvf.rfs(
out,
lvf.sraa(out,
1.65,
9,
alpha=0.3,
beta=0.45,
gamma=240,
nrad=3,
mdis=25), [(opstart + 840, opstart + 881)])
antialias_a = lvf.sraa(out,
1.3,
3,
alpha=0.3,
beta=0.45,
gamma=40,
nrad=3,
mdis=25)
antialias_b = lvf.sraa(out,
1.85,
13,
alpha=0.3,
beta=0.6,
gamma=400,
nrad=2,
mdis=15)
antialias = vdf.fade_filter(antialias, antialias_a, antialias_b, 12718,
12861)
antialias = lvf.rfs(antialias, antialias_b, [(24063, 24149)])
out = antialias
# Slight sharp though CAS
sharp = hvf.LSFmod(out,
strength=75,
Smode=3,
Lmode=1,
edgemode=1,
edgemaskHQ=True)
out = sharp
dering = gf.HQDeringmod(out, thr=16, darkthr=0.1)
out = dering
warp = xvs.WarpFixChromaBlend(out, thresh=48, depth=8)
out = warp
preden = core.knlm.KNLMeansCL(out,
d=0,
a=3,
h=0.6,
device_type='GPU',
channels='Y')
deband_mask = lvf.denoise.detail_mask(preden, brz_a=2000, brz_b=800, rad=4)
deband = dbs.f3kpf(out, 17, 42, 42)
deband_b = placebo.deband(out, 22, 6, 2)
deband = lvf.rfs(deband, deband_b, [(opstart + 1515, opstart + 1603)])
deband_c = placebo.deband(out, 10, 3, 1)
deband = lvf.rfs(deband, deband_c, [(241, 300), (11076, 11183)])
deband = core.std.MaskedMerge(deband, out, deband_mask)
out = deband
adg_mask = core.adg.Mask(out.std.PlaneStats(),
20).std.Expr(f'x x {128<<8} - 0.25 * +')
grain = core.grain.Add(out, 0.2, constant=True)
grain = core.std.MaskedMerge(out, grain, adg_mask, 0)
out = grain
rescale_mask = vdf.drm(luma, b=b, c=c, sw=4, sh=4)
ref, rescale_mask, src, src_ncop, src_nced = [
depth(x, 16) for x in
[denoise, rescale_mask, src, JPBD_NCOP.src_cut, JPBD_NCED.src_cut]
]
credit = lvf.rfs(out, core.std.MaskedMerge(out, ref, rescale_mask),
full_stuff)
out = credit
src_c, src_ncop, src_nced = [
c.knlm.KNLMeansCL(a=7, h=35, d=0, device_type='gpu')
for c in [src, src_ncop, src_nced]
]
opening_mask = vdf.dcm(out, src_c[opstart:opend + 1],
src_ncop[:opend - opstart + 1], opstart, opend, 4,
4).std.Inflate()
ending_mask = vdf.dcm(out, src_c[edstart:edend + 1],
src_nced[:edend - edstart + 1], edstart, edend, 4,
4).std.Inflate()
credit_mask = core.std.Expr([opening_mask, ending_mask], 'x y +')
credit = lvf.rfs(out, core.std.MaskedMerge(out, ref, credit_mask),
[(opstart, opend), (edstart, edend)])
out = credit
return depth(out, 10)
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_clip
src = depth(src, 16)
src = src[:34016] + src[34016 + 24 * 2 + 22:-24]
out = src
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, [(756, 764)])
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, [(23709, 23786), (30397, 30546)])
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_b = core.neo_f3kdb.Deband(out, 31, 18, 18, 18, 0, 0, 4)
import placebo
deband_c = placebo.deband(out, 18, 6, 1, 2)
deband = lvf.rfs(deband, deband_b, [(16328, 16607), (17272, 17447)])
deband = lvf.rfs(deband, deband_c, [(23709, 23786), (30397, 30546),
(31115, 31353)])
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()
credit = lvf.rfs(out, core.std.MaskedMerge(out, ref, credit_mask),
[(0, 661), (26731, 34015)])
credit = lvf.rfs(credit, src, [(34016, src.num_frames - 1)])
out = credit
return depth(out, 10)
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
src += src[-1]
ep10 = JPBD_10.src_cut
h = 720
w = get_w(h)
b, c = vdf.get_bicubic_params('robidoux')
opstart, opend = 1296, 3692
edstart, edend = 31887, src.num_frames - 1
opstart_ep10, opend_ep10 = 768, 3164
full_stuff = [(3713, 3844), (17713, 17866)]
# Fix compositing error in the OP
op_src, op_10 = src[opstart:opend + 1], ep10[opstart_ep10:opend_ep10 + 1]
fix = lvf.rfs(op_src, op_10, [(0, 79), (1035, 1037)])
fix_src = insert_clip(src, fix, opstart)
src = depth(fix_src, 32)
denoise = hybrid_denoise(src, 0.5, 2)
out = denoise
luma = get_y(out)
line_mask = vdf.edge_detect(luma, 'FDOG', 0.05, (1, 1))
descale = core.descale.Debicubic(luma, w, h, b, c)
upscale = vdf.fsrcnnx_upscale(descale, None, descale.height * 2,
'_shaders/FSRCNNX_x2_56-16-4-1.glsl',
core.resize.Point)
upscale_smooth = vdf.nnedi3_upscale(descale, pscrn=1)
upscale = vdf.fade_filter(upscale, upscale, upscale_smooth, 31516, 31539)
upscale = vdf.fade_filter(upscale, upscale_smooth, upscale, 31540, 31574)
antialias = single_rate_antialiasing(upscale,
13,
alpha=0.3,
beta=0.45,
gamma=320,
mdis=18)
scaled = muvf.SSIM_downsample(antialias,
src.width,
src.height,
kernel='Bicubic')
rescale = core.std.MaskedMerge(luma, scaled, line_mask)
merged = vdf.merge_chroma(rescale, out)
out = depth(merged, 16)
antialias = lvf.rfs(
out,
lvf.sraa(out,
1.65,
9,
alpha=0.3,
beta=0.45,
gamma=240,
nrad=3,
mdis=25), [(opstart + 840, opstart + 881)])
out = antialias
# Slight sharp though CAS
sharp = hvf.LSFmod(out,
strength=75,
Smode=3,
Lmode=1,
edgemode=1,
edgemaskHQ=True)
out = sharp
dering = gf.HQDeringmod(out, thr=16, darkthr=0.1)
out = dering
warp = xvs.WarpFixChromaBlend(out, thresh=48, depth=8)
out = warp
preden = core.knlm.KNLMeansCL(out,
d=0,
a=3,
h=0.6,
device_type='GPU',
channels='Y')
deband_mask = lvf.denoise.detail_mask(preden, brz_a=2000, brz_b=800, rad=4)
deband = dbs.f3kpf(out, 17, 42, 42)
deband_b = placebo.deband(out, 22, 6, 2)
deband = lvf.rfs(deband, deband_b, [(opstart + 1515, opstart + 1603)])
deband_c = placebo.deband(out, 17, 6, 3)
deband = lvf.rfs(deband, deband_c, [(4490, 4684), (5091, 5170),
(5441, 5536), (5703, 5802)])
deband_d = dbs.f3kpf(out, 16, 64, 64)
deband = lvf.rfs(deband, deband_d, [(13788, 13871)])
deband = core.std.MaskedMerge(deband, out, deband_mask)
out = deband
adg_mask = core.adg.Mask(out.std.PlaneStats(),
20).std.Expr(f'x x {128<<8} - 0.25 * +')
grain = core.grain.Add(out, 0.2, constant=True)
grain = core.std.MaskedMerge(out, grain, adg_mask, 0)
out = grain
rescale_mask = vdf.drm(luma, b=b, c=c, sw=4, sh=4)
ref, rescale_mask, src, src_ncop, src_nced = [
depth(x, 16) for x in
[denoise, rescale_mask, src, JPBD_NCOP.src_cut, JPBD_NCED.src_cut]
]
credit = lvf.rfs(out, core.std.MaskedMerge(out, ref, rescale_mask),
full_stuff)
out = credit
src_c, src_ncop, src_nced = [
c.knlm.KNLMeansCL(a=7, h=35, d=0, device_type='gpu')
for c in [src, src_ncop, src_nced]
]
opening_mask = vdf.dcm(out, src_c[opstart:opend + 1],
src_ncop[:opend - opstart + 1], opstart, opend, 4,
4).std.Inflate()
ending_mask = vdf.dcm(out, src_c[edstart:edend + 1],
src_nced[:edend - edstart + 1], edstart, edend, 4,
4).std.Inflate()
credit_mask = core.std.Expr([opening_mask, ending_mask], 'x y +')
credit = lvf.rfs(out, core.std.MaskedMerge(out, ref, credit_mask),
[(opstart, opend), (edstart, edend)])
out = credit
return depth(out, 10)
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
src = depth(src, 32)
h = 720
w = get_w(h)
b, c = vdf.get_bicubic_params('robidoux')
opstart, opend = 1392, 3788
edstart, edend = 31889, src.num_frames - 1
full_stuff = [(3801, 3908), (16203, 16358)]
denoise = hybrid_denoise(src, 0.5, 2)
out = denoise
luma = get_y(out)
line_mask = vdf.edge_detect(luma, 'FDOG', 0.05, (1, 1))
descale = core.descale.Debicubic(luma, w, h, b, c)
upscale = vdf.fsrcnnx_upscale(descale, None, descale.height * 2,
'_shaders/FSRCNNX_x2_56-16-4-1.glsl',
core.resize.Point)
upscale_smooth = vdf.nnedi3_upscale(descale, pscrn=1)
upscale = lvf.rfs(upscale, upscale_smooth, [(18547, 18586)])
antialias = single_rate_antialiasing(upscale,
13,
alpha=0.3,
beta=0.45,
gamma=320,
mdis=18)
scaled = muvf.SSIM_downsample(antialias,
src.width,
src.height,
kernel='Bicubic')
rescale = core.std.MaskedMerge(luma, scaled, line_mask)
merged = vdf.merge_chroma(rescale, out)
out = depth(merged, 16)
antialias = lvf.rfs(
out,
lvf.sraa(out,
1.65,
9,
alpha=0.3,
beta=0.45,
gamma=240,
nrad=3,
mdis=25), [(opstart + 840, opstart + 881)])
out = antialias
# Slight sharp though CAS
sharp = hvf.LSFmod(out,
strength=75,
Smode=3,
Lmode=1,
edgemode=1,
edgemaskHQ=True)
out = sharp
dering = gf.HQDeringmod(out, thr=16, darkthr=0.1)
out = dering
warp = xvs.WarpFixChromaBlend(out, thresh=48, depth=8)
out = warp
preden = core.knlm.KNLMeansCL(out,
d=0,
a=3,
h=0.6,
device_type='GPU',
channels='Y')
deband_mask = lvf.denoise.detail_mask(preden, brz_a=2000, brz_b=800, rad=4)
deband = dbs.f3kpf(out, 17, 42, 42)
deband_b = placebo.deband(out, 22, 6, 2)
deband = lvf.rfs(deband, deband_b, [(opstart + 1515, opstart + 1603)])
deband_c = placebo.deband(out, 17, 8, 3)
import kagefunc
deband_mask_c = kagefunc.retinex_edgemask(preden)
deband_mask_c = iterate(deband_mask_c, core.std.Maximum,
3).std.Binarize(15000).std.Deflate()
deband = lvf.rfs(deband,
core.std.MaskedMerge(deband_c, deband, deband_mask_c),
[(7409, 7600), (7960, 8055)])
deband = core.std.MaskedMerge(deband, out, deband_mask)
out = deband
adg_mask = core.adg.Mask(out.std.PlaneStats(),
20).std.Expr(f'x x {128<<8} - 0.25 * +')
grain = core.grain.Add(out, 0.2, constant=True)
grain = core.std.MaskedMerge(out, grain, adg_mask, 0)
out = grain
rescale_mask = vdf.drm(luma, b=b, c=c, sw=4, sh=4)
ref, rescale_mask, src, src_ncop, src_nced = [
depth(x, 16) for x in
[denoise, rescale_mask, src, JPBD_NCOP.src_cut, JPBD_NCED.src_cut]
]
credit = lvf.rfs(out, core.std.MaskedMerge(out, ref, rescale_mask),
full_stuff)
out = credit
src_c, src_ncop, src_nced = [
c.knlm.KNLMeansCL(a=7, h=35, d=0, device_type='gpu')
for c in [src, src_ncop, src_nced]
]
opening_mask = vdf.dcm(out, src_c[opstart:opend + 1],
src_ncop[:opend - opstart + 1], opstart, opend, 4,
4).std.Inflate()
ending_mask = vdf.dcm(out, src_c[edstart:edend + 1],
src_nced[:edend - edstart + 1], edstart, edend, 4,
4).std.Inflate()
credit_mask = core.std.Expr([opening_mask, ending_mask], 'x y +')
credit = lvf.rfs(out, core.std.MaskedMerge(out, ref, credit_mask),
[(opstart, opend), (edstart, edend)])
out = credit
return depth(out, 10)
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
src = depth(src, 16)
out = src
opstart, opend = 3106, 5263
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, [(10171, 10179)])
ref = decomb
out = decomb
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),
[(10178, 10248), (21423, 22764)])
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).std.Convolution([1] * 9)
credit = lvf.rfs(out, core.std.MaskedMerge(out, src, opening_mask),
[(opstart, opend)])
out = credit
logo_mask = lvf.src('credit_mask_logo.png', out).std.Convolution([1] * 9)
credit = lvf.rfs(out, core.std.MaskedMerge(out, ref, logo_mask),
[(20992, 23225)])
credit = lvf.rfs(credit, src, [(97766, src.num_frames - 1)])
out = credit
return depth(out, 10)
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
src = depth(src, 32)
h = 720
w = get_w(h)
b, c = vdf.get_bicubic_params('robidoux')
opstart, opend = 768, 3164
edstart, edend = 30571, 32728
full_stuff = [(3189, 3296), (13806, 13961)]
denoise = hybrid_denoise(src, 0.5, 2)
out = denoise
luma = get_y(out)
line_mask = vdf.edge_detect(luma, 'FDOG', 0.05, (1, 1))
descale = core.descale.Debicubic(luma, w, h, b, c)
upscale = vdf.fsrcnnx_upscale(descale, None, descale.height * 2,
'_shaders/FSRCNNX_x2_56-16-4-1.glsl',
core.resize.Point)
upscale_smooth = vdf.nnedi3_upscale(descale, pscrn=1)
upscale = lvf.rfs(upscale, upscale_smooth, [(5534, 5598)])
antialias = single_rate_antialiasing(upscale,
13,
alpha=0.3,
beta=0.45,
gamma=320,
mdis=18)
scaled = muvf.SSIM_downsample(antialias,
src.width,
src.height,
kernel='Bicubic')
rescale = core.std.MaskedMerge(luma, scaled, line_mask)
merged = vdf.merge_chroma(rescale, out)
out = depth(merged, 16)
antialias = lvf.rfs(
out,
lvf.sraa(out,
1.65,
9,
alpha=0.3,
beta=0.45,
gamma=240,
nrad=3,
mdis=25), [(opstart + 840, opstart + 881)])
out = antialias
# Slight sharp though CAS
sharp = hvf.LSFmod(out,
strength=75,
Smode=3,
Lmode=1,
edgemode=1,
edgemaskHQ=True)
out = sharp
dering = gf.HQDeringmod(out, thr=16, darkthr=0.1)
out = dering
warp = xvs.WarpFixChromaBlend(out, thresh=48, depth=8)
out = warp
preden = core.knlm.KNLMeansCL(out,
d=0,
a=3,
h=0.6,
device_type='GPU',
channels='Y')
deband_mask = lvf.denoise.detail_mask(preden, brz_a=2000, brz_b=800, rad=4)
deband = dbs.f3kpf(out, 17, 42, 42)
deband_b = placebo.deband(out, 22, 6, 2)
deband = lvf.rfs(deband, deband_b, [(opstart + 1515, opstart + 1603)])
deband = core.std.MaskedMerge(deband, out, deband_mask)
out = deband
adg_mask = core.adg.Mask(out.std.PlaneStats(),
20).std.Expr(f'x x {128<<8} - 0.25 * +')
grain = core.grain.Add(out, 0.2, constant=True)
grain = core.std.MaskedMerge(out, grain, adg_mask, 0)
out = grain
# Fix random productions errors
# AAAAAAAAAAAAARGHHHHHHHHHHHHHHH WHYYYY THE STUDIO DID THIS
ncop = JPBD_NCOP.src_cut
ncop = lvf.rfs(ncop,
depth(src, 8)[opstart:opend + 1], [(0, 79), (1035, 1037)])
rescale_mask = vdf.drm(luma, b=b, c=c, sw=4, sh=4)
ref, rescale_mask, src, src_ncop, src_nced = [
depth(x, 16)
for x in [denoise, rescale_mask, src, ncop, JPBD_NCED.src_cut]
]
credit = lvf.rfs(out, core.std.MaskedMerge(out, ref, rescale_mask),
full_stuff)
out = credit
src_c, src_ncop, src_nced = [
c.knlm.KNLMeansCL(a=7, h=35, d=0, device_type='gpu')
for c in [src, src_ncop, src_nced]
]
opening_mask = vdf.dcm(out, src_c[opstart:opend + 1],
src_ncop[:opend - opstart + 1], opstart, opend, 4,
4).std.Inflate()
ending_mask = vdf.dcm(out, src_c[edstart:edend + 1],
src_nced[:edend - edstart + 1], edstart, edend, 4,
4).std.Inflate()
credit_mask = core.std.Expr([opening_mask, ending_mask], 'x y +')
credit_mask = core.std.FreezeFrames(credit_mask, opstart + 1685,
opstart + 1699, opstart + 1684)
credit = lvf.rfs(out, core.std.MaskedMerge(out, ref, credit_mask),
[(opstart, opend), (edstart, edend)])
out = credit
return depth(out, 10)
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 ?')
custom_mask_a = lvf.src('rezeros2_01_4186-4400.png', detail_mask)
custom_mask_a = core.std.Expr([custom_mask_a, detail_mask], 'x y +')
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 = lvf.rfs(deband, deband_b, [(4920, 4961), (11027, 11055),
(15377, 15596)])
deband = core.std.MaskedMerge(deband, out, detail_mask)
deband = lvf.rfs(deband,
core.std.MaskedMerge(deband_b, deband, custom_mask_a),
[(4186, 4400)])
deband = core.neo_f3kdb.Deband(deband,
preset='depth',
grainy=24,
grainc=24)
out = deband
ref = depth(denoise, 16)
credit_mask = vdf.drm(ref, kernel='bilinear', mthr=65)
credit = lvf.rfs(out, core.std.MaskedMerge(out, ref, credit_mask, 0),
[(327, 6130), (34757, 39693), (41102, 41167)])
credit = lvf.rfs(credit, ref, [(8320, 8439), (41168, 41239)])
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, 32)
h = 720
w = get_w(h)
b, c = vdf.get_bicubic_params('robidoux')
full_stuff = [(0, 1310), (15484, 15639)]
denoise = hybrid_denoise(src, 0.5, 2)
out = denoise
luma = get_y(out)
line_mask = vdf.edge_detect(luma, 'FDOG', 0.05, (1, 1))
descale = core.descale.Debicubic(luma, w, h, b, c)
upscale = vdf.fsrcnnx_upscale(descale, None, descale.height * 2,
'_shaders/FSRCNNX_x2_56-16-4-1.glsl',
core.resize.Point)
upscale_smooth = vdf.nnedi3_upscale(descale, pscrn=1)
upscale = lvf.rfs(upscale, upscale_smooth, [(5534, 5598)])
antialias = single_rate_antialiasing(upscale,
13,
alpha=0.3,
beta=0.45,
gamma=320,
mdis=18)
scaled = muvf.SSIM_downsample(antialias,
src.width,
src.height,
kernel='Bicubic')
rescale = core.std.MaskedMerge(luma, scaled, line_mask)
merged = vdf.merge_chroma(rescale, out)
out = depth(merged, 16)
# Slight sharp though CAS
sharp = hvf.LSFmod(out,
strength=75,
Smode=3,
Lmode=1,
edgemode=1,
edgemaskHQ=True)
out = sharp
dering = gf.HQDeringmod(out, thr=16, darkthr=0.1)
out = dering
warp = xvs.WarpFixChromaBlend(out, thresh=48, depth=8)
out = warp
preden = core.knlm.KNLMeansCL(out,
d=0,
a=3,
h=0.6,
device_type='GPU',
channels='Y')
deband_mask = lvf.denoise.detail_mask(preden, brz_a=2000, brz_b=800, rad=4)
deband = dbs.f3kpf(out, 17, 42, 42)
deband = core.std.MaskedMerge(deband, out, deband_mask)
out = deband
adg_mask = core.adg.Mask(out.std.PlaneStats(),
20).std.Expr(f'x x {128<<8} - 0.25 * +')
grain = core.grain.Add(out, 0.2, constant=True)
grain = core.std.MaskedMerge(out, grain, adg_mask, 0)
out = grain
rescale_mask = vdf.drm(luma, b=b, c=c, sw=4, sh=4)
ref, rescale_mask, src = [
depth(x, 16) for x in [denoise, rescale_mask, src]
]
credit = lvf.rfs(out, core.std.MaskedMerge(out, ref, rescale_mask),
full_stuff)
credit = lvf.rfs(credit, src, [(31707, 33937)])
out = credit
smooth = gf.JohnFPS(out[31707:33937 + 1], 60000, 1001)
clips = [out[:31707], smooth, out[33937 + 1:]]
vfr = muvf.VFRSplice(clips, 'symphogearg_13_timecode.txt')
cfr = core.std.AssumeFPS(vfr, src)
out = cfr
return depth(out, 10)
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.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 ?')
custom_mask_a = lvf.src('rezeros2_07_25374-25642.png', detail_mask)
custom_mask_a = core.std.Expr([custom_mask_a, detail_mask], 'x y +')
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_d = core.neo_f3kdb.Deband(out, 20, 30, 30, 30, 0, 0, 4)
deband_e = placebo.deband(out, 18, 8, 2, 0)
deband = core.std.MaskedMerge(deband_a, deband_b, preden)
deband = lvf.rfs(deband, deband_d, [(1457, 1677), (8414, 8684),
(8788, 8915), (9348, 10179),
(11325, 11459), (12647, 12857),
(13025, 13574), (13874, 13987),
(20809, 21076), (23936, 25063),
(25219, 25373), (26231, 26530),
(26668, 26800), (26818, 27048),
(27174, 27454), (27503, 27943),
(28492, 28622), (29948, 30563),
(30965, 31498), (31624, 32005),
(32107, 32325), (32451, 35407),
(37171, 37955)])
deband = lvf.rfs(deband, deband_e, [(22116, 22173), (22454, 22459),
(38028, 38035)])
deband = core.std.MaskedMerge(deband, out, detail_mask)
deband = lvf.rfs(deband,
core.std.MaskedMerge(deband_e, deband, custom_mask_a),
[(25374, 25642), (25708, 25889)])
deband = core.neo_f3kdb.Deband(deband,
preset='depth',
grainy=24,
grainc=24)
out = deband
ref, src, src_nced = [
depth(x, 16) for x in [denoise, src, JPBD_NCED.src_cut[221:]]
]
credit_mask = vdf.drm(ref, kernel='bilinear', mthr=65)
credit = lvf.rfs(out, core.std.MaskedMerge(out, ref, credit_mask, 0),
[(113, 3315), (37171, src.num_frames - 1)])
credit = lvf.rfs(credit, ref, [(3316, 3435), (35408, 35485)])
out = credit
src_c, src_nced = [
c.knlm.KNLMeansCL(a=7, h=35, d=0, device_type='gpu')
for c in [src, src_nced]
]
ending_mask = vdf.dcm(out, src_c[EDSTART:EDEND + 1],
src_nced[:EDEND - EDSTART + 1], EDSTART, EDEND, 4,
4).std.Inflate()
credit = lvf.rfs(out, core.std.MaskedMerge(out, ref, ending_mask),
[(EDSTART, EDEND)])
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 += 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 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 = 456, 2613
edstart, edend = 31767, 33924
h = 720
w = get_w(h)
fixedges = awf.bbmod(out, 2, 2, 2, 2, 64<<8, 999)
out = fixedges
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
ref = fixedges
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),
[(2660, 2733), (33925, src.num_frames-1)])
out = credit
src_c, ncop, nced = [clip.std.Median() for clip in [src, JPBD_NCOP.src_cut, JPBD_NCED.src_cut]]
opening_mask = vdf.dcm(out, src_c[opstart:opend+1], ncop[:opend-opstart+1], opstart, opend, 3, 3)
ending_mask = vdf.dcm(out, src_c[edstart:edend+1], nced[:edend-edstart+1], edstart, edend, 3, 3)
credit_mask = core.std.Expr([opening_mask, ending_mask], 'x y +').std.Convolution([1]*9)
credit = lvf.rfs(out, core.std.MaskedMerge(out, src, credit_mask), [(opstart, opend), (edstart, edend)])
out = credit
return depth(out, 10)
