| nnedi3 for Avisynth v2.6.x | v0.9.2.3 (March 23, 2018) | by tritical | modified by Firesledge | modified by Elegant | modified by pinterf | | HELP FILE | ----------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------- INFO: eedi3 is an intra-field only deinterlacer. It takes in a frame, throws away one field, and then interpolates the missing pixels using only information from the kept field. It has same rate and double rate modes, and works with YV12, YUY2, and RGB24 input. nnedi3 is also very good for enlarging images by powers of 2, and includes a function 'nnedi3_rpow2' for that purpose. eedi3 works by finding the best non-decreasing (non-crossing) warping between two lines by minimizing a cost functional. The cost is based on neighborhood similarity (favor connecting regions that look similar), the vertical difference created by the interpolated values (favor small differences), the interpolation directions (favor short connections vs long), and the change in interpolation direction from pixel to pixel (favor small changes). *** Note: eedi3 is threaded using openmp, and is compiled with visual studio 2017. *** Therefore, it needs the visual studio 2017 redistributable package to be *** installed. *** https://www.visualstudio.com/downloads/ look for Microsoft Visual C++ Redistributable for Visual Studio 2017 FUNCTIONS: "eedi3", "c[field]i[dh]b[Y]b[U]b[V]b[alpha]f[beta]f[gamma]f[nrad]i[mdis]i[hp]b[ucubic]b[cost3]b[vcheck]i[vthresh0]f[vthresh1]f[vthresh2]f[sclip]c[threads]i[mclip]c[opt]i" "eedi3_rpow2", "c[rfactor]i[alpha]f[beta]f[gamma]f[nrad]i[mdis]i[hp]b[ucubic]b[cost3]b[vcheck]i[vthresh0]f[vthresh1]f[vthresh2]f[cshift]s[fwidth]i[fheight]i[ep0]f[ep1]f[threads]i[opt]i" PARAMETERS (eedi3): field - Controls the mode of operation (double vs same rate) and which field is kept. Possible settings: -2 = double rate (alternates each frame), uses avisynth's internal parity value to start -1 = same rate, uses avisynth's internal parity value 0 = same rate, keep bottom field 1 = same rate, keep top field 2 = double rate (alternates each frame), starts with bottom 3 = double rate (alternates each frame), starts with top If field is set to -1, then eedi3 calls child->GetParity(0) during initialization. If it returns true, then field is set to 1. If it returns false, then field is set to 0. If field is set to -2, then the same thing happens, but instead of setting field to 1 or 0 it is set to 3 or 2. Default: -1 (int) dh - Doubles the height of the input. Each line of the input is copied to every other line of the output and the missing lines are interpolated. If field=0, the input is copied to the odd lines of the output. If field=1, the input is copied to the even lines of the output. field must be set to either -1, 0, or 1 when using dh=true. Default: false (int) Y, U, V - These control whether or not the specified plane is processed. Set to true to process or false to ignore. Ignored planes are not copied, zero'd, or even considered. So what the ignored planes happen to contain on output is unpredictable. For RGB24 input Y=B, U=G, V=R. Default: Y = true (bool) U = true (bool) V = true (bool) alpha/beta/gamma (defaults: 0.2,0.25,20.0): These trade off line/edge connection vs artifacts created. alpha and beta must be in the range [0,1], and the sum alpha+beta must be in the range [0,1]. alpha is the weight given to connecting similar neighborhoods.. the larger it is the more lines/edges should be connected. beta is the weight given to vertical difference created by the interpolation... the larger beta is the less edges/lines will be connected (at 1.0 you get no edge directedness at all). The remaining weight (1.0-alpha-beta) is given to interpolation direction (large directions (away from vertical) cost more)... so the more weight you have here the more shorter connections will be favored. Finally, gamma penalizes changes in interpolation direction, the larger gamma is the smoother the interpolation field between two lines (range is [0,inf]. If lines aren't getting connected then increase alpha and maybe decrease beta/gamma. Go the other way if you are getting unwanted artifacts. nrad/mdis (defaults: 2,20): nrad sets the radius used for computing neighborhood similarity. Valid range is [0,3]. mdis sets the maximum connection radius. Valid range is [1,40]. If mdis=20, then when interpolating pixel (50,10) (x,y), the farthest connections allowed would be between (30,9)/(70,11) and (70,9)/(30,11). Larger mdis will allow connecting lines of smaller slope, but also increases the chance of artifacts. Larger mdis will be slower. Larger nrad will be slower. hp/ucubic/cost3 (defaults: false, true, true): These are speed vs quality options. hp=true, use half pel steps, hp=false, use full pel steps. ucubic=true, use cubic 4 point interpolation, ucubic=false, use 2 point linear interpolation. cost3=true, use 3 neighborhood cost function to define similarity, cost3=false, use 1 neighborhood cost function. vcheck/vthresh0/vthresh1/vthresh2/sclip (defaults: 2, 32.0, 64.0, 4.0, NULL): vcheck settings: 0 - no reliability check 1 - weak reliability check 2 - med reliability check 3 - strong reliability check If vcheck is greater than 0, then the resulting interpolation is checked for reliability/consistency. Assume we interpolated pixel 'fh' below using dir=4 (i.e. averaging pixels bl and cd). aa ab ac ad ae af ag ah ai aj ak al am an ao ap eh el ba bb bc bd be bf bg bh bi bj bk bl bm bn bo bp fd fh fl ca cb cc cd ce cf cg ch ci cj ck cl cm cn co cp gd gh da db dc dd de df dg dh di dj dk dl dm dn do dp When checking pixel 'fh' the following is computed: d0 = abs((el+fd)/2 - bh) d1 = abs((fl+gd)/2 - ch) q2 = abs(bh-fh)+abs(ch-fh) q3 = abs(el-bl)+abs(fl-bl) q4 = abs(fd-cd)+abs(gd-cd) d2 = abs(q2-q3) d3 = abs(q2-q4) mdiff0 = vcheck == 1 ? min(d0,d1) : vcheck == 2 ? ((d0+d1+1)>>1) : max(d0,d1) mdiff1 = vcheck == 1 ? min(d2,d3) : vcheck == 2 ? ((d2+d3+1)>>1) : max(d2,d3) a0 = mdiff0/vthresh0; a1 = mdiff1/vthresh1; a2 = max((vthresh2-abs(dir))/vthresh2,0.0f) a = min(max(max(a0,a1),a2),1.0f) final_value = (1.0-a)*fh + a*cint ** If sclip is supplied, cint is the corresponding value from sclip. If sclip isn't supplied, then vertical cubic interpolation is used to create it. mclip (default: not set) A mask to use edge-directed interpolation only on specified pixels. The clip should have the same format as the input clip. Pixels where the mask is 0 are generated using cubic linear or bicubic interpolation. The main goal of the mask is to save calculations. This parameter does not exist in eedi3_rpow2. opt (default: 0) Sets which cpu optimizations to use. Possible settings: 0 = auto detect 1 = use c 2 = use sse2 threads (default: 0): Sets the number of threads used by openmp. 0 = default (environment variable OMP_NUM_THREADS) > 0 = calls omp_set_num_threads(threads) PARAMETERS (eedi3_rpow2): rfactor - Image enlargement factor. Must be a power of 2 in the range [2,1024]. Default: not set (int) cshift - Sets the resizer used for correcting the image center shift that eedi3_rpow2 introduces. This can be any of Avisynth's internal resizers, such as "spline36resize", "lanczosresize", etc... If not specified the shift is not corrected. The correction is accomplished by using the subpixel cropping capability of Avisynth's internal resizers. Default: not set (string) fwidth/fheight - If correcting the image center shift by using the 'cshift' parameter, fwidth/fheight allow you to set a new output resolution. First, the image is enlarged by 'rfactor' using eedi3. Once that is completed the image center shift is corrected, and the image is resampled to fwidth x fheight resolution. The shifting and resampling happen in one call using the internal Avisynth resizer you specify via the 'cshift' string. If fwidth/fheight are not specified, then they are set equal to rfactor*width and rfactor*height respectively (in other words they do nothing). Default: not set (int) not set (int) ep0/ep1 - Some Avisynth resizers take optional arguments, such as 'taps' for lanczosresize or 'p' for gaussresize. ep0/ep1 allow you to pass values for these optional arguments when using the 'cshift' parameter. If the resizer only takes one optional argument then ep0 is used. If the argument that the resizer takes is not a float value, then ep0 gets rounded to an integer. If the resizer takes two optional arguments, then ep0 corresponds to the first one, and ep1 corresponds to the second. The only resizer that takes more than one optional argument is bicubicresize(), which takes 'b' and 'c'. So ep0 = b, and ep1 = c. If ep0/ep1 are not set then the default value for the optional argument(s) of the resizer is used. Default: not set (float) not set (float) alpha/beta/gamma/nrad/mdis/hp/ucubic/cost3/vcheck/vthresh0/vthresh1/vthresh2/threads/opt - Same as corresponding parameters in eedi3. eedi3_rpow2 EXAMPLES: a.) enlarge image by 4x, don't correct for center shift. eedi3_rpow2(rfactor=4) b.) enlarge image by 2x, correct for center shift using spline36resize. eedi3_rpow2(rfactor=2,cshift="spline36resize") c.) enlarge image by 8x, correct for center shift and downsample from 8x to 7x using lanczosresize with 5 taps. eedi3_rpow2(rfactor=8,cshift="lanczosresize",fwidth=width*7,fheight=height*7,ep0=5) CHANGE LIST: v0.9.2.3 - March 23, 2018 - Y8, Y16 and Y24 colorspaces as input: go live. v0.9.2.2 - March 23, 2018 - Moved to Visual Studio 2017 - Removed external asm files (integrated/replaced with intrinsics) - Update Avisynth headers - fix YUY2 x64 artifacts - https://github.com/pinterf/EEDI3 v0.9.2.1 - July 29th, 2015 - Switched to AVS 2.6 API - Added x64 support - Updated some variable types for clarity - Compiled with Visual Studio 2013 - https://github.com/Elegant996/EEDI3 v0.9.2 - November 11, 2013 - Added SSE2 optimizations for full-pel interpolation - Added mclip masking - Compiled with Visual Studio 2012 v0.9.1 - July 23, 2010 - fix field=0/1 flipped with rgb24 input - fix possible reading off the edge of a frame with cost3=true