Ejemplo n.º 1
0
    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)
        bdweb = lvf.rfs(bdweb, src_web_y, [(64, 1413), (32034, 33195),
                                           (33465, 33881), (34174, 34524)])
        out = vdf.misc.merge_chroma(bdweb, src)

        # ranges_frames = [
        #     (64, 131), (215, 292), (339, 410), (444, 515), (566, 657),
        #     (695, 786), (903, 971), (977, 1045), (1058, 1153), (1278, 1335),
        #     (1355, 1413)
        # ]
        # cm = partial(vdf.mask.region_mask, clip=out.std.BlankClip(format=vs.GRAY16, color=65535))

        # credit_mask = [
        #     cm()
        # ]

        # Restore BD changes
        dering_src = hvf.EdgeCleaner(src, 20, hot=True)

        diff_mask = Mask.diff_mask((src, src_cru), brz=4750.0)
        bdchanges = out
        bdchanges = lvf.rfs(bdchanges, dering_src, [(882, 902), (5596, 5701),
                                                    (9909, 10064),
                                                    (11804, 11864)])
        bdchanges = lvf.rfs(bdchanges,
                            core.std.MaskedMerge(out, dering_src, diff_mask),
                            [(2534, 2682), (2840, 2887), (3188, 3271),
                             (3818, 3859), (3986, 4087), (4499, 4618),
                             (5009, 5088), (14736, 14801), (15744, 15872),
                             (17106, 17135), (17913, 18143), (24247, 24438),
                             (33196, 33329), (34021, 34173)])
        # return bdchanges, diff_mask
        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

        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_d = vdf.deband.dumb3kdb(out, 17, 65)

        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_d, [(3920, 3985)])
        deband = core.std.MaskedMerge(deband, out, db_mask)
        out = deband

        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

        if int(NUM) != 12:
            while out.num_frames < 34646:
                out += out[-1]

        return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2],
                                          [0, 1, 2])
Ejemplo n.º 2
0
    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)
        bdweb = lvf.rfs(bdweb, src_web_y, [(793, 1503), (1696, 2301), (32121, 34164), (34472, 34523)])
        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, [(9419, 9512), (17731, 17865)])
        bdchanges = lvf.rfs(bdchanges, dering_src, [(14977, 15078), (15382, 15540), (23311, 23346)])
        # return bdchanges, diff_mask
        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


        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_x = vdf.placebo.deband(out, 28, 4, 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_x, [(6688, 6714)])
        deband = core.std.MaskedMerge(deband, out, db_mask)
        out = deband



        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


        if int(NUM) != 12:
            while out.num_frames < 34646:
                out += out[-1]

        return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2], [0, 1, 2])
Ejemplo n.º 3
0
    def main(self) -> vs.VideoNode:
        """Vapoursynth filtering"""
        src = JPBD.clip_cut
        src = depth(src, 16)

        ring_mask = Mask.ringing_mask(get_y(src))
        dering_src = hvf.EdgeCleaner(src, 20, hot=True)
        out = dering_src

        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

        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

        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

        if int(NUM) != 12:
            while out.num_frames < 2160:
                out += out[-1]

        return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2],
                                          [0, 1, 2])
Ejemplo n.º 4
0
    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, [(4455, 4607), (4876, 5078),
                                             (5199, 5246), (5958, 6035),
                                             (6894, 7076), (7275, 7406),
                                             (7653, 7784), (7863, 7970),
                                             (8142, 8348), (8784, 9065),
                                             (9276, 9800), (10613, 10720),
                                             (10739, 10780), (10949, 10969),
                                             (11105, 11230), (11924, 12289),
                                             (12865, 12891), (13139, 13213),
                                             (15520, 15733), (19160, 19243),
                                             (20351, 20422), (24824, 24979),
                                             (26357, 26527), (27920, 28000),
                                             (29576, 29659), (29780, 29881),
                                             (30128, 30271), (30644, 30763),
                                             (31776, 31811), (32522, 32641)])
        # return bdchanges, diff_mask
        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)
        import rekt
        deband_c = rekt.rekt_fast(out,
                                  lambda x: vdf.placebo.deband(x, 18, 6, 2, 0),
                                  bottom=600)
        deband_d = vdf.deband.dumb3kdb(out, 17, 65)

        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 = lvf.rfs(deband, deband_c, [(12362, 12391)])
        deband = lvf.rfs(deband, deband_d, [(14789, 15025)])
        deband = core.std.MaskedMerge(deband, out, db_mask)
        out = deband

        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

        if int(NUM) != 12:
            while out.num_frames < 34646:
                out += out[-1]

        return depth(out, 10).std.Limiter(16 << 2, [235 << 2, 240 << 2],
                                          [0, 1, 2])