def nr_f3kdb(src, range=16, y=64, cb=64, cr=64, grainy=0, grainc=0, dyn_grain=False, keep_tv_range=True, thr=0.35, thrc=None, elast=2.5, output_depth=16): if thrc == None: thrc = thr nr = core.rgvs.RemoveGrain(src, 20) diff = core.std.MakeDiff(src, nr) db = core.f3kdb.Deband(nr, range, y, cb, cr, grainy, grainc, keep_tv_range=keep_tv_range, output_depth=output_depth) db = core.std.MergeDiff(db, diff) db = mvf.LimitFilter(db, src, thr=thr, thrc=thrc, elast=elast) return db
def output(self, aaed): if self.process_depth != self.clip_bits: return mvf.LimitFilter(self.clip, mvf.Depth(aaed, self.clip_bits), thr=1.0, elast=2.0) else: return aaed
def gaussian_usm(src, sigma=1.0, sigmaV=None, thr=1.0, thrc=None, elast=3.0): if sigmaV == None: sigmaV = sigma if thrc == None: thrc = thr blur = core.bilateral.Gaussian(src, sigma, sigmaV) diff = core.std.MakeDiff(src, blur) sharp = core.std.MergeDiff(src, diff) res = mvf.LimitFilter(sharp, src, thr=thr, thrc=thrc, elast=elast) return res
def _ssharp(clip: vs.VideoNode, strength: float, width: int, height: int, factor: float = 2, b: float = -1, c: float = 6) -> vs.VideoNode: source = clip sharp = core.resize.Bicubic(clip, clip.width*factor, clip.height*factor, \ filter_param_a=b, filter_param_b=c).resize.Lanczos(width, height) source = core.resize.Spline64(source, sharp.width, sharp.height) sharp = core.rgvs.Repair(sharp, source, 13) sharp = mvf.LimitFilter(source, sharp, thrc=0.5, elast=6, brighten_thr=0.5, planes=0) final = core.std.Expr([sharp, source], f'x {strength} * y 1 {strength} - * +') return final
def MinBlur(clp, r=1, planes=None): if not isinstance(clp, vs.VideoNode): raise vs.Error('MinBlur: This is not a clip') if planes is None: planes = list(range(clp.format.num_planes)) elif isinstance(planes, int): planes = [planes] matrix1 = [1, 2, 1, 2, 4, 2, 1, 2, 1] matrix2 = [1, 1, 1, 1, 1, 1, 1, 1, 1] if r <= 0: RG11 = sbr(clp, planes=planes) RG4 = clp.std.Median(planes=planes) elif r == 1: RG11 = clp.std.Convolution(matrix=matrix1, planes=planes) RG4 = clp.std.Median(planes=planes) elif r == 2: RG11 = clp.std.Convolution( matrix=matrix1, planes=planes).std.Convolution(matrix=matrix2, planes=planes) RG4 = clp.ctmf.CTMF(radius=2, planes=planes) else: RG11 = clp.std.Convolution( matrix=matrix1, planes=planes).std.Convolution( matrix=matrix2, planes=planes).std.Convolution(matrix=matrix2, planes=planes) if clp.format.bits_per_sample == 16: s16 = clp RG4 = clp.fmtc.bitdepth(bits=12, planes=planes, dmode=1).ctmf.CTMF( radius=3, planes=planes).fmtc.bitdepth(bits=16, planes=planes) RG4 = mvf.LimitFilter(s16, RG4, thr=0.0625, elast=2, planes=planes) else: RG4 = clp.ctmf.CTMF(radius=3, planes=planes) expr = 'x y - x z - * 0 < x x y - abs x z - abs < y z ? ?' return core.std.Expr([clp, RG11, RG4], expr=[ expr if i in planes else '' for i in range(clp.format.num_planes) ])
def TAAmbk(clip, aatype=1, aatypeu=None, aatypev=None, preaa=0, strength=0.0, cycle=0, mtype=None, mclip=None, mthr=None, mthr2=None, mlthresh=None, mpand=(1, 0), txtmask=0, txtfade=0, thin=0, dark=0.0, sharp=0, aarepair=0, postaa=None, src=None, stabilize=0, down8=True, showmask=0, opencl=False, opencl_device=0, **args): core = vs.get_core() aatypeu = aatype if aatypeu is None else aatypeu aatypev = aatype if aatypev is None else aatypev if mtype is None: mtype = 0 if preaa == 0 and True not in (aatype, aatypeu, aatypev) else 1 if postaa is None: postaa = True if abs(sharp) > 70 or (0.4 < abs(sharp) < 1) else False if src is None: src = clip else: if clip.format.id != src.format.id: raise ValueError(MODULE_NAME + ': clip format and src format mismatch.') elif clip.width != src.width or clip.height != src.height: raise ValueError(MODULE_NAME + ': clip resolution and src resolution mismatch.') preaa_clip = clip if preaa == 0 else daa(clip, preaa) if thin == 0 and dark == 0: edge_enhanced_clip = preaa_clip elif thin != 0 and dark != 0: edge_enhanced_clip = haf.Toon(core.warp.AWarpSharp2(preaa_clip, depth=int(thin)), str=float(dark)) elif thin == 0: edge_enhanced_clip = haf.Toon(preaa_clip, str=float(dark)) else: edge_enhanced_clip = core.warp.AWarpSharp2(preaa_clip, depth=int(thin)) aa_kernel = { 1: AAEedi2, 2: AAEedi3, 3: AANnedi3, 4: AANnedi3UpscaleSangNom, 5: AASpline64NRSangNom, 6: AASpline64SangNom, -1: AAEedi2SangNom, -2: AAEedi3SangNom, -3: AANnedi3SangNom, 'Eedi2': AAEedi2, 'Eedi3': AAEedi3, 'Nnedi3': AANnedi3, 'Nnedi3UpscaleSangNom': AANnedi3UpscaleSangNom, 'Spline64NrSangNom': AASpline64NRSangNom, 'Spline64SangNom': AASpline64SangNom, 'Eedi2SangNom': AAEedi2SangNom, 'Eedi3SangNom': AAEedi3SangNom, 'Nnedi3SangNom': AANnedi3SangNom, 'PointSangNom': AAPointSangNom } aaed_clip = None if clip.format.color_family is vs.YUV: y = core.std.ShufflePlanes(edge_enhanced_clip, 0, vs.GRAY) u = core.std.ShufflePlanes(edge_enhanced_clip, 1, vs.GRAY) v = core.std.ShufflePlanes(edge_enhanced_clip, 2, vs.GRAY) if aatype != 0: try: y = aa_kernel[aatype](y, strength, down8, opencl=opencl, opencl_device=opencl_device, **args).out() cycle_y = cycle while cycle_y > 0: y = aa_kernel[aatype](y, strength, down8, opencl=opencl, opencl_device=opencl_device, **args).out() cycle_y -= 1 y = mvf.Depth( y, clip.format.bits_per_sample) if down8 is True else y except KeyError: raise ValueError(MODULE_NAME + ': unknown aatype.') if aatypeu != 0: try: u = aa_kernel[aatypeu]( u, 0, down8, opencl=opencl, opencl_device=opencl_device, **args).out() # Won't do predown for u plane cycle_u = cycle while cycle_u > 0: u = aa_kernel[aatypeu](u, 0, down8, opencl=opencl, opencl_device=opencl_device, **args).out() cycle_u -= 1 u = mvf.Depth( u, clip.format.bits_per_sample) if down8 is True else u except KeyError: raise ValueError(MODULE_NAME + ': unknown aatypeu.') if aatypev != 0: try: v = aa_kernel[aatypev]( v, 0, down8, opencl=opencl, opencl_device=opencl_device, **args).out() # Won't do predown for v plane cycle_v = cycle while cycle_v > 0: v = aa_kernel[aatypev](v, 0, down8, opencl=opencl, opencl_device=opencl_device, **args).out() cycle_v -= 1 v = mvf.Depth( v, clip.format.bits_per_sample) if down8 is True else v except KeyError: raise ValueError(MODULE_NAME + ': unknown aatypev.') aaed_clip = core.std.ShufflePlanes([y, u, v], [0, 0, 0], vs.YUV) elif clip.format.color_family is vs.GRAY: y = edge_enhanced_clip if aatype != 0: try: y = aa_kernel[aatype](y, strength, down8, **args).out() cycle_y = cycle while cycle_y > 0: y = aa_kernel[aatype](y, strength, down8, **args).out() cycle_y -= 1 aaed_clip = mvf.Depth( y, clip.format.bits_per_sample) if down8 is True else y except KeyError: raise ValueError(MODULE_NAME + ': unknown aatype.') else: raise ValueError(MODULE_NAME + ': Unsupported color family.') abs_sharp = abs(sharp) if sharp >= 1: sharped_clip = haf.LSFmod(aaed_clip, strength=int(abs_sharp), defaults='old', source=src) elif sharp > 0: per = int(40 * abs_sharp) matrix = [-1, -2, -1, -2, 52 - per, -2, -1, -2, -1] sharped_clip = core.std.Convolution(aaed_clip, matrix) elif sharp == 0: sharped_clip = aaed_clip elif sharp > -1: sharped_clip = haf.LSFmod(aaed_clip, strength=round(abs_sharp * 100), defaults='fast', source=src) elif sharp == -1: blured = core.rgvs.RemoveGrain( aaed_clip, mode=20 if aaed_clip.width > 1100 else 11) diff = core.std.MakeDiff(aaed_clip, blured) diff = core.rgvs.Repair(diff, core.std.MakeDiff(src, aaed_clip), mode=13) sharped_clip = core.std.MergeDiff(aaed_clip, diff) else: sharped_clip = aaed_clip postaa_clip = sharped_clip if postaa is False else soothe( sharped_clip, src, 24) repaired_clip = postaa_clip if aarepair == 0 else core.rgvs.Repair( src, postaa_clip, aarepair) stabilized_clip = repaired_clip if stabilize == 0 else temporal_stabilize( repaired_clip, src, stabilize) if mclip is not None: mask = mclip try: masked_clip = core.std.MaskedMerge(src, stabilized_clip, mask, first_plane=True) except vs.Error: raise RuntimeError(MODULE_NAME + ': Something wrong with your mclip. ' 'Maybe resolution or bit_depth mismatch.') elif mtype != 0: if mtype == 1 or mtype is 'Canny': opencl_device = args.get('opencl_device', 0) mthr = 1.2 if mthr is None else mthr mthr2 = 8.0 if mthr2 is None else mthr2 mask = MaskCanny(clip, sigma=mthr, t_h=mthr2, lthresh=mlthresh, mpand=mpand, opencl=opencl, opencl_devices=opencl_device).out() elif mtype == 2 or mtype is 'Sobel': mthr = 1.2 if mthr is None else mthr mthr2 = 48 if mthr2 is None else mthr2 mask = MaskSobel(clip, sigma=mthr, binarize=mthr2, lthresh=mlthresh, mpand=mpand).out() elif mtype == 3 or mtype is 'prewitt': mthr = 62 if mthr is None else mthr mask = MaskPrewitt(clip, factor=mthr, lthresh=mlthresh, mpand=mpand).out() else: raise ValueError(MODULE_NAME + ': unknown mtype.') masked_clip = core.std.MaskedMerge(src, stabilized_clip, mask) else: masked_clip = stabilized_clip if txtmask > 0 and clip.format.color_family is not vs.GRAY: text_mask = FadeTextMask(clip, lthr=txtmask, fade_nums=txtfade).out() txt_protected_clip = core.std.MaskedMerge(masked_clip, src, text_mask, first_plane=True) else: txt_protected_clip = masked_clip if clip.format.bits_per_sample > 8 and down8 is True: clamped_clip = mvf.LimitFilter(src, txt_protected_clip, thr=1.0, elast=2.0) else: clamped_clip = txt_protected_clip try: if showmask == -1: return text_mask elif showmask == 1: return mask elif showmask == 2: return core.std.StackVertical([ core.std.ShufflePlanes([mask, core.std.BlankClip(src)], [0, 1, 2], vs.YUV), src ]) elif showmask == 3: return core.std.Interleave([ core.std.ShufflePlanes([mask, core.std.BlankClip(src)], [0, 1, 2], vs.YUV), src ]) else: return clamped_clip except UnboundLocalError: raise RuntimeError(MODULE_NAME + ': No mask to show if you don\'t have one.')
def nnedi3_dh(input, field=1, nsize=None, nns=None, qual=None, etype=None, pscrn=None, device=None, fast=None, flat_kernel=None, flat_a1=None, flat_a2=None, flat_taps=None): core = vs.core sFormat = input.format sSType = sFormat.sample_type sbitPS = sFormat.bits_per_sample sVSubS = 1 << sFormat.subsampling_h if fast is None: fast = False if flat_kernel is None: flat_kernel = "nnedi3" else: flat_kernel = flat_kernel.lower() if (field == 0 or field == 1) and ((fast and sbitPS > 8)): if flat_kernel == "nnedi3": flat_kernel = "bicubic" input8 = mvf.Depth(input, depth=8, sample=vs.INTEGER) nn = core.nnedi3cl.NNEDI3CL(input8, field=field, dh=True, nsize=nsize, nns=nns, qual=qual, etype=etype, pscrn=pscrn, device=device) lr = core.fmtc.resample(input, sy=[-0.5, -0.5 * sVSubS] if field == 0 else 0, scaleh=1, scalev=2, kernel=flat_kernel, a1=flat_a1, a2=flat_a2, taps=flat_taps, center=False) return mvf.LimitFilter(mvf.Depth(lr, depth=sbitPS, sample=sSType), mvf.Depth(nn, depth=sbitPS, sample=sSType), thr=1.0, elast=2.0) elif flat_kernel == "nnedi3": return core.nnedi3cl.NNEDI3CL(input, field=field, dh=True, nsize=nsize, nns=nns, qual=qual, etype=etype, pscrn=pscrn, device=device) else: nn = core.nnedi3cl.NNEDI3CL(input, field=field, dh=True, nsize=nsize, nns=nns, qual=qual, etype=etype, pscrn=pscrn, device=device) lr = core.fmtc.resample(input, sy=[-0.5, -0.5 * sVSubS] if field == 0 else 0, scaleh=1, scalev=2, kernel=flat_kernel, a1=flat_a1, a2=flat_a2, taps=flat_taps, center=False) return mvf.LimitFilter(mvf.Depth(lr, depth=sbitPS, sample=sSType), mvf.Depth(nn, depth=sbitPS, sample=sSType), thr=1.0, elast=2.0)
def mts(src): src8 = mvf.ToYUV(src, css='420') src16 = core.fmtc.bitdepth(src8,bits=16) # Denoise src_rgb = mvf.ToRGB(src16,depth=32) #nr16_rgb = core.pdn.BM3DBasic(src_rgb, sigma=[0.5, 0.2, 0.2],group_size=16, bm_range=8) nr16_rgb = core.pdn.BM3DBasic(src_rgb, sigma=[1.0, 0.5, 0.5]) nr16 = mvf.ToYUV(nr16_rgb, css="420",depth=16) noise16 = core.std.MakeDiff(src16, nr16) # Mask pre16 = core.std.ShufflePlanes([nr16,src16],[0,1,2],vs.YUV) pre8 = mvf.Depth(pre16, depth=8, dither=5) eemask = core.tcanny.TCanny(pre8,sigma=0.6,op=2,gmmax=255,planes=[0,1,2],mode=1) eemask_u = core.std.ShufflePlanes(eemask, [1,1,1], vs.YUV).fmtc.resample(1920,1080,sx=0.25,css="420") eemask_v = core.std.ShufflePlanes(eemask, [2,2,2], vs.YUV).fmtc.resample(1920,1080,sx=0.25,css="420") weighted = core.std.Expr([eemask,eemask_u,eemask_v],["x 64 * y + z +",""],vs.YUV420P16) luma = core.std.ShufflePlanes(pre8, 0, vs.YUV).resize.Bilinear(format=vs.YUV420P8) eemask = core.std.Expr([eemask,luma],["x x * 20 * 255 y - dup * 0.2 * + 50000 min","x x * 30 * 255 y - dup * 0.3 * + 60000 min"],vs.YUV420P16) eemask = core.std.Maximum(eemask,planes=[0,1,2]) eemask = core.rgvs.RemoveGrain(eemask, [20,11]).rgvs.RemoveGrain([20,11]).rgvs.RemoveGrain([20,11]) aamask = core.std.Binarize(weighted, 12000, 0) nrmasks = core.std.Binarize(weighted, 4500, 0) dmaskb = core.std.Binarize(weighted, 3000, 0) dmaskm = core.std.Binarize(weighted, 3500, 0) dmasks = core.std.Binarize(weighted, 3800, 0) dmask_dark = core.misc.Hysteresis(dmaskm, dmaskb) dmask_bright = core.misc.Hysteresis(dmasks, dmaskm) dmask = core.std.Expr([src16, dmask_dark, dmask_bright], "x 24672 < y z ?") nrmaskg = core.tcanny.TCanny(pre8,sigma=1.5,t_l=8,t_h=15,op=2,planes=0) nrmaskb = core.tcanny.TCanny(pre8,sigma=1.2,t_l=8,t_h=11,op=2,planes=0) nrmask = core.std.Expr([nrmaskg,nrmaskb,nrmasks,pre8,dmask],["a 20 < 65535 a 64 < x 257 * b max a 160 < y 257 * z ? ? ?","",""],vs.YUV420P16) nrmask = core.std.Maximum(nrmask,0).std.Maximum(0).std.Minimum(0).std.Minimum(0) nrmask = core.rgvs.RemoveGrain(core.rgvs.RemoveGrain(nrmask,[20,0]),[20,0]) Y = core.std.ShufflePlanes(src16, 0, vs.YUV).resize.Bicubic(1920, 1080, format=vs.YUV420P16, filter_param_a=0, filter_param_b=0.5) U = core.std.ShufflePlanes(src16, [1,1,1], vs.YUV).resize.Bicubic(1920, 1080, format=vs.YUV420P16, filter_param_a=0, filter_param_b=0.5) V = core.std.ShufflePlanes(src16, [2,2,2], vs.YUV).resize.Bicubic(1920, 1080, format=vs.YUV420P16, filter_param_a=0, filter_param_b=0.5) textmask0 = core.std.Expr([Y,U,V], ["x 60000 > y 32768 - abs 768 < and z 32768 - abs 768 < and 65535 0 ?","0"]) #textmasks = core.std.Expr([Y,U,V], ["x 58000 > y 32768 - abs 512 < and z 32768 - abs 512 < and 65535 0 ?","0"]) textmask1 = core.std.Minimum(textmask0, 0).std.Minimum(planes=0).std.Minimum(planes=0).std.Maximum(0).std.Maximum(0).std.Maximum(0) textmask2 = core.misc.Hysteresis(textmask1, textmask0, planes=0) textmask = core.std.Expr([textmask0, textmask2], "x y > x 0 ?") #textmask = core.misc.Hysteresis(textmasks, textmaskb, planes=0) textmask = core.std.Maximum(textmask,0).std.Maximum(0).std.Maximum(0)#.std.Maximum(0)#.std.Maximum(0)#.std.Maximum(0)#.std.Minimum(0) debd = core.f3kdb.Deband(nr16,8,48,32,32,0,0,output_depth=16) debd = core.f3kdb.Deband(debd,15,32,24,24,0,0,output_depth=16) debd = mvf.LimitFilter(debd,nr16,thr=0.7,thrc=0.5,elast=2.0) debd = core.std.MaskedMerge(debd, nr16, nrmask, first_plane=1) w = 1920 h = 1080 oaa_y = core.std.ShufflePlanes(nr16, 0, vs.GRAY) aa_y = core.eedi2.EEDI2(oaa_y,field=1,mthresh=10,lthresh=20,vthresh=20,maxd=24,nt=50).fmtc.resample(w,h,sy=-0.5, kernel='bicubic', a1=0, a2=0.5,).std.Transpose() aa_y = core.eedi2.EEDI2(aa_y,field=1,mthresh=10,lthresh=20,vthresh=20,maxd=24,nt=50).fmtc.resample(h,w,sy=-0.5, kernel='bicubic', a1=0, a2=0.5,).std.Transpose() aa_clip = core.std.ShufflePlanes([aa_y,nr16], [0,1,2], vs.YUV) aaed = core.std.MaskedMerge(debd, aa_clip, aamask, 0, True) aaed = core.std.MaskedMerge(aaed, debd, textmask, 0, False) dif = core.std.MakeDiff(aaed, core.rgvs.RemoveGrain(aaed,20)) sharp = core.std.MergeDiff(aaed, dif) sharped = core.std.MaskedMerge(sharp, aaed, eemask, [0,1,2], False) noise16 = core.std.Expr(noise16,["x 32768 - 1.05 * 32768 +",""]) nullclip = core.std.Expr(src16,["32768",""]) nrweight = core.std.Expr(pre8, ["x 48 - 0 max dup * 5 * ",""], vs.YUV420P16) noise16 = core.std.MaskedMerge(noise16,nullclip,nrweight,0,True) res = core.std.MergeDiff(sharped,noise16,0) return res