Java启动浏览器，录制视频

最近接到通过服务端程序启动浏览器，同时访问固定网址，开起视频录制需求，在网上查了资料，整理记录起来。

在项目中增加ffmpeg依赖

<!-- https://mvnrepository.com/artifact/org.bytedeco.javacpp-presets/ffmpeg-platform -->
<dependency>
    <groupId>org.bytedeco.javacpp-presets</groupId>
    <artifactId>ffmpeg-platform</artifactId>
    <version>4.1-1.4.4</version>
</dependency>

启动浏览器，开始视频录制

/**
  * 视频录制
  *  @param userImage
  * @param runnable
  */
 private void videoRecording(UserImage userImage, Runnable runnable) {
     String videoName = "zkkj_" + DateUtils.dateStr(new Date(), DateUtils.DATE_FORMAT_4) + "_" + userImage.getImageName();
     String userImageParamStr = FastJsonUtils.beanToString(userImage);
     try {
         // 发送WebSocket消息通知web端
         websocketService.sendInfo(userImageParamStr, "1");
     } catch (IOException e) {
         log.warn("webSocket发送影像信息异常");
         e.printStackTrace();
         return;
     }
     // 调用系统默认浏览器打开三球球链接
     if (java.awt.Desktop.isDesktopSupported()) {
         try {
             // 创建一个URI实例
             java.net.URI uri = java.net.URI.create(earthUrl);
             // 获取当前系统桌面扩展
             java.awt.Desktop dp = java.awt.Desktop.getDesktop();
             // 判断系统桌面是否支持要执行的功能
             if (dp.isSupported(java.awt.Desktop.Action.BROWSE)) {
                 // 获取系统默认浏览器打开链接
                 dp.browse(uri);
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
     }


     // 执行录屏
     try {

         Thread.sleep(2000L);
         VideoRecordUtil videoRecordUtil = new VideoRecordUtil();
         videoRecordUtil.videoRecord(
                 VideoRecordUtil.VIDEO_PATH,
                 videoName,
                 false);
         videoRecordUtil.start();
         Thread.sleep(20000L);
         videoRecordUtil.stop();
     } catch (InterruptedException e) {
         log.warn("录屏异常");
         e.printStackTrace();
     }
 }

视频录制工具类

package org.zkkj.starview.util;

import org.springframework.stereotype.Component;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.ShortBuffer;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.TargetDataLine;
import org.bytedeco.javacpp.avcodec;
import org.bytedeco.javacpp.avutil;
import org.bytedeco.javacv.FFmpegFrameRecorder;
import org.bytedeco.javacv.Frame;
import org.bytedeco.javacv.FrameRecorder.Exception;
import org.bytedeco.javacv.Java2DFrameConverter;

/**
 * @ClassName: VideoRecordUtil
 * @Description: 视频录制工具
 * @Author: Gavin
 * @Create: 2021-07-23 10:46
 * @Version: 1.0
 * @Copyright: 2018~2021-07-23 10:46 www.clisia.cn. 保留所有权利。
 */
public class VideoRecordUtil {
    public static int width = Toolkit.getDefaultToolkit().getScreenSize().width;
    public static int height = Toolkit.getDefaultToolkit().getScreenSize().height;

    public static String VIDEO_PATH = "D:\\software\\ftp";
    /**
     * 线程池 screenTimer
     */
    public static ScheduledThreadPoolExecutor screenTimer;
    /**
     * 获取屏幕尺寸 截屏的大小
     */
    public static final Rectangle rectangle = new Rectangle(width, height);
    /**
     * 视频类 FFmpegFrameRecorder
     */
    public static FFmpegFrameRecorder recorder;
    public static Robot robot;
    /**
     * 线程池 exec
     */
    public static ScheduledThreadPoolExecutor exec;
    public static TargetDataLine line;
    public static AudioFormat audioFormat;
    public static DataLine.Info dataLineInfo;
    private boolean isHaveDevice = true;
    public static long startTime = 0;
    public static long videoTS = 0;
    public static long pauseTime = 0;
    public static double frameRate = 5;


    public void videoRecord(String videoPath, String fileName, boolean isHaveDevice) {
        recorder = new FFmpegFrameRecorder(videoPath + fileName + ".mp4", width, height);
        // recorder.setVideoCodec(avcodec.AV_CODEC_ID_H265); // 28
        // recorder.setVideoCodec(avcodec.AV_CODEC_ID_FLV1); // 28
        recorder.setVideoCodec(avcodec.AV_CODEC_ID_MPEG4); // 13
        recorder.setFormat("mp4");
        // recorder.setFormat("mov,mp4,m4a,3gp,3g2,mj2,h264,ogg,MPEG4");
        recorder.setSampleRate(44100);
        recorder.setFrameRate(frameRate);

        recorder.setVideoQuality(0);
        recorder.setVideoOption("crf", "23");
        // 2000 kb/s, 720P视频的合理比特率范围
        recorder.setVideoBitrate(1000000);
        /**
         * 权衡quality(视频质量)和encode speed(编码速度) values(值)： ultrafast(终极快),superfast(超级快),
         * veryfast(非常快), faster(很快), fast(快), medium(中等), slow(慢), slower(很慢),
         * veryslow(非常慢)
         * ultrafast(终极快)提供最少的压缩（低编码器CPU）和最大的视频流大小；而veryslow(非常慢)提供最佳的压缩（高编码器CPU）的同时降低视频流的大小
         * 参考：https://trac.ffmpeg.org/wiki/Encode/H.264 官方原文参考：-preset ultrafast as the
         * name implies provides for the fastest possible encoding. If some tradeoff
         * between quality and encode speed, go for the speed. This might be needed if
         * you are going to be transcoding multiple streams on one machine.
         */
        recorder.setVideoOption("preset", "slow");
        // yuv420p
        recorder.setPixelFormat(avutil.AV_PIX_FMT_YUV420P);
        recorder.setAudioChannels(2);
        recorder.setAudioOption("crf", "0");
        // Highest quality
        recorder.setAudioQuality(0);
        recorder.setAudioCodec(avcodec.AV_CODEC_ID_AAC);
        try {
            robot = new Robot();
        } catch (AWTException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try {
            recorder.start();
        } catch (Exception e) {
            // TODO Auto-generated catch block
        }
        this.isHaveDevice = isHaveDevice;
    }

    /**
     * 开始录制
     */
    public void start() {
        if (startTime == 0) {
            startTime = System.currentTimeMillis();
        }
        if (pauseTime == 0) {
            pauseTime = System.currentTimeMillis();
        }
        // 如果有录音设备则启动录音线程
        if (isHaveDevice) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    caputre();
                }
            }).start();

        }

        // 录屏
        screenTimer = new ScheduledThreadPoolExecutor(1);
        screenTimer.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                // 截屏
                BufferedImage screenCapture = robot.createScreenCapture(rectangle);
                // 声明一个BufferedImage用重绘截图
                BufferedImage videoImg = new BufferedImage(width, height, BufferedImage.TYPE_3BYTE_BGR);
                // 创建videoImg的Graphics2D
                Graphics2D videoGraphics = videoImg.createGraphics();

                videoGraphics.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE);
                videoGraphics.setRenderingHint(RenderingHints.KEY_COLOR_RENDERING,
                        RenderingHints.VALUE_COLOR_RENDER_SPEED);
                videoGraphics.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);
                // 重绘截图
                videoGraphics.drawImage(screenCapture, 0, 0, null);

                Java2DFrameConverter java2dConverter = new Java2DFrameConverter();

                Frame frame = java2dConverter.convert(videoImg);
                try {
                    videoTS = 1000L
                            * (System.currentTimeMillis() - startTime - (System.currentTimeMillis() - pauseTime));
                    // 检查偏移量
                    if (videoTS > recorder.getTimestamp()) {
                        recorder.setTimestamp(videoTS);
                    }
                    recorder.record(frame); // 录制视频
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                // 释放资源
                videoGraphics.dispose();
                videoGraphics = null;
                videoImg.flush();
                videoImg = null;
                java2dConverter = null;
                screenCapture.flush();
                screenCapture = null;

            }
        }, (int) (1000 / frameRate), (int) (1000 / frameRate), TimeUnit.MILLISECONDS);

    }

    /**
     * 抓取声音
     */
    public void caputre() {
        audioFormat = new AudioFormat(44100.0F, 16, 2, true, false);
        dataLineInfo = new DataLine.Info(TargetDataLine.class, audioFormat);
        try {
            line = (TargetDataLine) AudioSystem.getLine(dataLineInfo);
        } catch (LineUnavailableException e1) {
        }
        try {
            line.open(audioFormat);
        } catch (LineUnavailableException e1) {
            e1.printStackTrace();
        }
        line.start();

        final int sampleRate = (int) audioFormat.getSampleRate();
        final int numChannels = audioFormat.getChannels();

        int audioBufferSize = sampleRate * numChannels;
        final byte[] audioBytes = new byte[audioBufferSize];

        exec = new ScheduledThreadPoolExecutor(1);
        exec.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                try {
                    int nBytesRead = line.read(audioBytes, 0, line.available());
                    int nSamplesRead = nBytesRead / 2;
                    short[] samples = new short[nSamplesRead];
                    ByteBuffer.wrap(audioBytes).order(ByteOrder.LITTLE_ENDIAN).asShortBuffer().get(samples);
                    ShortBuffer sBuff = ShortBuffer.wrap(samples, 0, nSamplesRead);
                    recorder.recordSamples(sampleRate, numChannels, sBuff);
                } catch (org.bytedeco.javacv.FrameRecorder.Exception e) {
                    e.printStackTrace();
                }
            }
        }, (int) (1000 / frameRate), (int) (1000 / frameRate), TimeUnit.MILLISECONDS);
    }

    /**
     * 停止
     */
    public void stop() {
        if (null != screenTimer) {
            screenTimer.shutdownNow();
        }
        try {
            recorder.stop();
            recorder.release();
            recorder.close();
            screenTimer = null;
            if (isHaveDevice) {
                if (null != exec) {
                    exec.shutdownNow();
                }
                if (null != line) {
                    line.stop();
                    line.close();
                }
                dataLineInfo = null;
                audioFormat = null;
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    /**
     * 暂停
     * @throws Exception
     */
    public void pause() throws Exception {
        screenTimer.shutdownNow();
        screenTimer = null;
        if (isHaveDevice) {
            exec.shutdownNow();
            exec = null;
            line.stop();
            line.close();
            dataLineInfo = null;
            audioFormat = null;
            line = null;
        }
        pauseTime = System.currentTimeMillis();
    }

}