C#でFFmpeg操作！ライブラリ紹介と比較

はじめに

今日のソフトウェア開発において、動画や音声データの処理はますます重要になっています。動画編集アプリケーション、メディア変換ツール、ストリーミングサービス、あるいは単なるサムネイル生成機能など、様々な場面でメディア処理のニーズが発生します。このようなメディア処理の中核を担う強力なツールが「FFmpeg」です。

FFmpegは、動画・音声の記録、変換、ストリーミングを行うための、コマンドラインベースの非常に多機能なオープンソースプロジェクトです。膨大な数のフォーマットに対応し、高度なフィルタリングやエンコードオプションを提供するため、メディア処理のデファクトスタンダードと言える存在です。

しかし、FFmpegはその多機能さゆえに、コマンドライン引数が非常に複雑になりがちです。例えば、MP4ファイルをAVIファイルに変換するだけでもシンプルなコマンドで済みますが、特定のコーデック、ビットレート、解像度を指定し、さらに動画の一部を切り取り、ウォーターマークを追加するといった複雑な処理を行う場合、コマンドライン引数は驚くほど長くなります。

C#などのプログラミング言語からFFmpegを操作する場合、この複雑なコマンドラインを動的に生成し、FFmpegプロセスを実行し、その標準出力や標準エラー出力を監視し、完了を待機し、そしてエラーを適切に処理する必要があります。これを全て自前で実装するのは非常に手間がかかり、エラーも発生しやすくなります。特に、FFmpegが出力するテキストベースの進捗情報を解析してアプリケーションのUIに反映させるといった処理は、パースの信頼性を確保するのが困難です。

幸いなことに、C# (.NET) 環境では、FFmpegの操作をより簡単かつ安全に行うための様々なライブラリが提供されています。これらのライブラリは、FFmpegの複雑なコマンドラインをオブジェクト指向的にラップし、プロセス管理、非同期処理、出力解析といった煩雑なタスクを抽象化してくれます。

この記事では、C#からFFmpegを操作するための主要なアプローチと、代表的なライブラリを詳細に紹介し、それぞれの特徴、使い方、利点、欠点を比較します。これからC#アプリケーションでFFmpegを組み込みたいと考えている方が、自身のプロジェクトに最適な手法やライブラリを選択できるよう、実践的な情報を提供することを目指します。

FFmpegを直接実行する方法 (System.Diagnostics.Processクラス)

C#からFFmpegを操作する最も原始的で低レベルな方法は、.NET標準ライブラリに含まれるSystem.Diagnostics.Processクラスを使用して、FFmpegの実行ファイルを直接呼び出すことです。この方法は追加のライブラリを必要としないため、最も依存関係が少なく済みます。

System.Diagnostics.Processクラスの使用方法

Processクラスを使って外部プログラムを実行するには、いくつかの基本的なステップがあります。

1. ProcessStartInfo オブジェクトの作成: 実行するプログラムのファイル名、コマンドライン引数、作業ディレクトリ、標準入出力のリダイレクト設定などを定義します。
2. Process オブジェクトの作成: Process クラスの新しいインスタンスを作成します。
3. StartInfo の設定: 作成した ProcessStartInfo オブジェクトを Process オブジェクトの StartInfo プロパティに設定します。
4. プロセスの開始: Process.Start() メソッドを呼び出してプログラムを実行します。
5. 出力の取得: 必要に応じて、StandardOutput や StandardError ストリームからプログラムの出力やエラーを取得します。
6. プロセスの待機: Process.WaitForExit() メソッドを呼び出して、プログラムが終了するまで現在のスレッドをブロックします。非同期で待機する場合は WaitForExitAsync() を使用します。
7. 終了コードの確認: プロセスが終了した後、ExitCode プロパティを確認して正常終了したか判断します。

FFmpeg実行における具体的なコード例

FFmpegを実行する場合、最も重要なのはFileNameにFFmpeg実行ファイル（例: ffmpeg.exe または ffmpeg）のパスを指定し、ArgumentsにFFmpegのコマンドライン引数を正確に設定することです。また、多くのFFmpeg操作は時間がかかるため、アプリケーションのUIスレッドをブロックしないように非同期で実行し、進捗状況をリアルタイムで取得するために標準出力や標準エラーをリダイレクトすることが一般的です。

以下のコード例は、FFmpegを使用して動画ファイルを別の形式に変換し、同時に変換の進捗状況をコンソールに表示する方法を示しています。

“`csharp
using System;
using System.Diagnostics;
using System.IO;
using System.Text;
using System.Threading.Tasks;

public class FfmpegProcessRunner
{
private readonly string _ffmpegPath;

public FfmpegProcessRunner(string ffmpegPath)
{
    if (!File.Exists(ffmpegPath))
    {
        throw new FileNotFoundException($"FFmpeg実行ファイルが見つかりません: {ffmpegPath}");
    }
    _ffmpegPath = ffmpegPath;
}

public async Task ConvertMediaAsync(string inputPath, string outputPath, string ffmpegArguments, IProgress<string> progress = null)
{
    if (!File.Exists(inputPath))
    {
        throw new FileNotFoundException($"入力ファイルが見つかりません: {inputPath}");
    }

    // 出力ディレクトリが存在しない場合は作成
    var outputDirectory = Path.GetDirectoryName(outputPath);
    if (!string.IsNullOrEmpty(outputDirectory) && !Directory.Exists(outputDirectory))
    {
        Directory.CreateDirectory(outputDirectory);
    }

    // ffmpegArgumentsには "-i input.mp4 output.avi" のような形式で指定
    // 入力ファイルと出力ファイルはarguments内で指定することが多い
    // 例: $"-i \"{inputPath}\" {ffmpegArguments} \"{outputPath}\"" のように組み立てる必要があるが、
    // この例ではinput/output pathはargumentsに含める前提とする。
    // 実際のアプリケーションでは、入力・出力パスは引数に含める形で組み立てるのが一般的。
    // この例ではシンプルに、渡されたargumentsがそのまま -i ... ... output の形式になっていると仮定。
    string fullArguments = ffmpegArguments; // FFmpegの引数はinput/outputパスを含む形式で渡される前提

    var startInfo = new ProcessStartInfo
    {
        FileName = _ffmpegPath,
        Arguments = fullArguments,
        UseShellExecute = false, // シェルを使わずに直接実行
        RedirectStandardOutput = true, // 標準出力をリダイレクト
        RedirectStandardError = true, // 標準エラーをリダイレクト (FFmpegの進捗は通常こちらに出る)
        CreateNoWindow = true, // コマンドプロンプトウィンドウを表示しない
        StandardOutputEncoding = Encoding.UTF8, // エンコーディングを指定
        StandardErrorEncoding = Encoding.UTF8    // エンコーディングを指定
    };

    using (var process = new Process { StartInfo = startInfo })
    {
        // 非同期での出力読み取りを設定
        // DataReceivedイベントは別スレッドで実行される
        process.OutputDataReceived += (sender, e) =>
        {
            if (!string.IsNullOrEmpty(e.Data))
            {
                // 標準出力データを受信したときの処理
                // FFmpegの通常出力はここにあまり来ないかもしれない
                Console.WriteLine($"[FFmpeg StdOut] {e.Data}");
                // progress?.Report($"[StdOut] {e.Data}"); // 進捗として報告する場合
            }
        };

        process.ErrorDataReceived += (sender, e) =>
        {
            if (!string.IsNullOrEmpty(e.Data))
            {
                // 標準エラーデータを受信したときの処理
                // FFmpegの進捗情報やエラーは通常ここに出力される
                Console.WriteLine($"[FFmpeg StdErr] {e.Data}");
                // 進捗情報をパースして報告
                ParseProgress(e.Data, progress);
            }
        };

        // プロセスを開始
        process.Start();

        // 非同期での出力読み取りを開始
        process.BeginOutputReadLine();
        process.BeginErrorReadLine();

        // プロセスが終了するまで非同期で待機
        await Task.Run(() => process.WaitForExit());

        // 終了コードを確認
        if (process.ExitCode != 0)
        {
            // FFmpegがエラー終了した場合
            throw new Exception($"FFmpegプロセスがエラー終了しました。終了コード: {process.ExitCode}");
        }

        Console.WriteLine("FFmpeg処理が完了しました。");
    }
}

// FFmpegの標準エラー出力から進捗情報をパースする例
private void ParseProgress(string data, IProgress<string> progress)
{
    // FFmpegの出力はバージョンやコマンドによってフォーマットが変わることがあるため、パースは困難
    // よくある出力例:
    // frame= 1000 fps= 60 q=2.0 size=   1234kB time=00:00:10.00 bitrate= 987.6kbits/s speed= 1.5x
    // この例ではtime情報だけを取り出す
    if (data.Contains("time="))
    {
        // time=HH:MM:SS.ms の形式を抽出する簡単な例（正規表現を使うともっと正確）
        var timeMatch = System.Text.RegularExpressions.Regex.Match(data, @"time=(\d{2}:\d{2}:\d{2}\.\d{2})");
        if (timeMatch.Success)
        {
            // 抽出したtime情報を進捗として報告
            progress?.Report($"変換時間: {timeMatch.Groups[1].Value}");
        }
        // 他にもframe, fps, size, bitrate, speedなどを抽出可能
    }
    else if (data.StartsWith("error", StringComparison.OrdinalIgnoreCase))
    {
        // シンプルなエラー検出
        progress?.Report($"[FFmpeg Error] {data}");
    }
     // 必要に応じて他の出力形式（encoder, stream mappingなど）もパース
}

// 使用例
// public static async Task Main(string[] args)
// {
//     try
//     {
//         // 事前にFFmpeg実行ファイルをダウンロードして配置しておく必要があります。
//         // 例: C:\ffmpeg\bin\ffmpeg.exe
//         string ffmpegExePath = @"C:\path\to\ffmpeg.exe"; 
//         string inputVideo = @"C:\path\to\input.mp4";
//         string outputVideo = @"C:\path\to\output.avi";

//         // ffmpegArgumentsの例: -i "入力パス" [オプション] "出力パス"
//         // この例では -i と出力パスはConvertMediaAsync内で組み立てる前提なので、オプションだけ指定
//         // もしくは "-i \"input.mp4\" -c:v libxvid -qscale:v 2 \"output.avi\"" のようにすべて含める
//         string arguments = $"-i \"{inputVideo}\" -c:v libxvid -qscale:v 2 \"{outputVideo}\"";

//         var runner = new FfmpegProcessRunner(ffmpegExePath);

//         // 進捗報告用のIProgress<string>インスタンス
//         var progressReporter = new Progress<string>(report =>
//         {
//             Console.WriteLine($"進捗: {report}");
//         });

//         Console.WriteLine("変換を開始します...");
//         await runner.ConvertMediaAsync(inputVideo, outputVideo, arguments, progressReporter);
//         Console.WriteLine("変換が完了しました。");
//     }
//     catch (FileNotFoundException ex)
//     {
//         Console.WriteLine($"ファイルが見つかりません: {ex.Message}");
//     }
//     catch (Exception ex)
//     {
//         Console.WriteLine($"エラーが発生しました: {ex.Message}");
//     }
// }

}
“`

コード解説:

• FfmpegProcessRunner クラスは、FFmpeg実行ファイルのパスを保持し、変換処理を実行するメソッドを提供します。
• ConvertMediaAsync メソッドは、入力ファイル、出力ファイル、FFmpegの引数、そして進捗報告のための IProgress<string> オブジェクトを受け取ります。
• ProcessStartInfo オブジェクトで、実行ファイル名、引数、入出力のリダイレクト、ウィンドウ非表示などを設定します。
• RedirectStandardOutput = true および RedirectStandardError = true は必須です。FFmpegは通常、標準エラーに進行状況や詳細な情報を出力します。
• UseShellExecute = false は、シェルを介さずに直接プログラムを実行するために重要です。リダイレクトなどを行う場合に必要になります。
• BeginOutputReadLine() および BeginErrorReadLine() を呼び出すことで、FFmpegが標準出力/エラーに出力するたびに OutputDataReceived / ErrorDataReceived イベントが発生し、登録したハンドラが別スレッドで実行されます。これにより、アプリケーションがブロックされることなく、リアルタイムに進捗を取得できます。
• ParseProgress メソッドは、FFmpegの出力文字列から特定の情報を抽出する例です。FFmpegの出力フォーマットはバージョンやコマンドによって微妙に異なる場合があるため、このパース処理は頑健に実装するのが難しい部分です。正規表現などがよく使われます。
• await Task.Run(() => process.WaitForExit()) は、プロセスの終了を非同期で待機するイディオムです。process.WaitForExitAsync() (.NET Core 3.1+ / .NET 5+) が利用可能であればそちらを使う方がよりシンプルです。
• プロセスの終了後、process.ExitCode を確認することで、FFmpegが正常に終了したか（通常は0）またはエラー終了したかを確認できます。

利点

• 追加ライブラリ不要: .NETの標準機能のみを使用するため、外部ライブラリへの依存が発生しません。
• FFmpegの全機能にアクセス可能: コマンドライン引数を自由に組み立てられるため、FFmpegが提供するあらゆるオプション、フィルタ、機能を利用できます。ライブラリがサポートしていないニッチな機能を使いたい場合に有利です。
• FFmpegのバージョンアップに影響されにくい: FFmpegのコマンドライン引数体系が大きく変わらない限り、FFmpeg自体の新しいバージョンが出てもC#側のコードを修正する必要はほとんどありません。
• 高い柔軟性: プロセスの起動、停止、優先度設定など、OSレベルでのプロセス管理を細かく制御できます。

欠点

• コマンドライン引数の管理が複雑: FFmpegのコマンドライン引数は非常に多岐にわたり、正確に組み立てるのが困難です。特に動的に様々な条件で引数を変更する場合、コードが複雑になり、ミスが発生しやすくなります。エスケープ処理なども手動で行う必要があります。
• 出力解析が困難: FFmpegの出力（特に進捗やエラー情報）はテキストベースであり、そのフォーマットはFFmpegのバージョンやビルドオプションによって変わることがあります。これを安定してパースし、構造化された情報（例: 進捗率、現在の時間、ビットレートなど）として取得するのは非常に手間がかかり、脆弱になりがちです。
• エラー処理が煩雑: FFmpegのエラーは通常、標準エラーに出力されますが、その内容はエラーの種類によって様々です。これらのエラーメッセージを解釈し、C#側で適切な例外として処理するのは容易ではありません。FFmpegがクラッシュした場合の検出なども考慮する必要があります。
• スレッド管理、非同期処理の実装が手間: UIをブロックしないためには非同期でプロセスを実行し、イベントハンドラで出力を処理する必要がありますが、これらの実装は自前で行う必要があります。
• プラットフォーム依存性: ターゲットとするOSごとに適切なFFmpeg実行ファイルを別途用意し、アプリケーションからアクセスできる場所に配置する必要があります。

このように、Processクラスを直接使用する方法は最も柔軟で低レベルなアプローチですが、その分開発者の負担が大きく、特に複雑なFFmpeg操作や安定した出力解析が必要な場合には推奨されにくい方法です。次に紹介するライブラリは、これらの課題を解決するために開発されました。

主要なC# FFmpeg操作ライブラリ紹介

Processクラスを直接扱うことの課題を克服するために、C# (.NET) 環境ではいくつかのFFmpegラッパーライブラリが存在します。これらのライブラリは、FFmpegプロセスの実行、コマンドライン引数の生成、出力のパース、非同期処理などを抽象化し、よりC#のコードとして自然にFFmpegを操作できるように設計されています。

本記事では、特に広く使われている以下の2つのライブラリに焦点を当てて詳細に解説します。

1. Xabe.FFmpeg: 機能が豊富で、オブジェクト指向的なAPIを提供し、複雑なFFmpeg操作も比較的容易に行える高機能ライブラリです。非同期処理や詳細な進捗報告にも対応しています。
2. MediaToolkit: 比較的シンプルで、基本的な動画/音声変換やメタデータ取得に特化したライブラリです。簡単な操作を行いたい場合に適しています。

これらのライブラリはNuGetパッケージとして提供されており、プロジェクトへの追加は容易です。それぞれの詳細を見ていきましょう。

ライブラリ詳細: Xabe.FFmpeg

Xabe.FFmpeg は、C# から FFmpeg を操作するための最も強力で柔軟なライブラリの一つです。FFmpeg の複雑なコマンドラインインターフェースをオブジェクト指向的な API にラップし、開発者が C# コードで直感的にメディア処理タスクを記述できるように設計されています。

特徴

• オブジェクト指向API: FFmpeg の様々なオプションや設定を C# のクラスやメソッドとして提供します。例えば、コーデックの指定、ビットレート設定、フィルタリングなどをメソッドチェーンで記述できます。
• 非同期操作のフルサポート: .NET の async/await パターンに対応しており、FFmpeg 処理を非同期で実行し、UI スレッドをブロックすることなく進捗を監視できます。
• 構造化されたデータ取得: メディアファイルのメタデータ（解像度、フレームレート、コーデック、デュレーションなど）や、変換中の進捗状況などを、テキストパースではなく専用のオブジェクトとして取得できます。
• 豊富な機能: ファイル変換、ストリームの抽出（音声のみ、動画のみ）、サムネイル生成、フィルタリング（クロップ、リサイズ、ウォーターマークなど）、ストリーミング、字幕処理など、FFmpeg の主要な機能を幅広くサポートしています。
• クロスプラットフォーム対応: .NET (Core) 上で動作するため、Windows、macOS、Linux など、FFmpeg が動作する環境であれば利用可能です。
• ライセンス: オープンソースライセンス（LGPLなど）および商用ライセンスがあります。商用利用の場合はライセンスの詳細を確認する必要があります。ただし、ライブラリ自体は多くの場合オープンソースで利用可能です。FFmpeg自体のライセンス（GPL/LGPL）にも注意が必要です。

インストール

Xabe.FFmpeg は NuGet パッケージとして提供されています。Visual Studio の NuGet パッケージマネージャーや .NET CLI を使用してプロジェクトに追加できます。

“`bash

.NET CLI を使用する場合

dotnet add package Xabe.FFmpeg
“`

または、Visual Studio の NuGet パッケージマネージャーで「Xabe.FFmpeg」を検索してインストールします。

使い方

Xabe.FFmpeg を使うには、まずアプリケーションからアクセスできる場所に FFmpeg の実行ファイル（ffmpeg と ffprobe）を配置する必要があります。ライブラリ自体は FFmpeg を内包しているわけではありません。その後、アプリケーション起動時などに FFmpeg.SetFFmpegPath() メソッドを使用して、FFmpeg 実行ファイルがあるディレクトリのパスを設定します。

“`csharp
using Xabe.FFmpeg; // 名前空間を追加

// アプリケーションのどこか（例: 起動時）でFFmpegのパスを設定
string ffmpegDirectory = @”C:\path\to\ffmpeg\bin”; // ffmpeg.exe と ffprobe.exe が存在するディレクトリ
FFmpeg.SetFFmpegPath(ffmpegDirectory);

// 必要に応じて、ロギングを設定
// FFmpeg.SetLogging(Xabe.FFmpeg.LogLevel.Verbose);
“`

ffprobe はメディアファイルの情報を取得するために使用されます。Xabe.FFmpeg は ffprobe も利用するため、同じディレクトリに配置しておく必要があります。

基本的な使用例として、メディア情報の取得とファイル変換を示します。

メディア情報取得 (FFmpeg.GetMediaInfo)

メディアファイルの情報を取得するには FFmpeg.GetMediaInfo() メソッドを使用します。これは非同期メソッドです。

“`csharp
using Xabe.FFmpeg;
using System;
using System.Threading.Tasks;

public static class MediaInfoExample
{
public static async Task GetInfoAsync(string filePath)
{
try
{
// FFmpeg.SetFFmpegPath() は事前に呼び出しておくこと

        Console.WriteLine($"ファイル情報を取得中: {filePath}");
        IMediaInfo mediaInfo = await FFmpeg.GetMediaInfo(filePath);

        Console.WriteLine($"  デュレーション: {mediaInfo.Duration}");
        Console.WriteLine($"  フォーマット: {mediaInfo.Format}");
        Console.WriteLine($"  ビットレート: {mediaInfo.Bitrate}");
        Console.WriteLine($"  ストリーム数: {mediaInfo.Streams.Count}");

        foreach (var stream in mediaInfo.Streams)
        {
            Console.WriteLine($"    ストリーム #{stream.Index} ({stream.CodecType})");
            if (stream.CodecType == Xabe.FFmpeg.Model.CodecType.Video)
            {
                IVideoStream videoStream = (IVideoStream)stream;
                Console.WriteLine($"      コーデック: {videoStream.Codec}");
                Console.WriteLine($"      解像度: {videoStream.Width}x{videoStream.Height}");
                Console.WriteLine($"      フレームレート: {videoStream.Framerate}");
                Console.WriteLine($"      ビットレート: {videoStream.Bitrate}");
                Console.WriteLine($"      アスペクト比: {videoStream.Ratio}");
            }
            else if (stream.CodecType == Xabe.FFmpeg.Model.CodecType.Audio)
            {
                IAudioStream audioStream = (IAudioStream)stream;
                Console.WriteLine($"      コーデック: {audioStream.Codec}");
                Console.WriteLine($"      サンプルレート: {audioStream.SampleRate}");
                Console.WriteLine($"      チャンネル数: {audioStream.Channels}");
                Console.WriteLine($"      ビットレート: {audioStream.Bitrate}");
            }
            // 他にも Subtitle, Data ストリームなどがあります
        }

        Console.WriteLine("ファイル情報の取得が完了しました。");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"ファイル情報の取得中にエラーが発生しました: {ex.Message}");
    }
}

// 使用例:
// public static async Task Main(string[] args)
// {
//     FFmpeg.SetFFmpegPath(@"C:\path\to\ffmpeg\bin"); // 必ず事前に設定
//     string videoFile = @"C:\path\to\your_video.mp4";
//     await GetInfoAsync(videoFile);
// }

}
“`

GetMediaInfo は ffprobe を実行し、その出力 XML をパースして IMediaInfo オブジェクトとして返します。これにより、メディアファイルの情報を簡単かつ構造的に取得できます。

ファイル変換 (FFmpeg.Conversions.New())

ファイル変換は FFmpeg.Conversions.New() から始まるメソッドチェーンを使用して行います。

“`csharp
using Xabe.FFmpeg;
using System;
using System.Threading.Tasks;
using System.IO;

public static class ConversionExample
{
public static async Task ConvertFileAsync(string inputPath, string outputPath)
{
try
{
// FFmpeg.SetFFmpegPath() は事前に呼び出しておくこと

        // 出力ディレクトリが存在しない場合は作成
        var outputDirectory = Path.GetDirectoryName(outputPath);
        if (!string.IsNullOrEmpty(outputDirectory) && !Directory.Exists(outputDirectory))
        {
            Directory.CreateDirectory(outputDirectory);
        }

        Console.WriteLine($"変換を開始します: {inputPath} -> {outputPath}");

        // 変換設定を作成
        IConversion conversion = await FFmpeg.Conversions.New()
            .AddStream(inputPath) // 入力ファイルを指定
            // .AddStream(anotherInputPath) // 複数の入力ファイル指定も可能
            .SetOutput(outputPath) // 出力ファイルを指定
            // .SetVideoCodec(VideoCodec.libx264) // 動画コーデックを指定
            // .SetAudioCodec(AudioCodec.aac) // 音声コーデックを指定
            // .SetPreset(Preset.VerySlow) // 変換速度と品質のプリセット
            // .SetSize(VideoSize.Hd720) // 解像度を変更 (例: 1280x720)
            // .SetBitrate(1000) // ビットレートをkbpsで指定
            // .AddParameter("-vf scale=640:-1") // 高度なフィルタやオプションはAddParameterで直接指定
            // .UseMultithreading(true) // マルチスレッドを有効化
            .Build(); // 設定を確定し、IConversionオブジェクトを生成

        // 進捗報告イベントの購読
        conversion.OnProgress += (sender, args) =>
        {
            // args に進捗情報が含まれる
            double percent = (double)args.Duration.Ticks / args.TotalLength.Ticks * 100;
            Console.WriteLine($"  進捗: {percent:F2}% ({args.Duration} / {args.TotalLength}) speed: {args.Speed}");
        };

        // 変換開始 (非同期)
        IConversionResult result = await conversion.Start();

        // result オブジェクトには終了コード、エラー情報などが含まれる
        if (result.ExitCode != 0)
        {
             Console.WriteLine($"FFmpegエラーコード: {result.ExitCode}");
             // result.Output にFFmpegの出力が表示される場合がある
        }

        Console.WriteLine("変換が完了しました。");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"変換中にエラーが発生しました: {ex.Message}");
    }
}

// 使用例:
// public static async Task Main(string[] args)
// {
//     FFmpeg.SetFFmpegPath(@"C:\path\to\ffmpeg\bin"); // 必ず事前に設定
//     string inputVideo = @"C:\path\to\input.mp4";
//     string outputVideo = @"C:\path\to\output.avi";
//     await ConvertFileAsync(inputVideo, outputVideo);
// }

}
“`

コード解説:

• FFmpeg.Conversions.New() で新しい変換プロセスを開始するためのビルダーを取得します。
• AddStream(inputPath) で入力ファイルを指定します。複数の入力ファイルを指定して結合したり、ピクチャーインピクチャー効果を適用したりすることも可能です。
• SetOutput(outputPath) で出力ファイルを指定します。
• SetVideoCodec, SetAudioCodec, SetPreset, SetSize, SetBitrate などのメソッドを使って、動画/音声の変換オプションを設定できます。これらのメソッドは、対応する FFmpeg コマンドライン引数を自動的に生成します。
• ライブラリの API で提供されていない高度なオプションやフィルタグラフを使用したい場合は、AddParameter(string parameter) メソッドを使って生の FFmpeg コマンドライン引数を追加できます。
• Build() を呼び出すと、設定されたオプションに基づいて IConversion オブジェクトが生成されます。この時点ではまだ FFmpeg は実行されていません。
• conversion.OnProgress イベントは、変換の進行中に定期的に発生します。イベントハンドラ内で args オブジェクトから現在の変換時間 (Duration)、全体のデュレーション (TotalLength)、変換速度 (Speed) などの情報を取得し、進捗表示に利用できます。これらの情報は FFmpeg の標準エラー出力をライブラリがパースして提供しているものです。
• await conversion.Start() で非同期に変換処理を開始します。処理が完了するまで待機し、結果を IConversionResult オブジェクトとして返します。
• IConversionResult の ExitCode やその他のプロパティを確認することで、処理の成否や詳細情報を取得できます。

その他の機能例

• サムネイル生成: FFmpeg.Conversions.New().AddStream(inputPath).ExtractThumbnail(TimeSpan position, string outputPath).Start() のように使います。
• ストリーム抽出: FFmpeg.Conversions.New().AddStream(inputPath).SetOutput(outputPath).CopyAudio().Start() のように、特定のストリームのみをコピーして抽出できます。
• フィルタリング: AddParameter を使うか、ライブラリが提供するフィルタリング関連のメソッド（もしあれば）を使用します。例えば、動画をクロップするには AddParameter("-vf crop=...") といった引数を追加します。

利点

• 圧倒的な使いやすさ: オブジェクト指向的な API により、FFmpeg の複雑なコマンドライン引数を直接扱う必要がほとんどなく、コードが格段に読みやすく、記述しやすくなります。
• 非同期処理の容易さ: .NET の async/await とシームレスに統合されており、非同期での FFmpeg 処理の実装が非常に容易です。
• 信頼性の高い進捗表示と情報取得: FFmpeg の出力をライブラリがパースし、構造化されたデータとして提供するため、自前でテキストをパースするよりもはるかに信頼性が高いです。
• 豊富な機能サポート: FFmpeg の主要な機能をほぼ網羅しており、多くの一般的なメディア処理タスクに対応できます。
• 高いメンテナンス性: 活発に開発が行われており、バグ修正や新機能の追加が期待できます。

欠点

• 学習コスト: FFmpeg 自体の知識に加えて、Xabe.FFmpeg の API を学習する必要があります。多機能であるがゆえに、API もそれなりに大きいです。
• 特定の高度な機能: Xabe.FFmpeg が直接的にサポートしていない FFmpeg の特定の高度なオプションや複雑なフィルタグラフを使用したい場合は、結局 AddParameter メソッドで生の引数を追加する必要があります。この場合、引数の生成と検証は自前で行う必要があります。
• ライセンス: 商用利用を検討している場合は、Xabe.FFmpeg のライセンスモデルを確認し、必要に応じて商用ライセンスの取得を検討する必要があります。FFmpeg 自体のライセンス（GPL/LGPL）への準拠も考慮に入れる必要があります。

Xabe.FFmpeg は、C# で本格的なメディア処理機能を実装したい場合に、非常に強力な選択肢となります。複雑な FFmpeg コマンドを抽象化し、開発効率とコードの保守性を大幅に向上させてくれます。

ライブラリ詳細: MediaToolkit

MediaToolkit は、C# から FFmpeg を操作するためのもう一つの主要なライブラリです。Xabe.FFmpeg に比べると機能は限定的ですが、その分 API がシンプルで学習コストが低いのが特徴です。基本的なメディア変換や情報取得に特化しており、手軽に FFmpeg 機能を利用したい場合に適しています。

特徴

• シンプルで直感的なAPI: 基本的な変換や情報取得に必要な API に絞られており、分かりやすいメソッド名とクラス構成になっています。
• 基本的な機能に特化: ファイル変換（動画/音声）、メディア情報の取得、サムネイル生成といった、最も一般的な FFmpeg の利用シナリオをカバーしています。
• 同期および非同期操作: 同期メソッドと非同期メソッド（async/await 対応）の両方を提供しています。
• NuGet パッケージ: NuGet パッケージとして簡単にインストールできます。

インストール

MediaToolkit も NuGet パッケージとして提供されています。

“`bash

.NET CLI を使用する場合

dotnet add package MediaToolkit
“`

または、Visual Studio の NuGet パッケージマネージャーで「MediaToolkit」を検索してインストールします。

使い方

MediaToolkit を使用する際も、FFmpeg の実行ファイル（ffmpeg.exe または ffmpeg）がシステムパス上にあるか、またはアプリケーションからアクセスできる場所に配置されている必要があります。MediaToolkit はデフォルトではシステムパス上の ffmpeg を探しますが、エンジンインスタンス作成時に FFmpeg 実行ファイルのパスを指定することも可能です。

“`csharp
using MediaToolkit; // 名前空間を追加

// エンジンインスタンスを作成
// 引数なしの場合、システムパス上の ffmpeg を探します
// var engine = new Engine();

// FFmpeg 実行ファイルのパスを指定する場合
string ffmpegExePath = @”C:\path\to\ffmpeg.exe”; // ffmpeg.exe のフルパス
var engine = new Engine(ffmpegExePath);
“`

Engine クラスのインスタンスを作成し、そのメソッドを呼び出して FFmpeg 処理を実行します。

メディア情報取得 (Engine.GetMetadata)

メディアファイルの情報を取得するには Engine.GetMetadata() メソッドを使用します。

“`csharp
using MediaToolkit;
using MediaToolkit.Model;
using System;
using System.IO;

public static class MediaInfoExample
{
public static void GetInfo(string filePath)
{
// FFmpeg 実行ファイルのパスを指定してエンジンを作成
string ffmpegExePath = @”C:\path\to\ffmpeg.exe”;
var engine = new Engine(ffmpegExePath);

    try
    {
        Console.WriteLine($"ファイル情報を取得中: {filePath}");

        // InputFile オブジェクトを作成
        var inputFile = new InputFile(filePath);

        // メタデータを取得
        engine.GetMetadata(inputFile);

        // Metadata オブジェクトから情報を参照
        if (inputFile.Metadata != null)
        {
            var metadata = inputFile.Metadata;
            Console.WriteLine($"  ファイル名: {metadata.Filename}");
            Console.WriteLine($"  フォーマット: {metadata.Format}");
            Console.WriteLine($"  デュレーション: {metadata.Duration}");
            Console.WriteLine($"  ビットレート: {metadata.Bitrate}");
            Console.WriteLine($"  動画情報:");
            Console.WriteLine($"    コーデック: {metadata.VideoData.Codec}");
            Console.WriteLine($"    解像度: {metadata.VideoData.FrameSize}"); // 例: 1920x1080
            Console.WriteLine($"    フレームレート: {metadata.VideoData.Fps}");
            Console.WriteLine($"  音声情報:");
            Console.WriteLine($"    コーデック: {metadata.AudioData.Codec}");
            Console.WriteLine($"    サンプルレート: {metadata.AudioData.SampleRate}");
            Console.WriteLine($"    チャンネル数: {metadata.AudioData.ChannelOutput}");
            Console.WriteLine($"    ビットレート: {metadata.AudioData.BitRate}");
        }
        else
        {
            Console.WriteLine("メタデータを取得できませんでした。");
        }

        Console.WriteLine("ファイル情報の取得が完了しました。");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"ファイル情報の取得中にエラーが発生しました: {ex.Message}");
    }
    finally
    {
        // エンジンを適切に破棄
        engine.Dispose();
    }
}

 // 使用例:
// public static void Main(string[] args)
// {
//     string videoFile = @"C:\path\to\your_video.mp4";
//     GetInfo(videoFile);
// }

}
“`

GetMetadata は内部で FFmpeg を実行し、出力される情報を InputFile オブジェクトの Metadata プロパティに設定します。Metadata オブジェクトは VideoData や AudioData といったプロパティを持ち、構造化された情報を提供します。

ファイル変換 (Engine.Convert)

ファイル変換には Engine.Convert() メソッドを使用します。変換オプションを指定するための ConversionOptions クラスも用意されています。

“`csharp
using MediaToolkit;
using MediaToolkit.Model;
using MediaToolkit.Options;
using System;
using System.IO;
using System.Threading.Tasks; // 非同期版を使う場合

public static class ConversionExample
{
// 同期版
public static void ConvertFile(string inputPath, string outputPath)
{
string ffmpegExePath = @”C:\path\to\ffmpeg.exe”;
var engine = new Engine(ffmpegExePath);

    try
    {
        // 出力ディレクトリが存在しない場合は作成
        var outputDirectory = Path.GetDirectoryName(outputPath);
        if (!string.IsNullOrEmpty(outputDirectory) && !Directory.Exists(outputDirectory))
        {
            Directory.CreateDirectory(outputDirectory);
        }

        Console.WriteLine($"変換を開始します (同期): {inputPath} -> {outputPath}");

        var inputFile = new InputFile(inputPath);
        var outputFile = new OutputFile(outputPath);

        // 変換オプションを設定 (オプションなしの場合は null)
        // var options = new ConversionOptions
        // {
        //     VideoCodec = "libx264", // 動画コーデックを指定
        //     AudioCodec = "aac",     // 音声コーデックを指定
        //     // その他のオプション...
        // };

        // オプションを指定せずにデフォルト設定で変換
        engine.Convert(inputFile, outputFile);

        Console.WriteLine("変換が完了しました (同期)。");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"変換中にエラーが発生しました: {ex.Message}");
    }
     finally
    {
        engine.Dispose();
    }
}

// 非同期版
 public static async Task ConvertFileAsync(string inputPath, string outputPath)
{
    string ffmpegExePath = @"C:\path\to\ffmpeg.exe";
    var engine = new Engine(ffmpegExePath);

    try
    {
         // 出力ディレクトリが存在しない場合は作成
        var outputDirectory = Path.GetDirectoryName(outputPath);
        if (!string.IsNullOrEmpty(outputDirectory) && !Directory.Exists(outputDirectory))
        {
            Directory.CreateDirectory(outputDirectory);
        }

        Console.WriteLine($"変換を開始します (非同期): {inputPath} -> {outputPath}");

        var inputFile = new InputFile(inputPath);
        var outputFile = new OutputFile(outputPath);

         var options = new ConversionOptions
        {
            // 非同期の場合、ProgressEvent を購読して進捗を取得可能
            // オプション例：動画をリサイズ
            CustomWidth = 640,
            CustomHeight = 360,
            // その他のオプション...
        };

        // 進捗報告イベントの購読
        engine.ConvertProgressEvent += (sender, args) =>
        {
            // args に進捗情報が含まれる (TotalDuration, ProcessedDuration, Frame, Fps, SizeKb, Speedなど)
            double percent = (double)args.ProcessedDuration.Ticks / args.TotalDuration.Ticks * 100;
            Console.WriteLine($"  進捗: {percent:F2}% ({args.ProcessedDuration} / {args.TotalDuration}) fps: {args.FrameFps} speed: {args.Speed}");
        };

        // 変換開始 (非同期)
        await engine.ConvertAsync(inputFile, outputFile, options);

        Console.WriteLine("変換が完了しました (非同期)。");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"変換中にエラーが発生しました: {ex.Message}");
    }
     finally
    {
        engine.Dispose();
    }
}


// 使用例:
// public static async Task Main(string[] args)
// {
//     string inputVideo = @"C:\path\to\input.mp4";
//     string outputVideo = @"C:\path\to\output.avi";
//     // ConvertFile(inputVideo, outputVideo); // 同期実行
//     await ConvertFileAsync(inputVideo, outputVideo); // 非同期実行
// }

}
“`

コード解説:

• Engine インスタンスを作成し、FFmpeg 実行ファイルのパスを指定します。Engine クラスは IDisposable を実装しているため、using ステートメントで囲むか、明示的に Dispose() を呼び出してリソースを解放するのが推奨されます。
• 変換元ファイルと変換先ファイルをそれぞれ InputFile および OutputFile オブジェクトとしてラップします。
• ConversionOptions クラスを使って、変換に関する様々なオプションを設定できます。コーデック、解像度、ビットレートなどの基本的なオプションが用意されています。ただし、Xabe.FFmpeg のように FFmpeg のあらゆるオプションをメソッドで指定できるわけではありません。高度なオプションは直接サポートされていない場合があります。
• Engine.Convert() (同期) または Engine.ConvertAsync() (非同期) メソッドを呼び出して変換を実行します。
• 非同期版 (ConvertAsync) を使用する場合、engine.ConvertProgressEvent イベントを購読することで、変換の進捗状況をリアルタイムで取得し、アプリケーションの UI に反映させることができます。イベントハンドラに渡される ConvertProgressEventArgs オブジェクトには、処理された時間、全体のデュレーション、フレームレート、変換速度などの情報が含まれています。
• エラーが発生した場合は例外がスローされます。

サムネイル生成 (Engine.GetThumbnail)

動画から特定の時間のサムネイル画像を生成することも可能です。

“`csharp
using MediaToolkit;
using MediaToolkit.Model;
using System;
using System.IO;
using System.Threading.Tasks; // 非同期版を使う場合

public static class ThumbnailExample
{
// 非同期版
public static async Task CreateThumbnailAsync(string videoPath, string thumbnailPath, TimeSpan position)
{
string ffmpegExePath = @”C:\path\to\ffmpeg.exe”;
var engine = new Engine(ffmpegExePath);

    try
    {
         // 出力ディレクトリが存在しない場合は作成
        var outputDirectory = Path.GetDirectoryName(thumbnailPath);
        if (!string.IsNullOrEmpty(outputDirectory) && !Directory.Exists(outputDirectory))
        {
            Directory.CreateDirectory(outputDirectory);
        }

        Console.WriteLine($"サムネイルを生成中: {videoPath} -> {thumbnailPath} at {position}");

        var inputFile = new InputFile(videoPath);
        var outputFile = new OutputFile(thumbnailPath);

        // サムネイルオプションを指定
        var options = new ConversionOptions
        {
            Seek = position // サムネイルを生成する時間
        };

        // サムネイル生成を実行 (非同期)
        await engine.GetThumbnailAsync(inputFile, outputFile, options);

        Console.WriteLine("サムネイル生成が完了しました。");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"サムネイル生成中にエラーが発生しました: {ex.Message}");
    }
     finally
    {
        engine.Dispose();
    }
}

 // 使用例:
// public static async Task Main(string[] args)
// {
//     string videoFile = @"C:\path\to\your_video.mp4";
//     string thumbnailFile = @"C:\path\to\thumbnail.jpg";
//     TimeSpan thumbnailPosition = TimeSpan.FromSeconds(5); // 動画開始から5秒の時点

//     await CreateThumbnailAsync(videoFile, thumbnailFile, thumbnailPosition);
// }

}
“`

Engine.GetThumbnailAsync メソッドは、ConversionOptions の Seek プロパティで指定された時間のフレームを抽出し、画像ファイルとして出力します。

利点

• シンプルで使いやすい: API が直感的で、基本的な FFmpeg 操作を簡単に行えます。学習コストが低く、すぐに使い始めることができます。
• 基本的なタスクに十分: ファイル変換、メタデータ取得、サムネイル生成といった一般的なニーズには十分対応できます。
• 同期/非同期対応: プロジェクトの要件に応じて、同期または非同期で処理を実行できます。

欠点

• 機能が限定的: Xabe.FFmpeg に比べてサポートしている FFmpeg 機能が少ないです。高度なフィルタリング、複数の入力ストリームの操作、特定の細かいオプション設定など、MediaToolkit の API で直接サポートされていない機能を使用するには、FFmpeg のコマンドライン引数を直接指定するような回避策が必要になる場合がありますが、それが容易でない場合があります。
• 柔軟性の制限: ConversionOptions で指定できるオプション以外に、FFmpeg のあらゆる引数を自由に指定するような柔軟性はありません（少なくとも Xabe.FFmpeg の AddParameter ほど簡単ではありません）。
• メンテナンス状況: Xabe.FFmpeg に比べると、開発の活発さはやや低い可能性があります。最新の FFmpeg 機能への対応が遅れる可能性も考慮する必要があります。

MediaToolkit は、FFmpeg の高度な機能を深く使う必要はなく、基本的なメディア処理タスクをシンプルかつ手軽に実装したい場合に適したライブラリです。

その他（簡単な紹介）

上記以外にも、C# から FFmpeg を操作するためのライブラリやツールが存在します。

• NReco.VideoConverter: これは商用ライブラリですが、非常に機能が豊富で安定しており、サポートも充実しています。FFmpeg の実行ファイルを内包しているバージョンもあり、配布の手間を減らせる場合があります。複雑な要件やエンタープライズ用途で、コストをかけてでも信頼性やサポートを重視したい場合に選択肢となり得ます。API は MediaToolkit に近いシンプルなものから、より詳細な設定が可能なものまで提供しています。

これらのライブラリは、それぞれ異なる特徴とライセンスモデルを持っています。プロジェクトの要件、予算、必要な機能、開発者のスキルレベルなどを考慮して、最適なものを選ぶ必要があります。

ライブラリ比較

これまで紹介した C# から FFmpeg を操作する主な手法（Process 直接実行、Xabe.FFmpeg、MediaToolkit）を比較し、それぞれの適したユースケースをまとめます。

項目	Process 直接実行 (System.Diagnostics.Process)	Xabe.FFmpeg	MediaToolkit
難易度	高 (自前で全て実装)	中 (API 学習必要)	低 (API シンプル)
依存関係	.NET 標準ライブラリのみ	Xabe.FFmpeg NuGet パッケージ	MediaToolkit NuGet パッケージ
FFmpeg 機能へのアクセス	完全に自由 (コマンドライン引数次第)	豊富 (API 化されている機能 + AddParameter)	基本的 (主要機能のみ API 化)
コマンドライン管理	手動で文字列生成 (複雑、エラー多発)	オブジェクト指向 API (容易、間違いにくい)	オブジェクト指向 API (限定的)
出力解析 (進捗/エラー)	自前でテキストパース (困難、脆弱)	ライブラリがパースし構造化データ提供 (信頼性高い)	ライブラリがパースし構造化データ提供 (基本的)
非同期対応	自前で実装 (Task, async/await, イベントハンドラ)	フルサポート (async/await, イベント)	サポートあり (Async メソッド, イベント)
エラーハンドリング	自前で実装 (ExitCode, 標準エラーパース)	ライブラリがラップ (例外スロー、結果オブジェクト)	ライブラリがラップ (例外スロー)
学習コスト	FFmpeg コマンドラインとプロセス管理の詳細知識が必要	Xabe.FFmpeg API の学習が必要	MediaToolkit API の学習は容易
開発効率	低	高	中
コードの保守性	低 (複雑なコマンド文字列、パースコード)	高 (オブジェクト指向、構造化データ)	中 (シンプルだが複雑な処理には限界)
ライセンス	.NET 標準ライブラリのライセンス + FFmpeg ライセンス	Xabe.FFmpeg ライセンス + FFmpeg ライセンス (商用利用注意)	MediaToolkit ライセンス + FFmpeg ライセンス
メンテナンス状況	自前 (ライブラリに依存しない)	活発	やや限定的
FFmpeg 実行ファイルの配布	自前で用意し、パス指定/環境変数設定などを行う	自前で用意し、SetFFmpegPath または環境変数設定を行う	自前で用意し、Engine コンストラクタでパス指定またはシステムパスに配置する

どの手法/ライブラリを選ぶべきか？

プロジェクトの具体的な要件と状況に基づいて、最適なアプローチを選択します。

• System.Diagnostics.Process 直接実行:

  • 適しているケース:
    • FFmpeg の機能を完全に自由に制御したい場合。ライブラリがサポートしていない非常に特殊なコマンド、オプション、フィルタグラフなどを頻繁に使用する必要がある。
    • 外部ライブラリへの依存を最小限に抑えたい場合。
    • 開発チームが FFmpeg のコマンドラインインターフェースとプロセス管理に習熟しており、自前での実装コストを受け入れられる場合。
  • 避けるべきケース:
    • 開発効率を重視する場合。
    • 信頼性の高い進捗表示や詳細な情報取得が必要な場合。
    • FFmpeg コマンドライン引数やプロセス管理に不慣れな場合。

• Xabe.FFmpeg:

  • 適しているケース:
    • 多くの種類の FFmpeg 機能を C# から利用したい場合（変換、抽出、サムネイル、ストリーミング、基本的なフィルタリングなど）。
    • 非同期処理を積極的に利用し、UI スレッドをブロックせずに FFmpeg 処理を実行したい場合。
    • 信頼性の高い進捗表示や詳細な情報取得（メディア情報、ストリーム情報など）が必要な場合。
    • オブジェクト指向的な API でコードの可読性と保守性を高めたい場合。
    • 複雑な FFmpeg コマンドを組み立てる手間を減らしたい場合。
  • 検討すべき点:
    • ライブラリの API を学習するためのコスト。
    • 商用利用におけるライセンス要件。

• MediaToolkit:

  • 適しているケース:
    • FFmpeg の機能として必要なのが、基本的な動画/音声変換、メディア情報の取得、サムネイル生成といった限られた機能だけで十分な場合。
    • 開発効率を重視し、最もシンプルで手軽な API を求めている場合。
    • ライブラリの学習コストを最小限に抑えたい場合。
  • 避けるべきケース:
    • 高度なフィルタリングや、MediaToolkit の API でサポートされていない特定の FFmpeg オプションを使用する必要がある場合。
    • Xabe.FFmpeg ほど豊富な機能や詳細な制御が必要な場合。

多くの場合、Xabe.FFmpeg は機能と使いやすさのバランスが取れており、C# から FFmpeg を操作するための最初の選択肢として推奨できます。MediaToolkit は、より限定的な用途でシンプルさを最優先する場合に良い選択肢となります。Process を直接実行する方法は、どうしてもライブラリでは対応できない特殊なケースに限定するのが現実的です。

FFmpeg操作における注意点

C# から FFmpeg を操作する際には、使用するライブラリに関わらず共通して考慮すべき注意点がいくつかあります。

1. FFmpeg 実行ファイルの配布と配置:

   • FFmpeg ライブラリ自体は FFmpeg 実行ファイル（ffmpeg および ffprobe）を含んでいません。これらの実行ファイルは別途ダウンロードし、アプリケーションからアクセスできる場所に配置する必要があります。
   • アプリケーションと一緒に配布する場合、ユーザーの OS に合った適切なバイナリを選択し、アプリケーションのインストールディレクトリや特定のサブディレクトリに配置し、プログラムからそのパスを指定できるようにする必要があります。
   • ユーザーに FFmpeg を別途インストールしてもらい、システムパスを通して使用させる方法もありますが、ユーザーの環境に依存するため制御が難しくなります。
   • 実行ファイルのパスを指定する際、特に Windows 環境ではスペースを含むパスを適切に処理する必要があります。ライブラリを使う場合はライブラリ側で処理してくれることが多いですが、Process を直接使う場合は注意が必要です。

2. ライセンス:

   • FFmpeg 自体は GPL または LGPL ライセンスで配布されています。GPL 版を使用する場合、FFmpeg を利用するアプリケーション全体も GPL にする必要があるなど、強い制約がかかる可能性があります。LGPL 版は比較的緩やかですが、それでも動的リンクなどの条件があります。アプリケーションのライセンスモデル（商用、オープンソースなど）と FFmpeg のライセンスとの互換性を慎重に確認する必要があります。
   • 使用する C# ラッパーライブラリ（Xabe.FFmpeg, MediaToolkit など）にも独自のライセンスがあります。特に商用利用を検討している場合は、ライブラリのライセンス条項を確認し、必要に応じて商用ライセンスの購入を検討してください。
   • これらのライセンス問題を回避するために、FFmpeg を別プロセスとして実行し、IPC（Inter-Process Communication）やファイル経由で連携するといった設計手法が取られることもありますが、実装は複雑になります。

3. エラーハンドリング:

   • FFmpeg は様々な理由で失敗する可能性があります（入力ファイルが見つからない、出力ファイルに書き込めない、コーデックがサポートされていない、メモリ不足など）。
   • Process を直接実行する場合、FFmpeg の標準エラー出力をパースしてエラーを検出する必要がありますが、エラーメッセージのフォーマットが統一されていないため困難です。終了コード (ExitCode) も重要な情報源です。
   • ライブラリを使用する場合、通常は例外がスローされるか、結果オブジェクトにエラー情報が含まれます。ライブラリが提供するエラー情報を適切にハンドリングし、ユーザーに分かりやすいメッセージを表示するなどの対応が必要です。
   • FFmpeg プロセス自体がクラッシュする可能性も考慮し、プロセスが予期せず終了した場合の検出と処理も実装する必要があります。

4. パフォーマンスとリソース消費:

   • 動画/音声のエンコードやデコードは非常に CPU リソースを消費する処理です。複数の FFmpeg プロセスを同時に実行したり、非常に高負荷な変換を行ったりする場合、システム全体のパフォーマンスに影響を与える可能性があります。
   • 必要に応じて、FFmpeg プロセスの優先度を調整したり、同時に実行するプロセス数を制限したり、ハードウェアアクセラレーション（FFmpeg が対応しており、システム環境が満たしている場合）を利用するなどの最適化を検討する必要があります。
   • 特にモバイル環境や低スペックな環境では、処理時間とリソース消費が大きな問題となる可能性があります。

5. 進捗表示の精度と信頼性:

   • FFmpeg の進捗情報は通常、標準エラーにテキスト形式で出力されます。ライブラリはこれらのテキストをパースして構造化されたデータとして提供しますが、FFmpeg のバージョンやビルドオプションによって出力フォーマットが微妙に変わることがあり、パースが失敗する可能性もゼロではありません。
   • 進捗情報は通常「処理された時間 (time)」に基づいて報告されますが、これは必ずしも全体の進捗率を正確に反映するわけではありません（特に VBR や複雑なフィルタを使用する場合）。
   • 正確な進捗率を表示するためには、まず ffprobe などで全体のデュレーションを取得し、FFmpeg が報告する「処理された時間」と全体のデュレーションを比較して計算するのが一般的です。

6. クロスプラットフォーム対応:

   • Windows、macOS、Linux など複数の OS でアプリケーションを動作させたい場合、それぞれの OS に対応した FFmpeg 実行ファイルを用意する必要があります。
   • パスの指定方法（バックスラッシュ vs スラッシュ）や、実行ファイルのファイル名 (ffmpeg.exe vs ffmpeg) など、OS 固有の違いを吸収する必要があります。多くの C# ライブラリはこれらの違いを内部的に処理してくれます。
   • FFmpeg のビルドオプションによって、サポートされるコーデックや機能が異なる場合があることにも注意が必要です。

7. セキュリティ:

   • ユーザーからの入力（ファイルパス、オプションなど）を直接 FFmpeg のコマンドライン引数に渡す場合、コマンドインジェクションの脆弱性が発生しないよう、入力値を適切にサニタイズまたは検証する必要があります。ライブラリを使用する場合、ライブラリが引数を安全に生成してくれることが多いですが、AddParameter のように生の引数を指定できる機能を使用する際は特に注意が必要です。

これらの注意点を理解し、適切に対処することで、C# アプリケーションに FFmpeg 機能を安全かつ安定して組み込むことができます。

まとめ

この記事では、C# から FFmpeg を操作するための主要なアプローチとして、System.Diagnostics.Process クラスを使った直接実行、そして主要なラッパーライブラリである Xabe.FFmpeg と MediaToolkit を詳細に解説し、それぞれの特徴、使い方、利点、欠点を比較しました。

• System.Diagnostics.Process を直接使う方法は、最も柔軟で FFmpeg の全機能にアクセス可能ですが、コマンドライン引数の管理、出力のパース、エラー処理など、開発者の負担が最も大きい方法です。特定の高度な要件や依存関係を最小限にしたい場合に適していますが、推奨されるケースは少ないでしょう。
• Xabe.FFmpeg は、オブジェクト指向的な API、豊富な機能サポート、信頼性の高い非同期処理と進捗報告機能を提供します。多くのメディア処理タスクに対応でき、開発効率とコードの保守性を大幅に向上させます。本格的な FFmpeg 連携を必要とするプロジェクトで最初の選択肢となる強力なライブラリです。
• MediaToolkit は、シンプルな API と基本的な機能に特化しており、学習コストが低いです。動画/音声の変換、メディア情報取得、サムネイル生成といった基本的なニーズを手軽に実装したい場合に適しています。

どの手法やライブラリを選択するかは、プロジェクトで必要とされる FFmpeg 機能の範囲、開発チームのスキルレベル、開発期間、パフォーマンス要件、ライセンス上の制約など、様々な要因によって決定されるべきです。

FFmpeg は非常に強力かつ多機能なツールであり、C# と組み合わせることで、メディア処理に関する幅広いアプリケーションを開発することが可能になります。適切なライブラリを選択し、FFmpeg 操作における注意点を踏まえて実装することで、安定したメディア処理機能を C# アプリケーションに組み込むことができるでしょう。

この記事が、C# から FFmpeg を操作しようとしている開発者の皆様にとって、最適なアプローチを見つけ、開発をスムーズに進めるための一助となれば幸いです。