﻿
[Source]
Automatic = # can be configured at: Tools > Settings > Source Filters
AVISource = clip = core.avisource.AVISource(r"%source_file%")

BestSource =
    tcFile = r"%temp_file%_timestamps.txt" # timestamps file path
    # hwdevice: The interface to use for hardware decoding. Depends on OS and hardware. On windows d3d11va, cuda and vulkan (H264, HEVC and AV1) are probably the ones most likely to work. Defaults to CPU decoding. Will throw errors for formats where hardware decoding isn't possible.
    clip = core.bs.VideoSource(r"%source_file%", track=-1, fpsnum=-1, fpsden=1, rff=False, threads=0, seekpreroll=20, enable_drefs=False, use_absolute_path=False, cachemode=3, cachepath=r"%source_temp_file%", cachesize=1000, hwdevice="", extrahwframes=9, timecodes=tcFile) if os.path.exists(tcFile) else core.bs.VideoSource(r"%source_file%", track=-1, fpsnum=-1, fpsden=1, rff=False, threads=0, seekpreroll=20, enable_drefs=False, use_absolute_path=False, cachemode=3, cachepath=r"%source_temp_file%", cachesize=1000, hwdevice="", extrahwframes=9)

d2vSource = clip = core.d2v.Source(r"%source_file%")

ffms2 =
    tcFile = r"%temp_file%_timestamps.txt" # timestamps file path
    clip = core.ffms2.Source(r"%source_file%", cachefile=r"%source_temp_file%.ffindex", timecodes=tcFile) if os.path.exists(tcFile) else core.ffms2.Source(r"%source_file%", cachefile=r"%source_temp_file%.ffindex")

LibavSMASHSource = clip = core.lsmas.LibavSMASHSource(r"%source_file%")
LWLibavSource = clip = core.lsmas.LWLibavSource(r"%source_file%", cachefile=r"%source_temp_file%.lwi")
Manual = # shows filter selection dialog
MPEG2Source = clip = core.dgdecode.MPEG2Source(r"%source_file%")

[Color]
ColorSpace | Matrix = clip = core.fmtc.matrix(clip, mat='$select:msg:Select Matrix;Linear;470m;470bg;240m;SRGB;709;2020$')
ColorSpace | Primaries = clip = core.fmtc.primaries(clip, prims='$select:msg:Select Input;470m;470bg;240m;SRGB;709;2020$', primd='$select:msg:Select Output;Linear;470m;470bg;240m;SRGB;709;2020$')
ColorSpace | Range = clip = core.fmtc.bitdepth(clip, $select:msg:Select Range;PC to TV|fulls=True, fulld=False;TV to PC|fulls=False, fulld=True$)

ColorSpace | Respec =
    clip = core.fmtc.resample (clip, css='444')
    clip = core.fmtc.matrix (clip, mats='$select:msg:Select Input Colorspace;240;601;709;2020$', matd='$select:msg:Select Output Colorspace;240;601;709;2020$')
    clip = core.fmtc.resample (clip, css='420')
    clip = core.fmtc.bitdepth (clip, bits=10, fulls=$select:msg:Select Input Range;Limited|False;Full|True$, fulld=$select:msg:Select Output Range;Limited|False;Full|True$)

ColorSpace | Transfer = clip = core.fmtc.transfer(clip, transs='$select:msg:Select Input;Linear;470m;470bg;240m;SRGB;709;2020;2084$', transd='$select:msg:Select Output;Linear;470m;470bg;240m;SRGB;709;2020;2084$')
ColorYUV | Curve = clip = core.curve.Curve(clip, preset=$select:None|0, r=[0,0, 0.5,0.5, 1,1], g=[0,0, 0.5,0.5, 1,1], b=[0,0, 0.5,0.5, 1,1], master=[0,0, 0.5,0.5, 1,1];Color Negative (RGB)|1;Cross Process (RGB)|2;Darker|3;Increase Contrast|4;Lighter|5;Linear Contrast|6;Medium Contrast|7;Negative|8;Strong Contrast|9;Vintage (RGB)|10$, acv=None, planes=[0, 1, 2])
ColorYUV | Grayscale = clip = mvsfunc.GrayScale(clip)
ColorYUV | Tweak = clip = adjust.Tweak(clip, $select:Neutral|hue=0, sat=1, bright=0, cont=1;Brighter|hue=0, sat=1, bright=20, cont=1.04;Less Contrast|hue=0, sat=0.95, bright=8, cont=0.9;Vivid|hue=0, sat=1.15, bright=2, cont=1.08;Desaturate|hue=0, sat=0, bright=0, cont=1$)
Convert | BitDepth (fmtc) = clip = core.fmtc.bitdepth(clip, bits=$select:msg:Select BitDepth;8;10;12;16;32$)
Convert | Convert To = clip = core.resize.Bicubic(clip, format=vs.$select:GRAY16;GRAY8;GRAYH;GRAYS;RGB24;RGB27;RGB30;RGB48;RGBH;RGBS;YUV410P8;YUV411P8;YUV420P8;YUV420P9;YUV420P10;YUV420P12;YUV420P14;YUV420P16;YUV422P8;YUV422P9;YUV422P10;YUV422P12;YUV422P14;YUV422P16;YUV440P8;YUV444P8;YUV444P9;YUV444P10;YUV444P12;YUV444P14;YUV444P16;YUV444PH;YUV444PS$)
Convert | Format = clip = core.avs.z_ConvertFormat(clip, pixel_type='$enter_text:Enter the Format You Wish to Convert to$', colorspace_op='$select:msg:Select Input Color Matrix;rgb;709;unspec;fcc;470bg;170m;240;ycgco;2020ncl;2020cl;chromancl;chromacl;ictcp$:$select:msg:Select Input Color Transfer;709;unspec;470m;470bg;601;240m;linear;log100;log316;xvycc;srgb;2020_10;2020_12;st2084;std-b67$:$select:msg:Select Input Color Primaries;709;unspec;470m;470bg;170m;240m;film;2020;st428;st431-2;st432-1;jedec-p22$:$select:msg:Select Pixel Range;limited;l;full;f$=>$select:msg:Select Output Color Matrix;rgb;709;unspec;fcc;470bg;170m;240;ycgco;2020ncl;2020cl;chromancl;chromacl;ictcp$:$select:msg:Select Output Color Transfer;709;unspec;470m;470bg;601;240m;linear;log100;log316;xvycc;srgb;2020_10;2020_12;st2084;std-b67$:$select:msg:Select Output Color Primaries;709;unspec;470m;470bg;170m;240m;film;2020;st428;st431-2;st432-1;jedec-p22$:$select:msg:Select Pixel Range;limited;l;full;f$', dither_type='$select:msg:Select Dither Type;none;ordered;random;error_diffusion$')
Convert | To 444 = clip = core.fmtc.resample(clip, css='444')
Dither | Gamma / Linear = clip = $select:Gamma To Linear|Dither.gamma_to_linear;Linear To Gamma|Dither.linear_to_gamma$(clip, curve='$select:msg:Select the Color Curve;601;709;2020$')
Dither | Sigmoid = $select:Sigmoid Inverse|clip = havsfunc.SigmoidInverse(clip);Sigmoid Direct|clip = havsfunc.SigmoidDirect(clip)$
Dither | SmoothGrad = clip = muvsfunc.GradFun3(src=clip, mode=6, smode=1)
Dither | Stack = $select:Native to Stack16|clip = core.fmtc.nativetostack16(clip);Stack16 to Native|clip = fmtc.stack16tonative(clip)$
Dither | To RGB / YUV = clip = $select:To RGB|mvsfunc.ToRGB;To YUV|mvsfunc.ToYUV$(clip,matrix='$select:msg:Select Matrix;470bg;240;709;2020;2020cl;bt2020c$')

Tonemap | Placebo =
    clip = core.fmtc.bitdepth(clip, bits=16)
    clip = core.placebo.Tonemap(clip, src_csp=$select:msg:Select Source Color Space;SDR|0;HDR10 (Default)|1;HLG|2;Dolby Vision|3$, dst_csp=$select:msg:Select Target Color Space;SDR (Default)|0;HDR10|1;HLG|2;Dolby Vision|3$, dynamic_peak_detection=$select:msg:Dynamic Peak Detection?;Yes (Default)|1;No|0$, gamut_mapping=$select:msg:Gamut Mapping Function;Clip|0;Perceptual (Default)|1;Softclip|2;Relative|3;Saturation|4;Absolute|5;Desaturate|6;Darken|7;Highlight|8;Linear|9$, tone_mapping_function=$select:msg:Tonemapping Function;Clip|0;Spline (Default)|1;ST2094_40|2;ST2094_10|3;BT2390|4;BT2446a|5;Reinhard|6;Mobius|7;Hable|8;Gamma|9;Linear|10;LinearLight|11$, metadata=$select:msg:Metadata;Auto (Default)|0;None (Disabled)|1;HDR10 (Static)|2;HDR10+ (MaxRGB)|3;Luminance (CIE Y)|4$, contrast_recovery=0.0, smoothing_period=20.0, percentile=100.0)
    # clip = clip.resize.Bicubic(format = vs.YUV420P10)

[Crop]
Crop = clip = core.std.Crop(clip, %crop_left%, %crop_right%, %crop_top%, %crop_bottom%)
Hardware Encoder = # hardware encoder crops

[Field]
Deinterlace | Bwdif = clip = core.bwdif.Bwdif(clip, field=$select:msg:Select Mode;Same rate, keep Bottom field|0;Same rate, keep Top field|1;Double rate, starts with Bottom|2;Double rate, starts with Top|3$)
Deinterlace | EEDI = $select:EEDI2|clip = core.eedi2.EEDI2;EEDI3|clip = core.eedi3m.EEDI3$(clip,$select:msg:Select Field;Bottom Field|0;Top Field|1;Alternate Each Frame Bottom Field|2;Alternate Each Frame Top Field|3$)
Deinterlace | NNEDI3 = $select:znedi3|clip = core.znedi3.nnedi3;nnedi3cl|clip = core.nnedi3cl.NNEDI3CL;nnedi3|clip = core.nnedi3.nnedi3$(clip, field=$select:msg:Select Field Option;Same Rate Bottom Field|0;Same Rate Top Field|1;Double Rate Alternates Bottom Field|2;Double Rate Alternates Top Field|3$)

Deinterlace | QTGMC | QTGMC =
    clip = core.std.SetFieldBased(clip, <if('%source_mi_v:ScanOrder%'='BFF';1;2)>) # 1=BFF, 2=TFF
    clip = havsfunc.QTGMC(clip, TFF=True, Preset='$select:msg:Select a preset.;Draft;Ultra Fast;Super Fast;Very Fast;Faster;Fast;Medium;Slow;Slower;Very Slow;Placebo$', InputType=$select:msg:Select Input Type;Interlaced|0;Progressive|1;Progressive Repair Details|2;Progressive Full Repair|3$, SourceMatch=3, Sharpness=0.2)

Deinterlace | QTGMC | QTGMC with Repair =
    clip = core.std.SetFieldBased(clip, <if('%source_mi_v:ScanOrder%'='BFF';1;2)>) # 1=BFF, 2=TFF
    QTGMC1 = havsfunc.QTGMC(clip, TFF=<if('%source_mi_v:ScanOrder%'='BFF';False;True)>, Preset='Slower', InputType=2)
    QTGMC2 = havsfunc.QTGMC(clip, TFF=<if('%source_mi_v:ScanOrder%'='BFF';False;True)>, Preset='Slower', InputType=3)
    clip = core.rgvs.Repair(QTGMC1, QTGMC2, mode=1)

Deinterlace | W3FDIF = clip = core.w3fdif.W3FDIF(clip,$select:msg:Select Order Option;BFF|0;TFF|1$,$select:msg:Select Interlacing Filter Coefficients;Simple|0;Complex|1$)
Deinterlace | Yadifmod = clip = core.yadifmod.Yadifmod(clip, core.nnedi3.nnedi3(clip, field=0), order=1, field=-1, mode=0)
Field Base = clip = core.std.SetFieldBased(clip, $select:Frame Based|0;Bottom Field First|1;Top Field First|2$)

VIVTC =
    clip = core.vivtc.VFM(clip, 1)
    clip = core.vivtc.VDecimate(clip)

Select Every Other = $select:Even|clip = clip[::2];Odd|clip = clip[1::2]$
SeparateFields = clip = core.std.SeparateFields(clip)
Weave = clip = havsfunc.Weave(clip, tff=True)

[Frame Rate]
AssumeFPS | AssumeFPS = clip = core.std.AssumeFPS(clip, None, $select:msg:Select a frame rate.;24000/1001|24000, 1001;24|24, 1;25|25, 1;30000/1001|30000, 1001;30|30, 1;50|50, 1;60000/1001|60000, 1001;60|60, 1$)
AssumeFPS | AssumeFPS Source = clip = core.std.AssumeFPS(clip, fpsnum=int(%source_mi_v:FrameRate% * 1000), fpsden=1000)
InterFrame = clip = havsfunc.InterFrame(clip, Preset='Medium', Tuning='$select:msg:Select the Tuning Preset;Animation;Film;Smooth;Weak$', NewNum=$enter_text:Enter the NewNum Value$, NewDen=$enter_text:Enter the NewDen Value$, OverrideAlgo=$select:msg:Which Algorithm Do you Wish to Use?;Strong Predictions|2;Intelligent|13;Smoothest|23$, GPU=$select:msg:Enable GPU Feature?;True;False$)

SVPFlow | Core =
    crop_string = ''
    resize_string = ''
    super_params = '{pel:1,scale:{up:0},gpu:1,full:false,rc:true}'
    analyse_params = '{block:{w:16},main:{search:{coarse:{type:4,distance:-6,bad:{sad:2000,range:24}},type:4}},refine:[{thsad:250}]}'
    smoothfps_params = '{gpuid:11,linear:true,rate:{num:60000,den:1001,abs:true},algo:23,mask:{area:200},scene:{}}'
    def interpolate(clip):
        input = clip
        if crop_string!='':
            input = eval(crop_string)
        if resize_string != '':
            input = eval(resize_string)
        super   = core.svp1.Super(input, super_params)
        vectors = core.svp1.Analyse(super['clip'], super['data'], input, analyse_params)
        smooth  = core.svp2.SmoothFps(input, super['clip'], super['data'], vectors['clip'], vectors['data'], smoothfps_params, src=clip)
        smooth  = core.std.AssumeFPS(smooth, fpsnum=smooth.fps_num, fpsden=smooth.fps_den)
        return smooth
    clip =  interpolate(clip)

SVPFlow | MV =
    sup = core.mv.Super(clip, pel=2, hpad=0, vpad=0)
    bvec = core.mv.Analyse(sup, blksize=16, isb=True, chroma=True, search=3, searchparam=1)
    fvec = core.mv.Analyse(sup, blksize=16, isb=False, chroma=True, search=3, searchparam=1)
    $select:msg:Select FPS Filter to Use;FlowFPS|clip = core.mv.FlowFPS(clip, sup, bvec, fvec, mask=2;BlockFPS|clip = core.mv.BlockFPS(clip, sup, bvec, fvec, mode=3, thscd2=12$, num=$enter_text:Enter The Num Value$, den=$enter_text:Enter The Den Value$)

VFR to CFR | VFRToCFR =
    tcFile = r"%temp_file%_timestamps.txt" # timestamps file path
    try:
        clip = core.vfrtocfr.VFRToCFR(clip, timecodes=tcFile, fpsnum=$enter_text:Numerator of the target FPS (in integer)?$, fpsden=$enter_text:Denominator of the target FPS (in integer)?$)
    except:
        raise vs.Error("Timestamps extraction from MKV must be turned on in Options. Remux your input to MKV if it is not an MKV file.")
    # Don't forget to mux the timestamps file in the output mkv

[Line]

Anti-Aliasing | DAA = clip = havsfunc.daa(clip)
Anti-Aliasing | ediAA = clip = muvsfunc.ediaa(clip)
Anti-Aliasing | insaneAA = clip = insaneAA.insaneAA(clip, external_aa=None, external_mask=None, faster_aa=False, eedi3_mode=insaneAA.EEDI3Mode.CPU, eedi3_device=-1, eedi3_opt=0, nnedi3_mode=insaneAA.NNEDI3Mode.NNEDI3, nnedi3_device=-1, nnedi3_opt=0, descale_strength=0.3, kernel='bilinear', bicubic_b=1/3, bicubic_c=1/3, lanczos_taps=3, descale_width=None, descale_height=720, pscrn=1, alpha=0.2, beta=0.25, gamma=1000.0, nrad=2, mdis=20, nsize=0, nns=4, output_mode=insaneAA.ClipMode.FULL, input_mode=insaneAA.ClipMode.FULL)
Anti-Aliasing | MAA = clip = muvsfunc.maa(clip)
Anti-Aliasing | nnedi3AA = clip = muvsfunc.nnedi3aa(clip)
Anti-Aliasing | Sangnom = clip = core.sangnom.SangNom(clip)
Anti-Aliasing | Santiag = clip = havsfunc.santiag(c=clip, opencl=$select:msg:Use GPU Enabled Feature?;True;False$)
Anti-Aliasing | TAAmbk = clip = vsTAAmbk.TAAmbk(clip, preaa=-1, aatype=4, mtype=1, mthr=24, sharp=-1,aarepair=-20, postaa=False, stabilize=1)
Sharpen | aWarpSharpen2 = clip = core.warp.AWarpSharp2(clip=clip, blur=2)
Sharpen | CAS = clip = core.cas.CAS(clip, $enter_text:Enter the Amount of Sharpness in decimal (between 0.0 and 1.0)$)
Sharpen | DetailSharpen = clip = G41Fun.DetailSharpen(clip, z=4, sstr=1.5, power=4, ldmp=1, mode=1, med=False)
Sharpen | FineSharp = clip = finesharp.sharpen(clip, $select:msg:Select Strength;Light|mode=1, sstr=2, cstr=0.8, xstr=0.19, lstr=1.49, pstr=1.272;Moderate|mode=2, sstr=2.0, cstr=1.3, xstr=0.0, lstr=1.49, pstr=1.472;Strong|mode=3, sstr=6.0, cstr=1.3, xstr=0.0, lstr=1.49, pstr=1.472$)
Sharpen | LSFmod = clip = havsfunc.LSFmod(clip, defaults='slow', strength=100, Smode=5, Smethod=3, kernel=11, secure=True, Szrp= 16, Spwr= 4, SdmpLo= 4, SdmpHi= 48, Lmode=4, overshoot=1, undershoot=1, soft=-2, soothe=True, keep=20, edgemode=0, edgemaskHQ=True, ss_x= 1.50, ss_y=1.50)
Sharpen | McDegrainSharp = clip = mcdegrainsharp.mcdegrainsharp(clip, plane=4)
Sharpen | MSharpen = clip = core.msmoosh.MSharpen(clip, threshold=6.0, strength=39)
Sharpen | pSharpen = clip = psharpen.psharpen(clip)
Sharpen | SharpAAMcmod = clip = muvsfunc.SharpAAMcmod(clip)
Sharpen | Sharpen = clip = muvsfunc.Sharpen(clip, $enter_text:Enter the Amount of Sharpness in decimal (from -1.58 to 1.0)$)

[Misc]

Anamorphic to Standard =
    clip = core.fmtc.resample (clip, w=1280, h=720, css='444')
    clip = core.fmtc.matrix (clip, mat='709', col_fam=vs.RGB)
    clip = core.fmtc.transfer (clip, transs='1886', transd='srgb')
    clip = core.fmtc.bitdepth (clip, bits=8)

Borders | AddBorders = clip = core.std.AddBorders(clip, left=$enter_text:Number of Left Pixels$, top=$enter_text:Number of Top Pixels$, right=$enter_text:Number of Right Pixels$, bottom=$enter_text:Number of Bottom Pixels$)
Borders | FillBorders = clip = core.fb.FillBorders(clip, left=$enter_text:Number of Left Pixels$, top=$enter_text:Number of Top Pixels$, right=$enter_text:Number of Right Pixels$, bottom=$enter_text:Number of Bottom Pixels$, mode="$select:msg:Select Mode;repeat (Default)|repeat;mirror|mirror;fillmargins|fillmargins$", interlaced=0)

Borders | Letterbox =
    lb_l, lb_r, lb_t, lb_b = $enter_text:Number of Left Pixels$, $enter_text:Number of Right Pixels$, $enter_text:Number of Top Pixels$, $enter_text:Number of Bottom Pixels$
    clip = core.std.Crop(clip, left=lb_l, right=lb_r, top=lb_t, bottom=lb_b)
    clip = core.std.AddBorders(clip, left=lb_l, right=lb_r, top=lb_t, bottom=lb_b)

Cube = clip = core.timecube.Cube(clip, cube=r"$browse_file$")
Histogram = clip = muvsfunc.DisplayHistogram(clip)

SelectEvery =
    # SelectEvery(clip, cycle=, offsets=)
    # offsets is a single number, or a list of numbers, representing selected frames.
    # numbers in offsets should be a non-negative integer smaller than cycle.
    # Modify the following example:
    clip = core.std.SelectEvery(clip, cycle=5, offsets=[1, 2, 3, 4]) # only first frame in every cycle of 5 is removed.

UnSpec =
    clip = core.resize.Point(clip, matrix_in_s='unspec',range_s='limited')
    clip = core.std.AssumeFPS(clip, fpsnum=int(%source_mi_v:FrameRate% * 1000), fpsden=1000)
    clip = core.std.SetFrameProp(clip=clip, prop='_ColorRange', intval=1)

[Noise]
AddGrain = clip = core.grain.Add(clip, var=1.0, uvar=0.0, hcorr=0.0, vcorr=0.0, seed=-1, constant=False, opt=0)
BM3D = clip = mvsfunc.BM3D(clip, sigma=[3,3,3], radius1=0)

BM3DCUDA | BM3DCPU =
    clip = core.resize.Bicubic(clip, format=vs.YUV420PS)
    clip = core.bm3dcpu.BM3D(clip, ref=None, sigma=3.0, block_step=8, bm_range=9, radius=0, ps_num=2, ps_range=4, chroma=False, device_id=0, fast=False, extractor_exp=0)
    clip = core.resize.Bicubic(clip, format=vs.YUV420P10)

BM3DCUDA | BM3DCUDA =
    clip = core.resize.Bicubic(clip, format=vs.YUV420PS)
    clip = core.bm3dcuda.BM3D(clip, ref=None, sigma=3.0, block_step=8, bm_range=9, radius=0, ps_num=2, ps_range=4, chroma=False, device_id=0, fast=False, extractor_exp=0)
    clip = core.resize.Bicubic(clip, format=vs.YUV420P10)

BM3DCUDA | BM3DCUDA_RTC =
    clip = core.resize.Bicubic(clip, format=vs.YUV420PS)
    clip = core.bm3dcuda_rtc.BM3D(clip, ref=None, sigma=3.0, block_step=8, bm_range=9, radius=0, ps_num=2, ps_range=4, chroma=False, device_id=0, fast=False, extractor_exp=0)
    clip = core.resize.Bicubic(clip, format=vs.YUV420P10)

DegrainMedian = clip = core.dgm.DegrainMedian(clip=clip, interlaced=False)
DFTTest | DFTTest = clip = core.dfttest.DFTTest(clip, $select:msg:Select Strength;Light|sigma=6, tbsize=3, opt=3;Moderate|sigma=16, tbsize=5, opt=3;Strong|sigma=64, tbsize=1, opt=3$)
DFTTest | DFTTest2 = clip = dfttest2.DFTTest(clip, $select:msg:Select Strength;Light|sigma=6, tbsize=3;Moderate|sigma=16, tbsize=5;Strong|sigma=64, tbsize=1$, backend=dfttest2.Backend.$select:msg:Select the Backend;NVRTC|NVRTC;cuFFT|cuFFT;CPU|CPU;GCC|GCC$)
DFTTest | DFTTest Neo = clip = core.neo_dfttest.DFTTest(clip, ftype=0, sigma=2.0, planes=[0,1,2])
FFT3D Neo = clip = core.neo_fft3d.FFT3D(clip, sigma=2.0, bt=3, planes=[0,1,2])
HQDN3D = clip = core.hqdn3d.Hqdn3d(clip=clip)
KNLMeansCL = clip = core.knlm.KNLMeansCL(clip, d=1, a=1, h=$select:msg:Select Strength;Light|2;Medium|4;Strong|8$, device_type='auto')
mClean = clip = G41Fun.mClean(clip, thSAD=400, chroma=True, sharp=10, rn=14, deband=0, depth=0, strength=20)
MCTemporalDenoise = clip = havsfunc.MCTemporalDenoise(i=clip, settings='$select:msg:Select Strength;Very Low|very low;Low(Default)|low;Medium|medium;High|high;Very High|very high$')
MiniDeen = clip = core.neo_minideen.MiniDeen(clip, radius=[1,1,1], threshold=[10,12,12], planes=[0,1,2])
RemoveGrain | RemoveGrain = clip = core.rgvs.RemoveGrain(clip, 1)

RemoveGrain | RemoveGrain with Repair =
    Processed = core.rgvs.RemoveGrain(clip, 1)
    clip = core.rgvs.Repair(clip,Processed, mode=2)

SMDegrain | SMDegrain Hard Grain = clip = havsfunc.SMDegrain(clip, tr=4, thSAD=600, thSADC=300, prefilter=-1, contrasharp=True, RefineMotion=True)
SMDegrain | SMDegrain Normal Grain = clip = havsfunc.SMDegrain(clip, tr=2, thSAD=300, thSADC=150, prefilter=-1, contrasharp=True, RefineMotion=True)
SMDegrain | SMDegrain Light Grain = clip = havsfunc.SMDegrain(clip, tr=1, thSAD=300, thSADC=150, prefilter=-1, contrasharp=True, RefineMotion=True)
TemporalDegrain2 = clip = G41Fun.TemporalDegrain2(clip, degrainTR=2, postFFT=3, postSigma=3)
TTempSmooth = clip =  core.ttmpsm.TTempSmooth(clip)
VagueDenoiser = clip = core.vd.VagueDenoiser(clip=clip, method=$select:msg:Select Strength;Soft|1;Hard|0$)

[Resize]
Advanced | Hardware Encoder = # hardware encoder resizes
Advanced | NNEDI3_rpow2 = clip = nnedi3_rpow2.nnedi3_rpow2(clip, rfactor=$select:msg:Enlargement Factor?;2;4;8;16$, kernel="$select:msg:Center Shift Correction Algorithm?;bicubic;bilinear;blackman;box;gauss;lanczos;point;sinc;spline;spline16;spline36;spline64$", width=%target_width%, height=%target_height%)
Advanced | Placebo = clip = core.placebo.Resample(clip, %target_width%, %target_height%, filter = "$select:spline16;spline36;spline64;nearest;box;bilinear;gaussian;sinc;lanczos;ginseng;ewa_jinc;ewa_lanczos;ewa_lanczossharp;ewa_lanczos4sharpest;ewa_ginseng;ewa_hann;bicubic;hermite;catmull_rom;mitchell;mitchell_clamp;robidoux;robidouxsharp;ewa_robidoux;ewa_robidouxsharp;oversample$")
Advanced | ReSampleHQ = clip = resamplehq.resample_hq(clip, %target_width%, %target_height%, kernel='$select:Point;Linear;Cubic;Lanczos;Spline16;Spline36$')
Resize... = clip = $select:Bilinear|core.resize.Bilinear;Bicubic|core.resize.Bicubic;Point|core.resize.Point;Lanczos|core.resize.Lanczos;Spline16|core.resize.Spline16;Spline36|core.resize.Spline36;Spline64|core.resize.Spline64;Dither_Resize16|Dither.Resize16nr;Resample|core.fmtc.resample$(clip, %target_width%, %target_height%)

[Restoration]
Chroma Fix | Bifrost = clip = core.bifrost.Bifrost(clip, luma_thresh=10.0, variation=5, interlaced=$select:msg:Is the input video Interlaced?;Yes (Default)|True;No|False$, blockx=4, blocky=4)
Chroma Fix | CNR2 = clip = core.cnr2.Cnr2(clip, mode="oxx", scdthr=10.0, ln=35, lm=192, un=47, um=255, vn=47, vm=255, scenechroma=False)
Chroma Fix | DotKill | DotKillS = clip = core.dotkill.DotKillS(clip, iterations=1)

Chroma Fix | DotKill | DotKillZ =
    # 3:2 pulldown NTSC source, spatial
    clip = core.dotkill.DotKillZ(clip, order=0, offset=0)

Chroma Fix | DotKill | DotKillT =
    # 3:2 pulldown NTSC source, spatio-temporal
    clip = core.dotkill.DotKillT(clip, order=0, offset=0, dupthresh=64, tratio=3)

Chroma Fix | LUTDeRainbow = clip = havsfunc.LUTDeRainbow(clip, cthresh=10, ythresh=10, y=True, linkUV=True, mask=False)
DeBand | Legacy = $select:GradFun3|clip = muvsfunc.GradFun3(src=clip, mode=6, smode=1);f3kdb|clip = core.f3kdb.Deband(clip)$
DeBand | f3kdb Neo = clip = core.neo_f3kdb.Deband(clip, y=64, cb=64, cr=64, grainy=0, grainc=0)
DeBlock | Auto-Deblock = clip = fvsfunc.AutoDeblock(clip)
DeBlock | DeBlock = clip = core.deblock.Deblock(clip, quant=25, aoffset=0, boffset=0)
DeBlock | DeBlock PP7 = clip = core.pp7.DeblockPP7($select:msg:Select Strength;Medium|clip=clip, mode=2;Hard|clip=clip;Soft|clip=clip, mode=1$)
DeBlock | Deblock_QED = clip = havsfunc.Deblock_QED(clip)
DeBlock | MSmooth = clip = core.msmoosh.MSmooth(clip, threshold=3.0, strength=1)
DeComb | Vinverse = $select:Vinverse|clip = havsfunc.Vinverse(clip);Vinverse2|clip = havsfunc.Vinverse2(clip)$
DeDupe | FillDrops = clip = filldrops.FillDrops(clip, thresh=$enter_text:Enter the Luma Difference Threshold in decimal (Default: 0.1)$)
DeHalo | BlindDeHalo3 = clip = muvsfunc.BlindDeHalo3(clip, interlaced=False)
DeHalo | DeHaloAlpha = clip = havsfunc.DeHalo_alpha(clip)
DeHalo | EdgeCleaner = clip = havsfunc.EdgeCleaner(clip)
DeHalo | FineDehalo = clip = havsfunc.FineDehalo(clip)
DeHalo | HQDering = clip = havsfunc.HQDeringmod(clip, nrmode=2, darkthr=3.0)
DeHalo | MDeRing = clip = muvsfunc.mdering(clip)
DeHalo | YAHR = $select:YAHR|clip = havsfunc.YAHR(clip);YAHRmod|clip = muvsfunc.YAHRmod(clip)$
DeScratch | DeScratch = clip = core.descratch.DeScratch(clip, mindif=5, asym=10, maxgap=3, maxwidth=3, minlen=100, maxlen=2048, maxangle=5, blurlen=15, keep=100, border=2, modey=1, modeu=0, modev=0, mindifuv=0, mark=False, minwidth=1, left=0, right=%target_width%)

Fix Telecined Fades =
    clip = core.fmtc.bitdepth (clip, bits=32)
    clip = core.ftf.FixFades(clip)
    clip = core.fmtc.bitdepth (clip, bits=8)

[Flip]
Flip | Horizontal = clip = core.std.FlipHorizontal(clip)
Flip | Vertical = clip = core.std.FlipVertical(clip)

[Rotation]

Left =
    clip = core.std.FlipHorizontal(clip)
    clip = core.std.Transpose(clip)

Right =
    clip = core.std.FlipVertical(clip)
    clip = core.std.Transpose(clip)

Upside Down = clip = core.std.Turn180(clip)
