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 the current track on and off(use this as track-fx!):

                                
//A small demo-script that turns video of the current track on and off
//@param 1:VideoOnOff 'Video Off(0) On(1)' 1 0 1 0.5 1

frame=1; // 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 and width 
                                                   //   0=video squeezed to 0% height and width
        );

The following code allows turning the video of the track above(!) the current track on/off and allows moving it and turning it on and off

// A small demo-script that turns video of the current track on and off
//@param 1:VideoOnOff 'Video Off(0) On(1)' 1 0 1 0.5 1
//@param 2:MoveX 'Move X' 0 0 2048 1024 1
//@param 3:MoveY 'Move Y' 0 0 2048 1024 1

frame=input_track(0); // variable frame set with the videoframe from the first 
                      // videoitem in the project at a given position above the current one
                                      
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+MoveX,0+MoveY,  // put upper right corner of the video at position 0,0
                           // and add the knob-value of MoveX and MoveY to the position
                           // so changing position is possible
                               
         project_w*VideoOnOff, project_h*VideoOnOff // size of the video width, height, 
                           //  multiplied by the VideoOnOff-Parameter
                           //  1=video squeezed to 100% height and width 
                           //  0=video squeezed to 0% height and width
        );

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.

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().

project FPS (30.0, 29.97, etc)

current drawing color (alpha 0..1)

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

current drawing color (blue 0..1)

destination image handle, or -1 for main framebuffer

current drawing color (green 0..1)

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)

current drawing color (red 0..1)

Manage the knobs of your video-processor-script.
param1 hold the value for parameter 1 .. param40 for parameter 40.

used as:

//@param X:ParameterVariableName "ParamShownName" default_value minimum_val maximum_val medium_value step_size

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

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

current tempo in BPM

project time in seconds

current project position in QN

project setting time offset in seconds

current time signature denominator

current time signature numerator

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

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

item time in seconds (if in item)

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

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.

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

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)

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). 6.70+: _slice is an alias of _0. _slices is a count of the multiprocessing slices, _span is the number of calls per line, and _slice_size is the size of each slice in lines (the last slice may vary in size).

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

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

Unlike other gfx-functions, the values returned by this function are of the range of 0-255, NOT 0-1!

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

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

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

Releases an earlier allocated image index.

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

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.

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

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)

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)

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).

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.

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

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

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

Measures the size of #string, returns width

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.

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

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

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/...

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

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

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

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

Returns the number of available inputs on discrete tracks

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.

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

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

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

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

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.

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

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

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).

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). For Lua ReaScripts, see the function Lua-ReaScript function gmem_attach(), gmem_write() and gmem_read().

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
    
Note: you can have only one gmem-buffername attached per video-processor-script.

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

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).

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

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

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).

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.