From 5387d8ff11c684d9f4284a213c6b4b4127a9e92a Mon Sep 17 00:00:00 2001 From: louis Date: Wed, 23 Jun 2021 22:52:58 -0400 Subject: [PATCH] vivy: tv: 13 --- Vivy/13/13.vpy | 143 ++++++++++++++++++++++++++++++++++ yt_common/yt_common/deband.py | 27 +++++++ 2 files changed, 170 insertions(+) create mode 100644 Vivy/13/13.vpy diff --git a/Vivy/13/13.vpy b/Vivy/13/13.vpy new file mode 100644 index 0000000..558ad4f --- /dev/null +++ b/Vivy/13/13.vpy @@ -0,0 +1,143 @@ +import vapoursynth as vs + +from vivy_common import (VivyConfig, VivySource, antialias, deband, denoise, + finalize, fsrcnnx_rescale, letterbox_edgefix, letterbox_refix, regrain) + +from yt_common.automation import SelfRunner +from yt_common.deband import gray_mask +from yt_common.chapters import Chapter +from yt_common.source import waka_replace + +from lvsfunc.mask import BoundingBox +from lvsfunc.types import Range +from lvsfunc.util import replace_ranges +from lvsfunc.dehardsub import HardsubLine, HardsubSignFade, HardsubMask, bounded_dehardsub + +from awsmfunc import bbmod +from vsutil import scale_value +from vsutil import Range as CRange + +import lvsfunc as lvf +from debandshit import f3kbilateral +from vsutil import iterate + +from typing import List, Optional + +import os + +core = vs.core + + +EPNUM: int = int(os.path.basename(os.path.splitext(__file__)[0])) +CONFIG: VivyConfig = VivyConfig(EPNUM) +SOURCE: VivySource = VivySource(CONFIG) + +CHAPTERS: List[Chapter] = [ + Chapter("Intro", 0), + Chapter("OP", 1990), + Chapter("Part A", 4149), + Chapter("Part B", 16378), + Chapter("Credits", 30657), + Chapter("Outro", 32390), +] + +WAKA_REPLACE: List[List[Range]] = [ + [(30657, 31496)], + [], +] +SIGNS_RU: List[HardsubMask] = [ + HardsubLine([ + (1996, 4110), + (21898, 24539), + (24975, 28802), + ], ((283, 844), (1349, 204))), + HardsubLine([ + (1529, 1570), + ]), + HardsubSignFade([ + (1906, 1989), + (22928, 22951), + ]), +] + +CREDITS: List[Range] = [ + (30657, 32377), +] + +NOSCALE: List[Range] = [ +] +NOSCALE += CREDITS +AA_NONE: List[Range] = [ +] +AA_NONE += CREDITS +AA_STRONGER: List[Range] = [ +] +LETTERBOX: List[Range] = [ + (33393, 33545), +] +LETTERBOX_FADES: List[Range] = [ +] +DUMBSHIT_DEBAND: List[Range] = [ + (29745, 29870), +] + + +def credits_ef(clip: vs.VideoNode, ranges: Optional[List[Range]] = None) -> vs.VideoNode: + assert clip.format is not None + black = scale_value(0, 8, clip.format.bits_per_sample, scale_offsets=True, + range_in=CRange.FULL, range=CRange.LIMITED) + y = clip.std.ShufflePlanes(0, vs.GRAY) + y_crop = y.std.Crop(left=1050, top=55, right=98, bottom=55) + y_bb = bbmod(y_crop, top=2, bottom=2, left=3, right=2) + y_aa = antialias(y_bb) + y_border = y_aa.std.AddBorders(left=1050, top=55, right=98, bottom=55, color=black) + y_mask = BoundingBox((1049, 54), (774, 972)).get_mask(y_border) + y_fix = core.std.MaskedMerge(y, y_border, y_mask) + fixed = core.std.ShufflePlanes([y_fix, clip], [0, 1, 2], vs.YUV) + return replace_ranges(clip, fixed, ranges) + + +def colored_deband(clip: vs.VideoNode, deb_ref: vs.VideoNode, ranges: Optional[List[Range]] = None + ) -> vs.VideoNode: + deband_strong = iterate(clip.std.ShufflePlanes(0, vs.GRAY), + lambda c: f3kbilateral(c, range=12, y=80), 2) # type: ignore + deband_strong_u = iterate(clip.std.ShufflePlanes(1, vs.GRAY), + lambda c: f3kbilateral(c, range=12, y=40), 2) # type: ignore + deband_strong_v = iterate(clip.std.ShufflePlanes(2, vs.GRAY), + lambda c: f3kbilateral(c, range=12, y=40), 2) # type: ignore + db_yeet = core.std.ShufflePlanes([deband_strong, deband_strong_u, deband_strong_v], [0, 0, 0], vs.YUV) + db_yeet = core.std.MaskedMerge(db_yeet, clip, lvf.mask.detail_mask(clip)) + cmask = gray_mask(db_yeet, y=(0.165, 0.3)) + db_cmask = core.std.MaskedMerge(deb_ref, db_yeet, cmask) + return replace_ranges(deb_ref, db_cmask, ranges) + + +def filter_basic() -> vs.VideoNode: + wakas, ref = SOURCE.dhs_source() + waka = wakas[0] + waka, wakas = waka_replace(waka, wakas[1:], WAKA_REPLACE) + src = bounded_dehardsub(waka, ref, SIGNS_RU, wakas) + src.set_output(1) + return src + + +def filter() -> vs.VideoNode: + src = filter_basic() + den = denoise(src) + rescale = fsrcnnx_rescale(den, NOSCALE) + edgefix = letterbox_edgefix(rescale, crops=LETTERBOX, fades=LETTERBOX_FADES) + deb = deband(edgefix) + deb = colored_deband(edgefix, deb, DUMBSHIT_DEBAND) + aa = antialias(deb, stronger=AA_STRONGER, noaa=AA_NONE) + refix = letterbox_refix(aa, deb, LETTERBOX) + cfix = credits_ef(refix, CREDITS) + grain = regrain(cfix) + final = finalize(grain) + final.set_output(0) + return final + + +if __name__ == "__main__": + SelfRunner(CONFIG, SOURCE, filter, filter_basic, chapters=CHAPTERS) +else: + filter() diff --git a/yt_common/yt_common/deband.py b/yt_common/yt_common/deband.py index 7effd72..97c1086 100644 --- a/yt_common/yt_common/deband.py +++ b/yt_common/yt_common/deband.py @@ -4,6 +4,8 @@ from enum import Enum from functools import partial from typing import Any, Callable, List, Optional, Tuple, Union +from lvsfunc.util import scale_thresh + import vsutil @@ -93,3 +95,28 @@ def morpho_mask(clip: vs.VideoNode) -> Tuple[vs.VideoNode, vs.VideoNode]: grad_mask = core.std.Expr([ymph, yrangesml, ypw], expr="x y z max max") return grad_mask, yrangebig + + +def color_mask(clip: vs.VideoNode, y: Tuple[float, float], u: Tuple[float, float], v: Tuple[float, float] + ) -> vs.VideoNode: + expr = f"x {scale_thresh(y[0], clip)} >= x {scale_thresh(y[1], clip)} <= and " # Y bounds check + expr += f"y {scale_thresh(u[0], clip)} >= y {scale_thresh(u[1], clip)} <= and and " # U bounds check + expr += f"z {scale_thresh(v[0], clip)} >= z {scale_thresh(v[1], clip)} <= and and " # V bounds check + expr += f"{scale_thresh(1.0, clip)} 0 ?" # brz + wmask = core.std.Expr(vsutil.split(clip.resize.Bicubic(format=vs.YUV444P16)), expr) + wmask = wmask.std.Inflate().std.Binarize() + wmask_edge = wmask.std.Prewitt().std.Binarize() + wmask = core.std.Expr([wmask, wmask_edge], "x y -") # preserve edges for sharpness + return wmask + + +def gray_mask(clip: vs.VideoNode, y: Tuple[float, float], cthr: float = 0.02) -> vs.VideoNode: + expr = f"x {scale_thresh(y[0], clip)} >= x {scale_thresh(y[1], clip)} <= and " # Y bounds check + expr += "y z >= and " # U >= V for blue-ish grays + expr += f"y z - abs {scale_thresh(cthr, clip)} <= and " # UV proximity check + expr += f"{scale_thresh(1.0, clip)} 0 ?" # brz + wmask = core.std.Expr(vsutil.split(clip.resize.Bicubic(format=vs.YUV444P16)), expr) + wmask = wmask.std.Inflate().std.Binarize() + wmask_edge = wmask.std.Prewitt().std.Binarize() + wmask = core.std.Expr([wmask, wmask_edge], "x y -") # preserve edges for sharpness + return wmask