//@param [[:varname]|varname] 'name' [defval minval maxval centval step] 

Since Reaper 5, Reaper has proper video-editing support. In addition to that, Reaper has a plugin, called "Video Processor Plugin", that is focused on video-effect handling.
Though it is still in it's very early stages, it supports already a handful of useful effects that can be selected via the presets-selection.
It is also programmable. It opens up a small IDE-window, as part of the "Video-Processor-Plugin"-UI, in which you can put Eel-code(no Lua or Python!), that processes the video.

Unlike with other scripts, the scripts for the video processor plugin do not support the standard-reaper-API-commands, but have an own set of variables and functions. The list of functions can be reached by clicking into the IDE-window of the "video processor plugin" and hitting the F1-key.

Some general notes on the video-processor-plugin:
It has a very limited set of programmable UI-elements, means, only a knob (refer the param-variable for more details) at the time.
The plugin has also sometimes the behaviour of "added effects". That means: If you have several tracks whith video items and you put a video processor plugin on every track as track-FX, they do not only influence the video-items in this track. In fact, they also influence the video-items on the other tracks as well. If you have 10 tracks and every track has a video-effect as track-FX that turns the brightness down by 10%, the resulting image will be a black one. All effects added up each other (10 times -10% brightness).
This effect can be circumvented by putting the video-processor-plugin as item-FX, NOT as track-FX.

To write code, load the Video Processor Plugin into item-FX of the video or track-FX of the track containing your video. It opens a editor window, in which you can write the code. Hit F1 for commands and variables valid for use in the video processor plugin.
Next to it, on the left side of the editor-field, your parameter-knobs will appear(if you've defined some).
Code for the Video-Processor-Plugin must be written in EEL, not in Lua or Python.
Example code, with a knob for turning the video on and off:
        

        // A small demo-script that turns video on&off
        //@amp;param1:VideoOnOff 'Video Off(0) On(1)' 1 0 1 0.5 1

        frame=input_track(0); // variable frame set with the videoframe from the first 
                              // videoitem in the project at a given position
  
        gfx_fillrect(0,0,project_w,project_h); // deletes last frame, by putting a black rectangle on top of it
                                               // to prevent from having the last frame(s) be shown indefinately

        //Now, put the picture to the framebuffer -> outputting the video
        gfx_blit(frame,  // the current video-frame
                    1,   // don't preserve aspect-ratio
                    0,0, // put upper right corner of the video at position 0,0
                    project_w*VideoOnOff,project_h*VideoOnOff // size of the video width, height, 
                                                              //   multiplied by the VideoOnOff-Parameter
                                                              //   1=video squeezed to 100% height & width 
                                                              //   0=video squeezed to 0% height & width
                    );
          

EEL2: project_time

project time in seconds

EEL2: project_tempo

current tempo in BPM

EEL2: project_ts_num

current time signature numerator

EEL2: project_ts_denom

current time signature denominator

EEL2: project_time_qn

current project position in QN

EEL2: time

item time in seconds (if in item)

EEL2: framerate

project FPS (30.0, 29.97, etc)

EEL2: project_w

project preferred video width (code can override this before drawing)

EEL2: project_h

project preferred video height (code can override this before drawing)

EEL2: project_wh_valid

set nonzero if project_w/project_h reflect actual project setting (otherwise could be media-defined)

EEL2: colorspace

current rendering colorspace, e.g. 'RGBA', 'YV12', or 'YUY2'.
You can override this before drawing (or between drawing).

This may be set to 0 initially if the user has the Auto project colorspace set.
It will be automatically changed if 0 and a drawing operation occurs or an input is successfully queried via input_info().

EEL2: param_wet

if in FX form, wet/dry mix of effect.

EEL2: param1..param24

Hold the values for the individual parameters, means param1 hold the value for parameter 1 .. param24 for parameter 24.

EEL2: gfx_r

current drawing color (red 0..1)

EEL2: gfx_g

current drawing color (green 0..1)

EEL2: gfx_b

current drawing color (blue 0..1)

EEL2: gfx_a

current drawing color (alpha 0..1)

EEL2: gfx_a2

current drawing color alpha channel value (RGB-only, 0..1, defaults to 1)

EEL2: gfx_mode

drawing mode

    0 = normal
    1 = additive
    3 = multiply (very different in YUV vs RGBA)
    17 = (dest + src*gfx_a)*.5 + .5 (only valid when using YUV colorspaces)
    18 = dest + (src-0.5)*gfx_a*2.0 (only valid when using YUV colorspaces)
    19 = absolute difference: abs(dest-src)*gfx_a (only valid when using YUV colorspaces)
    0x100 (flag ORed to above mode) for blit() to enable filtering (if possible)
    0x10000 (flag ORed to above mode) to use source alpha (only valid when using RGBA colorspace)
    0x40000 (flag ORed to above mode) to use extra clamping in normal mode (for out of range alpha/gradient values)
    0x80000 (flag ORed to above mode) to interpret gfx_r/gfx_g/gfx_b as YUV values (in YUV colorspaces)

EEL2: gfx_dest

destination image handle, or -1 for main framebuffer

EEL2: integer count_inputs = input_count()

Returns number of inputs available (total), range [0..n)

EEL2: integer count_tracks = input_track_count()

Returns the number of available inputs on discrete tracks

EEL2: integer input = input_track(integer track)

Returns input for bottommost item or FX on discrete-track track (0 is first track with video item above current, etc)

EEL2: nteger num_tracks = input_track_exact_count()

Returns the number of tracks above the current track that could possibly contain video items.

EEL2: integer inputs = input_track_exact(integer track)

Returns input for bottommost item or FX on track relative to current track.

Returns -1000 if track does not contain any video items at the current time, or -10000 if no further tracks contain video.

EEL2: integer next_input = input_next_item(integer input)

Returns the next_input after input which is on a different item or track

EEL2: integer next_input = input_next_track(integer input)

Returns the next_input after input which is on a different track.

EEL2: float fx_position = input_ismaster()

Returns 1.0 if current FX is on master chain, 2.0 if on monitoring FX chain

EEL2: integer retval = input_info(integer input, integer w, integer h[, double srctime, double wet, double parm1, ...])

Returns 1 if input is available, sets w/h to dimensions.

If srctime specified, it will be set with the source-local time of the underlying media.

If input is a video processor in effect form, automated parameters can be queried via wet/parm1/...

EEL2: integer retval = input_get_name(integer input, string #str)

Gets the input take name or track name. returns >0 on success

EEL2: integer image_index = gfx_img_alloc([optional integer w, optional integer h, optional integer clear])

Returns an image index for drawing (can create up to 32 images). Contents of image undefined unless clear set.

EEL2: integer image_handle = gfx_img_resize(integer handle, integer w, integer h[, optional integer clear])

Sets an image size (handle can be -1 for main framebuffer).

Contents of image undefined after resize, unless clear set.

Clear=-1 will only clear if resize occurred.

Returns the image handle (if handle is invalid, returns a newly-allocated image handle)

EEL2: gfx_img_hold(integer handle)

Retains (cheaply) a read-only copy of an image in handle.

This copy should be released using gfx_img_free() when finished. Up to 32 images can be held.

EEL2: integer unique_identifier = gfx_img_getptr(integer handle)

Gets a unique identifier for an image, valid for while the image is retained.

Can be used (along with gfx_img_hold) to detect when frames change in a low frame rate video

EEL2: gfx_img_free(integer handle)

Releases an earlier allocated image index.

EEL2: integer retval = gfx_img_info(integer handle, integer #w, integer #h)

Gets dimensions of image, returns 1 if valid (resize it if it's inexplicably invalidated)

EEL2: gfx_set(float r,[optional float g, optional float b, optional float a=1, integer mode=0, optional integer dest, optional float a2=1])

Updates r/g/b/a/mode to values specified, dest is only updated if parameter specified.

EEL2: integer retval = gfx_blit(integer input[, optional integer preserve_aspect=0, integer x, optional integer y, optional integer w, optional integer h, optional integer srcx, optional integer srcy, optional integer srcw, optional integer srch])

Draws input to framebuffer. preserve_aspect=-1 for no fill in pad areas

EEL2: integer retval = gfx_fillrect(integer x, integer y, integer w, integer h)

Fills a rectangle with the current color/mode/alpha set by gfx_set

EEL2: integer retval = gfx_procrect(integer x, integer y, integer w, integer h, table channel_tab[, optional integer mode])

Processes a rectangle with 768-entry channel table [256 items of 0..1 per channel].

Specify mode=1 to use Y value for U/V source channels (colorization mode).

EEL2: integer retval = gfx_evalrect(integer x, integer y, integer w, integer h, string code_string[, optional integer flags, optional integer src, optional string init_code_string, optional string src2])

Processes a rectangle with code_string being executed for every pixel/pixel-group.

Returns -1 if code_string failed to compile.

Code should reference per pixel values (0-255, unclamped), depending on colorspace:
    RGBA:  r/g/b/a (0-255, unclamped)
    YUY2: y1,y2, u, v (0-255, unclamped; u/v are centered at 128)
    YV12: y1-y4, u, v (0-255, unclamped; u/v are centered at 128)

example for a codestring:
    "r[0]+=1; g[256]+=1; b[512]+=1;
    (0.299*r + 0.587*g + 0.114*b)[768] += 1;"


Additional options:
    flags|=1 in order to prevent multiprocessing (if your routine needs  to process pixels in-order)
    flags|=2 to ignore output (analysis-only). This is only valid when not using src2 and not using one of the 4/8 modes.
    flags|=4,8 -- only valid in RGBA/YV12, and only if src/src2 not specified. flags&8 means process in vertical slices (top to bottom unless flags&4). flags&4 but not flags&8 means right-to-left. In each case y1-y4 are reordered for convenience (the same filter code can typically be used in various orientations).
    If init_code_string specified, it will be executed in each thread context before processing
    If src specified (and >= -1), sr/sg/sb/sa, sy1/su/sv etc will be available to read. In this case only the intersection of valid rectangles between src and the destination buffer will be processed.
    If src and src2 specified (and >= -1), s2r/s2g/s2b/s2a, s2y1/s2u/s2v etc will also be available to read.
    Note: variables _1-_99 are thread-local variables which will always be initialized to 0, and _0 will be initialized to the thread index (usually 0 or 1)

EEL2: integer retval = gfx_gradrect(integer x, integer y, integer w, integer h, float r, float g, float b, float a [, optional float drdx, optional float dgdx, optional float dbdx, optional float dadx, optional float drdy, optional float dgdy, optional float dbdy, optional float dady])

Fills rectangle. r/g/b/a supply color at top left corner, drdx (if specified) is amount red changes per X-pixel, etc.

EEL2: integer retval = gfx_rotoblit(integer srcidx, float angle [, optional integer x, optional integer y, optional integer w, optional integer h, optional integer srcx, optional integer srcy, optional integer w, optional integer h, optional integer cliptosrcrect, optional integer centxoffs, optional integer centyoffs])

Blits with rotate. This function behaves a bit odd when the source and destination sizes/aspect ratios differ, so gfx_deltablit() is generally more useful.

EEL2: integer retval = gfx_deltablit(integer srcidx, integer x, integer y, integer w, integer h, integer srcx, integer srcy, integer dsdx, integer dtdx, integer dsdy, integer dtdy, integer dsdxdy, integer dtdxdy[, optional integer dadx, optional integer dady, optional integer dadxdy])

Blits with source pixel transformation control.

S and T refer to source coordinates:
    dsdx is how much the source X position changes with each X destination pixel,
    dtdx is how much the source Y position changes with each X destination pixel, etc.
    
All of the S, T and A parameters accept negative values as well.

EEL2: integer retval = gfx_xformblit(integer srcidx, integer x, integer y, integer w, integer h, integer wdiv, integer hdiv, table tab[, optional integer wantalpha])

Blits with a transformation table.
tab is wdiv*hdiv*2 table of source point coordinates in float-values.

If wantalpha=1, tab is wdiv*hdiv*3 table of src points including alpha for each point.

EEL2: integer retval = gfx_keyedblit(integer input[, optional integer x, optional integer y, optional integer w, optional integer h, optional integer srcx, optional integer srcy, optional float kv1, optional float kv2, optional float kv3, optional float kv4])

Chroma-key blits, using the source color as key. kv1-kv4 meaning depends on colorspace:
    YV12/YUY2:
        kv1 is U target (-0.5 default)
        kv2 is V target (-0.5 default)
        kv3 is closeness-factor (0.4 default)
        kv4 is the gain (2.0 default)
    RGBA:
        kv1 is green-factor (1.0 default)
        kv2 is blue-factor (-1.0 default)
        kv3 is offset (-1.0 default)
        kv4 enables spill removal (1.0 default)

EEL2: integer retval = gfx_destkeyedblit(input input[, optional integer x, optional integer y, optional integer w, optional integer h, optional integer srcx, optional integer srcy, optional float kv1, optional float kv2, optional float kv3, optional float kv4])

Chroma-key blits, using destination color as key. ignores gfx_a and gfx_mode.

See gfx_keyedblit() for kv1-kv4 explanation.

EEL2: integer retval = gfx_setfont(integer pxsize[, optional string #fontname, optional integer flags)

Sets a font. flags are specified as a multibyte integer, using a combination of the following flags (specify multiple as 'BI' or 'OI' or 'OBI' etc):
    'B' - Bold
    'I' - Italics
    'R' - Blur
    'V' - Invert
    'M' - Mono
    'S' - Shadow
    'O' - Outline

EEL2: integer string_length = gfx_str_measure(string #string[, optional integer #w, optional integer #h])

Measures the size of #string, returns width

EEL2: integer retval = gfx_str_draw(string #string[, optional integer x, optional integer y, optional float fxc_r, optional float fxc_g, optional float fxc_b])

Draw string, fxc_r/g/b are the FX color if Shadow/Outline are set in the font

EEL2: integer retval = gfx_getpixel(integer input, integer x, integer y, integer #v1, integer #v2, integer #v3[, optional integer #v4])

Gets the value of a pixel from input at x,y.

v1/v2/v3 will be YUV or RGB (v4 can be used to get Alphavalue), returns 1 on success

EEL2: integer retval = rgb2yuv(float #r, float #g, float #b)

Converts r,g,b to YUV, does not clamp [0..1]

EEL2: integer retval = yuv2rgb(float #r, float #g, float #b)

Converts YUV to r,g,b, not clamping [0..1]

EEL2: integer retval = fft(table buffer, integer size)

Performs a FFT on the data in the local memory buffer at the offset specified by the first parameter.
The size of the FFT is specified by the second parameter, which must be a power of two 16-32768.
The outputs are permuted, so if you plan to use them in-order, call fft_permute(buffer, size) before and fft_ipermute(buffer,size) after in-order use.
Inputs or outputs will need to be scaled down by 1/size.
Notes:
    fft()/ifft() require real / imaginary input pairs, so a 256 point FFT actually works with 512 items.
    fft()/ifft() must NOT cross a 65,536 item boundary, so be sure to specify the offset accordingly.

EEL2: integer retval = ifft(table buffer, integer size)

Performs an inverse FFT. For more information see fft().

EEL2: integer retval = fft_real(table buffer, integer size)

Performs a real FFT, taking size input samples and producing size/2 complex output pairs. Usually used along with fft_permute(size/2).
Inputs/outputs will need to be scaled by 0.5/size. The first output complex pair will be (DC, nyquist).

EEL2: integer retval = ifft_real(table buffer, integer size)

Performs an inverse FFT, taking size/2 complex input pairs (the first being DC, nyquist) and producing size real output values.
Usually used along with fft_ipermute(size/2).

EEL2: integer retval = fft_permute(table buffer, integer size)

Permutes the output of fft() to have bands in-order.

EEL2: integer retval = fft_ipermute(buffer,size)

Permutes the input for ifft(), taking bands from in-order to the order ifft() requires. See fft() for more information.

EEL2: integer retval = convolve_c(table dest, table src, integer size)

Multiplies each of size complex pairs in dest by the complex pairs in src. Often used for convolution.

EEL2: gmem

gmem[] can be used for a shared memory buffer (similar to JSFX) --

you can specify a named buffer which can be shared with EEL2 ReaScripts and JSFX, by using:
    //@gmem=sharedBufferName
on a line by itself.

Note that when synchronizing with ReaScripts or JSFX, all processing is asynchronous, so your code will have to deal with
synchronization issues (including vast differences between project_time and playback_position, and including race conditions).

To get/set values from gmem, use gmem[index].
Example:
    variable=gmem[7]; // put the value from gmem with index 7 into variable
    gmem[8]=project_time; // put the current project_time into gmem with index 8

EEL2: integer retval = ui_get_state(integer #ctx[, optional integer #mouse_x, optional integer #mouse_y, optional integer force_frame_in, optional integer #mouse_wheel_state, optional integer #mouse_hwheel_state])

Gets UI state and context, only usable from Monitoring FX (returns 0 if used from track).
Returns state
   (1/2/4 are l/r/m mouse buttons,
    8/16/32 are ctrl/shift/alt,
    1024 is whether configuration for this processor is visible).
    
If 'ctx' set to -1, context is video window and any returned mouse coordinates are [0..1] (where 0,0 is upper left corner, 1,1 is lower right corner of the video area).
If 'ctx' is set to [1..24], it means the user is editing that knob.
If force_frame_in is specified and is positive, then the processor will be re-executed in this amount of time (even if no new video source is available), otherwise only updated during playback or change of the video.

EEL2: integer retval = time_precise([optional float #val])

Sets the parameter (or a temporary buffer if omitted) to a system-local timestamp in seconds, and returns a reference to that value.

The granularity of the value returned is system defined (but generally significantly smaller than one second).

EEL2: on_parameter_change(float pvar[, optional integer isdone])

Notifies that the parameter pointed to by pvar (must be param1..param24 or a user-defined parameter) has changed.

Specify isdone=1 when done modifying parameter (e.g. releasing touch)