C#使用FFmpeg进行视频旋转的代码实现

// 1. 安装ffmpeg（windows示例）  
// 下载地址：https://www.gyan.dev/ffmpeg/builds/  
// 解压到c:\ffmpeg，并配置环境变量：  
// 右键此电脑→属性→高级系统设置→环境变量→path添加c:\ffmpeg\bin  

// 2. c#项目依赖  
// 添加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"; // 根据环境修改路径  

    #region 旋转方向枚举  
    public enum rotationdirection  
    {  
        clockwise90 = 1, // 顺时针90度（transpose=1）  
        counterclockwise90 = 2, // 逆时针90度（transpose=2）  
        clockwise180 = 3, // 顺时针180度（transpose=3两次）  
        fliphorizontal = 4, // 水平翻转（hflip）  
        flipvertical = 5 // 垂直翻转（vflip）  
    }  
    #endregion  

    #region 核心方法：异步旋转视频  
    public async task rotatevideoasync(string inputpath, string outputpath, rotationdirection direction)  
    {  
        // 1. 参数校验  
        if (!file.exists(inputpath))  
            throw new filenotfoundexception($"输入文件不存在：{inputpath}");  

        // 2. 构造ffmpeg命令  
        var arguments = buildrotationcommand(inputpath, outputpath, direction);  

        // 3. 启动ffmpeg进程  
        using var process = new process  
        {  
            startinfo = new processstartinfo  
            {  
                filename = ffmpegpath,  
                arguments = arguments,  
                useshellexecute = false,  
                redirectstandardoutput = true,  
                redirectstandarderror = true,  
                createnowindow = true  
            }  
        };  

        // 4. 异步执行并监控  
        await process.startasync();  
        await task.whenall(  
            readoutputasync(process.standardoutput),  
            readoutputasync(process.standarderror)  
        );  
        await process.waitforexitasync();  

        // 5. 处理结果  
        if (process.exitcode != 0)  
            throw new exception($"ffmpeg执行失败：{process.exitcode}");  
    }  
    #endregion  

    #region 私有方法：构建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))  
        };  

        // 添加关键参数：  
        // -y：覆盖输出文件  
        // -c:a copy：音频流直接复制  
        // -preset ultrafast：快速编码（可选）  
        return $"-y -i \"{input}\" -vf \"{filter}\" -c:a copy -preset ultrafast \"{output}\"";  
    }  
    #endregion  

    #region 辅助方法：实时日志输出  
    private async task readoutputasync(textreader reader)  
    {  
        while (!reader.endofstream)  
        {  
            var line = await reader.readlineasync();  
            console.writeline(line); // 可替换为日志库（如nlog）  
        }  
    }  
    #endregion  
}  

// 场景：手机拍摄的竖屏视频在电脑上显示为“躺倒”  
public async task fixmobilevideoasync(string inputpath, string outputpath)  
{  
    // 1. 清除rotate元数据（无损操作）  
    await executeffmpegcommandasync(  
        $"-i \"{inputpath}\" -c copy -metadata:s:v rotate=0 \"{outputpath}_tmp.mp4\"");  

    // 2. 重新编码旋转（转码旋转）  
    await rotatevideoasync(  
        outputpath + "_tmp.mp4",  
        outputpath,  
        rotationdirection.clockwise90);  

    // 3. 清理临时文件  
    file.delete(outputpath + "_tmp.mp4");  
}  

// 辅助方法：执行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个视频  
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));  
    }  

    // 控制并发数（避免cpu/gpu过载）  
    while (tasks.count > 0)  
    {  
        var completed = await task.whenany(tasks);  
        tasks.remove(completed);  
    }  
}  

// 高级设置：限制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  
    };  

    // 设置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);  
}  

// 自动检测ffmpeg路径  
private static string getffmpegpath()  
{  
    if (runtimeinformation.isosplatform(osplatform.windows))  
        return "ffmpeg.exe"; // 假设已配置环境变量  
    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的特殊处理（因权限问题）  
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();  
}  

// 主函数：修复手机视频  
public static async task main(string[] args)  
{  
    var rotator = new videorotator();  
    try  
    {  
        await rotator.fixmobilevideoasync(  
            inputpath: "input.mp4",  
            outputpath: "output.mp4");  
        console.writeline("修复完成！");  
    }  
    catch (exception ex)  
    {  
        console.writeline($"错误：{ex.message}");  
    }  
}  

// 进阶用法：多线程处理  
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个片段处理  
    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}\"");  
}  

// 终极代码：全自动视频旋转工厂  
public class videorotationfactory  
{  
    public async task processvideo(string inputpath,  
        rotationdirection direction = rotationdirection.clockwise90,  
        bool fixmobile = true,  
        bool asyncmode = true)  
    {  
        try  
        {  
            // 1. 检测是否为手机视频  
            if (fixmobile && ismobilevideo(inputpath))  
                await fixmobilevideoasync(inputpath, inputpath + "_fixed.mp4");  

            // 2. 执行旋转  
            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($"错误：{ex.message}");  
        }  
    }  

    // 辅助方法：检测手机视频  
    private bool ismobilevideo(string path)  
    {  
        // 通过元数据检测rotate属性  
        // （需调用ffmpeg的probe命令）  
        return true; // 简化示例  
    }  
}  

// c#视频旋转核心引擎（完整版）  
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); // 批量执行  
    }  

    // 3. 监控进度  
    console.writeline($"处理完成：{videos.length}个视频");  
}  

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

// 主函数：学生项目模板  
public static async task main(string[] args)  
{  
    var engine = new videoalchemyengine();  
    await engine.startalchemy("c:\\videos\\input", "c:\\videos\\output");  
    console.writeline("视频炼金术启动！");  
}