Shader Overlay (FFMPEGA)

Most of FFMPEGA is wrapped around an LLM agent that turns plain English into ffmpeg filters. Shader Overlay isn't. It's a standalone node: hand it frames, pick an effect, get shaded frames back. No model prompting, no agent, no API keys, and it runs fast enough that you can iterate. If you just want your clip to look like VHS or a CRT monitor, this is the shortest path in the pack.

How it works

The effects are GLSL shaders - 70 of them ship in the pack's shaders/ directory, everything from crt, vhs, holographic and glitch through weirder stuff like voronoi, water_ripple, night_vision, force_field, matrix, stained_glass, pixel_sort and singularity. They're applied through FFmpeg's libplacebo filter, which compiles and runs them on the GPU over Vulkan.

That's the mechanism, and it's also the caveat: libplacebo has to be compiled into your FFmpeg build, along with Vulkan and glslang. Plenty of distro and package-manager ffmpeg builds don't include it. The node detects this at import and, if libplacebo isn't there, falls back to plain FFmpeg filter approximations for each preset. The fallbacks are hand-written to be recognizable - vhs becomes noise plus a colour-balance shift and a saturation cut, glitch becomes an rgbashift - but they are not pixel-accurate versions of the shader. If you've seen screenshots of the shader and your output looks like a discount version of it, that's why.

What you actually set

preset is the main dial, and it's a long dropdown with emoji-named category dividers in it - ignore those, they're labels, not effects. The 🎲 random entry picks one for you, which is a better way to browse 70 shaders than scrolling.

• intensity - 0 to 1, blending the shaded result with the original. At partial values the shader output is blended with your source frame using blend_mode (normal, addition, multiply, screen, overlay, softlight). Full-strength glitch on a talking-head shot is unwatchable; 0.3 is a look.
• preset_2 / preset_3 with their own intensity_2 / intensity_3 - up to three stacked layers. This is where it gets fun, and also where it gets muddy. Two is usually plenty.
• speed, phase, hue_shift - animation speed multiplier, a phase offset in seconds so the effect starts at a different point in time, and a post-shader hue rotation in degrees.
• resolution_scale - 0.25 / 0.5 / 1.0 / 2.0. Half-res is a real speedup on long clips and barely visible for noisy effects like glitch or film grain.
• custom_shader_path - point this at your own .glsl file and it overrides the preset. It has to be a valid mpv/libplacebo HOOK-format shader.

The two inputs that turn this from a filter into something smarter are mask_target and enable_vda / enable_normals. mask_target is a SAM3 text prompt: name an object and the shader only applies there - which is how you put the scanline look on the character and leave the background clean. invert_mask flips that to everything except the target. The depth switches pull in Video Depth Anything (vits ~102 MB, vitb ~390 MB, vitl ~670 MB) and NormalCrafter surface normals, so depth-native shaders and depth-modulated intensity have real per-pixel data to work with; depth_strength scales how hard depth modulates the effect, and depth_input / normals_input let you supply your own maps and skip inference entirely.

Outputs and install

Outputs are images, video_path, and a mask pass-through (it forwards whatever you wire in, unchanged). Installing is the standard pack route:

cd ComfyUI/custom_nodes
git clone https://github.com/AEmotionStudio/ComfyUI-FFMPEGA.git
pip install -r ComfyUI-FFMPEGA/requirements.txt

or ComfyUI Manager → search ComfyUI-FFMPEGA. Restart after. FFMPEG on PATH is mandatory; the libplacebo/Vulkan part is the quality upgrade, not the entry condition.

Where people get burned

"It doesn't look like the demo." Almost always the libplacebo fallback. Check whether your ffmpeg has it compiled in - if it doesn't, either get a build that does or accept the approximation. There's no in-node error for this; it just quietly gives you the lesser version.

Stacking three heavy shaders at 2.0× resolution scale on a 1080p clip is a good way to make a GPU-bound node feel like a diffusion model. Start at 1.0, drop to 0.5 if you're iterating.

Depth and normals are model downloads. Enabling them on a whim means a first-run fetch and a slower queue. If you've already got a depth map, depth_input is the cheap path.