Comprimir vídeo con FFmpeg y H.265/HEVC: guía completa

H.265/HEVC (High Efficiency Video Coding) ofrece la misma calidad visual que H.264 con archivos un 40–50 % más pequeños. FFmpeg con el encoder libx265 es la forma más potente de aprovechar este códec desde línea de comandos.

H.264 vs H.265 vs AV1: comparativa rápida

H.265 es el equilibrio perfecto entre compatibilidad universal y eficiencia de compresión.

Conversión básica MP4→H.265

# Recodificar a H.265 con calidad por defecto
ffmpeg -i entrada.mp4 -c:v libx265 -c:a copy salida_h265.mp4

# Especificar CRF (Constant Rate Factor)
# 0 = sin pérdida | 18 = casi sin pérdida | 28 = defecto | 51 = peor
ffmpeg -i entrada.mp4 -c:v libx265 -crf 28 -c:a copy salida.mp4

# Recomendado para web (buena calidad, tamaño reducido)
ffmpeg -i entrada.mp4 -c:v libx265 -crf 24 -preset medium -c:a aac -b:a 128k salida.mp4

El parámetro CRF: control de calidad

# Comparativa visual de valores CRF
ffmpeg -i entrada.mp4 -c:v libx265 -crf 18 crf18_altisima.mp4  # casi sin pérdida
ffmpeg -i entrada.mp4 -c:v libx265 -crf 23 crf23_alta.mp4       # alta calidad
ffmpeg -i entrada.mp4 -c:v libx265 -crf 28 crf28_media.mp4      # defecto, buen equilibrio
ffmpeg -i entrada.mp4 -c:v libx265 -crf 35 crf35_baja.mp4       # muy comprimido

# Ver tamaños resultantes
ls -lh *.mp4

Guía práctica de CRF:

• 18–20: archivos máster, sin pérdida apreciable
• 21–26: distribución online alta calidad (YouTube, Vimeo)
• 27–32: streaming, descarga general
• 33–40: móvil, ancho de banda muy limitado

Presets: velocidad vs compresión

# Presets disponibles (de más rápido a más lento):
# ultrafast, superfast, veryfast, faster, fast, medium, slow, slower, veryslow

# ultrafast — mínima compresión, máxima velocidad (testing)
ffmpeg -i entrada.mp4 -c:v libx265 -crf 28 -preset ultrafast salida.mp4

# medium — equilibrio recomendado para producción
ffmpeg -i entrada.mp4 -c:v libx265 -crf 28 -preset medium salida.mp4

# slow — mejor compresión, ideal para archivos finales
ffmpeg -i entrada.mp4 -c:v libx265 -crf 28 -preset slow salida.mp4

# Regla: mismo CRF con preset más lento = archivo más pequeño a igual calidad

Aceleración por hardware (GPU)

# NVIDIA NVENC (GPUs NVIDIA)
ffmpeg -i entrada.mp4 -c:v hevc_nvenc -cq 28 -preset p4 salida_nvenc.mp4
# cq: Constant Quality (equivalente a CRF para NVENC)
# preset: p1 (rápido) → p7 (lento/mejor calidad)

# Intel Quick Sync Video (QSV)
ffmpeg -i entrada.mp4 -c:v hevc_qsv -global_quality 28 salida_qsv.mp4

# Apple VideoToolbox (Mac M1/M2/M3)
ffmpeg -i entrada.mp4 -c:v hevc_videotoolbox -q:v 60 salida_mac.mp4

# AMD AMF (GPUs AMD en Windows)
ffmpeg -i entrada.mp4 -c:v hevc_amf -quality quality salida_amd.mp4

# Verificar encoders disponibles en tu sistema
ffmpeg -encoders 2>/dev/null | grep hevc

Encodificación en dos pasos (two-pass)

La encodificación en dos pasos mejora la consistencia de calidad en bitrate objetivo:

# Paso 1 — análisis
ffmpeg -i entrada.mp4 -c:v libx265 -b:v 2M -x265-params pass=1 -an -f null /dev/null

# Paso 2 — encodificación
ffmpeg -i entrada.mp4 -c:v libx265 -b:v 2M -x265-params pass=2 -c:a aac -b:a 128k salida.mp4

Convertir directorio en batch (Bash)

#!/bin/bash
# Convierte todos los MP4 del directorio actual a H.265

mkdir -p output_h265

for f in *.mp4; do
    nombre="${f%.mp4}"
    echo "-> Convirtiendo: $f"
    ffmpeg -i "$f" \
        -c:v libx265 \
        -crf 26 \
        -preset medium \
        -c:a aac \
        -b:a 128k \
        -movflags +faststart \
        "output_h265/${nombre}_h265.mp4" \
        -y
done

echo "Conversion completa"
echo "Tamaños originales:"
du -sh *.mp4
echo "Tamaños H.265:"
du -sh output_h265/*.mp4

Python con subprocess

import subprocess
from pathlib import Path

def comprimir_h265(entrada, salida, crf=26, preset='medium'):
    """Comprimir vídeo a H.265 con FFmpeg desde Python."""
    cmd = [
        'ffmpeg',
        '-i', str(entrada),
        '-c:v', 'libx265',
        '-crf', str(crf),
        '-preset', preset,
        '-c:a', 'aac',
        '-b:a', '128k',
        '-movflags', '+faststart',
        str(salida),
        '-y',
    ]
    resultado = subprocess.run(cmd, capture_output=True, text=True)
    if resultado.returncode != 0:
        print(f"ERROR: {resultado.stderr[-500:]}")
        return False
    return True

# Conversión masiva
directorio = Path('videos_entrada')
for video in sorted(directorio.glob('*.mp4')):
    salida = video.parent / 'h265' / video.name
    salida.parent.mkdir(exist_ok=True)
    ok = comprimir_h265(video, salida, crf=26)
    if ok:
        orig = video.stat().st_size / 1024 / 1024
        comp = salida.stat().st_size / 1024 / 1024
        ahorro = (1 - comp / orig) * 100
        print(f"OK: {video.name} → {orig:.1f}MB → {comp:.1f}MB ({ahorro:.0f}% menos)")

Opciones adicionales útiles

# Limitar resolución máxima (escalar si es mayor a 1080p)
ffmpeg -i entrada.mp4 \
  -vf "scale='min(1920,iw)':'min(1080,ih)':force_original_aspect_ratio=decrease" \
  -c:v libx265 -crf 26 salida.mp4

# Recortar los primeros 60 segundos
ffmpeg -i entrada.mp4 -t 60 -c:v libx265 -crf 26 primeros60s.mp4

# Añadir -movflags +faststart para streaming web (MP4 optimizado)
ffmpeg -i entrada.mp4 -c:v libx265 -crf 26 -movflags +faststart salida.mp4

# Ver información del vídeo de salida
ffprobe -v quiet -print_format json -show_streams salida.mp4 | python3 -m json.tool

Cuándo usar H.265

• Archivado y máster: CRF 18–22 con preset slow
• Distribución online: CRF 24–28 con preset medium
• Streaming móvil: CRF 30–35 con preset fast
• Conversión rápida (testing): preset ultrafast (calidad inferior)

Para máxima compatibilidad (reproductores antiguos, SmartTV), usa H.264. Para mejor compresión con compatibilidad moderna, H.265 es la elección óptima en 2024.

Conversiones relacionadas

Conversiones de vídeo que encajan con esta guía:

• MOV a MP4
• AVI a MP4
• MKV a MP4
• MP4 a WEBM
• MP4 a GIF
• MP4 a MP3