C#でffmpegを活用するためのライブラリ紹介

---

C#で動画・音声を自在に操る：FFmpeg活用ライブラリ徹底解説

1. はじめに：動画・音声処理の強力な味方、FFmpegとは？

現代のソフトウェア開発において、動画や音声といったメディアデータを扱う機会はますます増えています。Webサイトでの動画再生、モバイルアプリでの動画編集、デスクトップアプリケーションでのメディア変換、監視システムでの録画処理、さらにはAIを活用した動画解析の前処理など、その応用範囲は広がる一方です。

これらのメディア処理において、デファクトスタンダードとも言えるほど世界中で広く利用されている強力なツールがあります。それが FFmpeg です。FFmpegは、動画や音声のエンコード（符号化）、デコード（復号化）、フォーマット変換、ストリーム処理、フィルタリングなど、メディア処理に関する膨大な機能を持つオープンソースのコマンドラインツール群です。非常に多くのコーデック（H.264, H.265, VP9, AAC, MP3など）やコンテナフォーマット（MP4, MKV, AVI, MOV, MP3, AACなど）をサポートしており、ほぼ全てのメディア処理タスクをこなすことができると言っても過言ではありません。

しかし、FFmpegは基本的にコマンドラインインターフェースを通じて操作するツールです。GUIアプリケーション、バックグラウンドサービス、Web APIといったC# (.NET) 環境で動作するアプリケーションからFFmpegの機能を利用したい場合、コマンドラインを直接実行するか、FFmpegの機能をラップしたライブラリを利用する必要があります。

本記事では、C# (.NET) 環境でFFmpegの強力な能力を最大限に引き出すための主要なライブラリに焦点を当て、それぞれの特徴、使い方、メリット・デメリット、そしてどのようなケースでどのライブラリを選択すべきかを詳細に解説します。約5000語というボリュームで、各ライブラリの基本的な使い方から、より進んだ機能の活用方法、さらにはFFmpegをC#から扱う上での実践的なヒントやトラブルシューティングまで、網羅的にご紹介します。

この記事を読むことで、あなたはC#アプリケーションに高度な動画・音声処理機能を組み込むための具体的な手法を理解し、自身のプロジェクトに最適なアプローチを選択できるようになるでしょう。

2. FFmpegコマンドラインツールの基本を知る

C#からFFmpegを利用するにしても、FFmpeg自体の基本的な使い方や考え方を理解しておくことは非常に重要です。多くのC#ラッパーライブラリは、内部でFFmpegのコマンドラインツールを呼び出しているか、あるいはFFmpegのC APIを直接利用しています。どちらのアプローチにせよ、FFmpegの概念を知っておくことは、ライブラリを効果的に使いこなすために役立ちます。

FFmpegは通常、以下の基本的な構文で実行されます。

bash
ffmpeg [global_options] {[input_file_options] -i input_url} ... {[output_file_options] output_url} ...

• ffmpeg: 実行ファイル名です。
• [global_options]: FFmpeg全体の挙動を制御するオプションです。例：ログレベル (-loglevel), スレッド数 (-threads) など。
• [input_file_options]: 入力ファイルに適用されるオプションです。例：入力フォーマット (-f), シーク位置 (-ss) など。入力ファイルのパス (-i input_url) の直前に置かれることが多いです。
• -i input_url: 入力ファイルのパスまたはURLを指定します。複数の入力ファイルを指定することも可能です。
• [output_file_options]: 出力ファイルに適用されるオプションです。例：出力フォーマット (-f), ビデオコーデック (-c:v), オーディオコーデック (-c:a), ビットレート (-b:v, -b:a), 解像度 (-s), 期間 (-t), フィルタグラフ (-filter_complex) など。出力ファイルのパス (output_url) の直前に置かれます。
• output_url: 出力ファイルのパスまたはURLを指定します。複数の出力ファイルを指定することも可能です。

基本的な変換例:

例えば、input.mp4 を H.264 ビデオコーデックと AAC オーディオコーデックを使って output.avi に変換する場合、コマンドは以下のようになります。

bash
ffmpeg -i input.mp4 -c:v libx264 -c:a aac output.avi

• -i input.mp4: 入力ファイルとして input.mp4 を指定。
• -c:v libx264: ビデオコーデックとして libx264 (H.264の実装の一つ) を指定。
• -c:a aac: オーディオコーデックとして aac を指定。
• output.avi: 出力ファイルとして output.avi を指定（拡張子からコンテナフォーマットが自動的に推測されます）。

その他のよく使うオプション:

• -ss <position>: シーク（指定した位置から処理を開始）。入力オプションとして使うと高速ですが不正確な場合があります。出力オプションとして使うと正確ですが低速です。
• -t <duration>: 処理する期間を指定。
• -s <width>x<height>: 動画の解像度を変更。例：-s 640x480
• -b:v <bitrate>: ビデオのビットレートを指定。例：-b:v 2M (2 Mbps)
• -b:a <bitrate>: オーディオのビットレートを指定。例：-b:a 128k (128 kbps)
• -vf <filtergraph>: ビデオフィルタを適用。例：-vf scale=640:-1 (アスペクト比を保って幅を640ピクセルにする)
• -af <filtergraph>: オーディオフィルタを適用。
• -filter_complex <filtergraph>: 複数の入力や複雑なフィルタリングを行うためのオプション（例：ピクチャー・イン・ピクチャー、複数の動画合成など）。
• -vn: ビデオトラックを含めない（音声のみ）。
• -an: オーディオトラックを含めない（ビデオのみ）。
• -f <format>: フォーマットを明示的に指定。例：-f gif でGIFアニメーション出力。

FFmpegは実行中に処理の進行状況やエラー情報を標準エラー出力 (stderr) に出力します。C#からFFmpegプロセスを実行する場合、この stderr を捕捉してユーザーに進捗を表示したり、エラーを検出したりするのが一般的なアプローチとなります。

FFmpegのコマンドラインオプションは非常に多岐にわたり、詳細なドキュメントは公式ウェブサイトで公開されています。C#ラッパーライブラリを使う際にも、FFmpegのドキュメントを参照することが度々必要になるでしょう。

3. C#からFFmpegを利用するアプローチ

C#アプリケーションからFFmpegの機能を利用するには、主に以下の2つのアプローチがあります。

1. System.Diagnostics.Process クラスを使用してFFmpegのコマンドラインツールを直接実行する。
2. FFmpegの機能やFFmpegコマンドラインツールをラップした.NETライブラリを使用する。

それぞれのメリット・デメリットを見てみましょう。

3.1 System.Diagnostics.Process アプローチ

このアプローチでは、C#の System.Diagnostics.Process クラスを使用して、FFmpegの実行ファイル（ffmpeg.exe や ffmpeg）を指定したコマンドライン引数付きで起動します。そして、プロセスの標準入力、標準出力、標準エラー出力をリダイレクトして、FFmpegとの間でデータのやり取りや情報の取得を行います。

メリット:

• 追加ライブラリが不要: .NET標準ライブラリだけで実装できます。
• FFmpegの最新機能にすぐアクセス: FFmpegの新しいバージョンがリリースされた際に、その新機能や新しいオプションをすぐに利用できます。ラッパーライブラリの更新を待つ必要がありません。
• FFmpegコマンドラインの知識がそのまま使える: 既存のFFmpegコマンドラインに関する知識やスクリプトをC#コードに比較的容易に組み込めます。
• 最大限の柔軟性: FFmpegが提供するあらゆるオプションや機能をコマンドライン引数として渡すことで利用可能です。

デメリット:

• コマンド文字列の構築が複雑: FFmpegのオプションは多岐にわたり、エスケープ処理なども考慮する必要があるため、動的に複雑なコマンド文字列を組み立てるのは手間がかかります。
• エラー処理や進行状況の取得が手動: FFmpegは進行状況やエラー情報を標準エラー出力にテキストとして出力します。これをパースしてアプリケーションのステータスとして表示したり、エラーを特定したりする処理を自分で実装する必要があります。テキスト形式はFFmpegのバージョンによって変更される可能性もあり、パース処理の頑強性を保つのが難しい場合があります。
• クロスプラットフォーム対応の考慮: Windows, macOS, Linux それぞれでFFmpeg実行ファイルのパスが異なる可能性があり、また、FFmpegのバージョン管理や配布も自分で管理する必要があります。
• コードが読みにくくなりがち: コマンド文字列が中心となるため、何をしているのかがコードから直感的に理解しにくい場合があります。

Process クラスを使った基本的なコード例：

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

public class FfmpegProcessRunner
{
private Process ffmpegProcess;
private TaskCompletionSource processCompletionSource;

public event EventHandler<string> OutputDataReceived;
public event EventHandler<string> ErrorDataReceived;
public event EventHandler<int> ProcessExited;

public async Task<int> RunFfmpegAsync(string ffmpegPath, string arguments, CancellationToken cancellationToken = default)
{
    processCompletionSource = new TaskCompletionSource<int>();

    ffmpegProcess = new Process
    {
        StartInfo = new ProcessStartInfo
        {
            FileName = ffmpegPath, // 例: "ffmpeg" または "/usr/local/bin/ffmpeg"
            Arguments = arguments,
            UseShellExecute = false,
            RedirectStandardInput = true, // 必要に応じて
            RedirectStandardOutput = true,
            RedirectStandardError = true,
            CreateNoWindow = true // コンソールウィンドウを表示しない
        },
        EnableRaisingEvents = true // Exited イベントを有効にする
    };

    ffmpegProcess.OutputDataReceived += (sender, e) =>
    {
        if (e.Data != null)
        {
            OutputDataReceived?.Invoke(this, e.Data);
            // 進捗パース処理などをここで行う
        }
    };

    ffmpegProcess.ErrorDataReceived += (sender, e) =>
    {
        if (e.Data != null)
        {
            ErrorDataReceived?.Invoke(this, e.Data);
            // エラー検出処理などをここで行う
        }
    };

    ffmpegProcess.Exited += (sender, e) =>
    {
        ProcessExited?.Invoke(this, ffmpegProcess.ExitCode);
        processCompletionSource.TrySetResult(ffmpegProcess.ExitCode);
        // プロセス終了後のクリーンアップなど
        ffmpegProcess.Dispose(); // プロセスリソースの解放
    };

    // キャンセル処理の登録
    using (cancellationToken.Register(() =>
    {
        try
        {
            if (!ffmpegProcess.HasExited)
            {
                ffmpegProcess.Kill(); // または ffmpegProcess.CloseMainWindow() など、より穏やかな終了方法も検討
            }
        }
        catch (InvalidOperationException) { /* プロセスがすでに終了している場合 */ }
        catch (Exception ex) { /* キャンセル中のエラーハンドリング */ }
        processCompletionSource.TrySetCanceled();
    }))
    {
        try
        {
            bool started = ffmpegProcess.Start();
            if (!started)
            {
                throw new Exception("FFmpegプロセスの起動に失敗しました。");
            }

            ffmpegProcess.BeginOutputReadLine();
            ffmpegProcess.BeginErrorReadLine();

            // プロセス終了を待機
            return await processCompletionSource.Task;
        }
        catch (Exception ex)
        {
            // プロセス起動失敗などのエラー
            processCompletionSource.TrySetException(ex);
            throw;
        }
    }
}

// 必要に応じて、プロセス起動後に標準入力にデータを書き込むメソッドなどを追加

}

// 使用例
// var runner = new FfmpegProcessRunner();
// runner.OutputDataReceived += (s, data) => Console.WriteLine($”OUT: {data}”);
// runner.ErrorDataReceived += (s, data) => Console.WriteLine($”ERR: {data}”);
// try
// {
// var exitCode = await runner.RunFfmpegAsync(“ffmpeg”, “-i input.mp4 output.avi”);
// Console.WriteLine($”FFmpeg exited with code: {exitCode}”);
// }
// catch (Exception ex)
// {
// Console.WriteLine($”Error running FFmpeg: {ex.Message}”);
// }
“`

このコードは基本的な構造を示していますが、実際のアプリケーションではエラー出力のパース（特に進捗状況の表示のため）や、より詳細なエラーハンドリング、リソース管理などが複雑になります。この複雑さを抽象化し、よりC#らしいオブジェクト指向なAPIを提供するのが、FFmpegラッパーライブラリです。

3.2 FFmpegラッパーライブラリ アプローチ

FFmpegラッパーライブラリは、前述の Process アプローチの複雑さを隠蔽し、C#開発者がより直感的にFFmpegの機能を利用できるように設計されています。これらのライブラリは、内部でFFmpegプロセスを起動してコマンドを実行したり、あるいはFFmpegのネイティブライブラリ（DLLや共有ライブラリ）をP/Invoke（Platform Invoke）を使って直接呼び出したりします。

メリット:

• 開発効率の向上: FFmpegコマンドラインの複雑な引数を意識することなく、メソッド呼び出しやオブジェクト設定で目的の処理を指定できます。
• コードの可読性向上: C#のオブジェクト指向パラダイムに沿ったコードになり、何をしているのかが分かりやすくなります。
• エラー処理と進行状況の取得が容易: ライブラリがFFmpegの出力をパースし、イベントや例外として通知してくれるため、エラーハンドリングや進捗表示の実装が容易になります。
• クロスプラットフォーム対応: ライブラリによっては、OSごとのFFmpegバイナリのパス解決や、ネイティブライブラリの読み込みなどを自動的に行ってくれます。FFmpegバイナリの配布や管理をサポートしてくれるものもあります。
• 非同期処理対応: 多くのモダンなラッパーライブラリは、FFmpegの長時間処理をブロックせずに実行できる非同期API (async/await) を提供しています。

デメリット:

• ライブラリの学習コスト: 各ライブラリ固有のAPIや概念を学習する必要があります。
• 機能の制限: ライブラリがFFmpegの全ての機能やオプションを完全にラップしているとは限りません。細かい、あるいは非常に特殊なFFmpegオプションを利用したい場合、ライブラリでは対応できないか、あるいは「raw argument」としてコマンド文字列の一部を直接渡す必要が出てくる場合があります。
• ライブラリの更新状況に依存: FFmpegの最新機能を利用できるようになるには、ラッパーライブラリがその機能をサポートするまで待つ必要があります。
• オーバーヘッド: Process を直接利用する場合に比べて、ライブラリによる抽象化の分のオーバーヘッドが発生する可能性があります（通常は無視できる程度ですが、極端なパフォーマンスが要求される場合は考慮が必要かもしれません）。

本記事では、このラッパーライブラリのアプローチに焦点を当て、主要なライブラリを詳しく見ていきます。

4. 主要なFFmpegラッパーライブラリの紹介

C#向けのFFmpegラッパーライブラリはいくつか存在しますが、ここでは現在（2024年時点）比較的に活発にメンテナンスされており、広く利用されている、あるいは特徴的なアプローチを取っている以下の3つのライブラリを中心に紹介します。

1. FFmpeg.Autogen: FFmpegのネイティブライブラリ（DLL）をP/Invokeで直接呼び出す、低レベルなバインディングライブラリ。最大限の柔軟性を提供するが、学習コストは高い。
2. FFmpegCore: FFmpegコマンドラインツールをプロセスとして起動する高レベルなラッパー。使いやすいオブジェクト指向APIを提供し、多くの一般的なユースケースに対応。
3. NReco.VideoConverter: FFmpegコマンドラインツールをプロセスとして起動する非常にシンプルなラッパー。使いやすさを最優先しており、基本的な変換タスクに最適。商用ライセンス。

これらのライブラリについて、それぞれの特徴、インストール方法、基本的な使い方、メリット・デメリットなどを詳細に掘り下げていきましょう。

4.1 FFmpeg.Autogen

概要:
FFmpeg.Autogen は、FFmpegのネイティブライブラリ（avformat, avcodec, avutil, swscale, avfilter など）のC APIを、C#からP/Invokeを使って呼び出すための低レベルな自動生成バインディングです。他のラッパーライブラリがFFmpegコマンドラインツールをプロセスとして呼び出すのに対し、FFmpeg.Autogen はFFmpegのDLL/soファイルを直接アプリケーションにロードし、その関数を呼び出します。これにより、FFmpegが提供するほぼ全ての機能にC#からアクセスできるという、他のラッパーにはない圧倒的な柔軟性を提供します。

特徴:
* 低レベルアクセス: FFmpegのC API（構造体、関数ポインタ、ポインタ演算など）をC#コード内で直接扱います。
* 最大限の機能アクセス: FFmpegの持つ全てのデコーダー、エンコーダー、ミキサー、パーサー、プロトコル、フィルターなどにアクセス可能です。
* 高いパフォーマンス: プロセス間通信のオーバーヘッドがなく、FFmpegの処理を直接呼び出すため、潜在的に最も高いパフォーマンスを発揮できます。
* FFmpegバイナリの管理が必要: FFmpegのDLLやsoファイルを別途用意し、アプリケーションから参照できる場所に配置する必要があります。対応するFFmpegのバージョンに依存します。
* 学習コストが高い: FFmpegのC APIに関する深い知識が必要です。ポインタ操作やメモリ管理（FFmpegが割り当てたメモリの解放など）もC#コード側で行う必要があります。C#の unsafe コードや Span<T> などの知識も役立ちます。

インストール:
NuGetパッケージマネージャーで FFmpeg.Autogen を検索してインストールします。
bash
dotnet add package FFmpeg.Autogen
これに加えて、アプリケーションが実行される環境にFFmpegのネイティブバイナリが必要です。公式ウェブサイトやコミュニティビルドからダウンロードし、アプリケーションの実行ディレクトリやシステムのパスが通った場所に配置します。FFmpeg.Autogen は特定のFFmpegバージョン向けに生成されている場合があるため、互換性のあるバージョンのバイナリを用意することが推奨されます。また、バイナリを探すのを助けるための別のNuGetパッケージ (FFmpeg.Native) が存在する場合がありますが、これはコミュニティによって提供されているため、利用の際は注意が必要です。

基本的な使用例（概念説明）:
FFmpeg.Autogen を使ったコードは、FFmpegのC APIドキュメントをC#に翻訳したような見た目になります。非常に低レベルなため、単純なファイル変換を行うだけでも多くのステップが必要です。

概念的なワークフロー:

1. FFmpegライブラリの初期化 (ffmpeg.av_register_all() など)。
2. 入力ファイルのオープン (ffmpeg.avformat_open_input())。AVFormatContext を取得。
3. ストリーム情報の取得 (ffmpeg.avformat_find_stream_info())。
4. ビデオストリームやオーディオストリームを探す。
5. 各ストリームに対応するデコーダーを見つける (ffmpeg.avcodec_find_decoder())。
6. デコーダーコンテキストを作成し、設定する (ffmpeg.avcodec_alloc_context3(), ffmpeg.avcodec_parameters_to_context(), ffmpeg.avcodec_open2())。AVCodecContext を取得。
7. 出力ファイルのオープン (ffmpeg.avformat_alloc_output_context2(), ffmpeg.avio_open2() など)。AVFormatContext (出力用) を取得。
8. 出力ストリームの作成 (ffmpeg.avformat_new_stream())。
9. エンコーダーを見つけ、エンコーダーコンテキストを作成し、設定・オープンする (ffmpeg.avcodec_find_encoder(), ffmpeg.avcodec_alloc_context3(), ffmpeg.avcodec_parameters_from_context(), ffmpeg.avcodec_open2())。AVCodecContext (出力用) を取得。
10. 入力からパケットを読み込むループ (ffmpeg.av_read_frame())。AVPacket を取得。
11. パケットをデコーダーに送信 (ffmpeg.avcodec_send_packet())。
12. デコーダーからフレームを受け取るループ (ffmpeg.avcodec_receive_frame())。AVFrame を取得。
13. 必要に応じてフィルタリング (ffmpeg.avfilter_graph_config(), ffmpeg.av_buffersrc_add_frame(), ffmpeg.av_buffersink_get_frame())。
14. フレームをエンコーダーに送信 (ffmpeg.avcodec_send_frame())。
15. エンコーダーからパケットを受け取るループ (ffmpeg.avcodec_receive_packet())。AVPacket (エンコード済み) を取得。
16. パケットを出力ファイルに書き込む (ffmpeg.av_interleaved_write_frame())。
17. ループ終了後、エンコーダーやデコーダーのフラッシュを行う。
18. 出力ファイルのフッターを書き込む (ffmpeg.av_write_trailer())。
19. 全てのリソースを解放する (ffmpeg.avformat_close_input(), ffmpeg.avio_closep(), ffmpeg.avcodec_free_context(), ffmpeg.av_frame_free(), ffmpeg.av_packet_unref() など)。

上記は非常に簡略化されたステップであり、実際にはエラーチェック、ストリームの同期、フォーマット変換（ピクセルフォーマットやサンプルフォーマット）、サイズ変更、タイムスタンプの計算など、多くの詳細な処理が必要になります。unsafe コンテキストを使用し、ポインタを扱うことが避けられません。

コードスニペット例（断片的な概念コード）:

“`csharp
// 一部のコードをunsafeブロックで囲む必要がある
unsafe
{
// FFmpegライブラリの初期化（一度だけ行う）
ffmpeg.av_register_all();
ffmpeg.avcodec_register_all();
ffmpeg.avformat_network_init(); // ネットワークストリームを扱う場合

AVFormatContext* pFormatContext = null;
string inputFilePath = "input.mp4";

// 入力ファイルを開く
// avformat_open_input は AVFormatContext のポインタを返すポインタへの参照を受け取る
// C#ではポインタへのポインタは IntPtr を使うか、unsafeで直接 AVFormatContext** を使う
AVFormatContext* formatContext = null;
var ret = ffmpeg.avformat_open_input(&formatContext, inputFilePath, null, null);
if (ret < 0)
{
    // エラー処理
    Console.WriteLine($"Failed to open input file: {inputFilePath}");
    // エラーメッセージ取得: string errorMessage = FFmpegUtil.AVErrorToString(ret);
    return;
}
pFormatContext = formatContext; // ポインタを別の変数に保持

// ストリーム情報を取得
ret = ffmpeg.avformat_find_stream_info(pFormatContext, null);
if (ret < 0)
{
    Console.WriteLine("Failed to find stream info.");
    ffmpeg.avformat_close_input(&pFormatContext); // リソース解放
    return;
}

// デバッグ情報表示（オプション）
ffmpeg.av_dump_format(pFormatContext, 0, inputFilePath, 0);

// ビデオストリームを探す
int videoStreamIndex = -1;
AVCodecParameters* pCodecParameters = null;
for (uint i = 0; i < pFormatContext->nb_streams; i++)
{
    if (pFormatContext->streams[i]->codecpar->codec_type == AVMediaType.AVMEDIA_TYPE_VIDEO)
    {
        videoStreamIndex = (int)i;
        pCodecParameters = pFormatContext->streams[i]->codecpar;
        break;
    }
}

if (videoStreamIndex == -1)
{
    Console.WriteLine("No video stream found.");
    ffmpeg.avformat_close_input(&pFormatContext);
    return;
}

// デコーダーを見つけて開く
AVCodec* pDecoder = ffmpeg.avcodec_find_decoder(pCodecParameters->codec_id);
if (pDecoder == null)
{
    Console.WriteLine("Supported decoder not found.");
    ffmpeg.avformat_close_input(&pFormatContext);
    return;
}

AVCodecContext* pDecoderContext = ffmpeg.avcodec_alloc_context3(pDecoder);
if (pDecoderContext == null)
{
    Console.WriteLine("Failed to allocate decoder context.");
    ffmpeg.avformat_close_input(&pFormatContext);
    return;
}

ret = ffmpeg.avcodec_parameters_to_context(pDecoderContext, pCodecParameters);
if (ret < 0)
{
    Console.WriteLine("Failed to copy decoder parameters to context.");
    ffmpeg.avcodec_free_context(&pDecoderContext);
    ffmpeg.avformat_close_input(&pFormatContext);
    return;
}

ret = ffmpeg.avcodec_open2(pDecoderContext, pDecoder, null);
if (ret < 0)
{
    Console.WriteLine("Failed to open decoder.");
    ffmpeg.avcodec_free_context(&pDecoderContext);
    ffmpeg.avformat_close_input(&pFormatContext);
    return;
}

// デコードとエンコードのループへ...
// AVPacket, AVFrame などのポインタを扱う
// ffmpeg.av_read_frame(), ffmpeg.avcodec_send_packet(), ffmpeg.avcodec_receive_frame() などを使用
// 出力処理 (AVFormatContext*, AVCodecContext* (エンコーダー用), AVPacket*, AVFrame* など) も同様に低レベルなAPIを使用
// ffmpeg.avformat_alloc_output_context2(), ffmpeg.avio_open2(), ffmpeg.avcodec_send_frame(), ffmpeg.avcodec_receive_packet(), ffmpeg.av_interleaved_write_frame() など

// 全てのリソース解放を忘れずに行う！
ffmpeg.avcodec_free_context(&pDecoderContext);
ffmpeg.avformat_close_input(&pFormatContext);
// 他にも、AVFrame や AVPacket を自分で確保した場合は解放が必要

} // unsafeブロックの終了

// FFmpegネットワークライブラリの解放（アプリケーション終了時に一度だけ）
// ffmpeg.avformat_network_deinit();
``
この例は非常に簡略化されており、実際には多くの構造体、ポインタ、API呼び出し、そして複雑なエラー処理とリソース管理が必要になります。例えば、AVFrameのピクセルフォーマットがエンコーダーでサポートされていない場合は、swscale` ライブラリを使ってフォーマット変換を行う必要があります。また、オーディオストリームの処理、複数の入力や出力、フィルタリングなども追加で実装する必要があります。

利点:
* FFmpegの全機能にアクセスでき、最大限の柔軟性を持つ。
* 低レベルなため、パフォーマンスが重要視される場面で有利。
* FFmpegの最新機能への対応が比較的早い（FFmpeg.Autogen自体のバインディング生成が追いつけば）。

欠点:
* 学習コストが非常に高い。FFmpegのC APIとメディア処理の概念に関する深い知識が必須。
* コード量が非常に多くなりがちで、複雑。
* ポインタ操作や手動でのメモリ管理が必須であり、バグを混入させやすい。
* FFmpegバイナリの配布とバージョン管理が開発者の責任となる。
* C#の unsafe コードを使用する必要がある場合が多い。

対象ユーザー/ユースケース:
* 既存のFFmpeg CコードベースをC#に移植したい。
* FFmpegのマイナーな機能や最新のオプション、あるいは複雑なフィルタグラフを最大限に制御したい。
* 最高レベルのパフォーマンスが要求されるリアルタイム処理やストリーミングアプリケーションを開発している。
* FFmpegの内部動作を深く理解しており、低レベルAPIを直接操作することに抵抗がない。
* 他の高レベルラッパーでは実現できない特殊な処理が必要。

FFmpeg.Autogen は強力ですが、その複雑さから多くの一般的なアプリケーション開発者には推奨されません。ほとんどのユースケースでは、後述の高レベルラッパーの方が開発効率と保守性の観点から適しています。

4.2 FFmpegCore

概要:
FFmpegCore は、FFmpegコマンドラインツールをプロセスとして実行するための、高レベルでモダンなC#ラッパーライブラリです。使いやすいオブジェクト指向APIを提供し、一般的なメディア処理タスク（フォーマット変換、エンコード、サムネイル生成、メディア情報取得など）を少ないコードで実現できます。非同期処理にも対応しており、GUIアプリケーションやWebサービスなど、バックグラウンドで長時間処理を実行する必要があるアプリケーションに適しています。

特徴:
* 高レベルAPI: FFmpeg.Autogen のような低レベルなFFmpeg C APIではなく、目的ベースのメソッドやオブジェクトを使って処理を記述します。
* 使いやすさ: 直感的で、学習コストは比較的低い。
* 一般的なタスクをサポート: ファイル変換、ストリーム変換、サムネイル生成、メディア情報の取得などが容易に行えます。
* 非同期処理対応: async/await を使った非同期APIが提供されており、アプリケーションの応答性を維持しやすいです。
* FFmpegバイナリの扱い: FFmpegバイナリのパスを指定するか、ライブラリの機能を使ってバイナリを自動的にダウンロード・配置させることができます。
* 進行状況とイベント: FFmpegプロセスの実行状況（進捗率、処理速度など）をパースしてイベントとして通知してくれます。エラーも例外として扱われます。
* クロスプラットフォーム対応: .NET Core/.NET 5+ 上で動作し、Windows, macOS, Linux をサポートしています（ただし、FFmpegバイナリ自体も対象OSのものである必要があります）。

インストール:
NuGetパッケージマネージャーで FFmpegCore を検索してインストールします。
bash
dotnet add package FFmpegCore
デフォルトでは、FFmpegバイナリは自動でダウンロードされません。別途用意するか、ライブラリの設定で自動ダウンロードを有効にする必要があります。

FFmpegバイナリの準備:
FFmpegCore がFFmpegを実行できるようにするには、ffmpeg 実行ファイル (ffmpeg.exe や ffmpeg) がライブラリからアクセスできる場所に存在する必要があります。以下のいずれかの方法でパスを指定します。

1. 環境変数 FFMPEG_BINARY_PATH を設定する。
2. アプリケーション起動時やFFmpeg処理実行前に、GlobalFFmpegOptions.Configure() メソッドでパスを設定する。
3. FFmpegConfiguration オブジェクトを作成し、FFmpeg クラスのメソッドに渡す。
4. ライブラリの機能を使ってFFmpegバイナリをダウンロードする。GlobalFFmpegOptions.Configure(new FFmpegConfiguration().UseFFmpegDownloader()) のように設定します。これは開発時には便利ですが、本番環境での配布方法については別途考慮が必要です。

基本的な使用例:

1. FFmpegバイナリパスの設定:

“`csharp
using FFmpegCore;

// 方法1: アプリケーション起動時などに設定
// FFmpeg実行ファイルのディレクトリパスを指定
FFmpegCore.GlobalFFmpegOptions.Configure(new FFmpegOptions { BinaryFolder = “/path/to/your/ffmpeg/binaries” });

// または、FFmpeg実行ファイル自体へのフルパスを指定
// FFmpegCore.GlobalFFmpegOptions.Configure(new FFmpegOptions { BinaryFolder = null, FFmpegBinaryAbsolutePath = “/path/to/your/ffmpeg” });

// 方法2: 自動ダウンロードを利用（開発用など）
// ダウンロード先ディレクトリを指定しない場合、ユーザーのテンポラリディレクトリなどにダウンロードされる
// FFmpegCore.GlobalFFmpegOptions.Configure(new FFmpegConfiguration().UseFFmpegDownloader());

// 方法3: 各FFmpeg呼び出し時に設定 (あまり一般的ではない)
// var config = new FFmpegConfiguration { BinaryFolder = … };
// await FFmpeg.Convert(…, config); // FFmpeg静的メソッドに config オブジェクトを渡す
``
通常は、アプリケーションの起動時に一度GlobalFFmpegOptions.Configure` を呼び出すのが最も簡単です。

2. ファイルフォーマット変換:

最も一般的な使い方は、一つの入力ファイルを別のフォーマットで出力する変換です。

“`csharp
using FFmpegCore;
using System.Threading.Tasks;

public class Converter
{
public async Task ConvertVideoAsync(string inputPath, string outputPath)
{
// ffmpeg -i input.mp4 output.avi
await FFmpeg.Convert(inputPath, outputPath);
Console.WriteLine($”変換が完了しました: {outputPath}”);
}

// 進行状況をハンドルする場合
public async Task ConvertVideoWithProgressAsync(string inputPath, string outputPath)
{
    var conversion = FFmpegArguments
        .FromInputFiles(inputPath)
        .OutputToFile(outputPath, true) // true は出力ファイルが存在する場合に上書きを許可
        .NotifyAboutProgress((progress) => Console.WriteLine($"進捗: {progress}%"), TimeSpan.FromMilliseconds(500)) // 500ms間隔で進捗通知
        .Configure(options => options.WithNice(19)) // プロセスの優先度を下げるオプションなど
        .CreateExtraction(); // または .CreateConversion() など、目的に応じたファクトリメソッド

    // ConversionProcess object を使って実行、進捗イベント購読、キャンセル処理など
    conversion.OnProgress += (sender, args) =>
    {
        Console.WriteLine($"Converted {args.ProcessedDuration.TotalSeconds:F2} seconds / {args.TotalDuration.TotalSeconds:F2} seconds ({args.ProcessedDuration.TotalSeconds / args.TotalDuration.TotalSeconds * 100:F1}%) at {args.FrameRate} fps");
        // args には FrameRate, ProcessedDuration, TotalDuration などが含まれる
    };
    conversion.OnError += (sender, args) =>
    {
        Console.WriteLine($"エラーが発生しました: {args.Exception.Message}");
    };
    conversion.OnComplete += (sender, args) =>
    {
        Console.WriteLine("変換処理が完了しました。");
    };

    var cancellationTokenSource = new CancellationTokenSource();
    // 例: 10秒後にキャンセル
    // cancellationTokenSource.CancelAfter(TimeSpan.FromSeconds(10));

    await conversion.ExecuteAsync(cancellationTokenSource.Token);

    if (cancellationTokenSource.IsCancellationRequested)
    {
        Console.WriteLine("変換処理がキャンセルされました。");
    }
}

}
``FFmpeg.Convertメソッドはシンプルですが、詳細なオプションを指定したい場合はFFmpegArgumentsクラスを使用するのが一般的です。FFmpegArguments` は流れるようなインターフェース（Fluent API）を提供し、FFmpegの様々なオプションをメソッドチェーンで設定できます。

3. オプションの指定:

ビデオコーデック、オーディオコーデック、ビットレート、解像度などのオプションを指定します。

“`csharp
using FFmpegCore;
using FFmpegCore.Arguments;
using System.Threading.Tasks;

public class AdvancedConverter
{
public async Task ConvertWithCustomOptionsAsync(string inputPath, string outputPath)
{
await FFmpegArguments
.FromInputFiles(inputPath)
.OutputToFile(outputPath, true)
// ビデオコーデックをH.264 (libx264) に指定
.WithVideoCodec(VideoCodec.Libx264)
// オーディオコーデックをAACに指定
.WithAudioCodec(AudioCodec.Aac)
// ビデオビットレートを2000k (2Mbps) に指定
.WithVideoBitrate(2000) // 単位は kbps
// オーディオビットレートを128k (128kbps) に指定
.WithAudioBitrate(128) // 単位は kbps
// 解像度を640×480に指定
.WithVideoSize(640, 480)
// 開始位置から10秒間だけを変換
.Seek(TimeSpan.FromSeconds(10))
// 期間を20秒に制限 (開始位置から20秒間)
.WithDuration(TimeSpan.FromSeconds(20))
// その他のFFmpegオプションを直接指定 (例: CRF値を23に設定)
.WithArgument(new CustomArgument(“-crf 23”))
.WithArgument(new CustomArgument(“-preset fast”)) // libx264のエンコード速度プリセット
.ExecuteAsync();

    Console.WriteLine($"カスタムオプションで変換完了: {outputPath}");
}

}
``FFmpegArgumentsには一般的なオプションに対応するメソッド (WithVideoCodec,WithAudioBitrateなど) が多数用意されています。ライブラリで直接サポートされていないオプションについては、WithArgument(new CustomArgument(“-option value”))` のように、生のFFmpegコマンドライン引数を文字列として渡すことも可能です。これにより、ライブラリが提供する抽象化と、FFmpegの細かい制御の両立が可能になっています。

4. サムネイル生成:

動画の特定の時点のフレームを画像として抽出する機能です。

“`csharp
using FFmpegCore;
using System.Threading.Tasks;
using System.IO;

public class ThumbnailGenerator
{
public async Task GenerateThumbnailAsync(string videoPath, string outputPath, TimeSpan position)
{
// ffmpeg -ss [position] -i input.mp4 -frames:v 1 output.jpg
await FFmpeg.GetThumbnail(position, videoPath, new System.Drawing.Size(320, 240), outputPath);
Console.WriteLine($”サムネイル生成完了: {outputPath}”);

    // または、より詳細なオプションを指定する場合
    await FFmpegArguments
        .FromInputFiles(videoPath)
        .Seek(position) // -ss [position]
        .OutputToFile(outputPath)
        .WithVideoFilter(Filter.Thumbnail(320, 240)) // -vf thumbnail=320:240
        .WithArguments(
            new CustomArgument("-frames:v 1"), // 出力フレーム数を1に制限
            new CustomArgument("-f image2") // フォーマットを画像ファイルに
        )
        .ExecuteAsync();
}

}
``FFmpeg.GetThumbnailメソッドは非常にシンプルですが、FFmpegArguments` を使えばより細かい制御が可能です。

5. メディア情報取得:

動画や音声ファイルのコーデック、解像度、 duration、ビットレートなどのメタデータを取得します。

“`csharp
using FFmpegCore;
using System.Threading.Tasks;

public class MediaInfoReader
{
public async Task GetMediaInfoAsync(string filePath)
{
// ffprobe -v quiet -print_format json -show_format -show_streams input.mp4
IMediaAnalysis mediaInfo = await FFmpeg.GetMediaInfo(filePath);

    Console.WriteLine($"ファイルパス: {mediaInfo.Path}");
    Console.WriteLine($"コンテナフォーマット: {mediaInfo.Format.FormatName}");
    Console.WriteLine($"Duration: {mediaInfo.Duration}");
    Console.WriteLine($"全体ビットレート: {mediaInfo.Format.Bitrate / 1000} kbps");

    var videoStream = mediaInfo.VideoStreams.FirstOrDefault();
    if (videoStream != null)
    {
        Console.WriteLine("--- Video Stream ---");
        Console.WriteLine($"コーデック: {videoStream.CodecName}");
        Console.WriteLine($"解像度: {videoStream.Width}x{videoStream.Height}");
        Console.WriteLine($"フレームレート: {videoStream.FrameRate}");
        Console.WriteLine($"ビットレート: {videoStream.BitRate / 1000} kbps");
        Console.WriteLine($"アスペクト比: {videoStream.DisplayAspectRatio}");
    }

    var audioStream = mediaInfo.AudioStreams.FirstOrDefault();
    if (audioStream != null)
    {
        Console.WriteLine("--- Audio Stream ---");
        Console.WriteLine($"コーデック: {audioStream.CodecName}");
        Console.WriteLine($"サンプルレート: {audioStream.SampleRate} Hz");
        Console.WriteLine($"チャンネル: {audioStream.Channels}");
        Console.WriteLine($"ビットレート: {audioStream.BitRate / 1000} kbps");
    }
}

}
``FFmpegCoreはffprobe(FFmpegに付属するメディア情報分析ツール) を内部で実行し、その出力をパースしてIMediaAnalysis` オブジェクトとして提供します。これにより、簡単にメディアファイルの情報を取得できます。

6. ストリーム処理（実験的/応用）:

ファイルパスだけでなく、 Stream オブジェクトを扱って、メモリ上のデータやネットワークストリームなどをFFmpegに渡したり、FFmpegの出力を直接 Stream として受け取ったりする機能も提供されています（実験的な側面もあります）。これは FromPipeInput や ToPipeOutput といったメソッドを使用します。

“`csharp
using FFmpegCore;
using System.IO;
using System.Threading.Tasks;

public class StreamProcessor
{
public async Task ProcessStreamAsync(Stream inputStream, Stream outputStream)
{
// 例: メモリ上の動画データを読み込み、H.264でエンコードして別のメモリ上のストリームに書き出す
// FFmpegArguments.FromPipeInput requires specifying the input format if not detectable from stream
await FFmpegArguments
.FromPipeInput(new StreamArgument(inputStream), options => options.WithFormat(“mp4”)) // 入力ストリームと必要ならフォーマット指定
.OutputToPipe(new StreamArgument(outputStream), options => options.WithFormat(“mp4”).WithVideoCodec(VideoCodec.Libx264)) // 出力ストリームとフォーマット/コーデック指定
.ExecuteAsync();

    Console.WriteLine("ストリーム処理が完了しました。");
}

}
“`
この機能は、一時ファイルを使わずにメディア処理をパイプライン化したい場合などに非常に有用ですが、FFmpeg自体のパイプ処理に関する知識や、使用するFFmpegバイナリがパイプ入出力をサポートしているか（Windows版などでは限定的な場合があります）を確認する必要があります。

利点:
* 非常に使いやすいオブジェクト指向API。
* 一般的なメディア処理タスクのほとんどを簡単に実現できる。
* 非同期処理対応で、アプリケーションの応答性を損なわずに長時間処理を実行できる。
* FFmpegバイナリの自動ダウンロード機能があり、環境構築の手間を減らせる。
* 進行状況やエラーをイベントとして取得しやすい。
* MIT/Apache 2.0ライセンス（FFmpegバイナリ自体のライセンスとは別）で、幅広いプロジェクトで利用しやすい。

欠点:
* FFmpeg.Autogen ほどの低レベルな制御や、FFmpegの全てのマイナーオプションに直接対応しているわけではない（ただし、CustomArgument で回避可能）。
* 内部でFFmpegプロセスを起動するため、若干の起動オーバーヘッドがある。

対象ユーザー/ユースケース:
* 多くのC#開発者。
* GUIデスクトップアプリケーション、Webアプリケーションのバックエンド、コンソールツールなどで一般的な動画・音声処理機能を実装したい。
* 開発効率を重視し、FFmpegの複雑さを可能な限り隠蔽したい。
* 非同期処理やイベント駆動で処理結果や進捗を受け取りたい。

FFmpegCore は、その使いやすさと機能のバランスから、多くのC#プロジェクトにとって最初の選択肢となる優れたライブラリです。

4.3 NReco.VideoConverter

概要:
NReco.VideoConverter は、FFmpegコマンドラインツールをラップした商用ライセンスのライブラリですが、開発・評価目的であれば無料で使用できます（詳細はライセンス条項をご確認ください）。最大の特徴は、圧倒的な使いやすさと、少ないコード量で動画変換タスクを実現できる点です。複雑なFFmpegオプションをほとんど意識することなく、メソッド呼び出し一つで変換を実行できます。FFmpegバイナリもライブラリに同梱されているか、自動でダウンロード・配置されるため、別途FFmpegを用意する手間がかかりません。

特徴:
* 超シンプルAPI: 非常に直感的なメソッド呼び出しで変換を実行します。
* FFmpegバイナリ込み: FFmpegバイナリを別途用意する必要がないか、ライブラリが自動で処理してくれます。
* 基本的な変換に特化: ファイル間のフォーマット変換や簡単なオプション設定に最適化されています。
* ストリーム対応: ファイルパスだけでなく、C#の Stream オブジェクトを入力または出力として扱うことができます。
* 商用ライセンス: 商用利用には通常ライセンスの購入が必要です。

インストール:
NuGetパッケージマネージャーで NReco.VideoConverter を検索してインストールします。
bash
dotnet add package NReco.VideoConverter
インストール後、通常はFFmpegバイナリに関する追加の設定は不要です。

基本的な使用例:

1. ファイルフォーマット変換 (最もシンプル):

入力ファイルパスと出力ファイルパス、そして出力フォーマットを指定するだけです。

“`csharp
using NReco.VideoConverter;

public class SimpleConverter
{
public void ConvertVideo(string inputPath, string outputPath)
{
var converter = new FFMpegConverter();
// mp4 から avi へ変換
converter.ConvertMedia(inputPath, null, outputPath, null, Format.avi);
Console.WriteLine($”変換が完了しました: {outputPath}”);
}
}
``ConvertMediaメソッドの引数は(inputPath, inputFormat, outputPath, outputFormat, settings)のような構造になっています。inputFormatやoutputFormatにnullを指定すると、ファイル拡張子から自動的に判別しようとします。settingsにnull` を渡すとデフォルト設定で変換されます。

2. オプションの指定:

解像度、ビットレートなどのオプションは、ConvertSettings オブジェクトを作成して ConvertMedia メソッドに渡します。

“`csharp
using NReco.VideoConverter;

public class SimpleConverterWithOptions
{
public void ConvertVideoWithSettings(string inputPath, string outputPath)
{
var converter = new FFMpegConverter();

    var settings = new ConvertSettings();
    settings.SetVideoFrameSize(640, 480); // 解像度 640x480
    settings.VideoCodec = "libx264";      // ビデオコーデックをH.264に
    settings.AudioCodec = "aac";          // オーディオコーデックをAACに
    settings.VideoRate = 2000;            // ビデオビットレートを2000k (2Mbps)
    settings.AudioRate = 128;             // オーディオビットレートを128k (128kbps)
    settings.Seek = 10;                   // 開始位置から10秒 (+ss 10)
    settings.MaxDuration = 20;            // 期間を20秒に (+t 20)
    settings.CustomOutputArgs = "-crf 23 -preset fast"; // その他のカスタムオプション

    converter.ConvertMedia(inputPath, null, outputPath, null, Format.avi, settings);

    Console.WriteLine($"カスタム設定で変換完了: {outputPath}");
}

}
``ConvertSettingsオブジェクトは一般的なオプションをプロパティとして持っています。FFmpegの全てのオプションに対応しているわけではありませんが、CustomOutputArgs` プロパティに文字列で直接FFmpegオプションを渡すことで、より細かい制御も可能です。

3. 進行状況イベント:

変換の進行状況はイベントとして購読できます。

“`csharp
using NReco.VideoConverter;

public class SimpleConverterWithProgress
{
public void ConvertVideoWithProgress(string inputPath, string outputPath)
{
var converter = new FFMpegConverter();

    converter.ConvertProgress += (sender, args) =>
    {
        // args には Processed, TotalDuration, Frame, Fps, Size, Bitrate などが含まれる
        // Processed は TimeSpan
        Console.WriteLine($"進捗: {args.Processed.TotalSeconds:F2}秒 / {args.TotalDuration.TotalSeconds:F2}秒 ({args.Processed.TotalSeconds / args.TotalDuration.TotalSeconds * 100:F1}%)");
    };
    converter.Error += (sender, args) =>
    {
        Console.WriteLine($"エラーが発生しました: {args.Exception.Message}");
    };
    converter.ConvertComplete += (sender, args) =>
    {
        Console.WriteLine("変換処理が完了しました。");
    };

    // ConvertMedia はデフォルトでブロッキング処理なので、非同期で実行するには Task.Run などでラップする必要がある
    Task.Run(() => converter.ConvertMedia(inputPath, null, outputPath, null, Format.mp4)).Wait();
}

}
``NReco.VideoConverterのConvertMediaメソッドは、デフォルトでは同期的に実行され、処理が完了するまで呼び出し元スレッドをブロックします。GUIアプリケーションなどでUIをブロックしたくない場合は、Task.Run` などを使用して非同期的に呼び出す必要があります。

4. ストリーム処理:

ファイルパスの代わりに Stream オブジェクトを入力または出力として扱うことも可能です。

“`csharp
using NReco.VideoConverter;
using System.IO;
using System.Threading.Tasks;

public class SimpleStreamProcessor
{
public void ProcessStream(Stream inputStream, Stream outputStream)
{
var converter = new FFMpegConverter();

    // InputStream を MP4 として読み込み、OutputStream に AVI フォーマットで書き出す
    // 入力/出力フォーマットは Format.mp4, Format.avi のように Format 列挙体で指定
    converter.ConvertMedia(inputStream, Format.mp4, outputStream, Format.avi, new ConvertSettings());

    Console.WriteLine("ストリーム処理が完了しました。");
}

}
“`
ストリーム処理は非常に強力で、メモリバッファ、ネットワークストリーム、パイプなど、様々なソース・シンクとFFmpegを連携させることができます。

利点:
* FFmpegラッパーの中でも非常にシンプルで使いやすいAPI。
* 少ないコードで基本的な動画変換タスクを実現できる。
* FFmpegバイナリの準備・管理が不要。
* ストリーム処理に対応。

欠点:
* 商用利用にはライセンスが必要（開発・評価目的は無料）。
* FFmpegCore や FFmpeg.Autogen に比べて、FFmpegの細かいオプションへのアクセスが限定的。
* APIが同期的なものが多く、非同期処理のためには別途 Task.Run などでラップする必要がある場合が多い。
* 開発コミュニティの規模は他のオープンソースライブラリに比べて小さい可能性がある。

対象ユーザー/ユースケース:
* 簡単な動画変換機能をアプリケーションに迅速に組み込みたい開発者。
* FFmpegの複雑なオプションを避けたい場合。
* 商用利用のライセンス費用を許容できる、または開発・評価目的のみ。
* FFmpegバイナリの準備・管理の手間を省きたい。
* ファイルだけでなく、ストリーム形式での入出力を行いたい。

NReco.VideoConverter はそのシンプルさから、特定のユースケースにおいて非常に魅力的な選択肢となり得ます。ただし、ライセンスモデルには注意が必要です。

4.4 その他のライブラリ (簡単に触れる)

過去には MediaToolkit といったFFmpegラッパーライブラリも存在しましたが、記事執筆時点ではメンテナンスが停止していたり、上記の3つのライブラリほど活発ではなかったりする場合があります。新しいプロジェクトを始める場合は、上記で紹介した FFmpeg.Autogen, FFmpegCore, NReco.VideoConverter のいずれかから選ぶのが現実的でしょう。特定の要件がある場合は、GitHubなどで「C# ffmpeg wrapper」といったキーワードで検索し、ライブラリの最終更新日やIssues/Pull Requestsの状況を確認して、アクティブなプロジェクトかどうかを判断することをおすすめします。

5. 適切なライブラリの選定

ここまで3つの主要なFFmpegラッパーライブラリを見てきました。それぞれに異なる特徴、メリット、デメリットがあります。どのライブラリを選択すべきかは、あなたのプロジェクトの要件によって異なります。

選定にあたって考慮すべき主な要素は以下の通りです。

• 必要な機能: 単純なファイル変換だけで十分か？ 複雑なフィルタリングやストリーム処理が必要か？ メタデータ取得やサムネイル生成は必須か？ FFmpegの最新機能やマイナーなオプションを使う必要があるか？
• 開発の容易さ・学習コスト: FFmpegのC APIに関する知識はどの程度あるか？ 短期間で実装を完了したいか？ コードの保守性はどの程度重要か？
• パフォーマンス要求: 最大限のパフォーマンスが必要か？ プロセス起動のオーバーヘッドは許容できるか？
• ライセンス: オープンソースライセンスが必須か？ 商用ライセンスでも問題ないか？
• FFmpegバイナリの扱い: FFmpegバイナリを自分で管理・配布できるか？ ライブラリに自動で処理してほしいか？
• 予算: ライセンス費用をかけられるか？

これらの考慮事項に基づいて、3つのライブラリを比較してみましょう。

特徴	FFmpeg.Autogen	FFmpegCore	NReco.VideoConverter
アプローチ	ネイティブライブラリ直接呼び出し (P/Invoke)	コマンドラインプロセス実行	コマンドラインプロセス実行
制御レベル	低レベル (C API)	高レベル (オブジェクト指向)	高レベル (非常にシンプル)
FFmpeg機能へのアクセス	ほぼ全ての機能にアクセス可能	一般的な機能 + カスタム引数	基本的な機能 + カスタム引数
使いやすさ	非常に難しい	中程度	非常に簡単
学習コスト	非常に高い	中程度	低い
コード量	非常に多くなる	中程度	少ない
パフォーマンス	高い可能性 (直接呼び出し)	中程度 (プロセス起動オーバーヘッド)	中程度 (プロセス起動オーバーヘッド)
ライセンス	FFmpegのライセンスに準拠 (LGPL/GPLなど)	MIT/Apache 2.0 (FFmpegバイナリは別途)	商用 (開発/評価は無料)
FFmpegバイナリ	手動で準備・管理が必要	自動ダウンロードまたは手動	同梱または自動ダウンロード
非同期処理	手動で実装が必要	async/await 対応	同期メソッドが中心 (Task.Runなどでラップ)
進行状況/エラー	手動でFFmpegのAPI/ログを扱う	イベント/例外で取得容易	イベント/例外で取得容易

シナリオ別の推奨:

• 最大限の制御とパフォーマンスが必要、FFmpeg C APIに詳しい: FFmpeg.Autogen を検討してください。ただし、開発コストは最も高くなります。既存のFFmpeg C/C++コードをC#に移植する場合などにも適しています。
• 多くの一般的な動画・音声処理タスクをモダンなC#コードで実装したい、開発効率を重視する、非同期処理が必要: FFmpegCore が最適な選択肢となる可能性が高いです。多くのデスクトップアプリケーションやWebサービスのバックエンドに適しています。ほとんどのユースケースはこのライブラリでカバーできるでしょう。
• 非常にシンプルな動画変換機能のみが必要、開発の手間を最小限に抑えたい、FFmpegバイナリの管理をしたくない、商用ライセンスを許容できる: NReco.VideoConverter を検討してください。短いコードで目的を達成でき、FFmpegの知識がほとんど不要です。

迷った場合は、まず FFmpegCore を試してみるのが良いでしょう。ほとんどのタスクを効率的にこなせ、十分な機能と使いやすさを兼ね備えています。もしFFmpegCoreで実現できない特定の高度な機能が必要になった場合に、FFmpeg.Autogenを検討するか、あるいはFFmpegCoreの CustomArgument を使って対応可能か試す、というステップを踏むのが現実的です。

6. C#でFFmpegを扱う上での実践的なヒントとトラブルシューティング

どのライブラリを選択するにしても、C#アプリケーションから外部ツールであるFFmpegを扱う際には、共通して考慮すべきいくつかのポイントがあります。

6.1 FFmpegバイナリの配布とパス設定

FFmpegラッパーライブラリの多くは、FFmpegの実行ファイルやライブラリがシステム上のどこかに存在することを前提としています。アプリケーションを配布する際に、ユーザーの環境にFFmpegがインストールされているとは限りません。以下のいずれかの方法でFFmpegバイナリを準備し、アプリケーションからアクセスできるようにする必要があります。

• アプリケーションに同梱する: アプリケーションの実行ディレクトリ内のサブフォルダなどにFFmpegバイナリを配置し、そのパスをライブラリに設定します (FFmpegCore や NReco.VideoConverter ではこの方法が一般的です)。これにより、ユーザーが別途FFmpegをインストールする手間がなくなりますが、アプリケーションの配布サイズは大きくなります。また、アプリケーションのインストール先ディレクトリに書き込み権限がない場合（Program Filesなど）、FFmpegが出力する一時ファイルやログの書き込みに問題が発生する可能性があります。
• 初回起動時にダウンロードさせる: アプリケーションの初回起動時に、信頼できるサーバーからFFmpegバイナリをダウンロードして配置します (FFmpegCore や NReco.VideoConverter はこのためのヘルパー機能を提供している場合があります)。配布サイズを小さくできますが、インターネット接続が必要になります。ダウンロード元サーバーの信頼性や、ダウンロード中のエラー処理を考慮する必要があります。
• ユーザーにインストールしてもらう: アプリケーションの要件としてFFmpegのインストールをユーザーに求める方法です。最もシンプルですが、ユーザーにとっての手間が増えます。インストール場所が予測できないため、システムの環境変数 PATH を利用したり、ユーザーにFFmpegのインストールパスを入力してもらったりするなどの対応が必要です。
• システムワイドなインストールを利用: 環境変数 PATH に登録されているFFmpegを利用します。開発環境では便利ですが、ユーザー環境で必ずしもFFmpegがインストールされている保証はありません。

どの方法を選ぶにしても、アプリケーションからFFmpeg実行ファイル（またはDLLファイル群、FFmpeg.Autogen の場合）の正しいパスを指定することが重要です。

6.2 エラー処理

FFmpegの処理は、入力ファイルの破損、サポートされていないフォーマット、リソース不足、不正なオプションなど、様々な理由で失敗する可能性があります。C#アプリケーションでは、これらのエラーを適切に捕捉してユーザーに通知したり、ログに記録したりする必要があります。

• ライブラリの例外: 多くのラッパーライブラリは、FFmpegプロセスの異常終了やFFmpeg APIの失敗をC#の例外としてスローします。try-catch ブロックでこれらの例外を捕捉します。例外情報には、FFmpegの終了コードや、場合によってはFFmpegの標準エラー出力の内容が含まれていることがあります。
• FFmpegの標準エラー出力 (stderr): FFmpegは、エラーメッセージ、警告、進行状況情報などを主に標準エラー出力に出力します。特に Process クラスを直接使う場合や、ラッパーライブラリが提供するイベントを利用する場合、この stderr の内容を監視することが重要です。エラーメッセージの特定のキーワード（例: “Error”, “failed”, “unsupported” など）をパースすることで、エラーの原因を特定する手助けになります。
• FFmpegの終了コード: FFmpegプロセスが終了した際に返される終了コードも重要です。通常、終了コード0は成功を示し、非ゼロの値は何らかのエラーが発生したことを示します。ライブラリによっては、この終了コードを例外情報として提供してくれます。

複雑なメディア処理を行う場合、FFmpegのログレベルを上げて詳細な出力を得られるように設定し (-loglevel debug など)、そのログを捕捉して解析する仕組みを用意すると、デバッグが非常に容易になります。

6.3 非同期処理とUIフリーズの回避

動画や音声のエンコード・デコードは、CPU負荷が高く時間のかかる処理です。GUIアプリケーションでこれらの処理を同期的に実行すると、UIスレッドがブロックされてしまい、アプリケーションが応答しなくなります（「フリーズ」したように見えます）。これを避けるためには、非同期処理を積極的に利用する必要があります。

• async / await: FFmpegCore のように非同期API (ExecuteAsync(), Convert(), GetMediaInfo() など) を提供しているライブラリを使用する場合、これらの非同期メソッドを await して呼び出します。これにより、FFmpegの処理中もUIスレッドは解放され、他のタスク（UIの更新、ユーザー入力の受付など）を実行できるようになります。
• Task.Run: もし使用しているライブラリが非同期APIを提供していない場合 (NReco.VideoConverter の同期的な ConvertMedia メソッドなど)、Task.Run(() => yourSyncMethod(...)) のように同期的なFFmpeg呼び出しをThreadPoolスレッドで実行することで、UIスレッドのブロックを防ぐことができます。

6.4 キャンセル処理の実装

長時間かかるFFmpeg処理に対して、ユーザーが「キャンセル」ボタンを押して中断できる機能は、アプリケーションの使い勝手を大きく向上させます。

• CancellationToken: FFmpegCore のようなモダンな非同期APIは、CancellationToken を引数として受け取るものが多くあります。CancellationTokenSource オブジェクトを作成し、その Token をFFmpeg処理のメソッドに渡します。ユーザーがキャンセルを要求した際には、CancellationTokenSource.Cancel() を呼び出すことで、FFmpeg処理（およびそれをラップするライブラリの処理）に中断を要求できます。ライブラリは CancellationToken をチェックし、適切にFFmpegプロセスを終了させたり、内部処理を中断したりします。
• Process.Kill(): Process クラスを直接使っている場合や、ラッパーライブラリに明示的なキャンセル機能がない場合は、起動した Process オブジェクトに対して Kill() メソッドを呼び出すことで、強制的にFFmpegプロセスを終了させることができます。ただし、これは突然の終了なので、出力ファイルが破損する可能性があることに注意が必要です。より穏やかな方法として、プロセスに特定のシグナルを送ったり (Process.CloseMainWindow() など)、FFmpegが監視している入力ストリームを閉じたりすることで、FFmpeg自身に gracefully に終了を促す方法もありますが、これはFFmpegの設計やOSによって異なります。

6.5 メモリ管理 (FFmpeg.Autogen 利用時)

FFmpeg.Autogen を使用してFFmpegのネイティブライブラリを直接呼び出す場合、FFmpegが内部で割り当てたメモリをC#コード側で明示的に解放する必要があるケースが多々あります。AVFrame, AVPacket, AVFormatContext, AVCodecContext などの構造体はポインタとして扱われ、それぞれに対応する解放関数（例: ffmpeg.av_frame_free(), ffmpeg.av_packet_unref(), ffmpeg.avformat_close_input(), ffmpeg.avcodec_free_context() など）を適切に呼び出さないと、メモリリークが発生します。

特にデコード・エンコードのループ内でフレームやパケットを繰り返し処理する場合は、ループの各イテレーションでメモリを解放するか、プールして再利用するなどの戦略が必要です。これはC#のガベージコレクタでは自動的に処理されない領域なので、手動での管理が必須となり、FFmpeg.Autogenの複雑さの大きな要因の一つです。

6.6 パフォーマンス最適化

FFmpegは非常に多くのパフォーマンス関連オプションを提供しています。C#ラッパーライブラリを通じてこれらのオプションを指定することで、処理速度を向上させることができます。

• ハードウェアアクセラレーション: FFmpegは多くのハードウェアアクセラレーション機能（例: NVENC (NVIDIA), Quick Sync Video (Intel), VCE/VCN (AMD) など）をサポートしています。これらの機能を利用するには、適切なFFmpegバイナリ（ハードウェアアクセラレーション有効でビルドされたもの）を使用し、エンコーダーとしてハードウェア対応のものを指定したり (-c:v h264_nvenc など)、ハードウェアデバイスを指定したりする必要があります。FFmpegCore や NReco.VideoConverter では CustomArgument を使ってこれらのオプションを渡すことができます。FFmpeg.Autogen では、AVHWDeviceType などのAPIを直接呼び出すことになります。
• スレッド数: マルチコアCPUを有効活用するため、FFmpegは複数のスレッドを使用して処理を実行できます。通常、デフォルトで適切なスレッド数が使われますが、-threads auto や -threads <number> オプションで明示的に指定することも可能です。これもライブラリを通じて設定可能です。
• エンコーダープリセット/オプション: H.264エンコーダーの libx264 など、多くのエンコーダーは速度と圧縮率のトレードオフを調整するためのプリセットや詳細なオプションを持っています (-preset fast, -crf 23 など)。これらのオプションも適切に設定することで、パフォーマンスや出力品質を調整できます。

これらの最適化オプションはFFmpeg自体のものであり、ラッパーライブラリはそれらをC#から設定するためのインターフェースを提供します。FFmpegのドキュメントを参照しながら、目的に合ったオプションを見つけて適用することが重要です。

6.7 クロスプラットフォーム開発の考慮

.NET Core/.NET 5+ を使用してクロスプラットフォームアプリケーションを開発する場合、FFmpegバイナリも対象とする各OS（Windows, macOS, Linux）向けにビルドされたものを用意する必要があります。

• バイナリの配置: 各OS向けのバイナリを適切にアプリケーションに同梱またはダウンロードさせる必要があります。配置パスもOSによって異なる可能性があるため、アプリケーションコードでOSを判別してFFmpegバイナリのパスを解決するロジックが必要になる場合があります。FFmpegCore の自動ダウンロード機能などはこの部分をサポートしてくれます。
• P/Invoke の差異 (FFmpeg.Autogen): FFmpeg.Autogen を使用する場合、DLL名や共有ライブラリ名がOSによって異なる（例: ffmpeg.dll vs libffmpeg.so）といったP/Invokeに関する考慮が必要になる場合があります。FFmpeg.Autogen 自体はこの辺りを吸収してくれるように設計されていることが多いですが、ネイティブライブラリの依存関係（例えばLinuxであればlibx264.soなどが別途必要）は各環境で満たされている必要があります。
• パス区切り文字: ファイルパスの区切り文字がOSによって異なる（\ vs /）ことにも注意が必要です。C#の Path.Combine や System.IO.Path.DirectorySeparatorChar を使用して、プラットフォームに依存しないパス文字列を生成するように心がけましょう。

7. まとめと今後の展望

本記事では、C#からFFmpegの強力な機能を利用するための主要なアプローチとライブラリについて、約5000語の詳細な解説を行いました。

FFmpegはコマンドラインツールとして非常に強力ですが、C#アプリケーションに統合する際にはいくつかの課題があります。System.Diagnostics.Process を直接利用する方法は最大限の柔軟性を提供しますが、コマンド文字列の管理、エラー処理、進行状況の取得などが開発者の負担となります。

これらの課題を解決するために、様々なC#向けFFmpegラッパーライブラリが存在します。特に、

• FFmpeg.Autogen: FFmpegのC APIを直接呼び出す低レベルバインディング。最大限の機能とパフォーマンスを引き出せますが、学習コストと開発の複雑さは非常に高いです。FFmpegの内部を深く理解している開発者や、他のライブラリでは実現できない高度な制御が必要な場合に適しています。
• FFmpegCore: FFmpegコマンドラインツールをプロセスとして実行する高レベルラッパー。使いやすいオブジェクト指向API、非同期処理、一般的なタスクの容易な実現など、多くのC#開発者にとってバランスの取れた優れた選択肢です。ほとんどの一般的な動画・音声処理要件はこのライブラリで満たせるでしょう。
• NReco.VideoConverter: FFmpegプロセスをラップする超シンプルなライブラリ。短期間で基本的な動画変換機能を実装したい場合に最適です。FFmpegバイナリの管理も不要ですが、商用ライセンスであり、細かいオプション制御には限界があります。

適切なライブラリの選定は、プロジェクトの具体的な要件、開発チームのスキルセット、そしてライセンスや予算といった様々な要素を総合的に考慮して行う必要があります。一般的には、まず FFmpegCore を検討し、それで満たせない要件がある場合に他のライブラリを検討するという流れが効率的でしょう。

C#でFFmpegを活用することで、あなたはデスクトップアプリケーション、Webサービス、バックグラウンド処理など、様々な種類のアプリケーションに高度な動画・音声処理機能を組み込むことができます。フォーマット変換、エンコード・デコード、ストリーミング、フィルタリング、メタデータ処理など、可能性は無限大です。

FFmpegの世界は広大であり、その機能を完全に理解するには時間と学習が必要です。しかし、今回紹介したような優れたC#ラッパーライブラリを活用することで、FFmpegのパワーをより身近なものとし、あなたのアプリケーション開発に新たな可能性をもたらすことができるでしょう。

ぜひ実際に手を動かし、興味を持ったライブラリをプロジェクトに導入して、C#による動画・音声処理の世界を体験してみてください。きっと、あなたの開発の幅が大きく広がるはずです。

---