fqmpeg Color y Efectos Visuales: 23 Verbos Explicados

El cluster C6 de fqmpeg es el más grande — veintitrés verbos que cambian cómo se ve un video. Algunos hacen trabajo puramente técnico (color, color-balance, equalize, lut, chroma, hdr-to-sdr). Otros sacan una pantalla verde y la componen sobre un fondo (chromakey, color-key, alpha). Otros aplican un look estilizado (cinematic, vintage, sepia, grayscale, negative, posterize, vignette, edge). El resto distorsiona, suaviza o añade grano (glitch, pixelate, motion-blur, sharpen, blur, noise).

Esta guía recorre cada verbo contra su código fuente en src/commands/ de fqmpeg 3.0.2 — el filtro FFmpeg subyacente, los valores por defecto, el nombre del archivo de salida y las trampas que no se ven con --help solo (el rango de contraste de color es de -1000 a 1000, alpha siempre genera .webm, vintage es una cadena de cuatro filtros, color-key no usa -c:a copy).

Qué vas a sacar de esta guía

• Una matriz de decisión de los 23 verbos por tarea (grading / keying / looks / distorsión / HDR)
• La invocación FFmpeg exacta que genera cada verbo (salida --dry-run verificada)
• Valores por defecto, valores permitidos y nombres de archivo de salida para todos los comandos
• Tres recetas end-to-end incluyendo un pipeline pantalla-verde → composición final

Los 23 Verbos de un Vistazo

El cluster se divide en cinco grupos por tarea. Eliges el grupo, luego el verbo.

Tres cosas a saber antes de seguir leyendo:

1. El rango de color --contrast es -1000 a 1000, no -1 a 1. Es el multiplicador de contraste del filtro eq y el valor por defecto es 1 (sin cambio). El rango útil es 0.5–2.0 para grading normal; 5+ es para looks de contraste aplastado estilizados. fqmpeg valida contra -1000/1000 porque ese es el máximo del lado de FFmpeg, no porque vayas a querer -1000.
2. alpha siempre genera .webm (VP9 + Opus). El video transparente necesita un códec que soporte alpha, y VP9-en-webm es la opción amigable para web. Si necesitas .mov con ProRes 4444 para apps de edición (Premiere, Resolve), copia la salida de --dry-run y cambia libvpx-vp9 por prores_ks -profile:v 4444 y la extensión por .mov antes de ejecutar FFmpeg directamente.
3. vintage es una cadena de cuatro filtros, no un único verbo FFmpeg. La cadena es colorchannelmixer (matriz tipo sepia) + eq (ligero ajuste de saturación/contraste/brillo) + vignette + noise. Copia el --dry-run y cambia o elimina etapas a gusto — es el ejemplo trabajado para "apila tus propios efectos" en este cluster.

Colorización y Corrección

color — Brillo, contraste, saturación, gamma

El caballo de batalla de grading — envuelve el filtro eq de FFmpeg con los cuatro parámetros expuestos.

• Código: src/commands/color.js
• Filtro: eq=brightness=B:contrast=C:saturation=S:gamma=G

$ npx fqmpeg color input.mp4 --brightness 0.05 --contrast 1.1 --saturation 1.2 --gamma 1.0 --dry-run

  ffmpeg -i input.mp4 -vf eq=brightness=0.05:contrast=1.1:saturation=1.2:gamma=1 -c:a copy input-color.mp4

Para ajustes por canal (calentar las luces altas, enfriar las sombras), usa color-balance. color opera sobre todo el cuadro de forma uniforme.

color-balance — Shadows / midtones / highlights × RGB

Ajusta el color en tres rangos tonales independientemente — nueve parámetros (3 canales × 3 rangos). Es el "lift / gamma / gain" de fqmpeg.

• Código: src/commands/color-balance.js
• Filtro: colorbalance=rs=:gs=:bs=:rm=:gm=:bm=:rh=:gh=:bh=
• Nombres: rs/gs/bs = sombras R/G/B, rm/gm/bm = midtones, rh/gh/bh = highlights

$ npx fqmpeg color-balance input.mp4 --rs -0.1 --bs 0.15 --rh 0.1 --bh -0.1 --dry-run

  ffmpeg -i input.mp4 -vf colorbalance=rs=-0.1:gs=0:bs=0.15:rm=0:gm=0:bm=0:rh=0.1:gh=0:bh=-0.1 -c:a copy input-balanced.mp4

El ejemplo de arriba es el clásico look "teal-and-orange" de Hollywood: enfriar las sombras (R negativo / B positivo), calentar las luces altas (R positivo / B negativo). Mantén los valores pequeños (±0.1–±0.2) — más fuerte y el cast de color se vuelve obvio.

equalize — Ecualización automática de histograma

Sin opciones. Ejecuta el filtro histeq de FFmpeg que estira el histograma para llenar todo el rango de luminancia, aclarando zonas oscuras y oscureciendo highlights lavadas.

• Código: src/commands/equalize.js
• Filtro: histeq

$ npx fqmpeg equalize input.mp4 --dry-run

  ffmpeg -i input.mp4 -vf histeq -c:a copy input-equalized.mp4

histeq trabaja por frame y puede parpadear en tomas con cambios rápidos de exposición — para un resultado más estable, gradéa manualmente con color --gamma 1.2 --contrast 1.15. Reserva equalize para material de archivo plano o clips submarinos de bajo contraste donde el parpadeo temporal no preocupa.

lut — Aplicar un LUT 3D (.cube, .3dl)

El verbo "real" de colorización. Carga un archivo LUT y lo aplica vía el filtro lut3d de FFmpeg. Funciona con archivos .cube estándar (el formato que exportan DaVinci Resolve, FilmConvert y Lumetri).

• Código: src/commands/lut.js
• Filtro: lut3d=<path>
• Dos argumentos posicionales — archivo de entrada y archivo LUT

$ npx fqmpeg lut input.mp4 film.cube --dry-run

  ffmpeg -i input.mp4 -vf lut3d=film.cube -c:a copy input-graded.mp4

Paquetes .cube gratis que puedes meter directo: FreshLUTs, RocketStock y el paquete de muestra de FilmConvert. Si un LUT aplicado vía lut3d se ve lavado, tu fuente probablemente ya está en log y el LUT espera Rec.709 — aplica primero un LUT de conversión "log a Rec.709" y luego el LUT de look.

chroma — Rotación de matiz / temperatura

A pesar del nombre "chroma," este verbo controla matiz + saturación — envuelve el filtro hue de FFmpeg, no es un ajustador de submuestreo chroma.

• Código: src/commands/chroma.js
• Filtro: hue=h=H:s=S

$ npx fqmpeg chroma input.mp4 --hue 20 --saturation 1.3 --dry-run

  ffmpeg -i input.mp4 -vf hue=h=20:s=1.3 -c:a copy input-chroma.mp4

--hue 20 calienta toda la imagen ligeramente (los verdes se desplazan hacia amarillo-verde, los azules hacia cian). Para un cambio real de temperatura de color (3200K → 5600K), conviene usar color-balance con --rh 0.05 --bh -0.05 (calentando highlights) — hue rota toda la rueda de color, lo que da un resultado más raro que simplemente desplazar el balance de blancos.

Keying y Alpha

chromakey — Composición pantalla verde/azul sobre fondo

Dos entradas (frente + fondo). Elimina el color clave del frente y lo superpone sobre el fondo. El color clave por defecto es verde puro (0x00FF00).

• Código: src/commands/chromakey.js
• Filtro: [0:v]colorkey=COLOR:SIM:BLEND[fg];[1:v][fg]overlay[out]
• Audio: copia el audio del frente (-c:a copy); ignora el audio del fondo

$ npx fqmpeg chromakey actor.mp4 background.mp4 --color 0x00FF00 --similarity 0.3 --blend 0.1 --dry-run

  ffmpeg -i actor.mp4 -i background.mp4 -filter_complex [0:v]colorkey=0x00FF00:0.3:0.1[fg];[1:v][fg]overlay[out] -map [out] -map 0:a? -c:a copy actor-keyed.mp4

Si queda derrame verde visible en los bordes del sujeto después del keying, sube --blend a 0.2–0.3. Si el tono de piel del sujeto se elimina (especialmente con pantallas azules), baja --similarity a 0.2 y elige un hex más preciso de tu fuente en lugar del genérico 0x00FF00. Detalle del grafo: colorkey es el filtro subyacente — el verbo chromakey se llama así por el caso de uso de pantalla verde, pero chromakey (el filtro FFmpeg) y colorkey (el filtro FFmpeg) operan de forma ligeramente distinta. fqmpeg usa colorkey por debajo para ambos verbos.

color-key — Compone un color específico sobre un fondo

Funcionalmente casi idéntico a chromakey — mismo filtro (colorkey), mismo overlay de dos entradas. La diferencia está en la semántica por defecto: chromakey se documenta como "pantalla verde/azul," color-key como "elimina un color específico y compone." Usa color-key cuando estés keyeando un hex no-verde (un fondo de logo, un color de pared sólido que filmaste sin chroma backdrop).

• Código: src/commands/color-key.js
• Filtro: [0]colorkey=COLOR:SIM:BLEND[fg];[1][fg]overlay[out]
• Audio: mapea el audio del frente con -map 0:a? pero sin -c:a copy — re-codifica el audio al códec por defecto del contenedor

$ npx fqmpeg color-key actor.mp4 background.mp4 --color 0x1A8FE5 --similarity 0.25 --blend 0.05 --dry-run

  ffmpeg -i actor.mp4 -i background.mp4 -filter_complex [0]colorkey=0x1A8FE5:0.25:0.05[fg];[1][fg]overlay[out] -map [out] -map 0:a? actor-colorkey.mp4

La ausencia de -c:a copy es intencional en el código fuente; si te importa preservar el códec de audio original, añade -c:a copy a la salida de --dry-run antes de ejecutar FFmpeg directamente. Si no, el audio se re-codifica (normalmente a AAC para salidas .mp4), lo cual es aceptable en la práctica pero añade una generación.

alpha — Exportar con fondo transparente (WebM/VP9 + Opus)

Una sola entrada. Mismo filtro colorkey, pero compuesto sobre transparencia en lugar de un fondo — la salida es WebM con canal alpha. Úsalo para overlays transparentes que vayas a meter en un editor de video.

• Código: src/commands/alpha.js
• Filtro: colorkey=COLOR:SIM:BLEND,format=yuva420p
• Códec: libvpx-vp9 video, libopus audio
• Contenedor: .webm (extensión por defecto)

$ npx fqmpeg alpha actor.mp4 --color 0x00FF00 --similarity 0.3 --blend 0.1 --dry-run

  ffmpeg -i actor.mp4 -vf colorkey=0x00FF00:0.3:0.1,format=yuva420p -c:v libvpx-vp9 -auto-alt-ref 0 -c:a libopus actor-alpha.webm

Para pipelines no-web (Premiere, Resolve, Final Cut) normalmente quieres .mov con ProRes 4444 — copia el --dry-run y cambia libvpx-vp9 por prores_ks -profile:v 4444 -pix_fmt yuva444p10le y la extensión a .mov. -auto-alt-ref 0 está ahí porque la función alt-ref frame de VP9 rompe la codificación del canal alpha.

Looks Estilizados

cinematic — Añade barras letterbox (look widescreen 2.35:1)

Recorta la fuente a una relación de aspecto ancha, luego rellena de nuevo a 16:9 con barras negras (o de cualquier color) arriba y abajo. El letterbox cinematográfico es una forma rápida de hacer que un clip de móvil "se sienta" como película.

• Código: src/commands/cinematic.js
• Filtro: crop=iw:iw/<ratio>,pad=iw:iw/(16/9):(ow-iw)/2:(oh-ih)/2:color=<color>

$ npx fqmpeg cinematic input.mp4 --ratio 2.35 --color black --dry-run

  ffmpeg -i input.mp4 -vf crop=iw:iw/2.35,pad=iw:iw/(16/9):(ow-iw)/2:(oh-ih)/2:color=black -c:a copy input-cinematic.mp4

2.35:1 es el clásico Scope (CinemaScope, anamórfico). Para cine digital moderno usa 2.39 o 2.40. Las barras son un recorte estético — pierdes la parte superior e inferior del cuadro, así que recompón a tu sujeto antes de aplicar si la acción está en el tercio superior.

vintage — Look retro de película (composición de 4 filtros)

Combina cuatro filtros en una cadena: mixer sepia-ish + ajuste de saturación/contraste + viñeta + grano. Es el verbo "instant 8mm."

• Código: src/commands/vintage.js
• Cadena de filtros: colorchannelmixer=.35:.75:.20:0:.30:.65:.17:0:.25:.50:.13:0,eq=saturation=0.7:contrast=1.1:brightness=0.02,vignette=angle=PI/4,noise=alls=15:allf=t+a

$ npx fqmpeg vintage input.mp4 --dry-run

  ffmpeg -i input.mp4 -vf colorchannelmixer=.35:.75:.20:0:.30:.65:.17:0:.25:.50:.13:0,eq=saturation=0.7:contrast=1.1:brightness=0.02,vignette=angle=PI/4,noise=alls=15:allf=t+a -c:a copy input-vintage.mp4

No hay perillas — vintage es opinionado. Si quieres más grano, sube el noise=alls=15 a 30 en la salida de --dry-run. Para un look retro más frío (tipo VHS de los 80), reemplaza el color mixer con chroma --hue -10 --saturation 0.6.

sepia — Tono sepia

La matriz clásica de sepia — la misma que usan Wikipedia y la W3C en sus ejemplos de filtros sepia.

• Código: src/commands/sepia.js
• Filtro: colorchannelmixer=.393:.769:.189:0:.349:.686:.168:0:.272:.534:.131:0

$ npx fqmpeg sepia input.mp4 --dry-run

  ffmpeg -i input.mp4 -vf colorchannelmixer=.393:.769:.189:0:.349:.686:.168:0:.272:.534:.131:0 -c:a copy input-sepia.mp4

Si quieres sepia con más contraste (look "foto vieja" típico), encadénalo: sepia input.mp4 -o tmp.mp4 && color tmp.mp4 --contrast 1.3 --brightness -0.05. La matriz en sí es fija.

grayscale — Blanco y negro

Elimina toda la saturación vía hue=s=0. Un pelín más barato que chroma --saturation 0 (no hay parámetro de matiz que multiplicar).

• Código: src/commands/grayscale.js
• Filtro: hue=s=0

$ npx fqmpeg grayscale input.mp4 --dry-run

  ffmpeg -i input.mp4 -vf hue=s=0 -c:a copy input-grayscale.mp4

Para un "B&N filmico" con el canal rojo realzado (tonos de piel brillan contra cielos oscuros), usa color --saturation 0 y añade color-balance --rh 0.1 antes — la desaturación uniforme de grayscale está más cerca de un Polaroid B&N que de un Kodak Tri-X.

negative — Invertir colores

El filtro negate de FFmpeg. Invierte cada píxel — útil para efectos rápidos de negativo de película o para "encontrar la zona más clara en una escena oscura" como herramienta de inspección.

• Código: src/commands/negative.js
• Filtro: negate

$ npx fqmpeg negative input.mp4 --dry-run

  ffmpeg -i input.mp4 -vf negate -c:a copy input-negative.mp4

Ejecutar negative dos veces te devuelve al original (negate es involutivo). También invierte el canal alpha si está presente — usa la variante negate=alpha=0 vía edición de --dry-run si quieres preservar alpha.

posterize — Reducir niveles de color

Aplasta cada canal a N valores discretos. --levels 4 (por defecto) da un gradiente de 4 pasos por canal — 64 colores en total (4³). Niveles más bajos = más caricatura; niveles más altos = banding sutil.

• Código: src/commands/posterize.js
• Filtro: format=rgb24,lutrgb=r='val-mod(val,256/N)':g='val-mod(val,256/N)':b='val-mod(val,256/N)'

$ npx fqmpeg posterize input.mp4 --levels 6 --dry-run

  ffmpeg -i input.mp4 -vf format=rgb24,lutrgb=r='val-mod(val,256/6)':g='val-mod(val,256/6)':b='val-mod(val,256/6)' -c:a copy input-posterized.mp4

--levels 2 produce un look negro-blanco-rojo-verde-azul-amarillo-magenta-cian (2³ = 8 colores). --levels 32 da banding sutil que es difícil de ver pero rompe tomas de cielo con gradiente. El format=rgb24 previo convierte de YUV para que la matemática por canal opere sobre RGB.

edge — Detección de bordes (sobel / prewitt / roberts)

Tres detectores de bordes clásicos. sobel (el default) es el más usado — produce el típico look "bordes blancos sobre negro" que muestran los tutoriales de gamedev.

• Código: src/commands/edge.js
• Filtro (sobel): edgedetect=mode=colormix:high=0
• Filtro (prewitt): prewitt
• Filtro (roberts): roberts

$ npx fqmpeg edge input.mp4 --mode sobel --dry-run

  ffmpeg -i input.mp4 -vf edgedetect=mode=colormix:high=0 -c:a copy input-edge.mp4

$ npx fqmpeg edge input.mp4 --mode prewitt --dry-run

  ffmpeg -i input.mp4 -vf prewitt -c:a copy input-edge.mp4

sobel usa edgedetect=mode=colormix de FFmpeg que preserva los colores en los bordes (el más estilístico). prewitt y roberts son filtros de borde directos con bordes blancos puros sobre negro. Para looks tipo "línea de tinta" de animación, sobel con colormix suele ser lo que quieres.

vignette — Bordes oscuros

El filtro vignette de FFmpeg, tomando un solo parámetro --angle (apertura de viñeta en radianes).

• Código: src/commands/vignette.js
• Filtro: vignette=angle=<radians>

$ npx fqmpeg vignette input.mp4 --angle PI/5 --dry-run

  ffmpeg -i input.mp4 -vf vignette=angle=PI/5 -c:a copy input-vignette.mp4

Contraintuitivamente, mayor --angle = apertura más amplia = menos viñeta. El default PI/5 (≈0.628 rad) es el default de FFmpeg. PI/4 es el valor que usa vintage internamente — un pelín más pesado. El evaluador de expresiones maneja PI/5 literalmente, así que no pases 0.6283 — pasa la forma simbólica.

Distorsión y Nitidez

glitch — Shift RGB + ruido + contraste

El verbo "estética datamosh" — encadena rgbashift (rojo a la derecha, azul a la izquierda), noise y un boost ligero de contraste. La intensidad escala los tres.

• Código: src/commands/glitch.js
• Cadena de filtros: rgbashift=rh=N:bh=-N:rv=N/2:bv=-N/2,noise=alls=M:allf=t,eq=contrast=1.2 donde N = intensity/5, M = min(intensity, 50)

$ npx fqmpeg glitch input.mp4 --intensity 30 --dry-run

  ffmpeg -i input.mp4 -vf rgbashift=rh=6:bh=-6:rv=3:bv=-3,noise=alls=30:allf=t,eq=contrast=1.2 -c:a copy input-glitch.mp4

--intensity 30 (el default) da un glitch visible-pero-sutil adecuado para una transición o cartón de título. --intensity 80+ para caos datamosh completo. El ruido tope a 50 aunque la intensidad sea 100, así que pasar de 50 solo añade más shift RGB sin más grano.

pixelate — Mosaico / bloque pixel-art

Reduce el video con muestreo nearest-neighbor, luego sube de nuevo con nearest-neighbor — el truco canónico de pixel-art.

• Código: src/commands/pixelate.js
• Filtro: scale=iw/S:ih/S:flags=neighbor,scale=iw*S:ih*S:flags=neighbor

$ npx fqmpeg pixelate input.mp4 --size 16 --dry-run

  ffmpeg -i input.mp4 -vf scale=iw/16:ih/16:flags=neighbor,scale=iw*16:ih*16:flags=neighbor -c:a copy input-pixelated.mp4

Para un resultado limpio el tamaño tiene que dividir las dimensiones de la fuente — --size 16 en 1280×720 da exactamente 80×45 bloques. En 1920×1080 la matemática da 120×67.5 → FFmpeg redondea, así que verás bloques ligeramente desiguales en los bordes. Para pixelar privacidad sobre una cara (mosaico en una región), usa blur --region X:Y:W:H --strength <n> — pixelate siempre aplica al cuadro entero.

motion-blur — Motion blur por mezcla de frames

Promedia múltiples frames consecutivos en un frame de salida vía el filtro tmix de FFmpeg. El resultado es un look de motion-trail emborronado.

• Código: src/commands/motion-blur.js
• Filtro: tmix=frames=N

$ npx fqmpeg motion-blur input.mp4 --frames 5 --dry-run

  ffmpeg -i input.mp4 -vf tmix=frames=5 -c:a copy input-motion-blur.mp4

tmix mantiene el framerate de salida igual al de entrada — promedia una ventana deslizante de frames, no decima. Eso lo hace apropiado para looks de "motion blur real" donde esperarías que el obturador de una cámara de cine capture movimiento dentro del frame. Para fantasmas artísticos (donde quieres que la estela persista más), sube --frames a 15–20; para motion blur realista de obturador sobre fuente 60fps, --frames 3 coincide con un ángulo de obturador de 180°.

sharpen — Unsharp mask (light / medium / strong)

El filtro unsharp de FFmpeg con tres fuerzas preset. light/medium/strong mapean a unsharp=3:3:1, 5:5:1.5, 7:7:2.

• Código: src/commands/sharpen.js
• Filtro: unsharp=<luma_size>:<luma_size>:<amount>

$ npx fqmpeg sharpen input.mp4 --strength medium --dry-run

  ffmpeg -i input.mp4 -vf unsharp=5:5:1.5 -c:a copy input-sharpened.mp4

medium (el default) es una opción segura para metraje de móvil ligeramente blando. strong puede introducir halos alrededor de bordes de alto contraste — más visibles en texto o en límites cielo-tejado. Para una cantidad personalizada, copia el --dry-run y reemplaza 5:5:1.5 con tus propios valores <x>:<y>:<amount> (ej. 7:7:1.0 para un sharpen más ancho pero suave).

blur — Box blur, cuadro completo o región

Filtro boxblur con fuerzas preset (light = 5, medium = 15, strong = 30) o un número personalizado. Con --region X:Y:W:H parte el stream, blureá solo la región recortada y la superpone de vuelta — útil para emborronar privacidad sobre una cara o matrícula sin tocar el resto del cuadro.

• Código: src/commands/blur.js
• Filtro (cuadro completo): boxblur=N
• Filtro (región): [0:v]split[base][blur];[blur]crop=W:H:X:Y,boxblur=N[blurred];[base][blurred]overlay=X:Y

$ npx fqmpeg blur input.mp4 --strength medium --dry-run

  ffmpeg -i input.mp4 -vf boxblur=15 -c:a copy input-blurred.mp4

$ npx fqmpeg blur input.mp4 --strength 8 --region 100:50:300:200 --dry-run

  ffmpeg -i input.mp4 -filter_complex [0:v]split[base][blur];[blur]crop=300:200:100:50,boxblur=8[blurred];[base][blurred]overlay=100:50 -c:a copy input-blurred.mp4

boxblur es rápido pero produce artefactos de blur cuadradiscos en bordes nítidos. Para un blur que se vea mejor, copia el --dry-run y cambia boxblur=N por gblur=sigma=N (Gaussiano, más lento pero más suave). Para la cara de un sujeto en movimiento, --region solo acepta un rectángulo estático — para motion tracking necesitarías un pipeline de detección de pose upstream.

HDR y Grano

hdr-to-sdr — Tone-map HDR (BT.2020 + PQ/HLG) → SDR (BT.709)

La conversión que la mayoría necesita al bajar contenido HDR de Netflix/YouTube y descubrir que su display no-HDR muestra colores lavados. Ejecuta una cadena zscale + tonemap con uno de tres algoritmos.

• Código: src/commands/hdr-to-sdr.js
• Cadena de filtros: zscale=t=linear:npl=100,format=gbrpf32le,zscale=p=bt709,tonemap=<algo>:desat=0,zscale=t=bt709:m=bt709:r=tv,format=yuv420p

$ npx fqmpeg hdr-to-sdr input.mp4 --tonemap hable --dry-run

  ffmpeg -i input.mp4 -vf zscale=t=linear:npl=100,format=gbrpf32le,zscale=p=bt709,tonemap=hable:desat=0,zscale=t=bt709:m=bt709:r=tv,format=yuv420p -c:a copy input-sdr.mp4

La cadena convierte de PQ/HLG a lineal, hace tone-map y re-codifica a BT.709 SDR. hable (la curva de Uncharted 2) es el default — midtones naturales, roll-off de highlights suave. reinhard comprime todo más agresivamente (look más plano). mobius preserva más detalle de highlights a costa de apagar midtones. Para un deep-dive en la teoría y las compensaciones por algoritmo ver Tone-mapping HDR a SDR con FFmpeg.

zscale requiere que FFmpeg esté compilado con --enable-libzimg. Si tu build no lo tiene verás Unrecognized option 'zscale'; instala un build que incluya zimg (la mayoría de Homebrew/apt/builds estáticos lo hacen).

noise — Añadir grano de película

El filtro noise de FFmpeg con dos distribuciones. gaussian (el default) se ve como grano de película orgánico. uniform se ve más digital — espolvoreo uniforme, sin agrupamiento.

• Código: src/commands/noise.js
• Filtro: noise=alls=N:allf=t+a (gaussian) o noise=alls=N:allf=t+u (uniform)

$ npx fqmpeg noise input.mp4 --strength 20 --type gaussian --dry-run

  ffmpeg -i input.mp4 -vf noise=alls=20:allf=t+a -c:a copy input-noisy.mp4

--strength 20 son niveles de grano de película (sutil, no compite con la imagen). --strength 60 son niveles de 8mm-en-mano. Por encima de 80 domina la imagen — útil para efectos de metraje envejecido estilizado. El flag +t en el filtro es "ruido temporal" (diferente por frame) — sin él tendrías un patrón de dithering estático. fqmpeg siempre usa +t.

Recetas Reales

Cada receta encadena varios verbos en un workflow que usarías de verdad.

Receta 1: Pasada de color "cinematográfica" rápida para metraje de móvil

Grabaste un clip con el móvil (bien expuesto, bastante saturado, los colores se ven planos en YouTube). Objetivo: highlights ligeramente más cálidos, sombras más frías, un toque de contraste y barras letterbox 2.35:1.

# Paso 1: división teal-and-orange shadow/highlight
npx fqmpeg color-balance clip.mp4 --rs -0.1 --bs 0.15 --rh 0.1 --bh -0.1
# → clip-balanced.mp4

# Paso 2: levanta contraste y añade un toque de saturación
npx fqmpeg color clip-balanced.mp4 --contrast 1.15 --saturation 1.1
# → clip-balanced-color.mp4

# Paso 3: letterbox 2.35:1
npx fqmpeg cinematic clip-balanced-color.mp4 --ratio 2.35
# → clip-balanced-color-cinematic.mp4

Si tienes un LUT de grading real (archivo .cube) — digamos, de un pack pagado o exportado de DaVinci Resolve — reemplaza los pasos 1-2 con npx fqmpeg lut clip.mp4 mylook.cube. Los LUTs te dejan llevar un grading consistente a lo largo de un proyecto entero; la combinación color-balance + color es el workflow "sin LUT disponible."

Receta 2: Actor en pantalla verde → composición final

Grabaste un actor contra un fondo verde y tienes un plate de fondo (una imagen o video). Objetivo: key limpio, sin derrame verde, master con canal alpha para edición posterior.

# Paso 1: compón sobre el fondo final para preview
npx fqmpeg chromakey actor.mp4 backdrop.jpg --color 0x00FF00 --similarity 0.3 --blend 0.15
# → actor-keyed.mp4

# Paso 2 (opcional): exporta un master con canal alpha para el editor
npx fqmpeg alpha actor.mp4 --color 0x00FF00 --similarity 0.3 --blend 0.15
# → actor-alpha.webm

# Paso 3 (opcional): si queda derrame verde, baja la saturación del verde
npx fqmpeg chroma actor-keyed.mp4 --hue -5 --saturation 0.9
# → actor-keyed-chroma.mp4

Si el verde envuelve los bordes o los hombros del sujeto, sube --blend a 0.2–0.3 para bordes más suaves (o acepta un halo leve). Para derrame chroma en el cuerpo (tonos de piel verdosos), el mejor arreglo es una pasada colorbalance que baje el verde en midtones (--gm -0.1) después del key.

Receta 3: Descarga HDR → upload SDR listo para web

Muchos streams de alta resolución de fuentes tipo Netflix vienen como HDR (BT.2020 + PQ o HLG). Tu re-upload a YouTube o share en redes necesita SDR (BT.709). Orden incorrecto aquí es la diferencia entre una conversión limpia y un render de 30 minutos que sale gris.

# Paso 1: tone-map HDR → SDR (debe ir primero - nunca re-codifiques HDR como SDR)
npx fqmpeg hdr-to-sdr hdr-clip.mp4 --tonemap hable
# → hdr-clip-sdr.mp4

# Paso 2: pasada opcional de grading para recuperar saturación perdida en tone-mapping
npx fqmpeg color hdr-clip-sdr.mp4 --saturation 1.15 --contrast 1.05
# → hdr-clip-sdr-color.mp4

# Paso 3: comprime para upload
npx fqmpeg compress hdr-clip-sdr-color.mp4 --crf 21
# → hdr-clip-sdr-color-compressed.mp4

tonemap=hable (curva de Uncharted 2) es el default seguro. Si los highlights se ven quemados — típico en metraje HDR exterior brillante — cambia a --tonemap mobius para más detalle de highlights a costa de midtones ligeramente apagados. El paso color --saturation 1.15 es porque el tone-mapping intrínsecamente desatura el contenido HDR; traerlo de vuelta a niveles SDR-naturales es una pasada final, no un punto de partida. Para más sobre la teoría subyacente ver Tone-mapping HDR a SDR con FFmpeg.

Preguntas Frecuentes

¿Por qué color --contrast acepta -1000 a 1000 si nunca usaría esos valores?

Porque ese es el rango del lado de FFmpeg para el parámetro de contraste del filtro eq, y fqmpeg valida contra él directamente. En la práctica te quedas entre 0.5 (contraste bajo, look gris) y 2.0 (contraste alto, aplastado). Valores por encima de 5 producen posterización extrema. El rango ancho existe para que usos artísticos (terror estilizado, vaporwave) no estén bloqueados.

chromakey vs color-key — ¿cuál debería usar?

Usan el mismo filtro FFmpeg colorkey por debajo y producen esencialmente la misma salida. chromakey añade -c:a copy para preservar el códec de audio original, mientras color-key no (así que el audio se re-codifica al códec por defecto del contenedor). Usa chromakey cuando keyees pantallas verdes/azules reales para mantener el audio limpio; usa color-key indistintamente cuando keyees un color no-tradicional (una pared coloreada, fondo de logo). Si te importa preservar el audio, prefiere chromakey.

alpha exporta .webm — ¿puedo conseguir .mov con ProRes 4444 para Premiere?

No vía fqmpeg directamente — las elecciones de códec de alpha (libvpx-vp9 + libopus) están hardcodeadas para amigabilidad web. Copia la salida de --dry-run y cambia libvpx-vp9 por prores_ks -profile:v 4444 -pix_fmt yuva444p10le (y la extensión de salida a .mov) antes de ejecutar FFmpeg directamente. La misma cadena de filtros colorkey,format=yuva420p funciona para ambos — solo difiere el encoder.

Mi archivo HDR no hace tone-map — hdr-to-sdr falla con "Unrecognized option 'zscale'"

Tu build de FFmpeg no incluye la librería zimg. Reinstala con un build que tenga --enable-libzimg: brew reinstall ffmpeg en macOS suele hacerlo (el bottle de Homebrew tiene zimg). En Ubuntu/Debian el paquete apt oficial ffmpeg normalmente también tiene zimg — builds más viejos pueden no tenerlo. Los builds estáticos de BtbN's FFmpeg-Builds incluyen zimg.

¿Cómo consigo un look más "Hollywood" sin un pack de LUTs?

El movimiento clásico es la división teal-and-orange de color-balance (sombras frías, highlights cálidos) más un bump ligero de contraste:

npx fqmpeg color-balance clip.mp4 --rs -0.1 --bs 0.15 --rh 0.1 --bh -0.1
npx fqmpeg color clip-balanced.mp4 --contrast 1.15 --saturation 1.05

Esto emula ~70% del look que sacas de packs de LUTs "cinematográficos" genéricos. Para looks matched-to-a-specific-film necesitas un LUT real — prueba los packs gratis de FreshLUTs o RocketStock.

¿Puedo correr un preview "antes/después" sin renderizar el video completo?

Recorta a un segmento de prueba corto primero, luego aplica el efecto al recorte:

npx fqmpeg trim input.mp4 --start 10 --duration 5 -o test.mp4
npx fqmpeg color test.mp4 --contrast 1.2 -o test-graded.mp4

El paso trim te da una muestra de 5 segundos que renderiza en segundos incluso con CRF alto, así puedes iterar en los ajustes de color sin esperas de 10 minutos.

¿Por qué pixelate --size 16 da bloques desiguales en una fuente 1920×1080?

Porque 16 no divide a 1080 exactamente (1080 ÷ 16 = 67.5). FFmpeg redondea el paso intermedio scale=iw/16:ih/16, así que el up-scale de vuelta a las dimensiones originales distribuye el error de redondeo por toda la imagen. Para bloques limpios elige un divisor de ambas dimensiones: 8, 10, o 20 para 1920×1080; 16 funciona limpiamente en 1280×720.

¿Cuál es la diferencia entre motion-blur y blur?

motion-blur es temporal (promedia múltiples frames en uno — usado cuando el movimiento ocurre durante un solo frame, simulando el obturador). blur es espacial (blurea cada frame independientemente — usado para suavizar toda la imagen u ocultar una región). Se ven muy distintos: motion-blur solo afecta las partes en movimiento; blur afecta a todo.

¿Puede lut aplicar un LUT 2D normal (curva 1D) en lugar de 3D?

No — lut está hardcodeado a lut3d=<file>. Para un LUT 1D (un archivo .1dl o una curva por canal), ejecutarías FFmpeg directamente con el filtro lut1d. Los workflows de grading modernos usan LUTs 3D de todos modos porque manejan shifts de color dependientes del matiz que los LUTs 1D no.

Conclusión

Los veintitrés verbos de C6 cubren las operaciones de look-y-efecto que usas después de la geometría pero antes de la compresión final:

• color, color-balance, equalize, lut, chroma para grading (nota de rango: color --contrast acepta -1000 a 1000 por el filtro eq subyacente; el rango útil es 0.5–2.0)
• chromakey, color-key, alpha para keying y composición (los tres usan el mismo filtro FFmpeg colorkey; alpha exporta .webm con VP9+Opus para video transparente amigable con web)
• cinematic, vintage, sepia, grayscale, negative, posterize, vignette, edge para looks estilizados (vintage es una cadena de cuatro filtros — útil como ejemplo trabajado para apilar tus propios efectos)
• glitch, pixelate, motion-blur, sharpen, blur para distorsión y nitidez (blur --region es el verbo de pixelación de privacidad)
• hdr-to-sdr, noise para conversión HDR y grano de película (hdr-to-sdr requiere zscale / zimg; noise defaultea a gaussiano)

Todos los verbos imprimen su invocación FFmpeg subyacente bajo --dry-run, así que cuando los defaults no encajan (una salida alpha no-.webm, un LUT .cube pero sobre fuente log, una cantidad personalizada de unsharp), puedes copiar el comando, customizar y correr FFmpeg directamente. Para el mapa más amplio de fqmpeg, ver la guía completa de fqmpeg.