Java程序处理视频裁剪（快速处理大文件）

野性酷女 2024-05-03 15:04 7阅读 0赞

**现在手机上的各种视频裁剪、剪切软件，裁剪视频特别方便。但是遇到大文件需要裁剪的时候，就麻烦了，动辄大几G、十几G的文件就不适合用手机裁剪app了，连上传都成功不了，而且还会被各种压缩，画质失真严重。这个时候，就只能用电脑裁剪了，电脑上还要找付费的视频剪切软件或费时费力找免费软件，就很麻烦了。这里用java程序实现一个视频剪切工具，处理大的视频软件不失真、速度快，轻松搞定大文件视频剪切的需求，非常方便，源码和思路往下看！**

#### 文章目录 ####

*   *  0.前期准备
     *  1.新建一个java项目
     *  2.代码生成ffmpeg指令
     *  3.视频裁剪任务执行
     *  4.主程序执行效果展示

### 0.前期准备 ###

下载并安装ffmpeg，如果电脑上已经有了，就可以忽略这个步骤。 [✈ 直达下载安装ffmpeg][_ffmpeg]

找到解压之后的地址，进入bin目录下，可以看到ffmpeg.exe的文件  
![在这里插入图片描述][9c9f78da8cf9425eb62ff246f57a8ee1.png]  
**工具准备好了，下面开始整代码👇👇👇**

### 1.新建一个java项目 ###

建一个最基本的java项目就行，不需要引第三方的依赖包，jdk自带的方法就够用了，所以不需要建maven项目或springboot项目了。

### 2.代码生成ffmpeg指令 ###

**首先，要验证一下本地的ffmpeg的地址是否存在，只有确实有ffmpeg.exe才可以执行视频裁剪工作。**

**其次，构造生成ffmpeg的shell指令，用于执行视频裁剪任务。此外，还可以按照自己的规则设置输出文件的名称和地址。**

> 方式一：ffmpeg.exe -ss %s -i %s -t %s -c copy %s -y  
> ffmpeg.exe -ss 00:00:05 -i test.mp4 -t 00:00:18 -c copy test\_new.mp4 -y，说明：从第5秒开始剪辑，裁剪时长为18秒，最终裁剪的时间段应该为（5-23）

> 方式二：ffmpeg.exe -ss %s -i %s -to %s -c copy %s -y  
> ffmpeg.exe -ss 00:00:05 -i test.mp4 -to 00:00:18 -c copy test\_new.mp4 -y，说明：从第5秒开始剪辑，第18秒为结束时间，最终裁剪的时间段应该为（5-18）

**ffmpeg指令参数说明：**  
ss 起始时间；i 指定要转换的文件；t 裁剪时长；to 截止时间；c 操作方式copy；y 覆盖已存在的文件

**踩坑指南：**  
按照官方的文档说明，正常t是裁剪的时长，to是裁剪的截止时间，但是t和to两种都用了之后，最终结果都是裁剪时长！暂时没找到原因，就先用裁剪时长吧，如果想要用截止时间，简单封装一下也可以

**代码贴在这里：**

/**
     * ffmpeg相关工具类
     */
    public class FFMpegShellUtil {
        
        /**
         * ffmpeg是否存在
         * @return
         */
        public static boolean isFFMpegReadied() {
        
            //电脑本地的ffmpeg的地址
            String ffmpegPath = "D:\\ffmpeg\\ffmpeg-5.1.2-full_build-shared\\bin\\ffmpeg.exe";
            File file = new File(ffmpegPath);
            boolean exists = file.exists();
            System.out.println("ffmpeg工具准备状态：" + exists);
            return exists;
        }
    
        /**
         * 构造ffmpeg指令
         * @param startTime 开始时间 00:01:00
         * @param input     源文件 video.mp4
         * @param durTime   裁剪时长 00:02:00
         */
        public static String createCutShell(String input, String startTime, String durTime) {
        
            String shell;
            //输出文件名称
            String output = getOutputName(input, startTime, durTime);
            System.out.println("剪辑输出视频文件的地址："+output);
            //系统名称
            String systemName = getSystemName();
            //ffmpeg指令参数说明（ss 起始时间 | i 指定要转换的文件 | t 裁剪时长 | c 操作方式，copy | y 覆盖已存在的文件）
            if (systemName.contains("windows")) {
         //windows系统
                shell = String.format("ffmpeg.exe -ss %s -i %s -t %s -c copy %s -y", startTime, input, durTime, output);
            } else {
         //其他系统
                shell = String.format("ffmpeg -ss %s -i %s -t %s -c copy %s -y", startTime, input, durTime, output);
            }
            return shell;
        }
    
        /**
         * 获取输出文件名称
         * @param input     源文件 video.mp4
         * @param startTime 开始时间 00:01:00
         * @param durTime   裁剪时长 00:02:00
         * @return
         */
        private static String getOutputName(String input, String startTime, String durTime){
        
            String[] arr = input.split("\\.");
            String name = arr[0];
            String suffix = arr[1];
            String start = startTime.replaceAll(":","");
            String dur = durTime.replaceAll(":","");
            return name+"_"+start+"_"+dur+"."+suffix;
        }
    
        /**
         * 获取系统平台名称：windows、linux...
         */
        private static String getSystemName() {
        
            return System.getProperty("os.name").toLowerCase();
        }
    }

### 3.视频裁剪任务执行 ###

**使用Runtime.getRuntime().exec()的方法执行，主要是Java应用生成一个新的进程调用系统外部的的程序，本质上也就是用来执行ffmpeg的shell指令的。**

> 但是这边有个很大的漏洞，使用waitFor()方法时，由于java给进程的输出流分配的缓冲区很小，特别容易发生缓冲区被填满、程序阻塞的问题，错误输出流缓冲区与标准输出流缓冲区会由于清空不及时发生阻塞，异步开两个线程分别去处理标准输出流和错误输出流，可以有效地解决缓冲区信息阻塞的问题，这里使用了两个线程方法threadExec执行！

/**
     * 视频裁剪任务
     */
    public class VideoCutTask {
        
    
        /**
         * 任务执行
         * @param shell ffmpeg指令
         * @return
         */
        public static void exec(String shell) {
        
            System.out.println("shell：" + shell);
            BufferedReader bufferedReader = null;
            try {
        
                Process process = Runtime.getRuntime().exec(shell);
    
    //            bufferedReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
    //            String line;
    //            StringBuilder sb = new StringBuilder();
    //            while (null != (line = bufferedReader.readLine())) {
        
    //                if (!line.isEmpty()) {
        
    //                    sb.append(line);
    //                }
    //            }
    //            process.waitFor();
    
                //使用waitFor()方法时，由于java给进程的输出流分配的缓冲区很小，特别容易发生缓冲区被填满、程序阻塞的问题
                //使用两个线程分别去处理标准输出流和错误输出流，可以有效地解决缓冲区信息阻塞的问题
                threadExec(process.getInputStream());
                threadExec(process.getErrorStream());
                process.waitFor();
    
                System.out.println("shell执行结束！");
            } catch (IOException e) {
        
                e.printStackTrace();
                System.err.println("shell执行IOException：" + e.getMessage());
            } catch (InterruptedException e) {
        
                e.printStackTrace();
                System.err.println("shell执行InterruptedException：" + e.getMessage());
            } finally {
        
                if (null != bufferedReader) {
        
                    try {
        
                        bufferedReader.close();
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                }
            }
        }
    
        /**
         * 分线程执行
         * @param input 输入流
         */
        private static void threadExec(final InputStream input) {
        
            new Thread(()->{
        
                BufferedReader bf = new BufferedReader(new InputStreamReader(input));
                String line = null;
                try{
        
                    while(null != (line = bf.readLine())) {
        
                        System.out.println(line);
                    }
                } catch (IOException e) {
        
                    e.printStackTrace();
                }
            }).start();
        }
    }

### 4.主程序执行效果展示 ###

main方法处直接执行看生成的效果，需要传入的参数有：【视频源文件路径】、【剪辑开始时间】、【剪辑时长】三个参数，默认输出的文件与源文件放在同一目录下，命名方式不同做区分。

public class Main {
        
    
        public static void main(String[] args) {
        
            //视频源文件路径
            String inputPath = "D:\\videoTest\\trailer.mp4";
            //剪辑开始时间
            String start = "00:00:11";
            //剪辑时长
            String duration = "00:00:25";
            //验证ffmpeg是否就绪
            if (FFMpegShellUtil.isFFMpegReadied()) {
        
                //创建ffmpeg裁剪指令
                String shell = FFMpegShellUtil.createCutShell(inputPath, start, duration);
                //执行剪辑操作
                VideoCutTask.exec(shell);
            }
        }
    }

最后执行的效果，可以看到当前路径下生成一个时长25秒的视频，就是裁剪后的视频，如下图  
![在这里插入图片描述][bbf125bcc9a9454e8717ab5c2e3484c6.png]

**试着裁剪了个14G的大视频，裁取中间的一段视频，基本都是在秒级时间内完成的，速度非常的快。可以看一下裁剪的日志：**

Connected to the target VM, address: '127.0.0.1:49712', transport: 'socket'
    ffmpeg工具准备状态：true
    剪辑输出视频文件的地址：E:\sjc_011210_000125.mp4
    shell：ffmpeg.exe -ss 01:12:10 -i E:\sjc.mp4 -t 00:01:25 -c copy E:\sjc_011210_000125.mp4 -y
    ffmpeg version 5.1.2-full_build-www.gyan.dev Copyright (c) 2000-2022 the FFmpeg developers
      built with gcc 12.1.0 (Rev2, Built by MSYS2 project)
      configuration: --enable-gpl --enable-version3 --enable-shared --disable-w32threads --disable-autodetect --enable-fontconfig --enable-iconv --enable-gnutls --enable-libxml2 --enable-gmp --enable-bzlib --enable-lzma --enable-libsnappy --enable-zlib --enable-librist --enable-libsrt --enable-libssh --enable-libzmq --enable-avisynth --enable-libbluray --enable-libcaca --enable-sdl2 --enable-libaribb24 --enable-libdav1d --enable-libdavs2 --enable-libuavs3d --enable-libzvbi --enable-librav1e --enable-libsvtav1 --enable-libwebp --enable-libx264 --enable-libx265 --enable-libxavs2 --enable-libxvid --enable-libaom --enable-libjxl --enable-libopenjpeg --enable-libvpx --enable-mediafoundation --enable-libass --enable-frei0r --enable-libfreetype --enable-libfribidi --enable-liblensfun --enable-libvidstab --enable-libvmaf --enable-libzimg --enable-amf --enable-cuda-llvm --enable-cuvid --enable-ffnvcodec --enable-nvdec --enable-nvenc --enable-d3d11va --enable-dxva2 --enable-libmfx --enable-libshaderc --enable-vulkan --enable-libplacebo --enable-opencl --enable-libcdio --enable-libgme --enable-libmodplug --enable-libopenmpt --enable-libopencore-amrwb --enable-libmp3lame --enable-libshine --enable-libtheora --enable-libtwolame --enable-libvo-amrwbenc --enable-libilbc --enable-libgsm --enable-libopencore-amrnb --enable-libopus --enable-libspeex --enable-libvorbis --enable-ladspa --enable-libbs2b --enable-libflite --enable-libmysofa --enable-librubberband --enable-libsoxr --enable-chromaprint
      libavutil      57. 28.100 / 57. 28.100
      libavcodec     59. 37.100 / 59. 37.100
      libavformat    59. 27.100 / 59. 27.100
      libavdevice    59.  7.100 / 59.  7.100
      libavfilter     8. 44.100 /  8. 44.100
      libswscale      6.  7.100 /  6.  7.100
      libswresample   4.  7.100 /  4.  7.100
      libpostproc    56.  6.100 / 56.  6.100
    [mov,mp4,m4a,3gp,3g2,mj2 @ 00000193bc227bc0] Unknown cover type: 0x1.
    Input #0, mov,mp4,m4a,3gp,3g2,mj2, from 'E:\sjc.mp4':
      Metadata:
        major_brand     : isom
        minor_version   : 512
        compatible_brands: isomiso2avc1mp41
        creation_time   : 2023-04-25T17:47:04.000000Z
        Hw              : 1
        bitrate         : 16000000
        maxrate         : 0
        te_is_reencode  : 1
        encoder         : Lavf58.76.100
      Duration: 02:34:43.70, start: 0.000000, bitrate: 12996 kb/s
      Stream #0:0[0x1](und): Video: h264 (Main) (avc1 / 0x31637661), yuv420p(tv, bt709, progressive), 1920x1080 [SAR 1:1 DAR 16:9], 12796 kb/s, 30 fps, 30 tbr, 30 tbn (default)
        Metadata:
          creation_time   : 2023-04-25T17:47:04.000000Z
          handler_name    : VideoHandler
          vendor_id       : [0][0][0][0]
      Stream #0:1[0x2](und): Audio: aac (LC) (mp4a / 0x6134706D), 44100 Hz, stereo, fltp, 194 kb/s (default)
        Metadata:
          creation_time   : 2023-04-25T17:47:04.000000Z
          handler_name    : SoundHandler
          vendor_id       : [0][0][0][0]
    Output #0, mp4, to 'E:\sjc_011210_000125.mp4':
      Metadata:
        major_brand     : isom
        minor_version   : 512
        compatible_brands: isomiso2avc1mp41
        te_is_reencode  : 1
        Hw              : 1
        bitrate         : 16000000
        maxrate         : 0
        encoder         : Lavf59.27.100
      Stream #0:0(und): Video: h264 (Main) (avc1 / 0x31637661), yuv420p(tv, bt709, progressive), 1920x1080 [SAR 1:1 DAR 16:9], q=2-31, 12796 kb/s, 30 fps, 30 tbr, 15360 tbn (default)
        Metadata:
          creation_time   : 2023-04-25T17:47:04.000000Z
          handler_name    : VideoHandler
          vendor_id       : [0][0][0][0]
      Stream #0:1(und): Audio: aac (LC) (mp4a / 0x6134706D), 44100 Hz, stereo, fltp, 194 kb/s (default)
        Metadata:
          creation_time   : 2023-04-25T17:47:04.000000Z
          handler_name    : SoundHandler
          vendor_id       : [0][0][0][0]
    Stream mapping:
      Stream #0:0 -> #0:0 (copy)
      Stream #0:1 -> #0:1 (copy)
    Press [q] to stop, [?] for help
    frame=    0 fps=0.0 q=-1.0 size=       0kB time=00:00:00.00 bitrate=N/A speed=   0x    
    frame= 1284 fps=0.0 q=-1.0 size=   65792kB time=00:00:43.76 bitrate=12314.9kbits/s speed=87.5x    
    frame= 2551 fps=0.0 q=-1.0 Lsize=  130852kB time=00:01:25.00 bitrate=12610.4kbits/s speed=85.4x    
    video:128759kB audio:2002kB subtitle:0kB other streams:0kB global headers:0kB muxing overhead: 0.070083%
    shell执行结束！
    Disconnected from the target VM, address: '127.0.0.1:49712', transport: 'socket'
    
    Process finished with exit code 0

**这样就实现了用Java程序进行视频裁剪的操作，有兴趣的小伙伴可以试一试！**

[_ffmpeg]: https://blog.csdn.net/csdn_yudong/article/details/129182648
[9c9f78da8cf9425eb62ff246f57a8ee1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/03/42468b1bdbd64cf9a96b8a1041ca9032.png
[bbf125bcc9a9454e8717ab5c2e3484c6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/03/d9a4d5fcd3b94ca489bfce612578fd75.png