Última actualización: 11 de septiembre

Automatiza miniaturas de video con FFmpeg y .NET

Tim Koschützki

Cofundador · Berlín, Alemania ·

El procesamiento de video es una parte esencial de muchas aplicaciones, ya sea que estés creando un sistema de gestión de contenido o simplemente ofreciendo vistas previas de video a tus usuarios. En este DevTip aprenderás a automatizar la generación de miniaturas de video con FFmpeg en .NET. Con bibliotecas modernas y programación asíncrona, puedes integrar un proceso robusto de extracción de miniaturas en tus aplicaciones.

Configurar FFmpeg y FFMpegCore

Primero, asegúrate de que FFmpeg esté instalado en tu sistema. Puedes descargarlo desde el sitio oficial o usar gestores de paquetes:

Windows: winget install ffmpeg
macOS: brew install ffmpeg
Ubuntu/Debian: apt install ffmpeg

Luego, agrega el paquete NuGet FFMpegCore a tu proyecto .NET:

<PackageReference Include="FFMpegCore" Version="5.2.0" />

Crear un servicio generador de miniaturas

Vamos a crear un servicio que se encargue de la generación de miniaturas con FFMpegCore:

using FFMpegCore;
using FFMpegCore.Enums;
using FFMpegCore.Exceptions;
using Microsoft.Extensions.Logging;

public class ThumbnailService
{
    private readonly ILogger<ThumbnailService> _logger;

    public ThumbnailService(ILogger<ThumbnailService> logger)
    {
        _logger = logger;
    }

    public async Task<bool> GenerateThumbnailAsync(
        string inputFile,
        string outputFile,
        TimeSpan captureTime,
        int width = 320,
        int height = 240)
    {
        try
        {
            await FFMpegArguments
                .FromFileInput(inputFile)
                .OutputToFile(outputFile, false, options =>
                    options
                        .Seek(captureTime)
                        .WithFrameOutputCount(1)
                        .WithVideoFilters(filterOptions =>
                            filterOptions.Scale(width: width, height: height))
                )
                .ProcessAsynchronously();

            return true;
        }
        catch (FFMpegException ex)
        {
            _logger.LogError(ex, "FFmpeg error while generating thumbnail");
            return false;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Unexpected error while generating thumbnail");
            return false;
        }
    }
}

Cómo funciona el código

El servicio usa inyección de dependencias para el logging
FFMpegCore ofrece una API fluida para configurar los comandos de FFmpeg
La operación de posicionamiento -ss se gestiona con el método Seek
El escalado del video se configura mediante la opción WithVideoFilters
Se implementan patrones async/await correctos
Se incluye un manejo de errores completo con logging

El argumento de sobrescritura false protege los archivos de salida existentes. Usa nombres de salida nuevos en ejecuciones repetidas; los trabajos de miniaturas que fallan devuelven false y quedan registrados en el log. Agrega Microsoft.Extensions.Logging.Console a un proyecto de consola antes de usar la configuración de logging que aparece más abajo.

Usar el servicio de miniaturas

Así se usa el servicio de miniaturas en una aplicación .NET:

using Microsoft.Extensions.Logging;

public class Program
{
    public static async Task Main(string[] args)
    {
        using var loggerFactory = LoggerFactory.Create(builder =>
        {
            builder
                .AddConsole()
                .SetMinimumLevel(LogLevel.Information);
        });

        var logger = loggerFactory.CreateLogger<ThumbnailService>();
        var thumbnailService = new ThumbnailService(logger);

        var result = await thumbnailService.GenerateThumbnailAsync(
            inputFile: "sample.mp4",
            outputFile: "thumbnail.jpg",
            captureTime: TimeSpan.FromSeconds(5)
        );

        Console.WriteLine(result
            ? "Thumbnail generated successfully"
            : "Failed to generate thumbnail");
    }
}

Funciones avanzadas

El servicio de miniaturas se puede ampliar con funciones adicionales:

public class ThumbnailService
{
    // ... existing code ...

    public async Task<IReadOnlyList<string>> GenerateMultipleThumbnailsAsync(
        string inputFile,
        string outputDirectory,
        int count)
    {
        Directory.CreateDirectory(outputDirectory);
        var mediaInfo = await FFProbe.AnalyseAsync(inputFile);
        var duration = mediaInfo.Duration;
        var interval = duration.TotalSeconds / (count + 1);
        var thumbnails = new List<string>();

        for (var i = 1; i <= count; i++)
        {
            var time = TimeSpan.FromSeconds(interval * i);
            var outputFile = Path.Combine(
                outputDirectory,
                $"thumbnail_{i:D2}.jpg"
            );

            if (await GenerateThumbnailAsync(inputFile, outputFile, time))
            {
                thumbnails.Add(outputFile);
            }
        }

        return thumbnails;
    }
}

Esta extensión permite generar varias miniaturas a intervalos uniformemente espaciados a lo largo del video.

Consideraciones multiplataforma

FFMpegCore gestiona automáticamente las diferencias de rutas entre sistemas operativos, pero asegúrate de que FFmpeg esté correctamente instalado y accesible en el PATH de tu sistema. Para entornos en contenedores, incluye la instalación de FFmpeg en tu Dockerfile:

FROM mcr.microsoft.com/dotnet/sdk:8.0
RUN apt-get update && apt-get install -y ffmpeg

Compatibilidad de versiones

Esta solución se probó con:

.NET v6.0 o posterior
FFmpeg 4.x o posterior
FFMpegCore 5.2.0

Conclusión

FFMpegCore proporciona una forma moderna y con seguridad de tipos de integrar FFmpeg en aplicaciones .NET para la generación de miniaturas de video. Este enfoque ofrece un mejor manejo de errores, soporte multiplataforma y operaciones asíncronas en comparación con las llamadas directas a procesos. Si tienes necesidades de procesamiento de video más avanzadas, consulta el Robot 🤖/video/thumbs de Transloadit, que gestiona la generación de miniaturas a gran escala.

¡Feliz programación!