kaustubhupadhyaya/enrutador-de-herramientas-de-video

Enrutador de Herramientas de Video

Elige la herramienta más económica que satisfaga completamente la tarea. En esta máquina, la CALIDAD de transcodificación está limitada por la fuente y no es diferenciadora (cada herramienta alcanza VMAF 98.4-99.8), así que nunca elijas una herramienta "porque es de mayor calidad" para una transcodificación simple. Solo elige DaVinci Resolve cuando la tarea sea CORRECTIVA o CREATIVA (etalonaje, mapeo de tonos, eliminación de ruido, estabilización, reescalado, finalización multiclips) — ese es el único régimen donde es la herramienta correcta. Cuesta ~15x el tiempo de FFmpeg más una configuración más pesada, y su ventaja en etalonaje/eliminación de ruido/estabilización/reescalado es una expectativa estándar del dominio, NO algo que el benchmark a continuación midió (ese benchmark solo cubre transcodificación simple).

Árbol de decisión (coincide con la PRIMERA regla que se ajuste)

1. Sin cambio de píxeles — cortar / recortar / unir / concatenar / remezclar / cambio de contenedor / extraer audio -> FFmpeg stream-copy (-c copy). ~1.2s, sin pérdida. La edición real más rápida — prefierela siempre que los píxeles no necesiten cambiar. Dos salvedades: (a) el corte es preciso en fotogramas clave, no en fotogramas exactos — el inicio se ajusta al fotograma clave más cercano; vuelve a codificar si necesitas un límite de fotograma exacto. (b) la salida permanece en el códec fuente (HEVC) — si necesitas un producto final H.264, esta regla no aplica; ve a la regla 2.

2. Transcodificar / escalar / comprimir (los píxeles cambian, sin corrección) -> FFmpeg libx264. Por defecto -preset medium -crf 20. Usa veryfast/ultrafast cuando la velocidad importe — la calidad apenas difiere (ultrafast sigue siendo VMAF 99.66). Recurre a veryslow solo cuando estés limitado por almacenamiento/ancho de banda — 40x el cómputo sobre ultrafast compra +0.12 VMAF (invisible) pero casi reduce el archivo a la mitad. Incluso así, medium ya captura casi toda esa reducción (13.3 MB vs 12.6 MB de veryslow), por lo que veryslow rara vez vale ~6x el tiempo de medium.

3. Eliminación de silencios / aire muerto en audio de entrevistas o tutoriales -> auto-editor. ADVERTENCIA: muy lento en HEVC (decodificación por software) y solo AYUDA si el audio realmente tiene silencios. Inútil en metraje con audio continuo (clips de conducción/carretera/música) — trabajará durante ~30+ min y cortará 0 segundos.

4. Ensamblaje programático — cortes scripteados + texto/superposiciones/transiciones en Python -> MoviePy 2.x. Espera aproximadamente la velocidad de ffmpeg más la sobrecarga de Python. Úsalo cuando la lógica de composición sea más fácil en código que en un filter_complex largo de ffmpeg.

5. Etalonaje / mapeo de tonos HLG->SDR / eliminación de ruido / estabilización / reescalado (SuperScale) / finalización creativa multiclips -> DaVinci Resolve mediante API de Python. El único régimen donde "hacerlo en Resolve" es correcto. ~15x el tiempo de FFmpeg, gestionado por color (no es un paso transparente). Su ventaja de calidad aquí es estándar del dominio, no está evaluada más abajo. Configuración en su propia sección.

6. Títulos 3D / gráficos en movimiento -> Blender sin interfaz -> fotogramas PNG -> ffmpeg mux. NOTA: La enumeración image_settings.file_format del renderizador de Blender 5.1 NO tiene opción FFMPEG/video. NO intentes image_settings.file_format='FFMPEG' o exportación de video VSE scripteada — está roto en esta compilación. Renderiza fotogramas de imagen, luego multiplexa con ffmpeg.

7. Edición basada en IA / texto (editar por transcripción, eliminar palabras de relleno, "hacerlo más corto") -> Descript MCP.

Comandos exactos (listos para copiar y pegar)

1. Stream-copy (sin recodificar)

# recortar: -t es DURACIÓN (inequívoco). El corte es preciso en fotogramas clave, la salida permanece HEVC.
ffmpeg -ss 10 -i in.mov -t 15 -c copy out.mov
# concatenar (list.txt líneas: file 'clip1.mov')
ffmpeg -f concat -safe 0 -i list.txt -c copy out.mov
# remezclar contenedor / extraer audio (sin recodificar)
ffmpeg -i in.mov -c copy out.mp4
ffmpeg -i in.mov -vn -c:a copy out.m4a

(Usa -t <segundos> para duración. Evita -ss ... -to ... con -c copy: el punto de referencia de -to es ambiguo con la búsqueda en el lado de entrada y puede producir la longitud incorrecta. Para un límite de fotograma exacto, elimina -c copy y recodifica — eso reintroduce el costo de decodificación HEVC.)

2. Transcodificar HEVC -> H.264

# equilibrio por defecto
ffmpeg -i in.mov -c:v libx264 -preset medium -crf 20 -c:a aac -b:a 192k out.mp4
# primero la velocidad (la calidad apenas difiere)
ffmpeg -i in.mov -c:v libx264 -preset veryfast -crf 20 -c:a aac -b:a 192k out.mp4
# escalar a 720p mientras se transcodifica
ffmpeg -i in.mov -vf scale=-2:720 -c:v libx264 -preset medium -crf 20 -c:a aac out.mp4

3. Eliminación de silencios

auto-editor in.mp4 --edit audio:threshold=4% -o out.mp4
# comprueba el corte primero si no estás seguro de que el audio tenga silencios:
auto-editor in.mp4 --edit audio:threshold=4% --preview

4. MoviePy 2.x (API renombrada: subclipped / with_position / with_duration)

from moviepy import VideoFileClip, TextClip, CompositeVideoClip
clip = VideoFileClip("in.mov").subclipped(10, 25)
# NOTA: MoviePy 2.x TextClip necesita una RUTA DE ARCHIVO de fuente, no un nombre de familia como "Arial".
txt = (TextClip(text="Hola", font=r"C:\Windows\Fonts\arial.ttf", font_size=48, color="white")
       .with_duration(5).with_position("center"))
final = CompositeVideoClip([clip, txt])
final.write_videofile("out.mp4", codec="libx264", preset="medium",
                      ffmpeg_params=["-crf", "20"])

6. Blender 3D/gráficos en movimiento -> fotogramas -> mux

# renderizar animación a fotogramas PNG (NO configures file_format='FFMPEG' en 5.1)
blender -b scene.blend -o "//frames/f_####" -F PNG -a
# multiplexar fotogramas a H.264 (coincide -framerate con los fps de la escena)
ffmpeg -framerate 30 -i frames/f_%04d.png -c:v libx264 -preset medium -crf 20 -pix_fmt yuv420p out.mp4

Guardia HLG (EJECUTA ESTO ANTES DE CUALQUIER EXPORTACIÓN SDR H.264)

Parte del metraje de iPhone es HLG de 10 bits. Una exportación ingenua a libx264 a SDR vuelve gris / lava el color a menos que se mapeen los tonos.

# 1. sondear la característica de transferencia
ffprobe -v error -select_streams v:0 -show_entries stream=color_transfer -of default=nk=1:nw=1 in.mov

• Salida arib-std-b67 (HLG) o smpte2084 (PQ) -> el metraje es HDR: mapea los tonos antes/durante la codificación.
• Cualquier otra cosa (bt709, desconocido) -> ya es SDR: usa el comando de transcodificación normal.

# 2. Mapeo de tonos HLG/PQ -> SDR BT.709 + H.264 en un solo paso (y etiqueta la salida como bt709)
ffmpeg -i in.mov -vf \
"zscale=t=linear:npl=100,format=gbrpf32le,zscale=p=bt709,tonemap=tonemap=hable:desat=0,zscale=t=bt709:m=bt709:r=tv,format=yuv420p" \
-c:v libx264 -preset medium -crf 20 -color_primaries bt709 -color_trc bt709 -colorspace bt709 \
-c:a aac -b:a 192k out_sdr.mp4

npl=100 es la luminancia pico nominal utilizada para la linealización; auméntala si los reflejos brillantes se recortan. Alternativa: deja que la gestión de color de DaVinci Resolve haga la conversión Rec.2020-HLG -> Rec.709 (enruta a Resolve si de todas formas vas a etalonar — lo hace con más precisión que el mapeo de tonos de ffmpeg).

Configuración de la API de Python de DaVinci Resolve (la ruta correctiva/creativa)

PROBLEMAS incluidos a continuación: debe ejecutarse en Python 3.11 (py -3.11) — el 3.14 por defecto falla al iniciar fusionscript.dll. RESOLVE_SCRIPT_API / RESOLVE_SCRIPT_LIB son variables de entorno persistentes. Resolve debe estar ejecutándose (o iniciarlo -nogui). Usa un proyecto temporal desechable, establece formato+códec explícitamente, luego renderiza y sondea.

# Ejecutar con:  py -3.11 resolve_render.py
import os, sys, time
sys.path.append(os.path.join(os.environ["RESOLVE_SCRIPT_API"], "Modules"))  # encabezado requerido
import DaVinciResolveScript as dvr

resolve = dvr.scriptapp("Resolve")          # Resolve ya debe estar ejecutándose (o iniciar -nogui primero)
pm      = resolve.GetProjectManager()

proj_name = "temp_render_" + str(int(time.time()))   # mantener el nombre para que la limpieza pueda coincidir
proj    = pm.CreateProject(proj_name)
pool    = proj.GetMediaPool()
items   = resolve.GetMediaStorage().AddItemListToMediaPool([r"C:\in\clip.mov"])
tl      = pool.CreateTimelineFromClips("temp_timeline", items)   # también lo establece como actual

# ---- aplicar el refinamiento que justificó Resolve aquí ----
# (etalonaje / gestión de color del proyecto para HLG->SDR / SuperScale / eliminación de ruido / estabilización)

proj.SetCurrentRenderFormatAndCodec("mp4", "H264")   # formato + códec explícito
proj.SetRenderSettings({
    "TargetDir": r"C:\out",
    "CustomName": "out",
    "SelectAllFrames": True,
})
pid = proj.AddRenderJob()
proj.StartRendering(pid)

while proj.IsRenderingInProgress():                   # bucle de render + espera
    time.sleep(1)
print("render:", proj.GetRenderJobStatus(pid))

# limpieza: cerrar el proyecto actual antes de eliminar el temporal
pm.CloseProject(proj)
pm.DeleteProject(proj_name)                           # coincide con el nombre que generamos arriba

Variables de entorno (para referencia / volver a persistir):

RESOLVE_SCRIPT_API = C:\ProgramData\Blackmagic Design\DaVinci Resolve\Support\Developer\Scripting
RESOLVE_SCRIPT_LIB = C:\Program Files\Blackmagic Design\DaVinci Resolve\fusionscript.dll

Realidad de rendimiento en esta máquina

• La decodificación de software HEVC es el verdadero cuello de botella. Cada transcodificación de este metraje de iPhone es lenta independientemente de la herramienta; veryslow tomó ~5 min para 15s de 720p. Cada herramienta paga el mismo impuesto de decodificación — el diferenciador es solo lo que sucede después de la decodificación.
• Prefiere stream-copy (~1.2s) siempre que no se necesite cambio de píxeles (y la salida HEVC sea aceptable). Si debes recodificar y la velocidad importa, usa FFmpeg ultrafast/veryfast (~7s).
• DaVinci Resolve es ~15x más lento que FFmpeg y gestiona el color en la salida (archivos más grandes, la salida difiere intencionalmente de la fuente). Vale la pena solo para etalonaje/mapeo de tonos/eliminación de ruido/estabilización/reescalado/finalización creativa.
• auto-editor puede tomar 30+ min en un clip HEVC largo y puede no eliminar nada — solo ejecútalo en audio de entrevistas/tutoriales que realmente tenga pausas.

Base empírica (confía en el enrutamiento, no en el segundo decimal)

Tarea: recortar segundos 10-25 (15s) luego transcodificar HEVC->H.264 720p, ejecutar en serie para un temporizado justo de CPU, VMAF vs la fuente sin tocar. Metraje: iPhone HEVC 720p30 (un clip representativo de un conjunto de 9 clips). Los números son ejecuciones individuales (n=1), sin repeticiones — las grandes brechas (el enrutamiento) son sólidas; las pequeñas (por ejemplo, MoviePy vs ffmpeg medium) están dentro del ruido de una sola ejecución.

Herramienta / configuración	Tiempo	Tamaño	VMAF	Veredicto
FFmpeg stream-copy (-c copy, permanece HEVC)	1.2s	11.0 MB	sin pérdida	Más rápido; solo cortar/unir/remezclar, sin cambio de píxeles, la salida permanece HEVC
FFmpeg libx264 ultrafast crf20	7.4s	22.3 MB	99.66	Transcódigo real más rápido; la calidad ya está en el techo limitado por la fuente
FFmpeg libx264 medium crf20	47.9s	13.3 MB	99.71	Equilibrio por defecto; captura casi todo el beneficio de tamaño
FFmpeg libx264 veryslow crf20	297s (~5 min)	12.6 MB	99.78	+0.12 VMAF (invisible), ~0.7 MB sobre medium — solo si estás limitado por tamaño
MoviePy (x264 medium crf20)	53.5s	13.4 MB	99.44*	~ velocidad ffmpeg + sobrecarga de Python (brecha dentro del ruido); úsalo para composiciones scripteadas
Blender VSE video export	FALLÓ	—	—	Sin enumeración de video en 5.1; renderiza fotogramas + ffmpeg mux
DaVinci Resolve (API, H264 por defecto)	109s	48.2 MB	98.40*	~15x más lento, gestionado por color; solo correctivo/creativo
auto-editor (clip completo de 81s)	2021s (~34 min)	—	—	Cortó 0s: el audio era continuo — herramienta incorrecta para ello

* Los VMAF de MoviePy y Resolve se midieron de nuevo en una pasada sin recorte emparejada, por lo que no son perfectamente comparables con las filas de ffmpeg recortadas. Los 48.2 MB y 98.40 para Resolve provienen de pasadas diferentes (la nueva medición sin recorte produjo 15.24 MB): Resolve lee más bajo en comparación con la fuente sin tocar porque está gestionado por color, no es un paso transparente, y su archivo más grande es un artefacto de tasa de bits por defecto que prioriza la calidad. Un renderizado Resolve con CQ/tamaño emparejado cambiaría ambas comparaciones — el tamaño 3.75x depende del valor por defecto, no es intrínseco.

Conclusiones sobre las que se basa el enrutamiento: (1) La calidad de transcodificación simple no es diferenciadora — no la persigas. (2) El barrido de preajustes de FFmpeg es un intercambio de velocidad vs eficiencia de tasa de bits, no un intercambio de calidad. (3) "Más refinado" solo significa algo para trabajo correctivo/creativo; ahí DaVinci Resolve es la herramienta correcta (una expectativa estándar del dominio, no medida aquí) — en ningún otro lado.