fqmpeg Redimensionar, Recortar y Rotar: Geometría

El cluster C5 de fqmpeg son catorce verbos que cambian la geometría del video: sus dimensiones (resize, scale2x), su región visible (crop, crop-detect), su lienzo (pad, aspect, backdrop), su orientación (rotate, transpose, mirror), su movimiento de encuadre (zoom) o la estructura de campos (deinterlace, interlace, field-order). Son las operaciones de "darle al cuadro la forma correcta" entre la captura y la publicación.

Esta guía recorre cada verbo — el filtro FFmpeg que genera, los valores por defecto, las reglas de nombrado de salida y los gotchas que vienen del filtro subyacente (el truco del -2 para dimensiones pares, la cadena force_original_aspect_ratio de pad, el 1920×1080 hardcodeado de zoom). Todo se ha verificado contra el código fuente en src/commands/ de fqmpeg 3.0.2.

Lo que vas a sacar de esta guía

• Una matriz de decisión para los 14 verbos por tarea (escalar / recortar / pad / rotar / movimiento / interlazado)
• La invocación FFmpeg exacta que cada verbo genera (salida --dry-run verificada)
• Defaults, valores admitidos y nombres de salida para cada comando
• Tres recetas de extremo a extremo, incluida la de "video vertical de móvil → YouTube"

Los 14 verbos de un vistazo

El cluster se parte limpiamente en seis grupos de tareas. Eliges el grupo, luego el verbo.

Tres cosas a tener en cuenta antes de seguir leyendo:

1. resize usa -2 para la dimensión auto-escalada. Si pasas -w 1280, la altura pasa a -2, que le dice a FFmpeg "preserva el aspecto, pero ajusta a múltiplo de 2". La mayoría de codecs (x264, x265, VP9) requieren dimensiones pares, así que -2 te ahorra los errores width not divisible by 2 que aparecen si usas -1 ingenuamente.
2. pad escala primero y luego rellena. El filtro es scale=W:H:force_original_aspect_ratio=decrease,pad=W:H:.... Así que pad input.mp4 1920x1080 sobre una fuente de 1280×720 escala primero hacia 1920×1080-fit y luego rellena — no es un pad puro. Para un pad literal sin escalar, edita la salida --dry-run.
3. zoom siempre saca 1920×1080 a 30 fps. El filtro tiene s=1920x1080:fps=30 hardcodeado — no hay opción para sobrescribir. Si necesitas otro tamaño o frame rate, copia la salida --dry-run y edita esos valores antes de ejecutar FFmpeg directamente.

Redimensionar y ampliar

resize — Escalar a un ancho o alto objetivo

El scaler de pan y mantequilla. Pasa -w para un ancho objetivo (la altura se auto-escala) o -h para una altura objetivo (el ancho se auto-escala). El lado automático se vuelve -2 para que la salida quede en dimensiones pares.

• Fuente: src/commands/resize.js
• Filtro: scale=W:-2 o scale=-2:H
• -w o -h es requerido — si no, sale con Error: specify --width (-w) or --height (-h).

$ npx fqmpeg resize input.mp4 -w 1280 --dry-run

  ffmpeg -i input.mp4 -vf scale=1280:-2 -c:a copy input-1280w.mp4

$ npx fqmpeg resize input.mp4 -h 720 --dry-run

  ffmpeg -i input.mp4 -vf scale=-2:720 -c:a copy input-720h.mp4

Si necesitas las dos dimensiones fijas (p.ej. exactamente 1280×720 sin importar el aspecto fuente), usa pad o aspect --mode stretch — resize preserva el aspecto a propósito.

scale2x — Ampliación 2× con super2xsai

Duplica las dimensiones de píxel usando el filtro super2xsai de FFmpeg, originalmente diseñado para pixel art y material de juegos de baja resolución. Preserva los bordes de un modo que el escalado bilineal/bicúbico no, lo que lo hace útil para capturas de juegos retro, sprite sheets o cualquier fuente con bordes duros. Para contenido fotográfico, resize -w <2x> con el Lanczos por defecto se ve mejor.

• Fuente: src/commands/scale2x.js
• Filtro: super2xsai

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

  ffmpeg -i input.mp4 -vf super2xsai -c:a copy input-2x.mp4

super2xsai está fijo en 2×; para 3× o 4× encadénalo (scale2x y otra vez scale2x sobre la salida). Los upscalers basados en IA modernos (Real-ESRGAN, Topaz Video AI) superan a super2xsai en recuperación de detalle, pero super2xsai corre en tiempo real en CPU mientras que los IA necesitan GPU.

Recortar

crop — Cortar una región rectangular

Recorta un rectángulo de tamaño fijo desde la fuente. Posición por defecto: centrada. Pasa --pos x:y para sobrescribir la esquina superior izquierda.

• Fuente: src/commands/crop.js
• Filtro: crop=W:H:X:Y
• Formato <size>: WxH (p.ej. 1280x720)

$ npx fqmpeg crop input.mp4 1280x720 --dry-run

  ffmpeg -i input.mp4 -vf crop=1280:720:(in_w-1280)/2:(in_h-720)/2 -c:a copy input-crop1280x720.mp4

$ npx fqmpeg crop input.mp4 800x600 --pos 100:50 --dry-run

  ffmpeg -i input.mp4 -vf crop=800:600:100:50 -c:a copy input-crop800x600.mp4

--pos solo acepta x:y numérico. Para "esquina superior derecha con margen de 20px de cada borde" o posiciones relativas similares, edita la salida --dry-run para usar expresiones FFmpeg como crop=W:H:in_w-W-20:20.

crop-detect — Encontrar el área óptima de recorte

No escribe archivo. Corre el filtro cropdetect de FFmpeg sobre la fuente e imprime las coordenadas de recorte sugeridas a stderr. Útil para quitar las barras negras de descargas con letterbox o pillarbox — pasa la salida a una invocación de crop.

• Fuente: src/commands/crop-detect.js
• Filtro: cropdetect=limit=N:round=2:reset=0 al muxer null
• --limit: 0–255, default 24. Píxeles más oscuros que esto se tratan como "borde negro".

$ npx fqmpeg crop-detect input.mp4 --dry-run

  ffmpeg -i input.mp4 -vf cropdetect=limit=24:round=2:reset=0 -f null -

La ejecución real imprime líneas como [Parsed_cropdetect_0 @ ...] x1:0 x2:1919 y1:140 y2:939 w:1920 h:800 x:0 y:140 crop=1920:800:0:140 — el último token es lo que copias en crop --pos. Si una fuente ruidosa no se detecta, sube --limit a 30–40.

Pad y aspecto

pad — Letterbox o pillarbox a un lienzo objetivo

Escala la fuente para que entre en WxH preservando el aspecto, luego rellena el espacio sobrante con un color sólido. La cadena de filtros es scale=W:H:force_original_aspect_ratio=decrease,pad=W:H:(ow-iw)/2:(oh-ih)/2:color=<color> — la fuente se reduce hasta caber, nunca se amplía más allá del lienzo, y se centra y rellena.

• Fuente: src/commands/pad.js
• Filtro: scale=...:force_original_aspect_ratio=decrease,pad=...:color=<color>
• Formato --color: cualquier nombre de color de FFmpeg o hex (black, white, 0x808080)

$ npx fqmpeg pad input.mp4 1920x1080 --dry-run

  ffmpeg -i input.mp4 -vf scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2:color=black -c:a copy input-pad1920x1080.mp4

$ npx fqmpeg pad input.mp4 1920x1080 --color white --dry-run

  ffmpeg -i input.mp4 -vf scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2:color=white -c:a copy input-pad1920x1080.mp4

force_original_aspect_ratio=decrease importa: encoge la fuente para que la mayor de las dos dimensiones escaladas sea igual al objetivo, y la menor se rellena. Así una fuente 1280×720 padded a 1920×1080 termina como 1920×1080 sin relleno (escala hacia arriba para caber), mientras que una fuente vertical 720×1280 termina como 608×1080 centrada en un lienzo 1920×1080 negro — barras pillarbox a los lados.

aspect — Cambiar la relación de aspecto de pantalla

Tres modos para forzar una relación de aspecto objetivo: pad (letterbox), crop (cortar para encajar) o stretch (deformar la imagen).

• Fuente: src/commands/aspect.js
• Formato <ratio>: W:H (p.ej. 16:9, 4:3, 1:1, 21:9)
• --mode: pad (default) / crop / stretch

$ npx fqmpeg aspect input.mp4 16:9 --dry-run

  ffmpeg -i input.mp4 -vf scale=iw:iw*9/16:force_original_aspect_ratio=decrease,pad=iw:iw*9/16:(ow-iw)/2:(oh-ih)/2:color=black,setsar=1 -c:a copy input-16x9.mp4

$ npx fqmpeg aspect input.mp4 1:1 --mode crop --dry-run

  ffmpeg -i input.mp4 -vf crop='min(iw,ih*1/1)':'min(ih,iw*1/1)' -c:a copy input-1x1.mp4

$ npx fqmpeg aspect input.mp4 21:9 --mode stretch --dry-run

  ffmpeg -i input.mp4 -vf scale=iw:iw*9/21,setsar=1 -c:a copy input-21x9.mp4

setsar=1 resetea la sample aspect ratio a 1:1 para que el aspecto de pantalla coincida con el aspecto de almacenamiento — sin él, los reproductores que respetan SAR mostrarían el resultado con el aspecto original. El modo pad aquí difiere del verbo pad independiente: aspect --mode pad deriva las dimensiones objetivo del ancho de la fuente y de la ratio, mientras que pad independiente toma dimensiones literales en píxeles.

backdrop — Video vertical a 16:9 con fondo difuminado

El verbo "arregla el video vertical de móvil para YouTube". Compone la fuente sobre una copia ampliada, recortada y difuminada de sí misma — el primer plano es el clip vertical original, y el fondo rellena el lienzo 16:9 con una versión desenfocada del mismo contenido. El filter graph tiene tres etapas: scale-and-crop-and-blur para el fondo, scale-fit para el primer plano, y overlay para centrarlos.

• Fuente: src/commands/backdrop.js
• Filtro: [0:v]scale=W:H:force_original_aspect_ratio=increase,crop=W:H,boxblur=N[bg];[0:v]scale=W:H:force_original_aspect_ratio=decrease[fg];[bg][fg]overlay=(W-w)/2:(H-h)/2

$ npx fqmpeg backdrop portrait.mp4 --dry-run

  ffmpeg -i portrait.mp4 -filter_complex [0:v]scale=1920:1080:force_original_aspect_ratio=increase,crop=1920:1080,boxblur=20[bg];[0:v]scale=1920:1080:force_original_aspect_ratio=decrease[fg];[bg][fg]overlay=(W-w)/2:(H-h)/2 -c:a copy portrait-backdrop.mp4

$ npx fqmpeg backdrop portrait.mp4 --size 1920x1080 --blur 30 --dry-run

  ffmpeg -i portrait.mp4 -filter_complex [0:v]scale=1920:1080:force_original_aspect_ratio=increase,crop=1920:1080,boxblur=30[bg];[0:v]scale=1920:1080:force_original_aspect_ratio=decrease[fg];[bg][fg]overlay=(W-w)/2:(H-h)/2 -c:a copy portrait-backdrop.mp4

Para salida 4:3 horizontal, pasa --size 1440x1080. El blur es boxblur y no el más bonito (y más lento) gblur — si quieres gaussian blur, edita boxblur=20 a gblur=sigma=20 en la salida --dry-run.

Rotar y reflejar

rotate — Rotar 90/180/270 o voltear

Cinco modos según el argumento: 90, 180, 270 (rotaciones en sentido horario), hflip (espejo horizontal), vflip (espejo vertical).

• Fuente: src/commands/rotate.js
• Filtro: transpose=1 para 90, transpose=1,transpose=1 para 180, transpose=2 para 270, hflip para hflip, vflip para vflip

$ npx fqmpeg rotate input.mp4 90 --dry-run

  ffmpeg -i input.mp4 -vf transpose=1 -c:a copy input-rot90.mp4

$ npx fqmpeg rotate input.mp4 hflip --dry-run

  ffmpeg -i input.mp4 -vf hflip -c:a copy input-rothflip.mp4

180 está implementado como dos rotaciones de 90 horario (transpose=1,transpose=1) en lugar del flag transpose=4 — el resultado es idéntico, pero pasar dos veces por el filtro es ligeramente más lento. Para una conversión puntual la diferencia es invisible; para procesar mil clips en batch, usa vflip,hflip directamente vía edición de --dry-run.

transpose — Dirección de transposición directa

El primo de bajo nivel de rotate. Expone el filtro transpose de FFmpeg directamente: 0 = 90 antihorario + vflip, 1 = 90 horario, 2 = 90 antihorario, 3 = 90 horario + vflip.

• Fuente: src/commands/transpose.js
• Filtro: transpose=<dir>

$ npx fqmpeg transpose input.mp4 --dir 2 --dry-run

  ffmpeg -i input.mp4 -vf transpose=2 -c:a copy input-transposed.mp4

Cuando dudes entre rotate y transpose: rotate 90 y transpose --dir 1 producen salida idéntica. Recurre a transpose solo cuando quieras las direcciones compuestas "rotación + reflejo" (0 o 3) que rotate no expone.

mirror — Original + espejo, lado a lado

Divide la entrada en dos streams, voltea uno, y los apila lado a lado (horizontal) o arriba-abajo (vertical). La salida es el doble de ancha (o alta) que la entrada, con el original en un lado y una copia espejada en el otro — un look común para fondos tipo caleidoscopio o tomas simétricas en videoclips.

• Fuente: src/commands/mirror.js
• Filtro (horizontal): [0:v]split[left][right];[right]hflip[flipped];[left][flipped]hstack
• Filtro (vertical): [0:v]split[top][bottom];[bottom]vflip[flipped];[top][flipped]vstack

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

  ffmpeg -i input.mp4 -filter_complex [0:v]split[left][right];[right]hflip[flipped];[left][flipped]hstack -c:a copy input-mirror.mp4

$ npx fqmpeg mirror input.mp4 --direction vertical --dry-run

  ffmpeg -i input.mp4 -filter_complex [0:v]split[top][bottom];[bottom]vflip[flipped];[top][flipped]vstack -c:a copy input-mirror.mp4

Si solo quieres voltear (un único lado, sin duplicar el ancho), usa rotate hflip. mirror siempre duplica la dimensión de salida en el eje elegido.

Movimiento

zoom — Zoom Ken Burns hacia adentro/afuera

El verbo de motion graphics. Aplica el filtro zoompan de FFmpeg para hacer zoom lento hacia el centro del cuadro (o desde él). La salida está hardcodeada a 1920×1080 a 30 fps — ver "tres cosas a tener en cuenta" #3 arriba.

• Fuente: src/commands/zoom.js
• Filtro: scale=8000:-1,zoompan=z='min(zoom+<speed>,1.5)':d=1:x='iw/2-(iw/zoom/2)':y='ih/2-(ih/zoom/2)':s=1920x1080:fps=30 (zoom in)
• La salida es siempre 1920×1080@30 — aunque tu fuente sea de otro tamaño o frame rate.
• El pre-escalado a 8000:-1 sirve para darle a zoompan una copia de trabajo en alta resolución para que el resultado ampliado se mantenga nítido.

$ npx fqmpeg zoom input.mp4 --direction in --dry-run

  ffmpeg -i input.mp4 -vf scale=8000:-1,zoompan=z='min(zoom+0.002,1.5)':d=1:x='iw/2-(iw/zoom/2)':y='ih/2-(ih/zoom/2)':s=1920x1080:fps=30 -c:a copy input-zoom-in.mp4

$ npx fqmpeg zoom input.mp4 --direction out --speed 0.005 --dry-run

  ffmpeg -i input.mp4 -vf scale=8000:-1,zoompan=z='if(eq(on,1),1.5,max(zoom-0.005,1))':d=1:x='iw/2-(iw/zoom/2)':y='ih/2-(ih/zoom/2)':s=1920x1080:fps=30 -c:a copy input-zoom-out.mp4

Speed 0.002 (default) llega a 1.5× en 250 frames (≈ 8 segundos a 30 fps). Speed 0.005 llega a 1.5× en 100 frames (≈ 3.3 segundos). Para secuencias Ken Burns de imágenes fijas, alarga la duración antes con loop o con los flags -loop 1 -t <segundos> de FFmpeg — zoom no extiende la duración por sí mismo.

Interlazado

deinterlace — Quitar artefactos de combing

Dos algoritmos: yadif (default — rápido, buena calidad) o bwdif (Bob Weaver Deinterlacing Filter — más nuevo, calidad un pelín mejor, ligeramente más lento). Para material moderno solo te encuentras interlazado en capturas de archivo o broadcast; ambos modos los manejan bien.

• Fuente: src/commands/deinterlace.js
• Filtro: yadif o bwdif

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

  ffmpeg -i input.mp4 -vf yadif -c:a copy input-deinterlaced.mp4

$ npx fqmpeg deinterlace input.mp4 --mode bwdif --dry-run

  ffmpeg -i input.mp4 -vf bwdif -c:a copy input-deinterlaced.mp4

Si tu fuente tiene combing visible (bordes en zigzag en movimiento horizontal), esto es lo primero que ejecutas — antes de cualquier compresión o color grading. Hacerlo después de re-encodear suele dejar artefactos residuales porque el patrón de combing ya quedó comprimido en el codec.

interlace — Hacer interlazado un video progresivo

La dirección inversa. Solo útil para entrega a pipelines broadcast o hardware legado que requiere entrada interlazada. Para todo lo web/móvil/streaming quieres progresivo — ni toques este comando.

• Fuente: src/commands/interlace.js
• Filtro: interlace

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

  ffmpeg -i input.mp4 -vf interlace -c:a copy input-interlaced.mp4

El orden de campo por defecto del filtro interlace es TFF (top-field-first). Si necesitas BFF para una spec específica de entrega, encadena field-order después.

field-order — Fijar TFF o BFF

Marca o reordena los campos para que la salida sea top-field-first (tff) o bottom-field-first (bff). Útil cuando una fuente interlazada se reproduce con movimiento entrecortado porque la etiqueta de orden de campo es errónea — invertirla suele arreglarlo.

• Fuente: src/commands/field-order.js
• Filtro: fieldorder=tff o fieldorder=bff

$ npx fqmpeg field-order input.mp4 tff --dry-run

  ffmpeg -i input.mp4 -vf fieldorder=tff -c:a copy input-tff.mp4

La mayoría de fuentes interlazadas modernas (1080i broadcast, DV) son TFF. Si tienes una captura vieja con BFF en disco pero TFF intencionado (o viceversa), field-order reescribe las etiquetas para que un deinterlace posterior aplique el algoritmo correcto.

Recetas reales

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

Receta 1: Video vertical de móvil a 16:9 amigable para YouTube

Grabaste un clip en el móvil (1080×1920 vertical) y quieres una salida 16:9 que no tenga barras de pillarbox enormes. backdrop rellena el lienzo con una copia difuminada de la fuente como fondo, y superpone el original encima.

# Paso 1: 1080x1920 vertical → 1920x1080 con fondo difuminado
npx fqmpeg backdrop phone-clip.mp4 --blur 25
# → phone-clip-backdrop.mp4 (1920x1080, fondo difuminado + video en primer plano)

# Paso 2 (opcional): comprimir para subida
npx fqmpeg compress phone-clip-backdrop.mp4 --crf 23
# → phone-clip-backdrop-compressed.mp4

Si el clip del móvil ya tiene movimiento que quieres conservar, baja el blur a 10–15 (el movimiento del fondo se ve más y crea un efecto "wallpaper en movimiento"). Un blur más alto (25–40) deja el fondo casi estático y mantiene la atención del espectador en el primer plano.

Receta 2: Quitar barras negras de un video descargado

Muchas descargas viejas vienen con barras de letterbox quemadas. crop-detect encuentra el rectángulo de contenido real, y crop quita lo de fuera.

# Paso 1: detectar el rectángulo de recorte
npx fqmpeg crop-detect movie.mp4
# Busca: [Parsed_cropdetect_0 @ ...] crop=1920:800:0:140
# (significa: conserva una región 1920x800 empezando en x=0, y=140)

# Paso 2: aplicar el recorte detectado
npx fqmpeg crop movie.mp4 1920x800 --pos 0:140
# → movie-crop1920x800.mp4

crop-detect corre sobre toda la entrada; el valor que imprime es la detección más común a través de los frames. Si la fuente tiene un logo o marca de agua que está en letterbox solo en los primeros frames pero no después, la detección puede salir mal — pasa --limit 30 (o más alto) para ser más agresivo tratando píxeles oscuros como "borde".

Receta 3: Restaurar material interlazado viejo a progresivo 1080p limpio

Tienes una captura DV o 1080i de una camcorder vieja. Objetivo: H.264 progresivo limpio listo para subir. El orden importa — primero deinterlace (antes de cualquier reescalado o compresión que congele el patrón de combing), luego resize, luego crop por si quedan bordes muertos.

# Paso 1: deinterlace primero - nunca comprimas antes de esto
npx fqmpeg deinterlace dv-capture.avi --mode bwdif
# → dv-capture-deinterlaced.avi (aún en la resolución DV original)

# Paso 2: redimensionar a 1080 de altura (el ancho se auto-escala manteniendo aspecto)
npx fqmpeg resize dv-capture-deinterlaced.avi -h 1080
# → dv-capture-deinterlaced-1080h.avi

# Paso 3: detectar y eliminar bordes negros si los hay
npx fqmpeg crop-detect dv-capture-deinterlaced-1080h.avi
# Aplicar las coordenadas detectadas:
npx fqmpeg crop dv-capture-deinterlaced-1080h.avi <WxH> --pos <x>:<y>
# → dv-capture-deinterlaced-1080h-crop<WxH>.avi

bwdif sobre yadif vale el tiempo extra en material de archivo — el pequeño bump de calidad evita que se compongan los "artefactos de deinterlazado encima de los artefactos de compresión" cuando re-encodees después para streaming. Tras los tres pasos de geometría, ejecuta compress --crf 20 para finalizar.

Preguntas Frecuentes

¿Por qué resize usa -2 en vez de -1 para el lado auto-escalado?

Porque la mayoría de codecs requieren dimensiones pares. -1 le dice a FFmpeg "preserva el aspecto", lo que puede producir números impares como 537. Cuando el encoder rechace eso con width not divisible by 2, has tirado un render. -2 dice "preserva el aspecto, pero ajusta a múltiplo de 2", que es lo que casi siempre quieres. fqmpeg hardcodea -2 para que no caigas en esto.

pad input.mp4 1920x1080 me amplía la fuente 1280×720 — ¿por qué?

Porque la cadena de filtros de pad empieza por scale=1920:1080:force_original_aspect_ratio=decrease. Eso amplía la fuente para que entre en el lienzo objetivo conservando el aspecto — para una fuente 1280×720 son 1920×1080 (no hace falta padding al mismo aspecto). Para un pad literal sin escalar, copia la salida --dry-run y borra la parte scale=..., dejando solo pad=1920:1080:(ow-iw)/2:(oh-ih)/2:color=black.

¿Por qué zoom está bloqueado en 1920×1080@30?

La expresión del filtro zoompan tiene s=1920x1080:fps=30 hardcodeada. No hay opción expuesta para sobrescribir. Si necesitas otro tamaño o frame rate, copia la salida --dry-run y edita los valores s=...:fps=... directamente. Para un zoom 1080p@60, cambia a s=1920x1080:fps=60.

Mi fuente tiene combing visible. ¿deinterlace es siempre seguro?

Es seguro en fuentes realmente interlazadas. En fuentes progresivas que han sido mal etiquetadas como interlazadas (o al revés), correr deinterlace ablanda la imagen y puede meter artefactos. Ejecuta ffprobe -show_streams input.mp4 | grep field_order para revisar la etiqueta, y comprueba visualmente si hay combing en movimiento horizontal. Si el archivo es progresivo pero está etiquetado como interlazado, ejecuta field-order para arreglar la etiqueta antes de tocar nada más.

¿Puedo correr crop-detect solo sobre los primeros 30 segundos?

No directamente desde fqmpeg — crop-detect siempre lee el archivo entero. El workaround es trim antes (trim source.mp4 --start 0 --duration 30 -o probe.mp4) y luego crop-detect probe.mp4. Para archivos largos esto puede ahorrar muchos minutos.

¿Cuál es la diferencia entre aspect --mode pad y el verbo pad?

aspect 16:9 --mode pad deriva el lienzo del ancho de la fuente y la ratio objetivo (una fuente 1280×720 se queda en 1280×720 — ya es 16:9, nada cambia; una fuente 1280×960 se queda en 1280×720 con barras de letterbox arriba y abajo). El pad 1920x1080 independiente siempre rellena hasta 1920×1080 literales sin importar el aspecto fuente, escalando antes si hace falta. Usa aspect cuando te importa la ratio, pad cuando te importan las dimensiones exactas en píxeles.

¿Cómo roto basándome en la orientación EXIF?

Vía fqmpeg no se puede — ningún verbo de geometría lee los metadatos de rotación. Pero FFmpeg sí respeta el metadato rotate cuando transcodea, así que cualquier encode (p.ej. compress) re-renderiza el video derecho si la fuente tiene tag de rotación. Para quitar el tag de rotación explícitamente sin rotar de verdad, usa FFmpeg directamente: ffmpeg -i input.mp4 -metadata:s:v:0 rotate=0 -c copy output.mp4.

¿Puedo redimensionar una carpeta entera en batch?

Loop estándar de shell:

for v in raw/*.mp4; do
  npx fqmpeg resize "$v" -h 720 -o "resized/$(basename "$v" .mp4)-720p.mp4"
done

Para batch de crop-detect-y-luego-crop, hay que capturar la línea crop=... de cada detección y reinyectarla, así que no es one-liner. El patrón habitual es find con while read.

Conclusión

Los catorce verbos C5 cubren las operaciones de geometría a las que recurres en un pase típico de "arreglar la imagen":

• resize, scale2x para cambios de dimensión (el truco del -2 para dimensiones pares; super2xsai para pixel art y fuentes con bordes duros)
• crop, crop-detect para recortar la región visible (la posición default de crop es centrada; crop-detect corre el filtro cropdetect y muestra coordenadas sugeridas)
• pad, aspect, backdrop para cambios de lienzo (pad escala-luego-rellena, aspect tiene tres modos, backdrop es el arreglo vertical-a-16:9)
• rotate, transpose, mirror para orientación (rotate cubre 90/180/270/hflip/vflip; transpose --dir 0 y --dir 3 añaden los compuestos rotación-y-reflejo)
• zoom para movimiento Ken Burns (siempre saca 1920×1080@30 — edita el --dry-run para otros tamaños)
• deinterlace, interlace, field-order para estructura de campos (deinterlace antes de cualquier re-encode; field-order arregla fuentes mal etiquetadas)

Cada verbo imprime su invocación FFmpeg subyacente con --dry-run, así que cuando los defaults no encajan (un zoom de otro tamaño, un pad literal sin pre-escalado), copias el comando, lo personalizas y ejecutas FFmpeg directamente. Para el mapa completo de fqmpeg, ver fqmpeg complete guide.