Si tienes una colección de películas o series en formato .mkv y te has dado cuenta de que ocupan una barbaridad (versiones 4K que superan los 40 o 50 GB, o incluso 1080p que pesan más de lo necesario), este artículo te va a interesar. Con la herramienta FFmpeg y el códec H.265 (HEVC) vamos a aprender a recomprimir vídeos desde la terminal de Linux sin perder una calidad apreciable, ya sea contenido en 4K, 1080p, SDR o HDR.

La idea es que puedas copiar y pegar los comandos tal cual, entender qué hace cada uno y adaptarlos a tu caso concreto. Todo lo he probado sobre Manjaro GNOME, pero sirve para cualquier distribución Linux basada en Arch (y con pequeños ajustes, para cualquier otra).

H.265 vs AV1: ¿qué códec elegir y por qué no uso AV1 todavía?

Antes de empezar a meter comandos, conviene dejar claro con qué vamos a codificar y por qué.

El códec que vamos a usar en esta guía es H.265, también conocido como HEVC (High Efficiency Video Coding). Es el sucesor del H.264 y ofrece aproximadamente la mitad de peso para una calidad visual similar. Lleva años en el mercado y tiene un soporte amplísimo: televisiones, reproductores multimedia, tarjetas gráficas, procesadores, sistemas operativos, etc.

Por otro lado existe AV1, un códec más moderno y abierto, impulsado por un consorcio de grandes empresas tecnológicas. AV1 comprime aún más que H.265 y mantiene la calidad incluso mejor en muchos casos. Sobre el papel, es superior.

Entonces, ¿por qué no lo usamos? Porque todavía es muy nuevo en lo que a hardware de reproducción se refiere. Muchos televisores, y sobre todo muchos televisores reproduciendo contenido por red (vía DLNA, Plex, Jellyfin, SMB o similar), no tienen decodificación por hardware de AV1 o directamente no lo soportan. El resultado: la TV se queda en negro, reproduce a tirones o directamente se niega a abrir el archivo. En cambio, H.265 lo reproduce prácticamente todo.

La conclusión práctica es sencilla:

• Hoy: recomprime en H.265 (HEVC). Compatibilidad total, buena compresión, calidad excelente.
• En el futuro: cuando tengas una TV compatible con AV1, podrás empezar a recomprimir por software con ese códec y ahorrar aún más espacio manteniendo todavía mejor la calidad.

Es decir, esta guía no es “la definitiva para siempre”, es la que tiene sentido usar hoy.

¿Qué necesitamos tener instalado en Linux?

Todo el trabajo lo vamos a hacer con dos herramientas de línea de comandos:

• FFmpeg: el navaja suiza de la edición y conversión de vídeo y audio.
• MKVToolNix: nos hará falta porque FFmpeg, al escribir en un archivo .mkv, a veces deja la cabecera del contenedor al final del archivo en lugar de al principio. El comando mkvmerge reescribe el archivo para que esa cabecera quede al principio y sea reproducible en cualquier reproductor.

En Manjaro, o cualquier distro basada en Arch, se instalan desde los repositorios oficiales con pacman:

sudo pacman -S ffmpeg mkvtoolnix-cli

Si usas otra distribución, el paquete será equivalente:

• Ubuntu / Debian / Linux Mint: sudo apt install ffmpeg mkvtoolnix
• Fedora: sudo dnf install ffmpeg mkvtoolnix
• openSUSE: sudo zypper install ffmpeg mkvtoolnix

Puedes comprobar que todo está instalado con:

ffmpeg -version
mkvmerge --version

Conceptos clave antes de tocar nada

Los comandos que veremos después usan una serie de parámetros que conviene entender para no ir a ciegas:

• CRF (Constant Rate Factor): controla la calidad. Más bajo = más calidad y más peso. Más alto = menos calidad y menos peso. En H.265, los valores útiles suelen ir de 18 a 23. El 18 se suele considerar “visualmente sin pérdida” y el 22 es un gran equilibrio entre tamaño y calidad. En pruebas reales, un 4K de 47 GB puede bajar a 28,5 GB sin que se note apenas nada.
• Preset: controla cuánto tiempo y esfuerzo dedica el codificador a analizar el vídeo. fast es un buen punto medio. medium tarda más pero comprime mejor. ultrafast comprime peor pero rapidísimo.
• pix_fmt: el formato de color. Para contenido SDR usaremos yuv420p y para contenido HDR usaremos yuv420p10le (10 bits por canal, necesario para el HDR).
• x265-params: parámetros avanzados que se le pasan directamente al codificador x265. Ahí es donde afinamos cosas como el AQ (Adaptive Quantization) o la psico-visual.

Paso 1: Detectar los bordes negros del vídeo (cropdetect)

Muchas películas en 4K vienen con barras negras arriba y abajo (letterbox). Esas barras ocupan espacio y no aportan nada. Si las recortamos antes de codificar, ahorramos bytes y además evitamos que el codificador pierda tiempo analizando píxeles negros planos.

Para detectar el recorte exacto de un vídeo, lanzamos varias muestras en distintos minutos del metraje y dejamos que FFmpeg nos diga el valor crop recomendado:

for ss in 600 1800 3000 4200 5400; do
echo "=== Minuto $((ss/60)) ==="
ffmpeg -ss $ss -i "NUESTRA-PELICULA.mkv" -t 20 -vf cropdetect -f null - 2>&1 | \
grep "crop=" | tail -n 30 | awk -F'crop=' '{print $2}' | sort -u
done

Qué hace este bloque:

• Recorre los segundos 600, 1800, 3000, 4200 y 5400, que equivalen a los minutos 10, 30, 50, 70 y 90 de la película.
• En cada punto, FFmpeg salta a ese segundo (-ss) y analiza 20 segundos (-t 20).
• El filtro cropdetect detecta automáticamente las barras negras.
• -f null - le dice a FFmpeg que no escriba salida, solo que procese (así no creamos ningún archivo).
• El resto del pipe filtra las líneas con crop=, coge las últimas 30, se queda con el valor que hay después de crop= y muestra los valores únicos con sort -u.

Si todos los valores coinciden (por ejemplo, 3840:1600:0:280), ese es el recorte que debes usar. Significa: ancho 3840, alto 1600, offset X = 0, offset Y = 280.

Paso 2: Comprobar colores y si es HDR

Antes de codificar, es importante saber si el vídeo es SDR o HDR, y con qué espacio de color. Si codificas un HDR como SDR, los colores se verán raros. Este comando nos lo dice:

ffprobe -v error -show_entries stream=pix_fmt,color_space,color_transfer,color_primaries,bits_per_raw_sample -of default=noprint_wrappers=1 "NUESTRA-PELICULA.mkv" | grep -E "pix_fmt|color_space|color_transfer|color_primaries|bits_per_raw_sample"

Qué hace:

• ffprobe es la herramienta de FFmpeg que analiza sin convertir.
• -show_entries selecciona solo los campos que nos interesan.
• -of default=noprint_wrappers=1 muestra los valores limpios sin corchetes.
• El grep final filtra la salida para quedarnos solo con las líneas relevantes.

Si ves color_transfer=smpte2084 o color_primaries=bt2020, estás ante un HDR. Si ves bt709, es SDR.

Comprobar metadatos de brillo HDR (opcional)

Algunas películas HDR llevan metadatos de brillo (mastering display y content light level). Si quieres conservarlos, puedes comprobarlos así:

ffprobe -v error -show_streams -select_streams v:0 "NUESTRA-PELICULA.mkv" | grep -i mastering

Si aparece información, la añadirás luego al comando de codificación con master-display y max-cll. Si no aparece nada, no los pongas: la configuración universal del comando HDR ya es segura.

Paso 3: Verificar que el MKV original no tiene errores

Antes de gastar horas codificando, conviene comprobar que el archivo original no está corrupto. Si lo está, cualquier recompresión arrastrará esos errores o fallará directamente.

Comando para un archivo concreto:

systemd-inhibit --what=sleep --why="Verificar mkv" \
ffmpeg -err_detect explode -v error \
-i "NUESTRA-PELICULA.mkv" \
-f null - 2>&1 | grep -Ei "concealing|corrupt|invalid|error|damaged|missing|bitstream|time=" | tee errores.txt

Qué hace:

• systemd-inhibit --what=sleep evita que el sistema entre en suspensión mientras se ejecuta.
• -err_detect explode hace que FFmpeg sea extremadamente estricto: cualquier mínimo error hará que avise.
• -v error baja el nivel de log para mostrar solo errores.
• -f null - vuelve a indicar que no queremos salida, solo analizar.
• El pipe con grep -Ei filtra mensajes sospechosos y los guarda en errores.txt con tee.

Si al terminar el errores.txt está vacío o solo contiene líneas de time=, el archivo está limpio. Si aparecen concealing, corrupt o invalid, mejor no recomprimas ese archivo hasta arreglarlo.

Verificar toda una carpeta a la vez

Si tienes una carpeta llena de MKVs, puedes generar un .txt de errores por cada archivo automáticamente:

systemd-inhibit --what=sleep --why="Verificar todos los mkv" \
bash -c 'for f in *.mkv; do
echo "Procesando: $f"
ffmpeg -err_detect explode -v error -i "$f" -f null - 2>&1 |
grep -Ei "concealing|corrupt|invalid|error|damaged|missing|bitstream|time=" > "${f%.mkv}.txt"
done'

Recorre todos los .mkv de la carpeta actual y genera un .txt con el mismo nombre por cada uno.

Paso 4: Comando base para recomprimir en SDR (1080p y 4K) SIN recorte de bandas negras

Este es el comando estrella. Sirve tanto para 4K como para 1080p en SDR. Solo tienes que cambiar el nombre del archivo de entrada y, si quieres, añadir el recorte (-vf crop=...) que hayas detectado antes.

systemd-inhibit --what=sleep --why="Encode ffmpeg" nice -n 10 ffmpeg -nostdin \
-analyzeduration 100M \
-probesize 100M \
-i "NUESTRA-PELICULA.mkv" \
-map 0:v -map 0:a -map "0:s?" \
-map_metadata 0 \
-c:v libx265 \
-preset fast \
-crf 22 \
-pix_fmt yuv420p \
-x265-params "aq-mode=4:aq-strength=0.8:psy-rd=2.0:psy-rdoq=1.0:rd=6:rdoq-level=2:pools=12:frame-threads=4" \
-threads 12 \
-c:a copy \
-c:s copy \
-stats "NUESTRA-PELICULA-22.mkv" && \
mkvmerge -o "NUESTRA-PELICULA-22_fixed.mkv" "NUESTRA-PELICULA-22.mkv" && \
mv "NUESTRA-PELICULA-22_fixed.mkv" "NUESTRA-PELICULA-22.mkv"

Vamos línea por línea:

• systemd-inhibit --what=sleep --why="Encode ffmpeg": evita que el equipo se duerma durante la codificación, que puede durar horas.
• nice -n 10: le da al proceso una prioridad ligeramente menor, para que no bloquee el sistema mientras trabajas.
• ffmpeg -nostdin: lanza FFmpeg desactivando la lectura del teclado (evita que se quede colgado con algunos pipes).
• -analyzeduration 100M -probesize 100M: aumenta el análisis inicial del archivo. Útil en archivos grandes o con estructura compleja.
• -i "...": archivo de entrada.
• -map 0:v -map 0:a -map "0:s?": copia todas las pistas de vídeo, audio y subtítulos. El ? en subtítulos indica que si no hay, no pasa nada.
• -map_metadata 0: conserva los metadatos del archivo original.
• -c:v libx265: aquí está la clave, codificamos vídeo con el códec H.265 usando la librería libx265.
• -preset fast: velocidad de codificación rápida pero decente.
• -crf 22: calidad. Recuerda: 18 más calidad, 22 más compresión (punto dulce), 26 aún más compresión pero con pérdida de calidad.
• -pix_fmt yuv420p: formato de color 8 bits, el estándar para SDR.
• -x265-params "...": parámetros finos del codificador. Lo que hace cada uno:
  • aq-mode=4: modo de cuantización adaptativa agresivo, mejora las zonas oscuras y con grano.
  • aq-strength=0.8: intensidad del modo anterior.
  • psy-rd=2.0 y psy-rdoq=1.0: optimizaciones psico-visuales, es decir, que el ojo humano perciba menos artefactos.
  • rd=6 y rdoq-level=2: mejoran la decisión de codificación (a cambio de tiempo).
  • pools=12:frame-threads=4: paralelización. Ajusta a los núcleos de tu CPU.
• -threads 12: hilos de FFmpeg.
• -c:a copy -c:s copy: audio y subtítulos se copian tal cual, sin recodificar. Así no pierden calidad y van rapidísimo.
• -stats "salida.mkv": muestra progreso y escribe el archivo de salida.
• Después, el && encadena el mkvmerge para arreglar la cabecera del MKV y el mv para dejar el archivo final con el nombre limpio pero con -22 indicando que es el nuevo archivo recomprimido a calidad 22 (puedes cambiar el nombre de archivo por cualquier otro nombre).

Paso 5: Comando para HDR 4K CON recorte de bandas negras

Si el vídeo original es HDR, hay que cambiar varias cosas: el pix_fmt a 10 bits, añadir los metadatos de color y activar hdr-opt en x265. Además, si tiene bandas negras y quieres recortarlas debes añadir el parámetro crop, en este caso al ser una resolucion 4K, éste comando de ejemplo solo vale para un vídeo de 4K HDR. Aquí tienes el comando, ya con el recorte que hayas detectado previamente y con las opciones HDR:

systemd-inhibit --what=sleep --why="Encode ffmpeg" nice -n 10 ffmpeg -nostdin \
-analyzeduration 100M \
-probesize 100M \
-i "NUESTRA-PELICULA.mkv" \
-map 0:v -map 0:a -map "0:s?" \
-map_metadata 0 \
-vf "crop=3840:1600:0:280" \
-c:v libx265 \
-preset fast \
-crf 22 \
-pix_fmt yuv420p10le \
-color_primaries bt2020 \
-color_trc smpte2084 \
-colorspace bt2020nc \
-x265-params "hdr-opt=1:repeat-headers=1:colorprim=bt2020:transfer=smpte2084:colormatrix=bt2020nc:aq-mode=4:aq-strength=0.8:psy-rd=2.0:psy-rdoq=1.0:rd=6:rdoq-level=2:pools=12:frame-threads=4" \
-threads 12 \
-c:a copy \
-c:s copy \
-stats "NUESTRA-PELICULA-22.mkv" && \
mkvmerge -o "NUESTRA-PELICULA-22_fixed.mkv" "NUESTRA-PELICULA-22.mkv" && \
mv "NUESTRA-PELICULA-22_fixed.mkv" "NUESTRA-PELICULA-22.mkv"

Diferencias frente al comando SDR:

• -vf "crop=...": recorta las barras negras. Sustituye los valores por los que te haya dado el cropdetect.
• -pix_fmt yuv420p10le: obligatorio para HDR. 10 bits por canal.
• -color_primaries bt2020 -color_trc smpte2084 -colorspace bt2020nc: metadatos de color HDR. No cambiar salvo que el original use otro espacio.
• hdr-opt=1:repeat-headers=1: activa optimizaciones para HDR y repite los headers SEI en cada keyframe (necesario para que el reproductor detecte HDR correctamente).
• En x265-params también se añaden colorprim, transfer y colormatrix para que queden grabados en el propio stream de vídeo, no solo en el contenedor.

Si además has encontrado metadatos de brillo con el comando ffprobe ... | grep -i mastering del Paso 2, añádelos al final del x265-params así (los valores son un ejemplo, sustituye por los tuyos):

:master-display=G(0.265,0.690)B(0.150,0.060)R(0.680,0.320)WP(0.3127,0.3290)L(40000000,50):max-cll=1000,551

Pero insisto: si ese comando no te devolvió nada, no los pongas. La configuración universal del comando HDR ya es segura y funcional para la gran mayoría de películas.

El resultado quedará con el nombre “NUESTRA-PELICULA-22.mkv”, hemos añadido como en el anterior ejemplo la terminación “-22” para saber que es éste el vídeo final recomprimido a esa calidad. Puedes cambiar el nombre del vídeo final a cualquier otro siempre que no pise el nombre original.

Paso 6: Comprimir toda una carpeta en bucle (ideal para series)

Si tienes una temporada completa con 10 o 20 episodios, hacerlo uno a uno es una tortura. Este script recorre todos los .mkv de la carpeta actual y los procesa en cadena, mostrando en pantalla por qué capítulo va.

La clave para que la consola no se llene de basura es quitar -stats y añadir -loglevel error -nostats. Así FFmpeg solo muestra mensajes si hay un problema real, y los echo con el progreso quedan siempre visibles en la última línea de la terminal.

systemd-inhibit --what=sleep --why="Encode batch x265" \
bash -c '
shopt -s nullglob
videos=(*.mkv)
total=${#videos[@]}
actual=0
for entrada in "${videos[@]}"; do
((actual++))
porcentaje=$(( actual * 100 / total ))
echo "=== Procesando $actual/$total ($porcentaje%) : $entrada ==="
nice -n 10 ffmpeg \
-analyzeduration 100M -probesize 100M \
-i "$entrada" \
-map 0:v -map 0:a -map "0:s?" -map_metadata 0 \
-vf "crop=3840:1600:0:280" \
-c:v libx265 -preset fast -crf 22 -pix_fmt yuv420p \
-x265-params "aq-mode=4:aq-strength=0.8:psy-rd=2.0:psy-rdoq=1.0:rd=6:rdoq-level=2:pools=12:frame-threads=4" \
-threads 12 -c:a copy -c:s copy \
-loglevel error -nostats \
"${entrada%.mkv}-22.mkv"
echo "✔ Terminado: ${entrada%.mkv}-22.mkv"
echo "-------------------------------------------------"
done
echo "Todos los $total archivos han sido procesados."
'

Qué hace:

• shopt -s nullglob: evita que si no hay MKVs, el bucle reciba un asterisco literal.
• videos=(*.mkv): guarda todos los MKVs en un array.
• El for recorre uno a uno y calcula el porcentaje de progreso.
• El bloque ffmpeg es igual que antes pero con -loglevel error -nostats para no ensuciar la salida.
• ${entrada%.mkv}-22.mkv: genera el nombre de salida quitando la extensión y añadiendo -22.

Si la serie es SDR, deja el -pix_fmt yuv420p. Si es HDR, sustituye toda la parte de codificación por la del Paso 5 (con yuv420p10le y los parámetros HDR). También puedes cambiar el crop por el que corresponda a esa serie en concreto.

Paso 7: Hacer una prueba rápida de 1 minuto antes de codificar todo partiendo del minuto 5 de la película

Antes de lanzar una codificación de dos horas, conviene hacer una prueba con un minuto para ver cuánto va a pesar y cómo se ve. Este comando hace justo eso, iniciando la prueba en el minuto 5 del vídeo:

ffmpeg \
-ss 00:05:00 \
-t 00:01:00 \
-analyzeduration 100M \
-probesize 100M \
-i "NUESTRA-PELICULA.mkv" \
-map 0:v -map 0:a -map "0:s?" \
-map_metadata 0 \
-vf "crop=3840:1632:0:264" \
-c:v libx265 \
-preset fast \
-crf 22 \
-pix_fmt yuv420p10le \
-x265-params "hdr-opt=1:repeat-headers=1:colorprim=bt2020:transfer=smpte2084:colormatrix=bt2020nc:aq-mode=4:aq-strength=0.8:psy-rd=2.0:psy-rdoq=1.0:rd=6:rdoq-level=2:pools=12:frame-threads=4" \
-threads 12 \
-c:a copy \
-c:s copy \
-stats \
"NUESTRA-PELICULA-22.mkv"

Codificar 60 segundos tarda muy poco y te sirve para comprobar el peso, la calidad y, sobre todo, que el comando no tiene ningún error antes de dejarlo corriendo horas. Además, pudiendo elegir en qué minuto iniciar la prueba, puedes comprobar como se vería una escena concreta. En este ejemplo hemos tomamos 1 minuto a partir del minuto 5 de la película.

Consejos finales y ajustes según tu equipo

• Ajusta los hilos: los valores pools=12, frame-threads=4 y -threads 12 están pensados para una CPU de 12 núcleos. Si tienes 8, baja a pools=8, frame-threads=4 y -threads 8. Si tienes 16, súbelo. Como regla general, usa tantos pools como núcleos físicos.
• CRF según prioridad: usa 18 si la película es de tus favoritas y quieres conservar el grano y los detalles finos al máximo. Usa 22 si quieres ahorrar espacio sin que se note apenas. Diferencias de calidad entre ambos son mínimas, pero el peso puede ser un 30-40% menor.
• El grano es lo más difícil de comprimir: películas con mucho grano (tipo cine clásico o rodajes con ISO alto) van a ocupar bastante más que otras más limpias con el mismo CRF. Es normal.
• Nunca uses ultrafast para archivar: comprime muy mal. Si tienes prisa, usa fast; si puedes dejarlo toda la noche, prueba medium.
• Verifica siempre el archivo de salida: reproduce unos minutos y comprueba que el audio y los subtítulos siguen sincronizados. Si algo falla, casi siempre es porque el archivo original tenía algún error no detectado.
• Espacio libre: la codificación temporalmente ocupa el archivo original + el nuevo. Asegúrate de tener el doble del tamaño del original en disco antes de empezar.

Conclusión

Recomprimir vídeos en Linux con FFmpeg y H.265 es una de esas tareas que parecen complicadas al principio, pero que una vez automatizadas te ahorran cientos de gigas y muchísimo tiempo. Con los comandos de esta guía puedes cubrir prácticamente todo tu catálogo: 4K SDR, 1080p SDR, y ambos casos en HDR, además de hacerlo en lote para temporadas completas de series.

El día que las televisiones del salón decodifiquen AV1 de forma nativa y por red, daremos el salto. Mientras tanto, H.265 sigue siendo el mejor equilibrio entre calidad, tamaño y compatibilidad real con lo que tienes enchufado al HDMI.

Si te ha servido esta guía o quieres que añada algún caso concreto (por ejemplo, series en 1080p HDR con recortes irregulares, o mezcla de SDR y HDR en la misma carpeta), puedes dejarlo en los comentarios y lo iremos ampliando.