video-as-code: transitions and effects

Cross-fade: the first clip fades out as the second fades in.

transition: dissolve

The second clip is revealed following a grey shape (luma:), darkest parts first.

transition: wipe
luma: radial

The second clip grows from the centre over the first.

transition: affine
style: zoom

The second clip slides in from the right over the first.

transition: affine
style: slide

The second clip opens up as a growing circle.

transition: iris

The second clip turns in like a card flipping in 3D.

transition: flip

A short burst of digital glitches at the cut.

transition: glitch

A short burst of blocks of the picture lagging behind, at the cut.

transition: delaygrab

A short burst of a coloured gradient sweeping over the cut.

transition: cairogradient

Any transition of melt's, by its name, with its properties as given.

transition: melt/composite
transition_properties: {geometry: "0=50%/50%:0%x0%;-1=0/0:100%x100%"}

Both images break into large blocks that blend, then sharpen into the incoming image

transition: gl
gl: AdvancedMosaic

A wipe that sweeps around the center from a starting angle

transition: gl
gl: angular

The incoming image appears in small random blocks

transition: gl
gl: BlockDissolve

The outgoing image turns like a book page from right to left, revealing the incoming one

transition: gl
gl: BookFlip

The outgoing image drops out of the frame with a few bounces, revealing the incoming one

transition: gl
gl: Bounce

Two triangles grow from the left and right edges into a bow tie that reveals the incoming image

transition: gl
gl: BowTieHorizontal

Two triangles grow from the top and bottom edges into a bow tie that reveals the incoming image

transition: gl
gl: BowTieVertical

A bow-tie wipe with an adjustable shape that can run in reverse

transition: gl
gl: BowTieWithParameter

The outgoing image shrinks into a box, toward the center or a corner, revealing the incoming one

transition: gl
gl: Box

A crossfade that brightens toward a color in the middle

transition: gl
gl: burn

The outgoing image burns away in noisy, glowing patches

transition: gl
gl: burn0

Wavy, color-separated ripples scramble the outgoing image into the incoming one

transition: gl
gl: ButterflyWaveScrawler

A cannabis-leaf shape grows from the center to reveal the incoming image

transition: gl
gl: cannabisleaf

A chessboard pattern of squares reveals the incoming image

transition: gl
gl: chessboard

The outgoing image closes into a circle over a background color, then the incoming one opens from it

transition: gl
gl: circle

The outgoing image closes into a circle over a background color, then the incoming one opens from it

transition: gl
gl: CircleCrop

A soft-edged circle opens from the center to reveal the incoming image

transition: gl
gl: circleopen

A crossfade in which each color channel changes at a different time

transition: gl
gl: colorphase

Pixels switch to the incoming image in order of how close their colors are

transition: gl
gl: ColourDistance

A crossfade in which the colors of one image displace the other

transition: gl
gl: coord-from-in

The outgoing image is pulled along a parametric curve into a psychedelic swirl

transition: gl
gl: CrazyParametricFun

The incoming image appears through a crosshatch of lines spreading from the center

transition: gl
gl: crosshatch

The outgoing image zooms in while the incoming one zooms out into place, sweeping from right to left

transition: gl
gl: crosswarp

A crossfade through a strong zoom blur

transition: gl
gl: CrossZoom

The two images are faces of a rotating 3D cube, with a floor reflection

transition: gl
gl: cube

A crossfade through an out-of-focus blur

transition: gl
gl: DefocusBlur

The incoming image pushes the outgoing one out in a given direction

transition: gl
gl: Directional

Like Directional, with an eased movement

transition: gl
gl: directional-easing

Like Directional, with both images scaled down while they slide

transition: gl
gl: DirectionalScaled

A diagonal wipe with a warped, smeared edge

transition: gl
gl: directionalwarp

A soft-edged diagonal wipe

transition: gl
gl: directionalwipe

A crossfade in which a displacement map (an extra grayscale texture) warps both images

transition: gl
gl: displacement

The incoming image spreads over the outgoing one with a hot, glowing edge

transition: gl
gl: dissolve

The outgoing image melts down in uneven columns, like the Doom screen wipe

transition: gl
gl: DoomScreenTransition

The outgoing image opens like double doors as the incoming one comes forward, with a floor reflection

transition: gl
gl: doorway

A crossfade with a gentle wavy distortion

transition: gl
gl: Dreamy

Zooms and rotates into a bright flash, then out to the incoming image

transition: gl
gl: DreamyZoom

A flickering glitch with RGB offset, ghosting and scanlines that flashes back to the outgoing image

transition: gl
gl: Drop_Zone_Flicker

Both images fade through black with their edges glowing

transition: gl
gl: EdgeTransition

A linear crossfade between the two images

transition: gl
gl: fade

A fade through a solid color, black by default

transition: gl
gl: fadecolor

A crossfade through grayscale

transition: gl
gl: fadegrayscale

Glowing film-burn light leaks wash over the image and reveal the incoming one

transition: gl
gl: FilmBurn

The image breaks into a fly's-eye grid of lenses with color separation

transition: gl
gl: flyeye

The incoming image unfolds from the left while the outgoing one folds away to the right

transition: gl
gl: Fold

The outgoing image shatters into fragments that fly away

transition: gl
gl: fragment

Blocks of the image are displaced in a glitch that flashes into the incoming image

transition: gl
gl: GlitchDisplace

A crossfade with glitchy, color-shifted blocks

transition: gl
gl: GlitchMemories

The image splits into a grid of tiles that flip one by one to the incoming image

transition: gl
gl: GridFlip

A heart shape grows from the center to reveal the incoming image

transition: gl
gl: heart

Both images turn into hexagons, crossfade, then sharpen again

transition: gl
gl: hexagonalize

The incoming image closes in from the top and bottom edges toward the middle

transition: gl
gl: HorizontalClose

The incoming image opens from a line in the middle toward the top and bottom edges

transition: gl
gl: HorizontalOpen

A crossfade through the HSV color space that cycles through hues

transition: gl
gl: HSVfade

The outgoing image curls away like a page, revealing the incoming one

transition: gl
gl: InvertedPageCurl

A crossfade through a spinning kaleidoscope

transition: gl
gl: kaleidoscope

The outgoing image shrinks away to the left while the incoming one slides in from the right

transition: gl
gl: LeftRight

A crossfade through a blur

transition: gl
gl: LinearBlur

A wipe that follows the brightness of a grayscale mask (the luma texture)

transition: gl
gl: luma

The outgoing image melts away in noisy vertical streaks, depending on its brightness

transition: gl
gl: luminance_melt

A crossfade in which each image is displaced by the other's colors, like a morph

transition: gl
gl: morph

The view pans across a mosaic of rotated tiles from both images and settles on the incoming one

transition: gl
gl: Mosaic

Both images break into mosaic blocks that blend, then sharpen into the incoming image

transition: gl
gl: mosaic_transition

A crossfade through the multiplied blend of both images

transition: gl
gl: multiply_blend

A crossfade with drifting tracking lines and tearing, like a TV losing its signal

transition: gl
gl: old_tv_lost_signal

A crossfade through a washed-out, overexposed white

transition: gl
gl: Overexposure

A crossfade with glitchy horizontal bands and color shifts

transition: gl
gl: parametric_glitch

The incoming image appears through blobs of Perlin noise

transition: gl
gl: perlin

A spinning pinwheel reveals the incoming image

transition: gl
gl: pinwheel

Both images pixelate, crossfade, then sharpen again

transition: gl
gl: pixelize

A flower shape with several petals grows to reveal the incoming image

transition: gl
gl: polar_function

The incoming image appears through growing polka dots

transition: gl
gl: PolkaDotsCurtain

The image folds into an animated kaleidoscope before revealing the incoming one

transition: gl
gl: powerKaleido

The image splits into a grid of tiles that flip one by one to the incoming image

transition: gl
gl: PuzzleRight

A radial wipe that sweeps around the center like a clock hand

transition: gl
gl: Radial

The incoming image appears pixel by pixel in random noise

transition: gl
gl: randomNoisex

The incoming image appears in random squares

transition: gl
gl: randomsquares

A rectangle grows from the center to cover the outgoing image, then shrinks to reveal the incoming one

transition: gl
gl: Rectangle

The outgoing image shrinks into a small rectangle over a background color, then the incoming one grows from it

transition: gl
gl: RectangleCrop

The outgoing image swirls and zooms with motion blur into the incoming one

transition: gl
gl: Revolve_Left

Ripples spread from the center while crossfading

transition: gl
gl: ripple

The outgoing image rolls away around a corner, revealing the incoming one

transition: gl
gl: Rolls

The outgoing image spins and zooms while fading to the incoming one, over a background color

transition: gl
gl: rotate_scale_fade

The outgoing image spins and shrinks away over the incoming one

transition: gl
gl: RotateScaleVanish

The images spin around the center while crossfading

transition: gl
gl: rotateTransition

The incoming image scales in from the center while fading in

transition: gl
gl: scale-in

The outgoing image flips around the vertical axis into the incoming one

transition: gl
gl: SimpleFlip

Zooms into the outgoing image, then fades to the incoming one

transition: gl
gl: SimpleZoom

The incoming image zooms out into place while fading in

transition: gl
gl: SimpleZoomOut

The outgoing image slides out, or the incoming one slides in, toward an edge, a corner or the center

transition: gl
gl: Slides

The incoming image slides in as two halves moving horizontally in opposite directions

transition: gl
gl: splitSlideInHorizontal

The halves of both images slide horizontally in opposite directions, out and in at once

transition: gl
gl: splitSlideInOutHorizontal

The halves of both images slide vertically in opposite directions, out and in at once

transition: gl
gl: splitSlideInOutVertical

The incoming image slides in as two halves moving vertically in opposite directions

transition: gl
gl: splitSlideInVertical

The outgoing image slides out as two halves moving horizontally in opposite directions

transition: gl
gl: splitSlideOutHorizontal

The outgoing image slides out as two halves moving vertically in opposite directions

transition: gl
gl: splitSlideOutVertical

Squares grow along a diagonal sweep to reveal the incoming image

transition: gl
gl: squareswire

The outgoing image is squeezed into a line with color separation, revealing the incoming one

transition: gl
gl: squeeze

A growing star reveals the incoming image

transition: gl
gl: StarWipe

A wipe from top to bottom with a band of TV static at its edge

transition: gl
gl: static_wipe

Cuts to the incoming image halfway, hidden behind a burst of TV static

transition: gl
gl: StaticFade

Both images shrink into rounded cards that swap, like a stereo viewer toy

transition: gl
gl: StereoViewer

A datamosh glitch: torn strips, chroma shifts and scan noise drag the outgoing image into the incoming one

transition: gl
gl: StripDatamoshGlitch

The two images swap places in 3D, with a floor reflection

transition: gl
gl: swap

Both images swirl around the center while crossfading

transition: gl
gl: Swirl

The outgoing image is flung away along a curve with motion blur

transition: gl
gl: tangentMotionBlur

The incoming image is revealed tile by tile in a diagonal wave

transition: gl
gl: TilesWave

The outgoing image shrinks away upward while the incoming one slides in from the bottom

transition: gl
gl: TopBottom

Cuts to full-screen TV static, then to the incoming image

transition: gl
gl: TVStatic

A circle with a wavy edge burns out from the center to reveal the incoming image

transition: gl
gl: undulatingBurnOut

The incoming image closes in from the left and right edges toward the middle

transition: gl
gl: VerticalClose

The incoming image opens from a line in the middle toward the left and right edges

transition: gl
gl: VerticalOpen

Ripples spread from the center like a drop falling into water, crossfading to the incoming image

transition: gl
gl: WaterDrop

A ragged left-to-right wipe, as if the image was blown away by the wind

transition: gl
gl: wind

A crossfade through horizontal window blinds

transition: gl
gl: windowblinds

The incoming image appears through vertical slices that widen

transition: gl
gl: windowslice

A hard-edged wipe from top to bottom

transition: gl
gl: wipeDown

A hard-edged wipe from right to left

transition: gl
gl: wipeLeft

A hard-edged wipe from left to right

transition: gl
gl: wipeRight

A hard-edged wipe from bottom to top

transition: gl
gl: wipeUp

The outgoing image slides to the right, uncovering a crossfade to the incoming one

transition: gl
gl: x_axis_translation

Concentric rings of the outgoing image zoom at different speeds before revealing the incoming one

transition: gl
gl: ZoomInCircles

Zooms into the outgoing image until it blurs into a flat color, then out to the incoming one

transition: gl
gl: zoomInOut

Zooms into the outgoing image, then the incoming one wipes in from right to left

transition: gl
gl: ZoomLeftWipe

Zooms into the outgoing image, then the incoming one wipes in from left to right

transition: gl
gl: ZoomRigthWipe

Composite (*DEPRECATED*) - A key-framable alpha-channel compositor for two frames.

transition: melt/composite

addition - Perform an RGB[A] addition operation of the pixel sources.

transition: melt/frei0r.addition

addition_alpha - Perform an RGB[A] addition_alpha operation of the pixel sources.

transition: melt/frei0r.addition_alpha

Alpha Injection - Averages Input 1 and uses this as Alpha Channel on Input 2

transition: melt/frei0r.alphainjection

alphaout - the alpha OUT operation

transition: melt/frei0r.alphaout

alphaxor - the alpha XOR operation

transition: melt/frei0r.alphaxor

blend - Perform a blend operation between two sources

transition: melt/frei0r.blend

burn - Perform an RGB[A] dodge operation between the pixel sources, using the generalised algorithm: D = saturation of 255 or depletion of 0, of ((255 - A) * 256) / (B + 1)

transition: melt/frei0r.burn

At its defaults it changes nothing; shown with x scale: 0.75. - cairoaffineblend - Composites second input on first input applying user-defined transformation, opacity and blend mode

transition: melt/frei0r.cairoaffineblend
transition_properties: {"x scale": 0.75}

color_only - Perform a conversion to color only of the source input1 using the hue and saturation values of input2.

transition: melt/frei0r.color_only

darken - Perform a darken operation between two sources (minimum value of both sources).

transition: melt/frei0r.darken

difference - Perform an RGB[A] difference operation between the pixel sources.

transition: melt/frei0r.difference

divide - Perform an RGB[A] divide operation between the pixel sources: input1 is the numerator, input2 the denominator

transition: melt/frei0r.divide

dodge - Perform an RGB[A] dodge operation between the pixel sources, using the generalised algorithm: D = saturation of 255 or (A * 256) / (256 - B)

transition: melt/frei0r.dodge

grain_extract - Perform an RGB[A] grain-extract operation between the pixel sources.

transition: melt/frei0r.grain_extract

grain_merge - Perform an RGB[A] grain-merge operation between the pixel sources.

transition: melt/frei0r.grain_merge

hardlight - Perform an RGB[A] hardlight operation between the pixel sources

transition: melt/frei0r.hardlight

hue - Perform a conversion to hue only of the source input1 using the hue of input2.

transition: melt/frei0r.hue

lighten - Perform a lighten operation between two sources (maximum value of both sources).

transition: melt/frei0r.lighten

multiply - Perform an RGB[A] multiply operation between the pixel sources.

transition: melt/frei0r.multiply

overlay - Perform an RGB[A] overlay operation between the pixel sources, using the generalised algorithm: D = A * (B + (2 * B) * (255 - A))

transition: melt/frei0r.overlay

saturation - Perform a conversion to saturation only of the source input1 using the saturation level of input2.

transition: melt/frei0r.saturation

screen - Perform an RGB[A] screen operation between the pixel sources, using the generalised algorithm: D = 255 - (255 - A) * (255 - B)

transition: melt/frei0r.screen

At its defaults it changes nothing; shown with position: 0.75. - push-down - Push from top to bottom

transition: melt/frei0r.sleid0r_push-down
transition_properties: {"position": 0.75}

At its defaults it changes nothing; shown with position: 0.75. - push-left - Push from right to left

transition: melt/frei0r.sleid0r_push-left
transition_properties: {"position": 0.75}

At its defaults it changes nothing; shown with position: 0.75. - push-right - Push from left to right

transition: melt/frei0r.sleid0r_push-right
transition_properties: {"position": 0.75}

At its defaults it changes nothing; shown with position: 0.75. - push-up - Push from bottom to top

transition: melt/frei0r.sleid0r_push-up
transition_properties: {"position": 0.75}

At its defaults it changes nothing; shown with position: 0.75. - slide-down - Slide from top to bottom

transition: melt/frei0r.sleid0r_slide-down
transition_properties: {"position": 0.75}

At its defaults it changes nothing; shown with position: 0.75. - slide-left - Slide from right to left

transition: melt/frei0r.sleid0r_slide-left
transition_properties: {"position": 0.75}

At its defaults it changes nothing; shown with position: 0.75. - slide-right - Slide from left to right

transition: melt/frei0r.sleid0r_slide-right
transition_properties: {"position": 0.75}

At its defaults it changes nothing; shown with position: 0.75. - slide-up - Slide from bottom to top

transition: melt/frei0r.sleid0r_slide-up
transition_properties: {"position": 0.75}

At its defaults it changes nothing; shown with position: 0.75. - wipe-barn-door-h - Horizontal barn door wipe

transition: melt/frei0r.sleid0r_wipe-barn-door-h
transition_properties: {"position": 0.75}

At its defaults it changes nothing; shown with position: 0.75. - wipe-barn-door-v - Vertical barn door wipe

transition: melt/frei0r.sleid0r_wipe-barn-door-v
transition_properties: {"position": 0.75}

At its defaults it changes nothing; shown with position: 0.75. - wipe-circle - Circle wipe

transition: melt/frei0r.sleid0r_wipe-circle
transition_properties: {"position": 0.75}

At its defaults it changes nothing; shown with position: 0.75. - wipe-down - Wipe from top to bottom

transition: melt/frei0r.sleid0r_wipe-down
transition_properties: {"position": 0.75}

At its defaults it changes nothing; shown with position: 0.75. - wipe-left - Wipe from right to left

transition: melt/frei0r.sleid0r_wipe-left
transition_properties: {"position": 0.75}

At its defaults it changes nothing; shown with position: 0.75. - wipe-rect - Rectangular wipe

transition: melt/frei0r.sleid0r_wipe-rect
transition_properties: {"position": 0.75}

At its defaults it changes nothing; shown with position: 0.75. - wipe-right - Wipe from left to right

transition: melt/frei0r.sleid0r_wipe-right
transition_properties: {"position": 0.75}

At its defaults it changes nothing; shown with position: 0.75. - wipe-up - Wipe from bottom to top

transition: melt/frei0r.sleid0r_wipe-up
transition_properties: {"position": 0.75}

softlight - Perform an RGB[A] softlight operation between the pixel sources.

transition: melt/frei0r.softlight

subtract - Perform an RGB[A] subtract operation of the pixel source input2 from input1.

transition: melt/frei0r.subtract

UV Map - Uses Input 1 as UV Map to distort Input 2

transition: melt/frei0r.uvmap

value - Perform a conversion to value only of the source input1 using the value of input2.

transition: melt/frei0r.value

At its defaults it changes nothing; shown with fader: 0.75. - xfade0r - a simple xfader

transition: melt/frei0r.xfade0r
transition_properties: {"fader": 0.75}

Wipe - A generic dissolve and wipe transition processor. "luma" gets its name from how it uses a grayscale "map" file. As the luma value varies over time, a threshold filter is applied to the map to determine what parts of frame A vs. frame B to show. It reads PGM files up to 16 bits! Alternatively, it can use the first frame from any producer that outputs yuv, but it will be limited to the luma gamut of 220 values. This performs field-based rendering unless the A frame property "progressive" or "consumer_progressive" or the transition property "progressive" is set to 1.

transition: melt/luma

Replace the alpha channel of track A with the luma channel from track B.

transition: melt/matte

At its defaults it changes nothing; shown with compositing: 30. - Composite and transform - A transition allowing compositing and transform.

transition: melt/qtblend
transition_properties: {"compositing": 30}

Video Quality Measurement - This performs the PSNR and SSIM video quality measurements by comparing the B frames to the reference frame A. It outputs the numbers to stdout in space-delimited format for easy by another tool. The bottom half of the B frame is placed below the top half of the A frame for visual comparison.

transition: melt/vqm

Cuts margins off the picture and fills the frame with the rest.

crop: {left: 80, right: 80}

Picture-in-picture: the clip as a smaller picture over the track below.

position: [170, 20]
size: [130, 73]

Colour grading: shadows (lift), midtones (gamma) and highlights (gain).

color_grade: {lift: [0.06, 0.03, 0], gain: [1.15, 1.0, 0.8]}

Old film: flicker and uneven developing.

old_film: true

Specks of dust, as on an old print.

film_dust: true

Dust as small round dots.

film_dust: {style: dots, size: 4, count: 10}

Vertical scratches running down the film.

film_scratches: true

Film grain that changes every frame.

film_grain: {noise: 30}

Smooths out camera shake.

stabilize: true

Keeps a rectangle sharp and blurs the rest.

focus_rect: [30, 20, 40, 60]
focus_blur: 6

Makes a colour transparent (a green screen), showing the track below.

chroma_key: "#00ff00"

Text burned onto the clip; may show the timecode, the frame...

overlay_text: "#timecode#"
overlay_font_size: 24

Applies a colour look from a 3D LUT file (.cube...).

lut: looks/teal-orange.cube

Any of melt's filters, by name, with its properties as given.

melt:
  - frei0r.cartoon: {diffspace: 0.4}
  - avfilter.hue: {av.h: "0=0;74=180"}

An old CRT screen: a curved picture, scanlines, darker corners.

glsl: crt

Chromatic aberration: red and blue pulled apart toward the edges.

glsl: chromatic

The clip fades in from, and out to, what's below it (black if nothing).

fade_in: 1
fade_out: 1

Plays the clip faster (or slower, below 1).

speed: 3

Plays the clip backwards.

speed: -1

Changes speed during the clip: fast, then slow motion.

duration: 3
speed_ramp: [{at: 0, speed: 4}, {at: 1, speed: 0.5}]

Plays a stretch forward and then backward.

duration: 1.5
boomerang: true

Freezes the picture at a moment of the clip.

freeze_at: 1
freeze_after: true

Picture-in-picture that moves and resizes over time.

position_keyframes:
  - {at: 0, position: [0, 0], size: [320, 180]}
  - {at: 2, position: [180, 100], size: [128, 72]}

A slow pan and zoom from one part of the picture to another.

ken_burns_from: [0, 0, 100, 100]
ken_burns_to: [40, 30, 40, 40]

A colour grade that changes over time.

color_grade_keyframes:
  - {at: 0, gain: [1, 1, 1]}
  - {at: 2, gain: [0.6, 0.8, 1.3]}

The picture ripples, as seen through moving water.

glsl: wave

Bands of the picture jump sideways and split their colours, now and then.

glsl: glitch

The picture mirrored into segments around the centre, turning.

glsl: kaleidoscope

A worn videotape: colour bleeding sideways, a rolling bright band, noise, jitter.

glsl: vhs

Fits the whole picture in the frame, over a blurred copy of itself.

derive:
  fit: {size: [320, 180], background: blur}

Fits the whole picture in the frame, over black.

derive:
  fit: {size: [320, 180], background: black}

The picture as a rounded card with a shadow, over its blurred copy.

derive:
  fit: {size: [320, 180], background: blur, margin: 12, radius: 10, shadow: 0.45, dim: 0.2}

Soft edges: the picture fades out towards its borders.

derive:
  scale: [320, 180]
  feather: 24

Darkens the corners.

derive:
  vignette: 0.5

Turns the picture 90, 180 or 270 degrees.

derive:
  rotate: 90

Vintage home video wobble, bleed, and grain.

derive:
  openshot:
    - {effect: AnalogTape}

Add colored bars around your video.

derive:
  openshot:
    - {effect: Bars}

Adjust the blur of the frame's image.

derive:
  openshot:
    - {effect: Blur}

Adjust the brightness and contrast of the frame's image.

derive:
  openshot:
    - {effect: Brightness}

Replaces the color (or chroma) of the frame with transparency (i.e. keys out the color).

derive:
  openshot:
    - {effect: ChromaKey, color: "#00ff00"}

Adjust colors using 3D LUT lookup tables (.cube format)

derive:
  openshot:
    - {effect: ColorMap, lut_path: looks/teal-orange.cube}

Shift the colors of an image up, down, left, and right (with infinite wrapping).

derive:
  openshot:
    - {effect: ColorShift}

Crop out any part of your video.

derive:
  openshot:
    - {effect: Crop}

Remove interlacing from a video (i.e. even or odd horizontal lines)

derive:
  openshot:
    - {effect: Deinterlace}

Adjust the hue / color of the frame's image.

derive:
  openshot:
    - {effect: Hue}

Simulate sunlight hitting a lens with flares and spectral colors.

derive:
  openshot:
    - {effect: LensFlare}

Negates the colors, producing a negative of the image.

derive:
  openshot:
    - {effect: Negate}

Pixelate (increase or decrease) the number of visible pixels.

derive:
  openshot:
    - {effect: Pixelate}

Adjust the color saturation.

derive:
  openshot:
    - {effect: Saturation}

Boost edge contrast to make video details look crisper.

derive:
  openshot:
    - {effect: Sharpen}

Shift the image up, down, left, and right (with infinite wrapping).

derive:
  openshot:
    - {effect: Shift}

Flatten and reproject 360° or fisheye inputs into a rectilinear view with yaw, pitch, roll, and FOV. Supports Equirect and multiple fisheye lens models.

derive:
  openshot:
    - {effect: SphericalProjection}

Distort the frame's image into a wave pattern.

derive:
  openshot:
    - {effect: Wave}

Random signal having equal intensity at different frequencies.

derive:
  openshot:
    - {effect: Noise}

Adjust the synchronism between the audio and video track.

derive:
  openshot:
    - {effect: Delay}

Reflection of sound with a delay after the direct sound.

derive:
  openshot:
    - {effect: Echo}

Alter the audio by clipping the signal.

derive:
  openshot:
    - {effect: Distortion}

Filter that allows you to adjust the volume level of a frequency in the audio track.

derive:
  openshot:
    - {effect: ParametricEQ}

Reduce the volume of loud sounds or amplify quiet sounds.

derive:
  openshot:
    - {effect: Compressor}

Louder parts of audio becomes relatively louder and quieter parts becomes quieter.

derive:
  openshot:
    - {effect: Expander}

Transform the voice present in an audio track into a robotic voice effect.

derive:
  openshot:
    - {effect: Robotization}

Transform the voice present in an audio track into a whispering voice effect.

derive:
  openshot:
    - {effect: Whisperization}

A text card made by the tool, over the clips below: any installed font (font:), its weight (font_weight:), a drop shadow (shadow:).

type: title
text: "Hello"
font: "DejaVu Serif"
font_size: 44
font_weight: bold
shadow: true

A Lottie animation (LottieFiles', or Telegram's .tgs) in the bin like any clip: it plays with its transparency over the tracks below.

bin:
  - {id: ball, path: ball.json}   # .json or .tgs

A title in italics (italic:), with an outline round each letter (outline:, outline_color:).

type: title
text: "Hello"
font: "Noto Serif"
font_size: 44
italic: true
outline: 2
outline_color: [180, 30, 30, 255]

melt:
  - BurningTV

Transform

melt:
  - affine

Audio Waveform (*DEPRECATED*) - Generate audio waveforms.

melt:
  - audiowave

amplify - Amplify changes between successive video frames.

melt:
  - avfilter.amplify

atadenoise - Apply an Adaptive Temporal Averaging Denoiser.

melt:
  - avfilter.atadenoise

At its defaults it changes nothing; shown with av.sizeX: 768. - avgblur - Apply Average Blur filter.

melt:
  - avfilter.avgblur: {"av.sizeX": 768}

At its defaults it changes nothing; shown with av.sigmaS: 384.0. - bilateral - Apply Bilateral filter.

melt:
  - avfilter.bilateral: {"av.sigmaS": 384.0}

boxblur - Blur the input.

melt:
  - avfilter.boxblur

bwdif - Deinterlace the input image.

melt:
  - avfilter.bwdif

chromahold - Turns a certain color range into gray.

melt:
  - avfilter.chromahold

At its defaults it changes nothing; shown with av.thres: 150.25. - chromanr - Reduce chrominance noise.

melt:
  - avfilter.chromanr: {"av.thres": 150.25}

At its defaults it changes nothing; shown with av.cbh: 128. - chromashift - Shift chroma.

melt:
  - avfilter.chromashift: {"av.cbh": 128}

At its defaults it changes nothing; shown with av.rs: 0.5. - colorbalance - Adjust the color balance.

melt:
  - avfilter.colorbalance: {"av.rs": 0.5}

At its defaults it changes nothing; shown with av.rr: -1.0. - colorchannelmixer - Adjust colors by mixing color channels.

melt:
  - avfilter.colorchannelmixer: {"av.rr": -1.0}

At its defaults it changes nothing; shown with av.rl: 0.5. - colorcorrect - Adjust color white balance selectively for blacks and whites.

melt:
  - avfilter.colorcorrect: {"av.rl": 0.5}

colorhold - Turns a certain color range into gray. Operates on RGB colors.

melt:
  - avfilter.colorhold

colorize - Overlay a solid color on the video stream.

melt:
  - avfilter.colorize

At its defaults it changes nothing; shown with av.rimin: 0.5. - colorlevels - Adjust the color levels.

melt:
  - avfilter.colorlevels: {"av.rimin": 0.5}

At its defaults it changes nothing; shown with av.temperature: 30250.0. - colortemperature - Adjust color temperature of video.

melt:
  - avfilter.colortemperature: {"av.temperature": 30250.0}

At its defaults it changes nothing; shown with av.0rdiv: 1610610000.0. - convolution - Apply convolution filter.

melt:
  - avfilter.convolution: {"av.0rdiv": 1610610000.0}

dblur - Apply Directional Blur filter.

melt:
  - avfilter.dblur

At its defaults it changes nothing; shown with av.sigma: 749.25. - dctdnoiz - Denoise frames using 2D DCT.

melt:
  - avfilter.dctdnoiz: {"av.sigma": 749.25}

dedot - Reduce cross-luminance and cross-color.

melt:
  - avfilter.dedot

deflate - Apply deflate effect.

melt:
  - avfilter.deflate

deflicker - Remove temporal frame luminance variations.

melt:
  - avfilter.deflicker

despill - Despill video.

melt:
  - avfilter.despill

dilation - Apply dilation effect.

melt:
  - avfilter.dilation

doubleweave - Weave input video fields into double number of frames.

melt:
  - avfilter.doubleweave

drawbox - Draw a colored box on the input video.

melt:
  - avfilter.drawbox

drawgraph - Draw a graph using input video metadata.

melt:
  - avfilter.drawgraph

drawgrid - Draw a colored grid on the input video.

melt:
  - avfilter.drawgrid

edgedetect - Detect and draw edge.

melt:
  - avfilter.edgedetect

erosion - Apply erosion effect.

melt:
  - avfilter.erosion

estdif - Apply Edge Slope Tracing deinterlace.

melt:
  - avfilter.estdif

At its defaults it changes nothing; shown with av.exposure: 1.5. - exposure - Adjust exposure of the video stream.

melt:
  - avfilter.exposure: {"av.exposure": 1.5}

At its defaults it changes nothing; shown with av.dc_Y: 750. - fftfilt - Apply arbitrary expressions to pixels in frequency domain.

melt:
  - avfilter.fftfilt: {"av.dc_Y": 750}

field - Extract a field from the input video.

melt:
  - avfilter.field

At its defaults it changes nothing; shown with av.qp: 48. - fspp - Apply Fast Simple Post-processing filter.

melt:
  - avfilter.fspp: {"av.qp": 48}

At its defaults it changes nothing; shown with av.sigma: 256.0. - gblur - Apply Gaussian Blur filter.

melt:
  - avfilter.gblur: {"av.sigma": 256.0}

At its defaults it changes nothing; shown with av.strength: 48.127. - gradfun - Debands video quickly using gradients.

melt:
  - avfilter.gradfun: {"av.strength": 48.127}

grayworld - Adjust white balance using LAB gray world algorithm

melt:
  - avfilter.grayworld

greyedge - Estimates scene illumination by grey edge assumption.

melt:
  - avfilter.greyedge

hflip - Horizontally flip the input video.

melt:
  - avfilter.hflip

histeq - Apply global color histogram equalization.

melt:
  - avfilter.histeq

hsvhold - Turns a certain HSV range into gray.

melt:
  - avfilter.hsvhold

At its defaults it changes nothing; shown with av.hue: 90.0. - huesaturation - Apply hue-saturation-intensity adjustments.

melt:
  - avfilter.huesaturation: {"av.hue": 90.0}

inflate - Apply inflate effect.

melt:
  - avfilter.inflate

kerndeint - Apply kernel deinterlacing to the input.

melt:
  - avfilter.kerndeint

kirsch - Apply kirsch operator.

melt:
  - avfilter.kirsch

lagfun - Slowly update darker pixels.

melt:
  - avfilter.lagfun

At its defaults it changes nothing; shown with av.k1: 0.5. - lenscorrection - Rectify the image by correcting for lens distortion.

melt:
  - avfilter.lenscorrection: {"av.k1": 0.5}

At its defaults it changes nothing; shown with av.min: 49151. - limiter - Limit pixels components to the specified range.

melt:
  - avfilter.limiter: {"av.min": 49151}

maskfun - Create Mask.

melt:
  - avfilter.maskfun

mcdeint - Apply motion compensating deinterlacing.

melt:
  - avfilter.mcdeint

At its defaults it changes nothing; shown with av.radius: 96. - median - Apply Median filter.

melt:
  - avfilter.median: {"av.radius": 96}

monochrome - Convert video to gray using custom color filter.

melt:
  - avfilter.monochrome

negate - Negate input video.

melt:
  - avfilter.negate

At its defaults it changes nothing; shown with av.s: 22.75. - nlmeans - Non-local means denoiser.

melt:
  - avfilter.nlmeans: {"av.s": 22.75}

At its defaults it changes nothing; shown with av.all_strength: 75. - noise - Add noise.

melt:
  - avfilter.noise: {"av.all_strength": 75}

Didn't finish in 180 s

owdenoise - Denoise using wavelets.

melt:
  - avfilter.owdenoise

pixelize - Pixelize video.

melt:
  - avfilter.pixelize

pp7 - Apply Postprocessing 7 filter.

melt:
  - avfilter.pp7

prewitt - Apply prewitt operator.

melt:
  - avfilter.prewitt

pseudocolor - Make pseudocolored video frames.

melt:
  - avfilter.pseudocolor

random - Return random frames.

melt:
  - avfilter.random

At its defaults it changes nothing; shown with av.rh: 128. - rgbashift - Shift RGBA.

melt:
  - avfilter.rgbashift: {"av.rh": 128}

roberts - Apply roberts cross operator.

melt:
  - avfilter.roberts

scharr - Apply scharr operator.

melt:
  - avfilter.scharr

At its defaults it changes nothing; shown with av.vertical: 0.5. - scroll - Scroll input video.

melt:
  - avfilter.scroll: {"av.vertical": 0.5}

shear - Shear transform the input image.

melt:
  - avfilter.shear

shufflepixels - Shuffle video pixels.

melt:
  - avfilter.shufflepixels

At its defaults it changes nothing; shown with av.map0: 2. - shuffleplanes - Shuffle video planes.

melt:
  - avfilter.shuffleplanes: {"av.map0": 2}

At its defaults it changes nothing; shown with av.luma_radius: 3.775. - smartblur - Blur the input video without impacting the outlines.

melt:
  - avfilter.smartblur: {"av.luma_radius": 3.775}

sobel - Apply sobel operator.

melt:
  - avfilter.sobel

At its defaults it changes nothing; shown with av.qp: 47. - spp - Apply a simple post processing filter.

melt:
  - avfilter.spp: {"av.qp": 47}

stereo3d - Convert video stereoscopic 3D view.

melt:
  - avfilter.stereo3d

swaprect - Swap 2 rectangular objects in video.

melt:
  - avfilter.swaprect

swapuv - Swap U and V components.

melt:
  - avfilter.swapuv

At its defaults it changes nothing; shown with av.all_opacity: 0.25. - tblend - Blend successive frames.

melt:
  - avfilter.tblend: {"av.all_opacity": 0.25}

tmedian - Pick median pixels from successive frames.

melt:
  - avfilter.tmedian

tmidequalizer - Apply Temporal Midway Equalization.

melt:
  - avfilter.tmidequalizer

tmix - Mix successive video frames.

melt:
  - avfilter.tmix

tonemap - Conversion to/from different dynamic ranges.

melt:
  - avfilter.tonemap

transpose - Transpose input video.

melt:
  - avfilter.transpose

At its defaults it changes nothing; shown with av.luma_amount: 3.25. - unsharp - Sharpen or blur the input video.

melt:
  - avfilter.unsharp: {"av.luma_amount": 3.25}

untile - Untile a frame into a sequence of frames.

melt:
  - avfilter.untile

At its defaults it changes nothing; shown with av.qp: 47. - uspp - Apply Ultra Simple / Slow Post-processing filter.

melt:
  - avfilter.uspp: {"av.qp": 47}

v360 - Convert 360 projection of video.

melt:
  - avfilter.v360

At its defaults it changes nothing; shown with av.threshold: 1.3482675e+308. - vaguedenoiser - Apply a Wavelet based Denoiser.

melt:
  - avfilter.vaguedenoiser: {"av.threshold": 1.3482675e+308}

vflip - Flip the input video vertically.

melt:
  - avfilter.vflip

At its defaults it changes nothing; shown with av.intensity: 1.0. - vibrance - Boost or alter saturation.

melt:
  - avfilter.vibrance: {"av.intensity": 1.0}

vignette - Make or reverse a vignette effect.

melt:
  - avfilter.vignette

w3fdif - Apply Martin Weston three field deinterlace.

melt:
  - avfilter.w3fdif

weave - Weave input video fields into frames.

melt:
  - avfilter.weave

yadif - Deinterlace the input image.

melt:
  - avfilter.yadif

zoompan - Apply Zoom & Pan effect.

melt:
  - avfilter.zoompan

Box Blur (*DEPRECATED*)

melt:
  - boxblur

At its defaults it changes nothing; shown with start: 11.25. - Adjust the brightness and opacity of the image.

melt:
  - brightness: {"start": 11.25}

melt:
  - burningtv

melt:
  - charcoal

Chroma Key

melt:
  - chroma

Chroma Hold

melt:
  - chroma_hold

At its defaults it changes nothing; shown with stepsize: 75. - Vid.Stab Deshake - Stabilize Video (for wiggly/rolling video)

melt:
  - deshake: {"stepsize": 75}

Drop Shadow - Create a shadow effect from the alpha channel.

melt:
  - dropshadow

At its defaults it changes nothing; shown with maxdiameter: 75. - Add dust and specks to the Video, as in old movies

melt:
  - dust: {"maxdiameter": 75}

Dynamic text - Overlay dynamic text onto the video

melt:
  - dynamictext

Freeze frame

melt:
  - freeze

3dflippo - Frame rotation in 3d-space

melt:
  - frei0r.3dflippo

B - Extracts Blue from Image

melt:
  - frei0r.B

G - Extracts Green from Image

melt:
  - frei0r.G

IIR blur - Three types of fast IIR blurring

melt:
  - frei0r.IIRblur

R - Extracts Red from Image

melt:
  - frei0r.R

aech0r - analog video echo

melt:
  - frei0r.aech0r

alpha0ps - Display and manipulation of the alpha channel

melt:
  - frei0r.alpha0ps

alpha0ps - Display and manipulation of the alpha channel

melt:
  - frei0r.alpha0ps_alpha0ps

alphagrad - Fills alpha channel with a gradient

melt:
  - frei0r.alpha0ps_alphagrad

alphaspot - Draws simple shapes into the alpha channel

melt:
  - frei0r.alpha0ps_alphaspot

alphagrad - Fills alpha channel with a gradient

melt:
  - frei0r.alphagrad

alphaspot - Draws simple shapes into the alpha channel

melt:
  - frei0r.alphaspot

White Balance - Adjust the white balance / color temperature

melt:
  - frei0r.balanc0r

Baltan - delayed alpha smoothed blit of time

melt:
  - frei0r.baltan

BgSubtract0r - Bluescreen the background of a static video.

melt:
  - frei0r.bgsubtract0r

bluescreen0r - Color to alpha (blit SRCALPHA)

melt:
  - frei0r.bluescreen0r

Brightness - Adjusts the brightness of a source image

melt:
  - frei0r.brightness

bw0r - Turns image black/white.

melt:
  - frei0r.bw0r

c0rners - Four corners geometry engine

melt:
  - frei0r.c0rners

cairogradient - Draws a gradient on top of image. Filter is given gradient start and end points, colors and opacities.

melt:
  - frei0r.cairogradient

cairoimagegrid - Draws a grid of input images.

melt:
  - frei0r.cairoimagegrid

Cartoon - Cartoonify video, do a form of edge detect

melt:
  - frei0r.cartoon

K-Means Clustering - Clusters of a source image by color and spatial distance

melt:
  - frei0r.cluster

White Balance (LMS space) - Do simple color correction, in a physically meaningful way

melt:
  - frei0r.colgate

coloradj_RGB - Simple color adjustment

melt:
  - frei0r.coloradj_RGB

Color Distance - Calculates the distance between the selected color and the current pixel and uses that value as new pixel value

melt:
  - frei0r.colordistance

colorhalftone - Filters image to resemble a halftone print in which tones are represented as variable sized dots

melt:
  - frei0r.colorhalftone

colorize - Colorizes image to selected hue, saturation and lightness

melt:
  - frei0r.colorize

colortap - Applies a pre-made color effect to image

melt:
  - frei0r.colortap

Contrast0r - Adjusts the contrast of a source image

melt:
  - frei0r.contrast0r

Curves - Adjust luminance or color channel intensity with curve level mapping

melt:
  - frei0r.curves

Nikon D90 Stairstepping fix - Removes the Stairstepping from Nikon D90 videos (720p only) by interpolation

melt:
  - frei0r.d90stairsteppingfix

Defish0r - Non rectilinear lens mappings

melt:
  - frei0r.defish0r

delay0r - video delay

melt:
  - frei0r.delay0r

Delaygrab - delayed frame blitting mapped on a time bitmap

melt:
  - frei0r.delaygrab

hqdn3d - High quality 3D denoiser from Mplayer

melt:
  - frei0r.denoise_hqdn3d

Distort0r - Plasma

melt:
  - frei0r.distort0r

dither - Dithers the image and reduces the number of available colors

melt:
  - frei0r.dither

Edgeglow - Edgeglow filter

melt:
  - frei0r.edgeglow

Elastic scale filter - This is a frei0r filter which allows one to scale video footage non-linearly.

melt:
  - frei0r.elastic_scale

emboss - Creates embossed relief image of source image

melt:
  - frei0r.emboss

Equaliz0r - Equalizes the intensity histograms

melt:
  - frei0r.equaliz0r

FaceBl0r - automatic face blur

melt:
  - frei0r.facebl0r

Film Grain - Adds film-like grain and softens the picture.

melt:
  - frei0r.filmgrain

Flippo - Flipping in x and y axis

melt:
  - frei0r.flippo

Gamma - Adjusts the gamma value of a source image

melt:
  - frei0r.gamma

Gate Weave - Randomly moves frame around to simulate film gate weave.

melt:
  - frei0r.gateweave

glfilter - A GLSL effect on a clip, run on the GPU

melt:
  - frei0r.glfilter

Glitch0r - Adds glitches and block shifting

melt:
  - frei0r.glitch0r

Glow - Creates a Glamorous Glow

melt:
  - frei0r.glow

heatmap0r - Performs a continuous trichromatic tinting

melt:
  - frei0r.heatmap0r

hqdn3d - High quality 3D denoiser from Mplayer

melt:
  - frei0r.hqdn3d

Hueshift0r - Shifts the hue of a source image

melt:
  - frei0r.hueshift0r

Invert0r - Inverts all colors of a source image

melt:
  - frei0r.invert0r

Kaleid0sc0pe - Applies a kaleid0sc0pe effect

melt:
  - frei0r.kaleid0sc0pe

keyspillm0pup - Reduces the visibility of key color spill in chroma keying

melt:
  - frei0r.keyspillm0pup

Lens Correction - Allows compensation of lens distortion

melt:
  - frei0r.lenscorrection

LetterB0xed - Adds Black Borders at top and bottom for Cinema Look

melt:
  - frei0r.letterb0xed

Levels - Adjust luminance or color channel intensity

melt:
  - frei0r.levels

Light Graffiti - Creates light graffitis from a video by keeping the brightest spots.

melt:
  - frei0r.lightgraffiti

Luminance - Creates a luminance map of the image

melt:
  - frei0r.luminance

Mask0Mate - Creates an square alpha-channel mask

melt:
  - frei0r.mask0mate

Medians - Implements several median-type filters

melt:
  - frei0r.medians

Mirr0r - Repeats and flips the input image when it goes out of bounds, allowing for adjustable offset, zoom and rotation. A versatile tool for creative video effects.

melt:
  - frei0r.mirr0r

NDVI filter - This filter creates a false image from a visible + infrared source.

melt:
  - frei0r.ndvi

Nervous - flushes frames in time in a nervous way

melt:
  - frei0r.nervous

Normaliz0r - Normalize (aka histogram stretch, contrast stretch)

melt:
  - frei0r.normaliz0r

nosync0r - broken tv

melt:
  - frei0r.nosync0r

NTSC - Simulates NTSC analog video.

melt:
  - frei0r.ntsc

pixeliz0r - Pixelize input image.

melt:
  - frei0r.pixeliz0r

pixs0r - Glitch image shifting rows to and fro

melt:
  - frei0r.pixs0r

posterize - Posterizes image by reducing the number of colors used in image

melt:
  - frei0r.posterize

Premultiply or Unpremultiply - Multiply (or divide) each color component by the pixel's alpha value

melt:
  - frei0r.premultiply

primaries - Reduce image to primary colors

melt:
  - frei0r.primaries

rgbnoise - Adds RGB noise to image.

melt:
  - frei0r.rgbnoise

rgbsplit0r - RGB splitting and shifting

melt:
  - frei0r.rgbsplit0r

Saturat0r - Adjusts the saturation of a source image

melt:
  - frei0r.saturat0r

Scale0Tilt - Scales, Tilts and Crops an Image

melt:
  - frei0r.scale0tilt

scanline0r - interlaced dark lines

melt:
  - frei0r.scanline0r

select0r - Color based alpha selection

melt:
  - frei0r.select0r

Sharpness - Unsharp masking (port from Mplayer)

melt:
  - frei0r.sharpness

sigmoidaltransfer - Desaturates image and creates a particular look that could be called Stamp, Newspaper or Photocopy

melt:
  - frei0r.sigmoidaltransfer

Sobel - Sobel filter

melt:
  - frei0r.sobel

softglow - Does softglow effect on highlights

melt:
  - frei0r.softglow

SOP/Sat - Slope/Offset/Power and Saturation color corrections according to the ASC CDL (Color Decision List)

melt:
  - frei0r.sopsat

spillsupress - Remove green or blue spill light from subjects shot in front of green or blue screen

melt:
  - frei0r.spillsupress

Squareblur - Variable-size square blur

melt:
  - frei0r.squareblur

TehRoxx0r - Something videowall-ish

melt:
  - frei0r.tehRoxx0r

TehRoxx0r - Something videowall-ish

melt:
  - frei0r.tehroxx0r

3 point color balance - Adjust color balance with 3 color points

melt:
  - frei0r.three_point_balance

threelay0r - dynamic 3 level thresholding

melt:
  - frei0r.threelay0r

Threshold0r - Thresholds a source image

melt:
  - frei0r.threshold0r

Timeout indicator - Timeout indicators e.g. for slides.

melt:
  - frei0r.timeout

Tint0r - Tint a source image with specified colors

melt:
  - frei0r.tint0r

Transparency - Tunes the alpha channel.

melt:
  - frei0r.transparency

Twolay0r - dynamic thresholding

melt:
  - frei0r.twolay0r

Vertigo - alpha blending with zoomed and rotated images

melt:
  - frei0r.vertigo

Vignette - Lens vignetting effect, applies natural vignetting

melt:
  - frei0r.vignette

melt:
  - glsl.manager

GPS Text - Overlay GPS-related text onto the video

melt:
  - gpstext

Gradient Map

melt:
  - gradientmap

Grain over the Image

melt:
  - grain

Greyscale - Convert colour image to greyscale

melt:
  - grayscale

Convert colour image to greyscale

melt:
  - greyscale

At its defaults it changes nothing; shown with h_shift_red: 270.0. - HSL Primaries - Adjust Hue, Saturation and Lightness for each of the 6 primary/secondary colors.

melt:
  - hslprimaries: {"h_shift_red": 270.0}

melt:
  - invert

At its defaults it changes nothing; shown with line_width: 75. - Scratchlines - Scratchlines over the Picture

melt:
  - lines: {"line_width": 75}

Wipe - Applies a luma transition between the current and next frames. Useful for transitions from a slideshow created using producer pixbuf.

melt:
  - luma

This filter modifies image's alpha channel as a function of its luma value. This is used together with a compositor to combine two images so that bright or dark areas of source image are overwritten on top of the destination image.

melt:
  - lumakey

At its defaults it changes nothing; shown with lift: 0.25. - Filter can be used to apply lift, gain and gamma correction to luma values of image.

melt:
  - lumaliftgaingamma: {"lift": 0.25}

Apply a filter mask - This filter works in conjunction with the mask_start filter, which makes a snapshot of the frame. There can be other filters between the two, which are masked by the alpha channel via this filter's compositing transition.

melt:
  - mask_apply

Setup a filter mask - This filter works in conjunction with the mask_apply filter to make filter masking easier. This filter makes a snapshop of the frame before applying a filter, typically one to affect the alpha channel defining the mask. Then, the mask_apply filter uses a transition to composite the current frame's image over the snapshot. The typical use case is to add filters in the following sequence: mask_start, zero or more filters, mask_apply.

melt:
  - mask_start

Provides various mirror and image reversing effects.

melt:
  - mirror

Obscuring filter.

melt:
  - obscure

Moves the Picture up and down and random brightness change

melt:
  - oldfilm

Simulate a stroke along edges within an alpha channel. It is not very smart or sophisticate, which is why you should limit the thickness and avoid hard angles.

melt:
  - outline

Pillar Echo - Create an echo effect (blur) outside of an area of interest. The area of interest is scaled to fill the image, then blurred. Then the original image is replaced back on top.

melt:
  - pillar_echo

Composite and transform - A filter allowing compositing and transform.

melt:
  - qtblend

Crop by padding - This filter crops the image to a rounded rectangle or circle by padding it with a color.

melt:
  - qtcrop

Overlay text onto the video

melt:
  - qtext

Apply a color tint. Default values give a sepia tone like an old photograph.

melt:
  - sepia

Alpha strobing - Strobes the alpha channel to 0. Many other filters overwrite the alpha channel, in that case this needs to be last.

melt:
  - strobe

Technicolor - Oversaturate the Color in Video, like in old Technicolor movies

melt:
  - tcolor

melt:
  - telecide

Overlay text onto the video

melt:
  - text

melt:
  - threshold

Overlay a timer onto the video. The timer can count up or down.

melt:
  - timer

Didn't finish in 180 s

Typewriter effect applied to kdenlivetitler producer

melt:
  - typewriter

Vignette Effect - Vignette around a point with adjustable smooth, radius, position and transparency

melt:
  - vignette

Overlay - Overlay text or images onto the video

melt:
  - watermark

melt:
  - wave

bbox - Compute bounding box for each frame.

melt:
  - avfilter.bbox

blackdetect - Detect video intervals that are (almost) black.

melt:
  - avfilter.blackdetect

blockdetect - Blockdetect filter.

melt:
  - avfilter.blockdetect

blurdetect - Blurdetect filter.

melt:
  - avfilter.blurdetect

ciescope - Video CIE scope.

melt:
  - avfilter.ciescope

colordetect - Detect video color properties.

melt:
  - avfilter.colordetect

cropdetect - Auto-detect crop size.

melt:
  - avfilter.cropdetect

datascope - Video data analysis.

melt:
  - avfilter.datascope

entropy - Measure video frames entropy.

melt:
  - avfilter.entropy

freezedetect - Detects frozen video input.

melt:
  - avfilter.freezedetect

graphmonitor - Show various filtergraph stats.

melt:
  - avfilter.graphmonitor

histogram - Compute and draw a histogram.

melt:
  - avfilter.histogram

idet - Interlace detect Filter.

melt:
  - avfilter.idet

oscilloscope - 2D Video Oscilloscope.

melt:
  - avfilter.oscilloscope

pixscope - Pixel data analysis.

melt:
  - avfilter.pixscope

scdet - Detect video scene change

melt:
  - avfilter.scdet

showinfo - Show textual information for each video frame.

melt:
  - avfilter.showinfo

sidedata - Manipulate video frame side data.

melt:
  - avfilter.sidedata

signalstats - Generate statistics from video analysis.

melt:
  - avfilter.signalstats

siti - Calculate spatial information (SI) and temporal information (TI).

melt:
  - avfilter.siti

thistogram - Compute and draw a temporal histogram.

melt:
  - avfilter.thistogram

vectorscope - Video vectorscope.

melt:
  - avfilter.vectorscope

waveform - Video waveform monitor.

melt:
  - avfilter.waveform

opencvfacedetect - detect faces and draw shapes on them

melt:
  - frei0r.facedetect

pr0be - Measure video values

melt:
  - frei0r.measure_pr0be

pr0file - 2D video oscilloscope

melt:
  - frei0r.measure_pr0file

pr0be - Measure video values

melt:
  - frei0r.pr0be

pr0file - 2D video oscilloscope

melt:
  - frei0r.pr0file

RGB-Parade - Displays a histogram of R, G and B of the video-data

melt:
  - frei0r.rgbparade

Vectorscope - Displays the vectorscope of the video-data

melt:
  - frei0r.vectorscope

Audio Levels - Compute the audio amplitude.

melt:
  - audiolevel

ashowinfo - Show textual information for each audio frame.

melt:
  - avfilter.ashowinfo

asidedata - Manipulate audio frame side data.

melt:
  - avfilter.asidedata

aspectralstats - Show frequency domain statistics about audio frames.

melt:
  - avfilter.aspectralstats

astats - Show time domain statistics about audio frames.

melt:
  - avfilter.astats

drmeter - Measure audio dynamic range.

melt:
  - avfilter.drmeter

silencedetect - Detect silence.

melt:
  - avfilter.silencedetect

volumedetect - Detect audio volume.

melt:
  - avfilter.volumedetect

stats - Process audio using a SoX effect.

melt:
  - sox.stats

Auto Fade - Automatically fade audio between clips in a playlist. This filter will fade the audio out at the end of a clip and fade the audio in at the beginning of a clip. Only to be used as a filter on playlist producers. Uses the "meta.playlist.clip_position" and "meta.playlist.clip_length" properties that are added by the playlist producer to determine where the splices between clips occur.

melt:
  - autofade

acompressor - Audio compressor.

melt:
  - avfilter.acompressor

acontrast - Simple audio dynamic range compression/expansion filter.

melt:
  - avfilter.acontrast

acrusher - Reduce audio bit resolution.

melt:
  - avfilter.acrusher

adecorrelate - Apply decorrelation to input audio.

melt:
  - avfilter.adecorrelate

At its defaults it changes nothing; shown with av.level: -180.25. - adenorm - Remedy denormals by adding extremely low-level noise.

melt:
  - avfilter.adenorm: {"av.level": -180.25}

aderivative - Compute derivative of input audio.

melt:
  - avfilter.aderivative

adynamicequalizer - Apply Dynamic Equalization of input audio.

melt:
  - avfilter.adynamicequalizer

adynamicsmooth - Apply Dynamic Smoothing of input audio.

melt:
  - avfilter.adynamicsmooth

aecho - Add echoing to the audio.

melt:
  - avfilter.aecho

aemphasis - Audio emphasis.

melt:
  - avfilter.aemphasis

aexciter - Enhance high frequency part of audio.

melt:
  - avfilter.aexciter

afade - Fade in/out input audio.

melt:
  - avfilter.afade

afreqshift - Apply frequency shifting to input audio.

melt:
  - avfilter.afreqshift

agate - Audio gate.

melt:
  - avfilter.agate

aintegral - Compute integral of input audio.

melt:
  - avfilter.aintegral

alimiter - Audio lookahead limiter.

melt:
  - avfilter.alimiter

allpass - Apply a two-pole all-pass filter.

melt:
  - avfilter.allpass

aphaser - Add a phasing effect to the audio.

melt:
  - avfilter.aphaser

aphaseshift - Apply phase shifting to input audio.

melt:
  - avfilter.aphaseshift

apulsator - Audio pulsator.

melt:
  - avfilter.apulsator

asoftclip - Audio Soft Clipper.

melt:
  - avfilter.asoftclip

asubboost - Boost subwoofer frequencies.

melt:
  - avfilter.asubboost

asubcut - Cut subwoofer frequencies.

melt:
  - avfilter.asubcut

asupercut - Cut super frequencies.

melt:
  - avfilter.asupercut

asuperpass - Apply high order Butterworth band-pass filter.

melt:
  - avfilter.asuperpass

asuperstop - Apply high order Butterworth band-stop filter.

melt:
  - avfilter.asuperstop

atilt - Apply spectral tilt to audio.

melt:
  - avfilter.atilt

bandpass - Apply a two-pole Butterworth band-pass filter.

melt:
  - avfilter.bandpass

bandreject - Apply a two-pole Butterworth band-reject filter.

melt:
  - avfilter.bandreject

bass - Boost or cut lower frequencies.

melt:
  - avfilter.bass

biquad - Apply a biquad IIR filter with the given coefficients.

melt:
  - avfilter.biquad

bs2b - Bauer stereo-to-binaural filter.

melt:
  - avfilter.bs2b

compand - Compress or expand audio dynamic range.

melt:
  - avfilter.compand

At its defaults it changes nothing; shown with av.mm: 8. - compensationdelay - Audio Compensation Delay Line.

melt:
  - avfilter.compensationdelay: {"av.mm": 8}

crossfeed - Apply headphone crossfeed filter.

melt:
  - avfilter.crossfeed

crystalizer - Simple audio noise sharpening filter.

melt:
  - avfilter.crystalizer

At its defaults it changes nothing; shown with av.shift: 0.5. - dcshift - Apply a DC shift to the audio.

melt:
  - avfilter.dcshift: {"av.shift": 0.5}

At its defaults it changes nothing; shown with av.i: 0.75. - deesser - Apply de-essing to the audio.

melt:
  - avfilter.deesser: {"av.i": 0.75}

earwax - Widen the stereo image.

melt:
  - avfilter.earwax

extrastereo - Increase difference between stereo audio channels.

melt:
  - avfilter.extrastereo

firequalizer - Finite Impulse Response Equalizer.

melt:
  - avfilter.firequalizer

flanger - Apply a flanging effect to the audio.

melt:
  - avfilter.flanger

haas - Apply Haas Stereo Enhancer.

melt:
  - avfilter.haas

highpass - Apply a high-pass filter with 3dB point frequency.

melt:
  - avfilter.highpass

highshelf - Apply a high shelf filter.

melt:
  - avfilter.highshelf

lowpass - Apply a low-pass filter with 3dB point frequency.

melt:
  - avfilter.lowpass

lowshelf - Apply a low shelf filter.

melt:
  - avfilter.lowshelf

mcompand - Multiband Compress or expand audio dynamic range.

melt:
  - avfilter.mcompand

speechnorm - Speech Normalizer.

melt:
  - avfilter.speechnorm

At its defaults it changes nothing; shown with av.level_in: 48.004. - stereotools - Apply various stereo tools.

melt:
  - avfilter.stereotools: {"av.level_in": 48.004}

stereowiden - Apply stereo widening effect.

melt:
  - avfilter.stereowiden

tiltshelf - Apply a tilt shelf filter.

melt:
  - avfilter.tiltshelf

treble - Boost or cut upper frequencies.

melt:
  - avfilter.treble

tremolo - Apply tremolo effect.

melt:
  - avfilter.tremolo

vibrato - Apply vibrato effect.

melt:
  - avfilter.vibrato

Copy Channels - Copy one audio channel to another.

melt:
  - channelcopy

Copy Channels - Copy one audio channel to another.

melt:
  - channelswap

Dynamic Loudness - Dynamically correct audio loudness as recommended by EBU R128.

melt:
  - dynamic_loudness

At its defaults it changes nothing; shown with 0: 6000.0. - Simple Low Pass Filter - LADSPA plugin

melt:
  - ladspa.1041: {"0": 6000.0}

At its defaults it changes nothing; shown with 0: 6000.0. - Simple High Pass Filter - LADSPA plugin

melt:
  - ladspa.1042: {"0": 6000.0}

Simple Delay Line - LADSPA plugin

melt:
  - ladspa.1043

Sine Oscillator (Freq:audio, Amp:audio) - LADSPA plugin

melt:
  - ladspa.1044

Sine Oscillator (Freq:audio, Amp:control) - LADSPA plugin

melt:
  - ladspa.1045

Sine Oscillator (Freq:control, Amp:audio) - LADSPA plugin

melt:
  - ladspa.1046

Mixdown - Mix all channels of audio into a mono signal and output it as N channels.

melt:
  - mono

Audio Pan - Pan an audio channel, adjust balance, or adjust fade.

melt:
  - panner

Rubberband Pitch - Adjust the audio pitch using the Rubberband library.

melt:
  - rbpitch

chorus - Process audio using a SoX effect.

melt:
  - sox.chorus

contrast - Process audio using a SoX effect.

melt:
  - sox.contrast

deemph - Process audio using a SoX effect.

melt:
  - sox.deemph

dolbyb - Process audio using a SoX effect.

melt:
  - sox.dolbyb

downsample - Process audio using a SoX effect.

melt:
  - sox.downsample

melt failed rendering '/home/juan/.cache/video-as-code/public/gallery/files/melt-audio-sox-firfit-7286ebf0a33cae2b.partial.mp4': Detected locale "C" with character encoding "ANSI_X3.4-1968", which is not UTF-8.
Qt depends on a UTF-8 locale, and has switched to "C.UTF-8" instead.
If this causes problems, reconfigure your locale. See the locale(1) manual
for more information.
xmalloc: malloc size overflow

firfit - Process audio using a SoX effect.

melt:
  - sox.firfit

flanger - Process audio using a SoX effect.

melt:
  - sox.flanger

melt failed rendering '/home/juan/.cache/video-as-code/public/gallery/files/melt-audio-sox-hilbert-b9642c1b794ff987.partial.mp4': Detected locale "C" with character encoding "ANSI_X3.4-1968", which is not UTF-8.
Qt depends on a UTF-8 locale, and has switched to "C.UTF-8" instead.
If this causes problems, reconfigure your locale. See the locale(1) manual
for more information.
melt: effects_i_dsp.c:189: update_fft_cache: Assertion `fft_len >= 0' failed.

hilbert - Process audio using a SoX effect.

melt:
  - sox.hilbert

melt failed rendering '/home/juan/.cache/video-as-code/public/gallery/files/melt-audio-sox-loudness-0af5c9f7e56ceb2b.partial.mp4': Detected locale "C" with character encoding "ANSI_X3.4-1968", which is not UTF-8.
Qt depends on a UTF-8 locale, and has switched to "C.UTF-8" instead.
If this causes problems, reconfigure your locale. See the locale(1) manual
for more information.
melt: effects_i_dsp.c:189: update_fft_cache: Assertion `fft_len >= 0' failed.

loudness - Process audio using a SoX effect.

melt:
  - sox.loudness

norm - Process audio using a SoX effect.

melt:
  - sox.norm

overdrive - Process audio using a SoX effect.

melt:
  - sox.overdrive

phaser - Process audio using a SoX effect.

melt:
  - sox.phaser

reverb - Process audio using a SoX effect.

melt:
  - sox.reverb

reverse - Process audio using a SoX effect.

melt:
  - sox.reverse

riaa - Process audio using a SoX effect.

melt:
  - sox.riaa

saturation - Process audio using a SoX effect.

melt:
  - sox.saturation

Didn't finish in 180 s

spectrogram - Process audio using a SoX effect.

melt:
  - sox.spectrogram

speexdsp - Process audio using a SoX effect.

melt:
  - sox.speexdsp

synth - Process audio using a SoX effect.

melt:
  - sox.synth

trim - Process audio using a SoX effect.

melt:
  - sox.trim

upsample - Process audio using a SoX effect.

melt:
  - sox.upsample

melt failed rendering '/home/juan/.cache/video-as-code/public/gallery/files/melt-audio-sox-vad-c2a7e4b7ea142400.partial.mp4': Detected locale "C" with character encoding "ANSI_X3.4-1968", which is not UTF-8.
Qt depends on a UTF-8 locale, and has switched to "C.UTF-8" instead.
If this causes problems, reconfigure your locale. See the locale(1) manual
for more information.
melt: effects_i_dsp.c:189: update_fft_cache: Assertion `fft_len >= 0' failed.

vad - Process audio using a SoX effect.

melt:
  - sox.vad

Mix two audio tracks.

transition: melt/mix