// 1. 安裝FFmpeg（Windows示例）  
// 下載地址：https://www.gyan.dev/ffmpeg/builds/  
// 解壓到C:\FFmpeg，并配置環(huán)境變量：  
// 右鍵此電腦→屬性→高級(jí)系統(tǒng)設(shè)置→環(huán)境變量→Path添加C:\FFmpeg\bin  

// 2. C#項(xiàng)目依賴  
// 添加NuGet包：  
Install-Package System.Diagnostics.Process  
Install-Package System.Threading.Tasks  

using System;  
using System.Diagnostics;  
using System.IO;  
using System.Threading.Tasks;  

public class VideoRotator  
{  
    private const string FFmpegPath = "ffmpeg.exe"; // 根據(jù)環(huán)境修改路徑  

    #region 旋轉(zhuǎn)方向枚舉  
    public enum RotationDirection  
    {  
        Clockwise90 = 1, // 順時(shí)針90度（transpose=1）  
        CounterClockwise90 = 2, // 逆時(shí)針90度（transpose=2）  
        Clockwise180 = 3, // 順時(shí)針180度（transpose=3兩次）  
        FlipHorizontal = 4, // 水平翻轉(zhuǎn)（hflip）  
        FlipVertical = 5 // 垂直翻轉(zhuǎn)（vflip）  
    }  
    #endregion  

    #region 核心方法：異步旋轉(zhuǎn)視頻  
    public async Task RotateVideoAsync(string inputPath, string outputPath, RotationDirection direction)  
    {  
        // 1. 參數(shù)校驗(yàn)  
        if (!File.Exists(inputPath))  
            throw new FileNotFoundException($"輸入文件不存在：{inputPath}");  

        // 2. 構(gòu)造FFmpeg命令  
        var arguments = BuildRotationCommand(inputPath, outputPath, direction);  

        // 3. 啟動(dòng)FFmpeg進(jìn)程  
        using var process = new Process  
        {  
            StartInfo = new ProcessStartInfo  
            {  
                FileName = FFmpegPath,  
                Arguments = arguments,  
                UseShellExecute = false,  
                RedirectStandardOutput = true,  
                RedirectStandardError = true,  
                CreateNoWindow = true  
            }  
        };  

        // 4. 異步執(zhí)行并監(jiān)控  
        await process.StartAsync();  
        await Task.WhenAll(  
            ReadOutputAsync(process.StandardOutput),  
            ReadOutputAsync(process.StandardError)  
        );  
        await process.WaitForExitAsync();  

        // 5. 處理結(jié)果  
        if (process.ExitCode != 0)  
            throw new Exception($"FFmpeg執(zhí)行失敗：{process.ExitCode}");  
    }  
    #endregion  

    #region 私有方法：構(gòu)建FFmpeg命令  
    private string BuildRotationCommand(string input, string output, RotationDirection direction)  
    {  
        string filter = direction switch  
        {  
            RotationDirection.Clockwise90 => "transpose=1",  
            RotationDirection.CounterClockwise90 => "transpose=2",  
            RotationDirection.Clockwise180 => "transpose=1,transpose=1",  
            RotationDirection.FlipHorizontal => "hflip",  
            RotationDirection.FlipVertical => "vflip",  
            _ => throw new ArgumentOutOfRangeException(nameof(direction))  
        };  

        // 添加關(guān)鍵參數(shù)：  
        // -y：覆蓋輸出文件  
        // -c:a copy：音頻流直接復(fù)制  
        // -preset ultrafast：快速編碼（可選）  
        return $"-y -i \"{input}\" -vf \"{filter}\" -c:a copy -preset ultrafast \"{output}\"";  
    }  
    #endregion  

    #region 輔助方法：實(shí)時(shí)日志輸出  
    private async Task ReadOutputAsync(TextReader reader)  
    {  
        while (!reader.EndOfStream)  
        {  
            var line = await reader.ReadLineAsync();  
            Console.WriteLine(line); // 可替換為日志庫（如NLog）  
        }  
    }  
    #endregion  
}  

// 場景：手機(jī)拍攝的豎屏視頻在電腦上顯示為“躺倒”  
public async Task FixMobileVideoAsync(string inputPath, string outputPath)  
{  
    // 1. 清除rotate元數(shù)據(jù)（無損操作）  
    await ExecuteFFmpegCommandAsync(  
        $"-i \"{inputPath}\" -c copy -metadata:s:v rotate=0 \"{outputPath}_tmp.mp4\"");  

    // 2. 重新編碼旋轉(zhuǎn)（轉(zhuǎn)碼旋轉(zhuǎn)）  
    await RotateVideoAsync(  
        outputPath + "_tmp.mp4",  
        outputPath,  
        RotationDirection.Clockwise90);  

    // 3. 清理臨時(shí)文件  
    File.Delete(outputPath + "_tmp.mp4");  
}  

// 輔助方法：執(zhí)行FFmpeg通用命令  
private Task ExecuteFFmpegCommandAsync(string command)  
{  
    var process = new Process  
    {  
        StartInfo = new ProcessStartInfo  
        {  
            FileName = FFmpegPath,  
            Arguments = command,  
            CreateNoWindow = true,  
            UseShellExecute = false  
        }  
    };  
    return process.StartAsync().ContinueWith(_ => process.WaitForExit());  
}  

// 場景：批量處理100個(gè)視頻  
public async Task BatchRotateAsync(string[] inputs, RotationDirection direction)  
{  
    var tasks = new List<Task>();  

    foreach (var input in inputs)  
    {  
        var output = Path.ChangeExtension(input, "rotated.mp4");  
        tasks.Add(RotateVideoAsync(input, output, direction));  
    }  

    // 控制并發(fā)數(shù)（避免CPU/GPU過載）  
    while (tasks.Count > 0)  
    {  
        var completed = await Task.WhenAny(tasks);  
        tasks.Remove(completed);  
    }  
}  

// 高級(jí)設(shè)置：限制FFmpeg資源占用  
public async Task RotateWithResourceLimitAsync(string input, string output)  
{  
    var process = new Process  
    {  
        StartInfo = new ProcessStartInfo  
        {  
            FileName = FFmpegPath,  
            Arguments = BuildRotationCommand(input, output, RotationDirection.Clockwise90),  
            UseShellExecute = false  
        },  
        EnableRaisingEvents = true  
    };  

    // 設(shè)置CPU親和性（僅Windows）  
    process.Start();  
    var handle = process.Handle;  
    NativeMethods.SetProcessAffinityMask(handle, (IntPtr)1); // 僅使用CPU 0  

    await process.WaitForExitAsync();  
}  

// P/Invoke聲明（Windows專用）  
internal static class NativeMethods  
{  
    [DllImport("kernel32.dll")]  
    public static extern IntPtr SetProcessAffinityMask(IntPtr hProcess, IntPtr dwProcessAffinityMask);  
}  

// 自動(dòng)檢測FFmpeg路徑  
private static string GetFFmpegPath()  
{  
    if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))  
        return "ffmpeg.exe"; // 假設(shè)已配置環(huán)境變量  
    else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))  
        return "/usr/bin/ffmpeg"; // Linux安裝路徑  
    else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))  
        return "/usr/local/bin/ffmpeg"; // macOS安裝路徑  
    else  
        throw new PlatformNotSupportedException();  
}  

// macOS的特殊處理（因權(quán)限問題）  
public async Task RotateOnMacAsync(string input, string output)  
{  
    var process = new Process  
    {  
        StartInfo = new ProcessStartInfo  
        {  
            FileName = "/bin/bash",  
            Arguments = $"-c \"chmod +x {FFmpegPath} && {FFmpegPath} {BuildRotationCommand(input, output, RotationDirection.CounterClockwise90)}\"",  
            UseShellExecute = false  
        }  
    };  
    await process.StartAsync();  
    await process.WaitForExitAsync();  
}  

// 主函數(shù)：修復(fù)手機(jī)視頻  
public static async Task Main(string[] args)  
{  
    var rotator = new VideoRotator();  
    try  
    {  
        await rotator.FixMobileVideoAsync(  
            inputPath: "input.mp4",  
            outputPath: "output.mp4");  
        Console.WriteLine("修復(fù)完成！");  
    }  
    catch (Exception ex)  
    {  
        Console.WriteLine($"錯(cuò)誤：{ex.Message}");  
    }  
}  

// 進(jìn)階用法：多線程處理  
public async Task ProcessBatch()  
{  
    var videos = Directory.GetFiles("input_videos", "*.mp4");  
    await BatchRotateAsync(videos, RotationDirection.Clockwise90);  
}  

// 解決方案：添加抗鋸齒濾鏡  
private string BuildRotationCommand(string input, string output, RotationDirection direction)  
{  
    // 在濾鏡鏈中添加抗鋸齒  
    string filter = direction switch  
    {  
        RotationDirection.Clockwise90 => "transpose=1,unsharp=5:5:1:5:5:1",  
        // 其他方向同理...  
    };  
    return $"-i \"{input}\" -vf \"{filter}\" -c:a copy \"{output}\"";  
}  

// 解決方案：分塊處理（適用于超大視頻）  
public async Task RotateInChunksAsync(string input, string output)  
{  
    // 分成10個(gè)片段處理  
    for (int i = 0; i < 10; i++)  
    {  
        var chunkOutput = $"chunk_{i}.mp4";  
        await ExecuteFFmpegCommandAsync(  
            $"-ss {i*60} -t 60 -i \"{input}\" -c copy \"{chunkOutput}\"");  

        await RotateVideoAsync(  
            chunkOutput,  
            $"rotated_{i}.mp4",  
            RotationDirection.Clockwise90);  

        File.Delete(chunkOutput);  
    }  

    // 合并片段  
    await ExecuteFFmpegCommandAsync(  
        $"-f concat -safe 0 -i \"chunks.txt\" -c copy \"{output}\"");  
}  

// 終極代碼：全自動(dòng)視頻旋轉(zhuǎn)工廠  
public class VideoRotationFactory  
{  
    public async Task ProcessVideo(string inputPath,  
        RotationDirection direction = RotationDirection.Clockwise90,  
        bool fixMobile = true,  
        bool asyncMode = true)  
    {  
        try  
        {  
            // 1. 檢測是否為手機(jī)視頻  
            if (fixMobile && IsMobileVideo(inputPath))  
                await FixMobileVideoAsync(inputPath, inputPath + "_fixed.mp4");  

            // 2. 執(zhí)行旋轉(zhuǎn)  
            var output = inputPath.Replace(".mp4", "_rotated.mp4");  
            await RotateVideoAsync(  
                fixMobile ? inputPath + "_fixed.mp4" : inputPath,  
                output,  
                direction);  

            // 3. 清理  
            if (fixMobile) File.Delete(inputPath + "_fixed.mp4");  

            Console.WriteLine($"處理完成：{output}");  
        }  
        catch (Exception ex)  
        {  
            Console.WriteLine($"錯(cuò)誤：{ex.Message}");  
        }  
    }  

    // 輔助方法：檢測手機(jī)視頻  
    private bool IsMobileVideo(string path)  
    {  
        // 通過元數(shù)據(jù)檢測rotate屬性  
        // （需調(diào)用FFmpeg的probe命令）  
        return true; // 簡化示例  
    }  
}  

// C#視頻旋轉(zhuǎn)核心引擎（完整版）  
public class VideoAlchemyEngine  
{  
    private const string FFmpegPath = "ffmpeg.exe";  
    private readonly VideoRotator _rotator = new VideoRotator();  

public async Task StartAlchemy(string inputDir, string outputDir)  
{  
    // 1. 掃描所有視頻文件  
    var videos = Directory.GetFiles(inputDir, "*.mp4");  

    // 2. 并行處理（限4核）  
    var tasks = new List<Task>();  
    foreach (var video in videos)  
    {  
        tasks.Add(ProcessVideoAsync(video, outputDir));  
        if (tasks.Count % 4 == 0)  
            await Task.WhenAll(tasks); // 批量執(zhí)行  
    }  

    // 3. 監(jiān)控進(jìn)度  
    Console.WriteLine($"處理完成：{videos.Length}個(gè)視頻");  
}  

private async Task ProcessVideoAsync(string input, string outputDir)  
{  
    var output = Path.Combine(outputDir, Path.GetFileName(input));  
    await _rotator.ProcessVideo(  
        input,  
        direction: RotationDirection.Clockwise90,  
        fixMobile: true,  
        asyncMode: true);  
}  

// 主函數(shù)：學(xué)生項(xiàng)目模板  
public static async Task Main(string[] args)  
{  
    var engine = new VideoAlchemyEngine();  
    await engine.StartAlchemy("C:\\Videos\\Input", "C:\\Videos\\Output");  
    Console.WriteLine("視頻煉金術(shù)啟動(dòng)！");  
}