def test_insert_clip(self):
inserted_middle = vsutil.insert_clip(self.BLACK_SAMPLE_CLIP,
self.WHITE_SAMPLE_CLIP[:10], 50)
self.assert_same_frame(inserted_middle[0], self.BLACK_SAMPLE_CLIP[0])
self.assert_same_frame(inserted_middle[50], self.WHITE_SAMPLE_CLIP[0])
self.assert_same_frame(inserted_middle[60], self.BLACK_SAMPLE_CLIP[60])
inserted_start = vsutil.insert_clip(self.BLACK_SAMPLE_CLIP,
self.WHITE_SAMPLE_CLIP[:10], 0)
self.assert_same_frame(inserted_start[0], self.WHITE_SAMPLE_CLIP[0])
self.assert_same_frame(inserted_start[10], self.BLACK_SAMPLE_CLIP[10])
inserted_end = vsutil.insert_clip(self.BLACK_SAMPLE_CLIP,
self.WHITE_SAMPLE_CLIP[:10], 90)
self.assert_same_frame(inserted_end[-1], self.WHITE_SAMPLE_CLIP[9])
self.assert_same_frame(inserted_end[89], self.BLACK_SAMPLE_CLIP[89])
# make sure we didn’t lose or add any frames in the process
self.assert_same_metadata(self.BLACK_SAMPLE_CLIP, inserted_start)
self.assert_same_metadata(self.BLACK_SAMPLE_CLIP, inserted_middle)
self.assert_same_metadata(self.BLACK_SAMPLE_CLIP, inserted_end)
with self.assertRaises(ValueError):
vsutil.insert_clip(self.BLACK_SAMPLE_CLIP, self.BLACK_SAMPLE_CLIP,
90)
def fade_filter(clip: vs.VideoNode, clip_a: vs.VideoNode, clip_b: vs.VideoNode,
start_f: int, end_f: int) -> vs.VideoNode:
"""Applies a filter by fading clip_a to clip_b.
Args:
clip (vs.VideoNode): Source clip
clip_a (vs.VideoNode): Fade in clip.
clip_b (vs.VideoNode): Fade out clip.
start_f (int): Start frame.
end_f (int): End frame.
Returns:
vs.VideoNode: Faded clip.
"""
length = end_f - start_f
def _fade(n: int, clip_a: vs.VideoNode, clip_b: vs.VideoNode,
length: int) -> vs.VideoNode: # noqa: PLC0103
return core.std.Merge(clip_a, clip_b, n / length)
func = partial(_fade,
clip_a=clip_a[start_f:end_f + 1],
clip_b=clip_b[start_f:end_f + 1],
length=length)
clip_fad = core.std.FrameEval(clip[start_f:end_f + 1], func)
return insert_clip(clip, clip_fad, start_f)
def mask_opening(ref: vs.VideoNode) -> vs.VideoNode:
mask = core.imwri.Read('rezeros2_ncop_0-16.png') * 17 + core.imwri.Read(
'rezeros2_ncop_17-18.png') * 2
mask += core.imwri.Read('rezeros2_ncop_19.png')
mask += core.imwri.Read('rezeros2_ncop_20.png')
mask += core.imwri.Read('rezeros2_ncop_21.png')
mask += core.imwri.Read('rezeros2_ncop_22.png')
mask += core.imwri.Read('rezeros2_ncop_23.png')
mask += core.imwri.Read('rezeros2_ncop_24.png')
mask += core.imwri.Read('rezeros2_ncop_25.png')
mask += core.imwri.Read('rezeros2_ncop_26.png')
mask += core.imwri.Read('rezeros2_ncop_27.png')
mask += core.imwri.Read('rezeros2_ncop_28.png')
mask += core.imwri.Read('rezeros2_ncop_29.png')
mask += core.imwri.Read('rezeros2_ncop_30.png')
mask += core.imwri.Read('rezeros2_ncop_31.png')
mask += core.imwri.Read('rezeros2_ncop_32.png')
mask += core.imwri.Read('rezeros2_ncop_33.png')
mask += core.imwri.Read('rezeros2_ncop_34.png')
mask += core.imwri.Read('rezeros2_ncop_35.png')
mask += core.imwri.Read('rezeros2_ncop_36.png')
mask += core.imwri.Read('rezeros2_ncop_37.png')
mask += core.imwri.Read('rezeros2_ncop_38.png')
ref = ref.std.BlankClip(format=vs.GRAY16)
mask = core.resize.Bicubic(mask, format=vs.GRAY16,
matrix_s='709').std.AssumeFPS(ref)
return insert_clip(ref, mask, OPSTART)
def pre_filter() -> vs.VideoNode:
"""Pre-filtering to fix some stuff"""
from vsutil import insert_clip
src = JP_BD.clip_cut
# The grain pattern randomly stops in the middle??? ufo, WHAT
ins = insert_clip(src, src[877:881], 881)
return ins
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Main filterchain"""
import havsfunc as haf
import lvsfunc as lvf
import vardefunc as vdf
from adptvgrnMod import adptvgrnMod
from ccd import ccd
from vsutil import depth, insert_clip
src = JP_BD.clip_cut
src = depth(src, 16)
scaled, descale_mask = flt.rescaler(src, height=855)
denoise_y = core.knlm.KNLMeansCL(scaled, d=2, a=3, h=0.35)
denoise_uv = ccd(denoise_y, threshold=7, matrix='709')
stab = haf.GSMC(denoise_uv, radius=1, thSAD=200, planes=[0])
decs = vdf.noise.decsiz(stab, sigmaS=8, min_in=200 << 8, max_in=232 << 8)
aa_weak = lvf.aa.nneedi3_clamp(decs, strength=4)
aa_strong = lvf.sraa(decs, rfactor=1.6)
aa_clamp = lvf.aa.clamp_aa(decs, aa_weak, aa_strong, strength=2)
aa_rfs = lvf.rfs(aa_clamp, aa_strong, [(434, 592)])
halo_mask = lvf.mask.halo_mask(aa_rfs)
darken = flt.line_darkening(aa_rfs, strength=0.35)
dehalo = core.std.MaskedMerge(
darken, lvf.dehalo.bidehalo(darken, sigmaS_final=1.2, sigmaR=11 / 255),
halo_mask)
merged_credits = core.std.MaskedMerge(dehalo, src, descale_mask)
deband = flt.masked_f3kdb(merged_credits,
rad=21,
thr=[28, 24],
grain=[32, 16])
grain: vs.VideoNode = adptvgrnMod(deband,
seed=42069,
strength=0.25,
luma_scaling=10,
size=1.35,
sharp=80,
grain_chroma=False)
# Making sure there's no weird dynamic noise on the titlecard
final = insert_clip(grain, grain[869] * (903 - 869), 869)
return final
def pre_freeze() -> vs.VideoNode:
"""Performing some freezeframing in the OP at the Typesetter's request"""
from adjust import Tweak
from vsutil import insert_clip
src = JP_clip.clip_cut
freeze = 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])
to_adjust = freeze[opstart + freeze_ranges[1][0]]
adjust = Tweak(to_adjust, hue=-18)
adjust = adjust * (freeze_ranges[2][1] - freeze_ranges[2][0] + 1)
insert = insert_clip(freeze, adjust, freeze_ranges[2][0])
return insert
def fader(clip: vs.VideoNode,
start_frame: int,
end_frame: int,
duration: Optional[int] = None,
input_frame: Optional[int] = None) -> vs.VideoNode:
"""
A function to fade a part of a given clip into itself.
Hyper specific, and probably only useful for clip-to-black fades or something.
start_frame and end_frame are for trimming the clip. Exclusive.
duration determines how long the fade is.
input_frame determines where in the clip the faded clip gets inserted.
"""
import kagefunc as kgf
duration = duration or (end_frame - start_frame)
input_frame = input_frame or start_frame
fade = kgf.crossfade(clip[start_frame] * duration,
clip[end_frame] * duration, duration - 1)
return insert_clip(clip, fade, input_frame)
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
ep11 = JPBD_11.src_cut
opstart = 0
opstart_ep11, opend_ep11 = 744, 3140
h = 720
w = get_w(h)
b, c = vdf.get_bicubic_params('robidoux')
# Fix compositing error in the OP
ncop, op_11 = src, ep11[opstart_ep11:opend_ep11 + 1]
fix = lvf.rfs(ncop, op_11, [(0, 79), (1035, 1037)])
src = depth(fix, 32)
def denoise_and_rescale(clip):
denoise = hybrid_denoise(clip, 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)
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)
return depth(merged, 16)
out = denoise_and_rescale(src)
to_zoom = denoise_and_rescale(depth(JPBD_11.src_cut[8590:8605], 32))
zoom = core.std.FrameEval(to_zoom, partial(_zoom_prog, clip=to_zoom))
out = insert_clip(out, zoom, 1685)
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, show=False)
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')
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, 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
return depth(out, 10)
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
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
src01 = JPBD_01.src_cut
fr_s01, fr_e01 = 30492, 30536
fr_s, fr_e = 1529, 1573
src = insert_clip(src, src01[fr_s01:fr_e01 + 1], fr_s)
image01 = core.imwri.Read('1080elements_mv01_01.png', alpha=True)
image01[0] = core.resize.Bicubic(image01[0], format=vs.YUV420P8,
matrix=1) * src.num_frames
image01[0] = core.std.AssumeFPS(image01[0], src)
image02 = core.imwri.Read('1080elements_mv01_02.png', alpha=True)
image02[0] = core.resize.Bicubic(image02[0], format=vs.YUV420P8,
matrix=1) * src.num_frames
image02[0] = core.std.AssumeFPS(image02[0], src)
src = lvf.rfs(src, core.std.MaskedMerge(src, image01[0], image01[1]),
[(fr_s, 1534)])
src = lvf.rfs(src, core.std.MaskedMerge(src, image02[0], image02[1]),
[(1535, fr_e)])
src = depth(src, 16)
out = src
h = 846
w = get_w(h)
cubic_filters = ['catrom', 'mitchell', 'robidoux', 'robidoux sharp']
cubic_filters = [vdf.get_bicubic_params(cf) for cf in cubic_filters]
degrain = hybrid_denoise(out, 0.35, 1.2, dict(a=2, d=1))
out = degrain
y = get_y(out)
y32 = depth(y, 32)
lineart = vdf.edge_detect(y32, 'kirsch', 0.055,
(1, 1)).std.Median().std.Inflate()
descale_clips = [
core.descale.Debicubic(y32, w, h, b, c) for b, c in cubic_filters
]
descale = core.std.Expr(descale_clips,
'x y z a min min min x y z max max min')
conv = core.std.Convolution(descale, [1, 2, 1, 2, 0, 2, 1, 2, 1])
thr, coef = 0.013, 3
descale_fix = core.std.Expr([descale, conv],
f'x y - abs {thr} < y x ?').std.PlaneStats()
adapt_mask = core.adg.Mask(
descale_fix,
12).std.Invert().std.Expr(f'x 0.5 - {coef} * 0.5 + 0 max 1 min')
descale = core.std.MaskedMerge(descale, descale_fix, adapt_mask)
upscale = vdf.fsrcnnx_upscale(descale,
w * 2,
h * 2,
r'shaders\FSRCNNX_x2_56-16-4-1.glsl',
upscaler_smooth=eedi3_upscale,
profile='zastin',
sharpener=partial(gf.DetailSharpen,
sstr=1.25,
power=4))
aa_strong = sraa_eedi3(upscale, 13, alpha=0.3, beta=0.5, gamma=40)
aa = aa_strong
down = muvf.SSIM_downsample(aa,
src.width,
src.height,
filter_param_a=0,
filter_param_b=0)
upscale = depth(core.std.MaskedMerge(y32, down, lineart), 16)
merged = vdf.merge_chroma(upscale, out)
out = merged
y = get_y(out)
detail_light_mask = lvf.denoise.detail_mask(y, brz_a=2500, brz_b=1200)
pf = iterate(out, core.std.Maximum, 2).std.Convolution([10] * 9, planes=0)
diff = core.std.MakeDiff(out, pf)
deband = core.f3kdb.Deband(pf,
17,
36,
36,
36,
12,
12,
2,
keep_tv_range=True,
output_depth=16)
deband = core.std.MergeDiff(deband, diff)
deband = core.std.MaskedMerge(deband, out, detail_light_mask)
out = deband
grain = adptvgrnMod(out,
0.25,
0.15,
size=out.height / h,
sharp=80,
luma_scaling=10,
static=True)
out = grain
# # Restore 1080p stuff
ref = src
rescale_mask = vdf.drm(ref, h, mthr=65, sw=4, sh=4)
credit = out
credit = core.std.MaskedMerge(credit, ref, rescale_mask, 0)
credit = lvf.rfs(credit, ref, [(431, 516), (2582, src.num_frames - 1)])
out = credit
return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2])
def preqpfileflt(self) -> None:
"""Pre-QP file generation filtering so the scenes match properly"""
self.file.clip_cut = replace_ranges(self.file.clip_cut,
JPBD_NCOP2.clip_cut, replace_op)
self.file.clip_cut = insert_clip(self.file.clip_cut,
JPBD_NCOP2.clip_cut[826:1038], 823)
def do_filter():
"""Vapoursynth filtering"""
src = JPBD.src_cut
src = depth(src, 16)
out = src
h = 900
w = get_w(h)
# Remove the grain
ref = hvf.SMDegrain(out, tr=1, thSAD=300, plane=4)
degrain = mvf.BM3D(out, sigma=[1.5, 1], radius1=1, ref=ref)
degrain = insert_clip(degrain, smhdegrain(out[5539:5670], 2, 280), 5539)
degrain = insert_clip(degrain, smhdegrain(out[5933:5992], 2, 200), 5933)
degrain = insert_clip(degrain, smhdegrain(out[6115:6180], 2, 200), 6115)
degrain = insert_clip(degrain, smhdegrain(out[6180:6281], 2, 200), 6180)
degrain = insert_clip(degrain, smhdegrain(out[39303:39482], 2, 280), 39303)
degrain = insert_clip(degrain, smhdegrain(out[40391:40837], 2, 200), 40391)
degrain = insert_clip(degrain, smhdegrain(out[40908:41087], 2, 280), 40908)
degrain = insert_clip(degrain, smhdegrain(out[41671:41791], 2, 280), 41671)
degrain = insert_clip(degrain, smhdegrain(out[41791:41977], 2, 280), 41791)
degrain = insert_clip(degrain, smhdegrain(out[41977:42073], 2, 280), 41977)
degrain = insert_clip(degrain, smhdegrain(out[43083:44462], 2, 350), 43083)
degrain = lvf.rfs(degrain, out, [(51749, 52387)])
out = depth(degrain, 32)
luma = get_y(out)
line_mask = vdf.edge_detect(luma, 'kirsch', 0.075,
(1, 1)).std.Median().std.Inflate()
descale = core.descale.Debilinear(luma, w, h)
upscale = eedi3_upscale(descale)
antialias = single_rate_antialiasing(upscale,
13,
alpha=0.2,
beta=0.6,
gamma=300,
mdis=15).resize.Bicubic(
src.width, src.height)
rescale = core.std.MaskedMerge(luma, antialias, line_mask)
merged = vdf.merge_chroma(rescale, out)
out = depth(merged, 16)
y = get_y(out)
detail_light_mask = lvf.denoise.detail_mask(y.std.Median(),
brz_a=2500,
brz_b=1200)
pf = out.std.Convolution([1] * 9).std.Merge(out, 0.45)
diffdb = core.std.MakeDiff(out, pf)
deband = dumb3kdb(pf, 16, 30)
deband_b = dbs.f3kbilateral(pf, 20, 100)
deband = lvf.rfs(deband, deband_b, [(43083, 44461)])
deband = core.std.MergeDiff(deband, diffdb)
deband = core.std.MaskedMerge(deband, out, detail_light_mask)
deband = lvf.rfs(deband, out, [(51749, 52387)])
out = deband
sharp = hvf.LSFmod(out,
strength=65,
Smode=3,
Lmode=1,
edgemode=1,
edgemaskHQ=True)
out = sharp
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.00)
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.05, sharp=60, static=False)
dygrain = core.std.MaskedMerge(out, dygrain, adgmask_a)
grain = core.std.MergeDiff(dygrain, out.std.MakeDiff(stgrain))
out = grain
ref = src
rescale_mask = vdf.drm(ref, h, mthr=65, sw=4, sh=4)
credit = out
credit = lvf.rfs(credit, core.std.MaskedMerge(credit, ref, rescale_mask,
0), [(0, 2956),
(43104, 45749)])
credit = lvf.rfs(credit, ref, [(45824, 50401),
(52388, 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 = 2973, 5370
edstart, edend = 31887, src.num_frames - 1
opstart_ep10, opend_ep10 = 768, 3164
full_stuff = [(5449, 5580), (16465, 16620)]
# 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)
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(deband, 17, 5, 1)
deband_c = dbs.f3kbilateral(deband_c, 22, 64, 64)
deband = lvf.rfs(deband, deband_c, [(15612, 15695)])
deband_mask2 = vdf.edge_detect(
out.knlm.KNLMeansCL(d=2, a=2, h=0.4, device_type='GPU', channels='Y'),
'FDOG', 1100, (8, 1))
deband_mask2 = iterate(deband_mask2, core.std.Deflate, 4)
deband_d = placebo.deband(out, 16, 12, 3)
deband_d = core.std.MaskedMerge(deband_d, out, deband_mask2)
deband = lvf.rfs(deband, deband_d, [(16339, 16542)])
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 filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Main filterchain"""
import havsfunc as haf
import lvsfunc as lvf
import muvsfunc as muf
import debandshit as dbs
import vardefunc as vdf
from vsutil import depth, get_y, insert_clip, join, plane
src = JP_DVD.clip_cut.std.AssumeFPS(fpsnum=24000, fpsden=1001)
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
src_ncop = flt.rekt(src_ncop)
src_nced = flt.rekt(src_nced)
src_03 = flt.rekt(src_03)
# 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_mask = vdf.dcm(
src_03, src_03[opstart:opstart+masked_ncop.num_frames-op_offset], masked_ncop[:-op_offset],
start_frame=opstart, thr=85, prefilter=True) if opstart is not False \
else get_y(core.std.BlankClip(src))
op_mask = depth(core.resize.Bicubic(op_mask, 1296, 728).std.Crop(top=4, bottom=4), 16)
# Stick credits ontop of NC because it looks way better
masked_ncop = src_ncop.resize.Bicubic(chromaloc_in=1, chromaloc=0)
cwarp_ncop = masked_ncop.warp.AWarpSharp2(thresh=88, blur=3, type=1, depth=6, planes=[1, 2])
descale_ncop = lvf.kernels.Bicubic().descale(plane(depth(src_ncop, 16), 0), 1280, 720)
chroma_down_ncop = core.resize.Bicubic(cwarp_ncop, 1280, 720, vs.YUV444P16)
scaled_ncop = join([descale_ncop, plane(chroma_down_ncop, 1), plane(chroma_down_ncop, 2)])
scaled_ncop = scaled_ncop.resize.Bicubic(1296, 728).std.Crop(top=4, bottom=4)
downscale_03 = src_03.resize.Bicubic(1296, 728, vs.YUV444P16).std.Crop(top=4, bottom=4)
merge_credits_03 = core.std.MaskedMerge(scaled_ncop, downscale_03, op_mask)
for prop, val in PROPS_DVD:
src = src.std.SetFrameProp(prop, intval=val)
dvd_i444 = vdf.scale.to_444(depth(src, 32), src.width, src.height, join_planes=True)
dvd_rgb = dvd_i444.resize.Bicubic(format=vs.RGB24, dither_type='error_diffusion', matrix_in=6)
upscale = vsgan.run(dvd_rgb)
conv = core.resize.Bicubic(upscale, format=vs.YUV444P16, matrix=1)
scaled = depth(muf.SSIM_downsample(conv, 1296, 720), 16)
splice_op = lvf.rfs(scaled, merge_credits_03, [(0, 203), (263, 1740), (1836, 2018)])
# Splicing for the ED. Halves of the ED have visuals, others are credits
masked_nced = src_nced.resize.Bicubic(chromaloc_in=1, chromaloc=0)
cwarp_nced = masked_nced.warp.AWarpSharp2(thresh=88, blur=3, type=1, depth=6, planes=[1, 2])
descale_nced = lvf.kernels.Bicubic().descale(plane(depth(src_nced, 16), 0), 1280, 720)
chroma_down_nced = core.resize.Bicubic(cwarp_nced, 1280, 720, vs.YUV444P16)
scaled_nced = join([descale_nced, plane(chroma_down_nced, 1), plane(chroma_down_nced, 2)])
scaled_nced = scaled_nced.resize.Bicubic(1296, 728).std.Crop(top=4, bottom=4)
ed_nc = scaled_nced
ed_dvd = splice_op[31888:]
sq_top = lvf.mask.BoundingBox((0, 0), (ed_nc.width, ed_nc.height/2)).get_mask(ed_nc)
sq_left = lvf.mask.BoundingBox((0, 0), (ed_nc.width/2, ed_nc.height)).get_mask(ed_nc)
sq_right = sq_left.std.Invert()
mask_top = core.std.MaskedMerge(ed_dvd, ed_nc, sq_top)
mask_left = core.std.MaskedMerge(ed_dvd, ed_nc, sq_left)
mask_right = core.std.MaskedMerge(ed_dvd, ed_nc, sq_right)
ed_splice = lvf.rfs(ed_dvd, mask_top, [(0, 1213), (1613, 1673), (1794, None)])
ed_splice = lvf.rfs(ed_splice, mask_left, [(1390, 1503)])
ed_splice = lvf.rfs(ed_splice, mask_right, [(1214, 1389), (1504, 1612), (1674, 1793)])
splice_ed = insert_clip(splice_op, ed_splice, edstart)
# Back to more regular filtering
stab = haf.GSMC(splice_ed, radius=2, planes=[0])
decs = vdf.noise.decsiz(stab, sigmaS=8, min_in=208 << 8, max_in=232 << 8)
detail_mask = flt.detail_mask(decs, brz=(1800, 3500))
deband = dbs.debanders.dumb3kdb(decs, threshold=32, grain=16)
deband_masked = core.std.MaskedMerge(deband, decs, detail_mask)
grain = vdf.noise.Graigasm( # Mostly stolen from Varde tbh
thrs=[x << 8 for x in (32, 80, 128, 176)],
strengths=[(0.25, 0.0), (0.2, 0.0), (0.15, 0.0), (0.0, 0.0)],
sizes=(1.2, 1.15, 1.05, 1),
sharps=(65, 50, 40, 40),
grainers=[
vdf.noise.AddGrain(seed=69420, constant=True),
vdf.noise.AddGrain(seed=69420, constant=False),
vdf.noise.AddGrain(seed=69420, constant=False)
]).graining(deband_masked)
return grain
def main(self) -> vs.VideoNode:
"""Vapoursynth filtering"""
src = JPBD.clip_cut
src = depth(src, 16)
src_cru = WEB_CRU.clip_cut
src_aod = WEB_AOD.clip_cut
# Dehardsubbing using .ass file
masksub = Mask.hardsub_mask(src_aod.std.BlankClip(), SUB, FONTDIR)
dehardsub = core.std.MaskedMerge(src_aod, src_cru, masksub)
src_web = dehardsub
# AoD is poorly rescaled
src_y, src_cru_y, src_web_y = map(get_y, [src, src_cru, src_web])
thr = 10
src_web_y = core.std.Expr([src_web_y, src_cru_y], f'x y - abs {thr} < x y * sqrt y ?')
src_web_y = depth(src_web_y, 16)
ringrid = core.rgvs.Repair(src_web_y, src_web_y.std.Convolution([1]*9), 11)
ringrid = core.std.Expr([ringrid, src_web_y], 'x y min')
# Remove ringing with AoD+CR
ring_mask = Mask.ringing_mask(src_y)
bdweb = core.std.MaskedMerge(src_y, ringrid, ring_mask)
out = vdf.misc.merge_chroma(bdweb, src)
# Restore BD changes
dering_src = hvf.EdgeCleaner(src, 20, hot=True)
diff_mask = Mask.diff_mask((src, src_cru), brz=4750.0)
bdchanges = core.std.MaskedMerge(out, dering_src, diff_mask)
bdchanges = lvf.rfs(out, bdchanges, [(17008, 17085), (17200, 17283)])
bdchanges = lvf.rfs(bdchanges, src, [(17551, 17730)])
out = bdchanges
ref = Denoise.ref_denoise(get_y(out), tr=1)
denoise = Denoise.hybrid_denoise(
depth(out, 32), knlm_h=0.15, sigma=1,
knlm_args=dict(d=1, a=3, s=3), bm3d_args=dict(ref=depth(ref, 32))
)
denoise = depth(denoise, 16)
out = denoise
pre = get_y(out)
# Remove haloing
dehalo = gf.MaskedDHA(pre, rx=1.4, ry=1.4, darkstr=0.1, brightstr=1.0, maskpull=40, maskpush=255)
bila = core.bilateral.Bilateral(dehalo, sigmaS=1, sigmaR=0.08)
dehalorp = core.rgvs.Repair(dehalo, bila, 13)
dehalo = core.std.MaskedMerge(dehalo, dehalorp, ring_mask.std.Maximum(), 0)
dehalo = core.std.Expr([dehalo, pre], 'x y min')
out = dehalo
# Antialiasing sraaaaaaaaaa
lineart = vdf.mask.ExPrewitt().get_mask(out, 4000, 7500).std.Convolution([1] * 25)
aaa = AA().upscaled_sraaaaaaaaaa(out, height=1620)
out = aaa
unwarp = self.line_darkening(out, 0.075).warp.AWarpSharp2(depth=-1)
out = unwarp
motion = hvf.SMDegrain(out, tr=3, thSADC=600, RefineMotion=True)
masked = core.std.MaskedMerge(out, motion, lineart)
out = masked
mergechroma = vdf.misc.merge_chroma(out, denoise)
out = mergechroma
ref = depth(src_cru, 16)
cred_mask = Mask.credits_mask(src, JPBD_NCOP.clip_cut, JPBD_NCED.clip_cut, OPSTART, OPEND, EDSTART, EDEND)
cred = out
cred = lvf.rfs(cred, core.std.MaskedMerge(cred, ref, cred_mask, 0), [(OPSTART, OPEND), (EDSTART, EDEND)])
out = cred
db_mask = Mask.deband_mask(out, (4000, 4000, 4000), (2000, 2000, 2000))
deband_1 = vdf.deband.dumb3kdb(out, 17, [36, 48])
deband_2 = vdf.deband.dumb3kdb(out, 17, 30, sample_mode=4, use_neo=True)
deband_a = vdf.placebo.deband(out, 22, threshold=8, iterations=3, grain=0)
th_lo, th_hi = 22 << 8, 28 << 8
strength = f'{th_hi} x - {th_hi} {th_lo} - /'
deband = core.std.Expr(
[out.std.Convolution([1]*9), deband_1, deband_2],
[f'x {th_lo} > x {th_hi} < and z ' + strength + ' * y 1 ' + strength + f' - * + x {th_lo} <= z y ? ?',
'x y * sqrt x z * sqrt * y * z * 0.25 pow'])
deband = lvf.rfs(deband, deband_a, [(OPSTART+1382, OPSTART+1433)])
deband = core.std.MaskedMerge(deband, out, db_mask)
out = deband
newpan = self.refine_motion(out[17284:17329], [1, 5, 9, 14, 18, 22, 27, 31, 35], out)
motion = insert_clip(out, newpan, 17284)
out = motion
ref = get_y(out).std.PlaneStats()
adgmask_a = ref.adg.Mask(25)
adgmask_b = ref.adg.Mask(10)
stgrain_a = core.grain.Add(out, 0.1, 0, seed=333, constant=True)
stgrain_a = core.std.MaskedMerge(out, stgrain_a, adgmask_b.std.Invert())
stgrain_b = sizedgrn(out, 0.2, 0.1, 1.15, sharp=80, static=True, fade_edges=False, protect_neutral=False, seed=333)
stgrain_b = core.std.MaskedMerge(out, stgrain_b, adgmask_b)
stgrain_b = core.std.MaskedMerge(out, stgrain_b, adgmask_a.std.Invert())
stgrain = core.std.MergeDiff(stgrain_b, out.std.MakeDiff(stgrain_a))
dygrain = sizedgrn(out, 0.3, 0.1, 1.25, sharp=80, static=False, fade_edges=False, protect_neutral=False, seed=333)
dygrain = core.std.MaskedMerge(out, dygrain, adgmask_a)
grain = core.std.MergeDiff(dygrain, out.std.MakeDiff(stgrain))
out = grain
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 recursive_apply_mask(
src_a: vs.VideoNode,
src_b: vs.VideoNode,
mask_folder: Union[str, Path],
iter: int = 1,
) -> vs.VideoNode:
"""
Recursively check `mask_folder` for a .png or .ass file
After it found all of them, it will use the mask
to merge together the two clips.
Acceptable filename format:
- frameNum.png
- frameStart-frameEnd.png
- itsUpToYou.ass
Example:
- 2500.png
- 2000-2004.png
- maskep1.ass
Parameters
----------
src_a: :class:`VideoNode`
The first clip.
src_b: :class:`VideoNode`
The second clip.
mask_folder: :class:`Union[str, Path]`
The folder that contains the masks.
iter: :class:`int`
How many times we will need to iterate the mask.
Returns
-------
:class:`VideoNode`
The merged clip.
"""
if isinstance(mask_folder, str):
mask_folder = Path(mask_folder)
has_plugin_or_raise(["fmtc", "imwri"])
imwri = core.imwri
masks_png = mask_folder.glob("*.png")
for mask in masks_png:
frame = os_path.basename(mask).rsplit(".", 1)[0]
frame = [int(i) for i in frame.split("-")][:2]
if len(frame) < 2:
frame = [frame[0], frame[0]]
first_f, last_f = frame
image = fvf.Depth(
imwri.Read(str(mask), ).resize.Point(format=vs.GRAYS,
matrix_s="709"),
src_a.format.bits_per_sample,
).std.AssumeFPS(
fpsnum=src_a.fps.numerator,
fpsden=src_a.fps.denominator,
)
src_a_n, src_b_n = src_a[first_f:last_f + 1], src_b[first_f:last_f + 1]
image = image * ((last_f + 1) - first_f)
image = get_y(image)
src_masked = core.std.MaskedMerge(src_a_n, src_b_n, image)
for _ in range(iter - 1):
src_masked = src_masked.std.MaskedMerge(src_b_n, image)
src_a = insert_clip(src_a, insert=src_masked, start_frame=first_f)
masks_ass = mask_folder.glob("*.ass")
for mask in masks_ass:
blank_mask = src_a.std.BlankClip()
ass_mask = get_y(blank_mask.sub.TextFile(str(mask)))
src_a = core.std.MaskedMerge(src_a, src_b, ass_mask)
return src_a
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 = 744, 3140
opstart_ep10, opend_ep10 = 768, 3164
full_stuff = [(3145, 3269), (18289, 18444), (29158, 33410)]
border = rkt.rekt_fast(src,
lambda x: core.fb.FillBorders(x, 0, 0, 0, 2),
right=1212)
fixstudioshit = lvf.rfs(src, border, [31759])
border = rkt.rekt_fast(src,
lambda x: core.fb.FillBorders(x, 0, 0, 0, 6),
right=1212)
fixstudioshit = lvf.rfs(fixstudioshit, border, [31760])
border = rkt.rekt_fast(src,
lambda x: core.fb.FillBorders(x, 0, 0, 0, 6),
right=1274)
fixstudioshit = lvf.rfs(fixstudioshit, border, [(31761, 31762)])
border = rkt.rekt_fast(src,
lambda x: core.fb.FillBorders(x, 0, 0, 0, 6),
right=1300)
fixstudioshit = lvf.rfs(fixstudioshit, border, [31763])
border = rkt.rekt_fast(src,
lambda x: core.fb.FillBorders(x, 0, 0, 0, 6),
right=1322)
fixstudioshit = lvf.rfs(fixstudioshit, border, [31764])
border = rkt.rekt_fast(src,
lambda x: core.fb.FillBorders(x, 0, 0, 0, 6),
right=1342)
fixstudioshit = lvf.rfs(fixstudioshit, border, [31765])
border = rkt.rekt_fast(src,
lambda x: core.fb.FillBorders(x, 0, 0, 0, 6),
right=1356)
fixstudioshit = lvf.rfs(fixstudioshit, border, [31766])
border = rkt.rekt_fast(src,
lambda x: core.fb.FillBorders(x, 0, 0, 0, 6),
right=1368)
fixstudioshit = lvf.rfs(fixstudioshit, border, [31767])
border = rkt.rekt_fast(src,
lambda x: core.fb.FillBorders(x, 0, 0, 0, 6),
right=1376)
fixstudioshit = lvf.rfs(fixstudioshit, border, [31768])
border = rkt.rekt_fast(src,
lambda x: core.fb.FillBorders(x, 0, 0, 0, 6),
right=1382)
fixstudioshit = lvf.rfs(fixstudioshit, border, [(31769, 31793)])
src = fixstudioshit
# 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)
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, [(12529, 12615)])
deband_d = placebo.deband(out, 10, 3, 1)
deband = lvf.rfs(deband, deband_d, [(21077, 21304), (22141, 22278),
(22861, 22944), (29354, 29425),
(33555, 33614)])
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 = [
depth(x, 16) for x in [denoise, rescale_mask, src, JPBD_NCOP.src_cut]
]
credit = lvf.rfs(out, core.std.MaskedMerge(out, ref, rescale_mask),
full_stuff)
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
return depth(out, 10)
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Vapoursynth filtering"""
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, insert_clip, 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)
])
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)
no_flt = lvf.rfs(grain, depth(bb32, 16), no_filter)
if edstart is not False:
src_nced = depth(JP_NCED.clip_cut, 16)
no_flt = insert_clip(no_flt, src_nced, edstart)
return no_flt
def do_filter():
"""Vapoursynth filtering"""
def _nneedi3_clamp(clip: vs.VideoNode, strength: int = 1)-> vs.VideoNode:
bits = clip.format.bits_per_sample - 8
thr = strength * (1 >> bits)
luma = get_y(clip)
def _strong(clip: vs.VideoNode)-> vs.VideoNode:
args = dict(alpha=0.25, beta=0.5, gamma=40, nrad=2, mdis=20, vcheck=3)
clip = core.eedi3m.EEDI3(clip, 1, True, **args).std.Transpose()
clip = core.eedi3m.EEDI3(clip, 1, True, **args).std.Transpose()
return core.resize.Spline36(clip, luma.width, luma.height, src_left=-.5, src_top=-.5)
def _weak(clip: vs.VideoNode)-> vs.VideoNode:
args = dict(nsize=3, nns=2, qual=2)
clip = core.znedi3.nnedi3(clip, 1, True, **args).std.Transpose()
clip = core.znedi3.nnedi3(clip, 1, True, **args).std.Transpose()
return core.resize.Spline36(clip, luma.width, luma.height, src_left=-.5, src_top=-.5)
clip_aa = core.std.Expr([_strong(luma), _weak(luma), luma],
'x z - y z - * 0 < y x y {0} + min y {0} - max ?'.format(thr))
return vdf.merge_chroma(clip_aa, clip)
def _perform_endcard(path: str, ref: vs.VideoNode)-> vs.VideoNode:
endcard = lvf.src(path).std.AssumeFPS(ref)
endcard = core.std.CropRel(endcard, left=7, top=0, right=11, bottom=22)
endcard = core.resize.Bicubic(endcard, ref.width, ref.height, vs.RGBS, dither_type='error_diffusion')
endcard = core.w2xc.Waifu2x(endcard, noise=3, scale=1, photo=True)
endcard = core.resize.Bicubic(endcard, format=vs.YUV444PS, matrix_s='709', dither_type='error_diffusion')
endcard = lvf.util.quick_resample(endcard, lambda c: core.neo_f3kdb.Deband(c, 15, 36, 36, 36, 24, 24, 4))
return Tweak(endcard, sat=1.4, cont=1.2)
def _perform_motion_mask(clip: vs.VideoNode, brz: int)-> vs.VideoNode:
clip = depth(clip, 8)
sup = core.hqdn3d.Hqdn3d(clip).neo_fft3d.FFT3D().mv.Super(sharp=1)
fv1 = core.mv.Analyse(sup, isb=False, delta=1, truemotion=False, dct=2)
fv2 = core.mv.Analyse(sup, isb=True, delta=1, truemotion=True, dct=2)
momask1 = core.mv.Mask(clip, fv1, ml=2, kind=1)
momask2 = core.mv.Mask(clip, fv2, ml=3, kind=1)
momask = core.std.Merge(momask1, momask2).rgvs.RemoveGrain(3).std.Binarize(brz)
momask = momask.std.Minimum().std.Minimum()
return depth(get_y(momask), 16)
src = JPBD.src_cut
src = depth(src, 16)
denoise_a = CoolDegrain(src, tr=2, thsad=48, blksize=8, overlap=4, plane=4)
denoise = denoise_a
antialias = _nneedi3_clamp(denoise)
antialias_a = TAAmbk(antialias, aatype='Eedi3', cycle=3)
antialias_b = lvf.sraa(denoise, 2, 13)
motion_mask = _perform_motion_mask(denoise[16914:17001], 140).std.FreezeFrames([0, 18, 57], [2, 38, 86], [2, 38, 57])
motion_mask = insert_clip(src.std.BlankClip(format=vs.GRAY16), motion_mask, 16914)
antialias = lvf.rfs(antialias, core.std.MaskedMerge(antialias_a, antialias, motion_mask), [(16914, 17000)])
antialias = lvf.rfs(antialias, antialias_b, [(18084, 18179)])
predenoise = mClean(antialias, thSAD=200, chroma=False)
detail_mask = lvf.denoise.detail_mask(predenoise, rad=2, radc=2, brz_a=3250, brz_b=1250)
ret_mask = kgf.retinex_edgemask(predenoise).std.Binarize(9250).std.Median().std.Inflate()
line_mask = core.std.Expr([detail_mask, ret_mask], 'x y max')
deband_a = core.neo_f3kdb.Deband(antialias, 17, 42, 42, 42, 12, 0, sample_mode=4, keep_tv_range=True)
deband_a = core.std.MaskedMerge(deband_a, antialias, line_mask)
deband = deband_a
grain = kgf.adaptive_grain(deband, 0.25, luma_scaling=10)
ending = lvf.rfs(grain, src, [(32079, 33098)])
endcard = _perform_endcard(r'[BDMV][200902][Magia Record][Vol.5]\Scans\endcard13_front_descreen.png', src)
endcard_length = 119
final = core.std.Splice([ending, endcard * endcard_length], True)
final = core.resize.Bicubic(final, format=vs.YUV420P10, dither_type='error_diffusion')
final = core.std.Limiter(final, 16, [235 << 2, 240 << 2])
return depth(final, 10), endcard_length
def filterchain() -> Union[vs.VideoNode, Tuple[vs.VideoNode, ...]]:
"""Main VapourSynth filterchain"""
import EoEfunc as eoe
import lvsfunc as lvf
import vardefunc as vdf
from ccd import ccd
from finedehalo import fine_dehalo
from vsutil import depth, get_y, insert_clip
src = JP_BD.clip_cut
src_c = src
src_ncop, src_nced = JP_NCOP.clip_cut, JP_NCED.clip_cut
b = core.std.BlankClip(src, length=1)
# OP/ED stack comps to check if they line up
if opstart is not False:
op_scomp = lvf.scomp(src[opstart:opstart+src_ncop.num_frames-1]+b, src_ncop[:-op_offset]+b) \
.text.Text('src', 7).text.Text('op', 9)
if edstart is not False:
ed_scomp = lvf.scomp(src[edstart:edstart+src_nced.num_frames-1]+b, src_nced[:-ed_offset]+b) \
.text.Text('src', 7).text.Text('ed', 9)
# Splicing in NCs and diff'ing back the credits
if opstart is not False:
src = insert_clip(src, src_ncop[:-op_offset], opstart)
src = lvf.rfs(src, src_c, [(opstart + 811, opstart + 859)])
if edstart is not False:
src = insert_clip(src, src_nced[:-ed_offset], edstart)
den_src, den_ncs = map(partial(core.dfttest.DFTTest, sigma=10),
[src_c, src])
den_src, den_ncs = depth(den_src, 32), depth(den_ncs, 32)
diff = core.std.MakeDiff(den_src, den_ncs).dfttest.DFTTest(sigma=50.0)
# For some reason there's noise from previous credits remaining? Removing that here
diff_brz = vdf.misc.merge_chroma(diff.std.Binarize(0.03), diff)
diff = core.std.Expr([diff, diff_brz], "x y min")
src = depth(src, 16)
# This noise can burn in hell.
denoise_pre = get_y(src.dfttest.DFTTest(sigma=1.0))
denoise_ret = core.retinex.MSRCP(denoise_pre,
sigma=[50, 200, 350],
upper_thr=0.005)
denoise_mask = flt.detail_mask(denoise_ret, sigma=2.0,
lines_brz=3000).rgvs.RemoveGrain(4)
denoise_pre = core.dfttest.DFTTest(src, sigma=4.0)
denoise_smd = eoe.dn.CMDegrain(src,
tr=5,
thSAD=275,
freq_merge=True,
prefilter=denoise_pre)
denoise_masked = core.std.MaskedMerge(denoise_smd, src, denoise_mask)
denoise_uv = ccd(denoise_masked, threshold=6)
decs = vdf.noise.decsiz(denoise_uv,
sigmaS=8,
min_in=200 << 8,
max_in=235 << 8)
# F**K THIS SHOW'S LINEART HOLY SHIT
baa = lvf.aa.based_aa(decs.std.Transpose(), str(shader_file), gamma=120)
baa = lvf.aa.based_aa(baa.std.Transpose(), str(shader_file), gamma=120)
sraa = lvf.sraa(decs, rfactor=1.4)
clmp_aa = lvf.aa.clamp_aa(decs, baa, sraa, strength=1.65)
# AAing introduces some haloing (zzzzzz)
restr_edges = fine_dehalo(clmp_aa, decs)
restr_dark = core.std.Expr([clmp_aa, restr_edges], "x y min")
# Masking credits at the end if there's no NCED
get_max = core.std.Expr([restr_dark, decs], "x y max")
if opstart is False:
restr_dark = lvf.rfs(restr_dark, get_max, [(None, 3500)])
if edstart is False:
restr_dark = lvf.rfs(restr_dark, get_max, [(-5000, None)])
deband = core.average.Mean([
flt.masked_f3kdb(restr_dark, rad=17, thr=[28, 20], grain=[12, 8]),
flt.masked_f3kdb(restr_dark, rad=21, thr=[36, 32], grain=[24, 12]),
flt.masked_placebo(restr_dark, rad=6.5, thr=2.5, 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.20, 1.15, 1.10, 1),
sharps=(80, 70, 60, 50),
grainers=[
vdf.noise.AddGrain(seed=69420,
constant=True),
vdf.noise.AddGrain(seed=69420,
constant=False),
vdf.noise.AddGrain(seed=69420,
constant=False)
]).graining(deband)
merge_creds = core.std.MergeDiff(depth(grain, 32), diff)
return merge_creds
def creditless(self, src_clip: vs.VideoNode, credit_clip: vs.VideoNode, nc_clip: vs.VideoNode,
start_frame: int, thr: int, expand: int = 2, *,
prefilter: bool = False, bilateral_args: Dict[str, Any] = {}) -> vs.VideoNode:
"""Makes a mask based on difference from 2 clips.
Args:
src_clip (vs.VideoNode):
Source clip. Can be Gray, YUV or RGB.
credit_clip (vs.VideoNode): Credit clip.
It will be resampled according to the src_clip.
nc_clip (vs.VideoNode): Creditless clip.
It will be resampled according to the src_clip.
start_frame (int): Start frame.
thr (int): Binarize threshold.
25 is a good starting value in 8 bit.
expand (int, optional):
Growing/shrinking shape. 0 is allowed. Defaults to 2.
prefilter (bool, optional):
Blurs the credit_clip and nc_clip with Bilateral to avoid false posivive
such as noise and compression artifacts.
Defaults to False.
bilateral_args (Dict[str, Any], optional):
Additionnal and overrided Bilateral parameters if prefilter=True. Defaults to {}.
Returns:
vs.VideoNode: Credit mask clip.
Example:
import vardefunc as vdf
opstart, opend = 792, 2948
opmask = diff_creditless_mask(clip, clip[opstart:opend+1], ncop[:opend+1-opstart], opstart, thr=25, prefilter=True)
"""
if src_clip.format is None:
raise FormatError('diff_creditless_mask: Variable format not allowed!')
gray_only = src_clip.format.num_planes == 1
clips = [credit_clip, nc_clip]
if prefilter:
bilargs: Dict[str, Any] = dict(sigmaS=((5 ** 2 - 1) / 12) ** 0.5, sigmaR=0.5)
bilargs |= bilateral_args
clips = [c.bilateral.Bilateral(**bilargs) for c in clips]
clips = [
c.resize.Bicubic(
format=src_clip.format.replace(
bits_per_sample=get_depth(src_clip),
subsampling_w=0, subsampling_h=0).id
) for c in clips]
diff = core.std.Expr(
sum(map(split, clips), []),
mae_expr(gray_only),
format=src_clip.format.replace(color_family=vs.GRAY).id
)
mask = PrewittStd().get_mask(diff).std.Binarize(thr)
mask = self._minmax(mask, 2 + expand, True)
blank = core.std.BlankClip(
src_clip, format=src_clip.format.replace(
color_family=vs.GRAY, subsampling_w=0, subsampling_h=0
).id
)
mask = insert_clip(blank, mask, start_frame)
return mask
