Zuletzt aktualisiert: 11. September

Video-Thumbnails mit FFmpeg und .NET automatisieren

Tim Koschützki

Mitgründer · Berlin, Deutschland ·

Die Videoverarbeitung ist ein wesentlicher Bestandteil vieler Anwendungen, egal ob Sie ein Content-Management-System entwickeln oder Ihren Nutzern einfach nur Videovorschauen bereitstellen. In diesem DevTip erfahren Sie, wie Sie die Erzeugung von Video-Thumbnails mit FFmpeg in .NET automatisieren. Mit modernen Bibliotheken und asynchroner Programmierung können Sie einen robusten Prozess zur Thumbnail-Extraktion in Ihre Anwendungen integrieren.

FFmpeg und FFMpegCore einrichten

Stellen Sie zunächst sicher, dass FFmpeg auf Ihrem System installiert ist. Sie können es von der offiziellen Website herunterladen oder Paketmanager verwenden:

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

Fügen Sie anschließend das FFMpegCore-NuGet-Paket zu Ihrem .NET-Projekt hinzu:

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

Einen Dienst zur Thumbnail-Erzeugung erstellen

Erstellen wir einen Dienst, der die Thumbnail-Erzeugung mit FFMpegCore übernimmt:

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;
        }
    }
}

So funktioniert der Code

Der Dienst verwendet Dependency Injection für das Logging
FFMpegCore bietet eine Fluent-API zum Konfigurieren von FFmpeg-Befehlen
Die Seek-Operation -ss wird von der Methode Seek übernommen
Die Videoskalierung wird über die Option WithVideoFilters konfiguriert
Korrekte async/await-Muster sind implementiert
Eine umfassende Fehlerbehandlung mit Logging ist enthalten

Das Overwrite-Argument false schützt vorhandene Ausgabedateien. Verwenden Sie bei wiederholten Durchläufen neue Ausgabenamen; fehlgeschlagene Thumbnail-Jobs geben false zurück und werden protokolliert. Fügen Sie einem Konsolenprojekt Microsoft.Extensions.Logging.Console hinzu, bevor Sie das folgende Logging-Setup verwenden.

Den Thumbnail-Dienst verwenden

So verwenden Sie den Thumbnail-Dienst in einer .NET-Anwendung:

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");
    }
}

Erweiterte Funktionen

Der Thumbnail-Dienst lässt sich um zusätzliche Funktionen erweitern:

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;
    }
}

Diese Erweiterung ermöglicht es, mehrere Thumbnails in gleichmäßigen Abständen über das gesamte Video hinweg zu erzeugen.

Plattformübergreifende Aspekte

FFMpegCore behandelt Pfadunterschiede zwischen Betriebssystemen automatisch. Stellen Sie jedoch sicher, dass FFmpeg korrekt installiert und im PATH Ihres Systems verfügbar ist. Nehmen Sie die FFmpeg-Installation für containerisierte Umgebungen in Ihr Dockerfile auf:

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

Versionskompatibilität

Diese Lösung wurde getestet mit:

.NET v6.0 oder neuer
FFmpeg 4.x oder neuer
FFMpegCore 5.2.0

Fazit

FFMpegCore bietet eine moderne, typsichere Möglichkeit, FFmpeg für die Erzeugung von Video-Thumbnails in .NET-Anwendungen einzubinden. Dieser Ansatz bietet im Vergleich zu direkten Prozessaufrufen eine bessere Fehlerbehandlung, plattformübergreifende Unterstützung und asynchrone Operationen. Für anspruchsvollere Anforderungen an die Videoverarbeitung lohnt sich ein Blick auf den Robot 🤖/video/thumbs von Transloadit, der die Thumbnail-Erzeugung in großem Maßstab übernimmt.

Viel Spaß beim Programmieren!