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
| Códec | Año | Compresión | Velocidad | Compatibilidad | Licencias |
|---|---|---|---|---|---|
| H.264 (libx264) | 2003 | Buena | Muy rápida | Universal | Patentado |
| **H.265 (libx265)** | **2013** | **Muy buena** | **Media** | **Amplia** | **Patentado** |
| AV1 (libaom) | 2018 | Excelente | Lenta | Creciente | Libre |
| VP9 | 2013 | Muy buena | Lenta | Amplia | Libre |
H.265 es el equilibrio perfecto entre compatibilidad universal y eficiencia de compresión.
## Conversión básica MP4→H.265
```bash
# 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
```bash
# 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
```bash
# 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)
```bash
# 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:
```bash
# 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)
```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
```python
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
```bash
# 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.
Guía