Java实现跨平台屏幕录制：从Robot捕获到FFmpeg编码的完整实践

1. 项目概述：从需求到实现的思考路径

最近在做一个内部工具时，碰到了一个挺实际的需求：需要把软件的操作过程自动录制成视频，方便后续做演示或者排查问题。一开始想找现成的工具，但要么功能太臃肿，要么无法很好地集成到Java应用里进行程序化控制。于是，干脆自己动手，用Java来实现一个轻量级的屏幕录制功能。这听起来可能有点“重复造轮子”，但自己实现的好处是可控性极高，你可以精确地控制录制的区域、帧率、编码格式，并且能无缝地嵌入到你的Java应用中，实现自动化录制。

这个需求背后，其实涉及几个核心点：首先是如何捕获屏幕画面，也就是从操作系统获取当前显示器的像素数据；其次是如何处理这些连续的图像帧，将它们编码成主流的视频格式（如MP4）；最后，也是更具挑战性的，是如何支持多显示器环境。现在很多开发者和用户都使用双屏甚至多屏办公，录制单个屏幕已经不够用了，我们需要能灵活选择录制哪个屏幕，或者甚至录制一个跨越多个显示器的虚拟区域。

实现这个功能，你会接触到Java在桌面应用开发、图像处理以及多媒体封装方面的能力。它不只是一个简单的API调用，更需要你理解屏幕捕获的原理、视频编码的基础知识，以及不同操作系统（Windows, macOS, Linux）在图形接口上的差异。下面，我就把自己从零搭建这个功能的过程、踩过的坑以及一些优化心得，详细地分享出来。

2. 核心技术选型与架构设计

要实现屏幕录制，我们需要一套清晰的“流水线”：捕获 -> 处理 -> 编码 -> 封装。每个环节都有不同的技术方案可选，我的选型主要基于“轻量、高效、跨平台”的原则。

2.1 屏幕捕获方案：Robot vs. 原生API

Java标准库中，最直接的屏幕捕获工具是java.awt.Robot类。它的createScreenCapture(Rectangle screenRect)方法可以获取指定矩形区域的屏幕截图，返回一个BufferedImage对象。这个方案的最大优点是纯Java实现，跨平台，在Windows、macOS和Linux上都能运行。

但是，Robot类在高频率捕获时（例如每秒30帧）存在明显的性能瓶颈。它的捕获操作是同步的，并且依赖于操作系统的底层事件机制，在部分系统上可能会触发全局屏幕刷新，导致CPU占用率偏高。对于需要长时间、高帧率录制的情况，这可能会成为问题。

另一种方案是使用各平台的原生API，例如Windows的GDI或DirectX，macOS的CoreGraphics，Linux的X11或Wayland。通过JNI（Java Native Interface）调用这些API，可以获得更高的捕获效率和更丰富的功能（如捕获指定窗口、捕获硬件加速渲染的内容）。著名的开源项目FFmpeg在实现屏幕录制时，就大量使用了各平台的原生捕获模块。

我的选择与理由：对于大多数Java应用场景，尤其是希望保持部署简单、避免引入复杂原生依赖的情况，Robot类仍然是首选。它的性能对于制作教程、记录操作日志（通常15-30帧）已经足够。在本项目中，我们以Robot为基础进行实现，同时会探讨一些优化其性能的技巧。多屏支持的核心，在于正确获取所有屏幕的布局信息，而Robot同样可以做到这一点。

2.2 视频编码与封装：FFmpeg的桥梁作用

获取到连续的BufferedImage帧后，我们需要将它们压缩并打包成视频文件。Java生态中并没有强大的内置视频编码库，因此引入外部工具是必然的。这里，FFmpeg几乎是唯一且最佳的选择。它是一个完整的、跨平台的音视频处理解决方案，支持几乎所有已知的编码格式。

我们不需要在Java中重新实现编码器，而是通过进程调用的方式，将图像帧数据通过管道（Process的OutputStream）实时传递给FFmpeg进程，由FFmpeg完成高效的编码和文件写入。这种方式将复杂的编码工作交给了久经考验的专业工具，我们只需专注于图像的捕获和传递。

编码格式选择：

• H.264 / AVC：最通用的选择，兼容性极好，压缩率高。使用libx264编码器。
• HEVC / H.265：更高的压缩效率，适合对文件大小有严格要求的场景，但编解码开销稍大，部分旧设备可能不支持。
• VP9：开放、免专利费的格式，Web端支持好，但编码速度较慢。

对于屏幕录制内容（大量静态区域、文本），推荐使用H.264编码，并配合tune=zerolatency（零延迟）和preset=ultrafast（超快）参数，以优先保证编码速度和实时性，画质损失在可接受范围内。

2.3 整体架构设计

基于以上选型，我们的系统架构可以设计如下：

1. 配置模块：用户指定录制区域（全屏、单个屏幕、自定义矩形）、帧率、输出文件路径、视频参数（分辨率、码率、编码器）。
2. 捕获调度器：一个独立的线程，按照设定的帧率循环工作。在每次循环中，它调用Robot.captureScreen获取当前帧的BufferedImage。
3. 图像处理管道（可选）：对捕获的原始图像进行预处理，例如缩放至目标分辨率、转换为FFmpeg接受的像素格式（如BGRA或RGB24）。
4. FFmpeg进程管理器：启动一个FFmpeg子进程，配置好输入（从标准输入stdin读取原始视频帧）和输出（写入MP4文件）。Java端将处理后的图像帧数据写入该进程的输出流。
5. 控制模块：提供开始、暂停、停止录制的API，并负责资源的清理（停止捕获线程、关闭FFmpeg进程）。

对于多屏录制，关键在于第一步的配置模块。我们需要通过GraphicsEnvironment获取所有GraphicsDevice（屏幕设备），并计算出每个屏幕的绝对坐标位置，从而允许用户指定一个可能跨越多个屏幕的录制区域。

3. 核心实现细节与代码拆解

接下来，我们深入到代码层面，看看每个核心环节如何实现。我会先给出单屏录制的基础版本，再扩展到多屏。

3.1 获取屏幕信息与定义录制区域

这是所有工作的起点。我们需要知道屏幕有多大，有多少块屏幕，它们是怎么排列的。

import java.awt.*; import java.util.ArrayList; import java.util.List; public class ScreenRecorder { private Robot robot; private Rectangle captureArea; // 要录制的矩形区域 public ScreenRecorder() throws AWTException { this.robot = new Robot(); } /** * 获取系统中所有屏幕的边界信息。 * @return 包含所有屏幕Rectangle的列表 */ public static List<Rectangle> getAllScreenBounds() { GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment(); GraphicsDevice[] screens = ge.getScreenDevices(); List<Rectangle> bounds = new ArrayList<>(); for (GraphicsDevice screen : screens) { bounds.add(screen.getDefaultConfiguration().getBounds()); } return bounds; } /** * 计算所有屏幕构成的虚拟全屏边界。 * 例如，两个1920x1080的屏幕左右并列，则返回一个3840x1080的Rectangle。 * @return 虚拟全屏的Rectangle */ public static Rectangle getVirtualScreenBounds() { List<Rectangle> screenBounds = getAllScreenBounds(); if (screenBounds.isEmpty()) { return new Rectangle(0, 0, 0, 0); } // 计算能包围所有屏幕的最小矩形 int minX = Integer.MAX_VALUE; int minY = Integer.MAX_VALUE; int maxX = Integer.MIN_VALUE; int maxY = Integer.MIN_VALUE; for (Rectangle rect : screenBounds) { minX = Math.min(minX, rect.x); minY = Math.min(minY, rect.y); maxX = Math.max(maxX, rect.x + rect.width); maxY = Math.max(maxY, rect.y + rect.height); } return new Rectangle(minX, minY, maxX - minX, maxY - minY); } /** * 设置录制区域。 * @param area 要录制的矩形区域（基于虚拟坐标系） */ public void setCaptureArea(Rectangle area) { this.captureArea = area; // 简单验证：区域是否在虚拟屏幕范围内 Rectangle virtualBounds = getVirtualScreenBounds(); if (!virtualBounds.contains(area)) { System.err.println("警告：录制区域部分或全部在屏幕可见范围之外。"); } } }

关键点解析：

• GraphicsDevice代表一个屏幕设备。它的getBounds()返回的Rectangle中的x和y坐标是全局虚拟坐标系下的位置。主屏通常是(0, 0)，副屏可能在(1920, 0)（右扩展）或(-1920, 0)（左扩展）。
• getVirtualScreenBounds()函数计算出的矩形，就是你能“录制”的最大区域。如果你想录制所有屏幕的内容，直接将这个矩形设为捕获区域即可。
• 坐标原点：在Windows和大多数Linux桌面环境中，虚拟坐标系的原点(0,0)位于主显示器的左上角。macOS的行为可能略有不同，但Robot类会处理好这些差异。

3.2 启动FFmpeg进程与配置编码参数

我们需要在Java中构造正确的FFmpeg命令并启动进程。核心是让FFmpeg从stdin读取原始视频帧。

import java.io.*; import java.util.concurrent.atomic.AtomicBoolean; public class FFmpegRecorder { private Process ffmpegProcess; private OutputStream ffmpegInput; private AtomicBoolean isRecording = new AtomicBoolean(false); private Thread captureThread; /** * 启动FFmpeg进程，准备接收原始帧数据。 * @param outputFile 输出文件路径（如 output.mp4） * @param frameRate 帧率（如 30） * @param width 视频宽度 * @param height 视频高度 * @throws IOException 如果启动进程失败 */ public void start(String outputFile, int frameRate, int width, int height) throws IOException { // 构造FFmpeg命令 // -y: 覆盖输出文件 // -f rawvideo: 输入格式为原始视频 // -pixel_format bgr0: 输入像素格式（与BufferedImage.TYPE_INT_ARGB转换后的数据对应） // -video_size wxh: 输入视频尺寸 // -framerate fr: 输入帧率 // -i -: 从标准输入读取 // -c:v libx264: 使用H.264编码 // -preset ultrafast: 编码预设，追求速度 // -tune zerolatency: 零延迟调优，适合实时流 // -pix_fmt yuv420p: 输出像素格式，兼容性最好 // -f mp4: 输出格式为MP4 String[] cmd = { "ffmpeg", "-y", "-f", "rawvideo", "-pixel_format", "bgr0", // 注意：Java的ARGB内存布局是A|R|G|B，但FFmpeg的bgr0是B|G|R|A，顺序不同！需要转换。 "-video_size", width + "x" + height, "-framerate", String.valueOf(frameRate), "-i", "-", "-c:v", "libx264", "-preset", "ultrafast", "-tune", "zerolatency", "-pix_fmt", "yuv420p", "-f", "mp4", outputFile }; ProcessBuilder pb = new ProcessBuilder(cmd); // 将错误流重定向到标准输出，方便查看FFmpeg日志 pb.redirectErrorStream(true); ffmpegProcess = pb.start(); // 获取向FFmpeg写入数据的流 ffmpegInput = ffmpegProcess.getOutputStream(); isRecording.set(true); // 启动一个线程来读取FFmpeg的输出（日志），防止进程阻塞 new Thread(() -> { try (BufferedReader reader = new BufferedReader(new InputStreamReader(ffmpegProcess.getInputStream()))) { String line; while ((line = reader.readLine()) != null) { System.out.println("[FFmpeg] " + line); } } catch (IOException e) { if (isRecording.get()) { e.printStackTrace(); } } }).start(); } }

重要提示：像素格式的坑。BufferedImage内部存储的像素格式（TYPE_INT_ARGB）是AARRGGBB（按字节顺序）。而FFmpeg的bgr0格式期望的是BB GG RR AA。直接写入会导致颜色完全错误。我们必须在写入前进行转换。一个更稳妥、兼容性更好的方式是使用rgb24格式，并忽略Alpha通道，将ARGB转换为RGB。

3.3 屏幕捕获循环与帧数据传递

这是最核心的循环，它需要稳定、高效地运行。

public class FFmpegRecorder { // ... 接上文代码 /** * 开始屏幕捕获并编码。 * @param captureArea 捕获区域 * @param frameRate 目标帧率 */ public void startCapture(Rectangle captureArea, int frameRate) { if (captureThread != null && captureThread.isAlive()) { System.err.println("捕获线程已在运行。"); return; } captureThread = new Thread(() -> { Robot robot; try { robot = new Robot(); } catch (AWTException e) { e.printStackTrace(); return; } int width = captureArea.width; int height = captureArea.height; long frameIntervalMs = 1000 / frameRate; // 每帧的理论间隔（毫秒） BufferedImage capturedImage; byte[] frameBuffer; // 预分配缓冲区，避免在循环中频繁创建对象 // 计算RGB24格式一帧的大小：width * height * 3 (R, G, B各一个字节) int frameSize = width * height * 3; frameBuffer = new byte[frameSize]; System.out.println("开始屏幕捕获，区域: " + captureArea + ", 帧率: " + frameRate + " FPS"); while (isRecording.get()) { long frameStartTime = System.currentTimeMillis(); // 1. 捕获屏幕 capturedImage = robot.createScreenCapture(captureArea); // 2. 将BufferedImage转换为RGB24字节数组 convertImageToRGB24(capturedImage, frameBuffer); try { // 3. 将帧数据写入FFmpeg进程 ffmpegInput.write(frameBuffer); ffmpegInput.flush(); // 确保数据被推送 } catch (IOException e) { // 如果写入失败（例如FFmpeg进程异常退出），停止录制 System.err.println("写入FFmpeg失败: " + e.getMessage()); stop(); break; } // 4. 帧率控制：计算本次捕获+编码耗时，进行休眠以稳定帧率 long processingTime = System.currentTimeMillis() - frameStartTime; long sleepTime = frameIntervalMs - processingTime; if (sleepTime > 0) { try { Thread.sleep(sleepTime); } catch (InterruptedException e) { Thread.currentThread().interrupt(); break; } } else { // 如果处理时间超过帧间隔，说明当前负载下无法达到目标帧率 // 可以记录一个警告，或者动态调整捕获区域/质量 // System.err.println("警告：帧处理超时，当前负载较高。"); } } System.out.println("屏幕捕获线程结束。"); }); captureThread.start(); } /** * 将BufferedImage (TYPE_INT_ARGB) 转换为RGB24格式的字节数组。 * 忽略Alpha通道。 * @param image 源图像 * @param buffer 目标缓冲区（大小必须为 width*height*3） */ private void convertImageToRGB24(BufferedImage image, byte[] buffer) { int width = image.getWidth(); int height = image.getHeight(); int[] pixels = new int[width * height]; // 一次性获取所有像素的ARGB值，效率比逐个getRGB高 image.getRGB(0, 0, width, height, pixels, 0, width); int pixelIndex = 0; int bufferIndex = 0; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { int argb = pixels[pixelIndex++]; // 提取R, G, B分量，并放入buffer buffer[bufferIndex++] = (byte) ((argb >> 16) & 0xFF); // R buffer[bufferIndex++] = (byte) ((argb >> 8) & 0xFF); // G buffer[bufferIndex++] = (byte) (argb & 0xFF); // B // 忽略Alpha: (argb >> 24) & 0xFF } } } public void stop() { isRecording.set(false); if (captureThread != null) { try { captureThread.join(1000); // 等待捕获线程结束 } catch (InterruptedException e) { e.printStackTrace(); } } if (ffmpegInput != null) { try { ffmpegInput.close(); // 关闭输入流，告知FFmpeg输入结束 } catch (IOException e) { e.printStackTrace(); } } if (ffmpegProcess != null) { try { // 等待FFmpeg进程完成最后的写入和封装 int exitCode = ffmpegProcess.waitFor(); System.out.println("FFmpeg进程退出，代码: " + exitCode); } catch (InterruptedException e) { e.printStackTrace(); ffmpegProcess.destroyForcibly(); } } } }

性能优化关键点：

1. 预分配缓冲区：在循环外创建frameBuffer和pixels数组，避免在每秒数十次的循环中频繁创建和垃圾回收，这对性能影响巨大。
2. 批量获取像素：使用BufferedImage.getRGB(int, int, int, int, int[], int, int)一次性获取所有像素，远比在嵌套循环中调用image.getRGB(x, y)高效。
3. 帧率控制：简单的Thread.sleep控制并不精确，但足以应对屏幕录制场景。更精确的控制可以使用ScheduledExecutorService。如果处理一帧的时间超过了设定的帧间隔，说明系统负载过高，可以考虑动态降低捕获分辨率或帧率。
4. 颜色空间转换：这里我们选择了兼容性最好的RGB24格式。转换过程是纯CPU计算，是主要的性能开销之一。如果对性能有极致要求，可以研究使用JavaCV（OpenCV的Java封装）或JNI调用更优化的原生转换函数。

3.4 多屏录制的使用示例

将上面的模块组合起来，实现多屏录制就非常直观了。

public class MultiScreenRecordingDemo { public static void main(String[] args) throws AWTException, IOException, InterruptedException { // 1. 获取所有屏幕信息 List<Rectangle> screens = ScreenRecorder.getAllScreenBounds(); System.out.println("检测到 " + screens.size() + " 个屏幕:"); for (int i = 0; i < screens.size(); i++) { Rectangle rect = screens.get(i); System.out.printf(" 屏幕 %d: 位置(%d, %d), 分辨率 %dx%d%n", i, rect.x, rect.y, rect.width, rect.height); } // 2. 创建录制器 FFmpegRecorder recorder = new FFmpegRecorder(); // 3. 选择录制区域 Rectangle areaToRecord; if (screens.size() == 1) { // 单屏：录制整个主屏 areaToRecord = screens.get(0); System.out.println("录制模式：单屏（全屏）"); } else { // 多屏示例1：录制所有屏幕组成的虚拟全屏 // areaToRecord = ScreenRecorder.getVirtualScreenBounds(); // System.out.println("录制模式：虚拟全屏（所有屏幕）"); // 多屏示例2：仅录制第二个屏幕（索引1） int screenIndex = 1; // 假设录制副屏 if (screenIndex < screens.size()) { areaToRecord = screens.get(screenIndex); System.out.println("录制模式：仅录制屏幕 " + screenIndex); } else { System.out.println("指定的屏幕索引无效，回退到主屏。"); areaToRecord = screens.get(0); } // 多屏示例3：录制一个自定义区域（例如，跨越主屏和副屏的一部分） // areaToRecord = new Rectangle(500, 200, 2500, 800); // 自定义坐标和大小 // System.out.println("录制模式：自定义区域"); } // 4. 配置并启动FFmpeg int frameRate = 20; String outputFile = "screen_record_" + System.currentTimeMillis() + ".mp4"; recorder.start(outputFile, frameRate, areaToRecord.width, areaToRecord.height); // 5. 开始捕获 recorder.startCapture(areaToRecord, frameRate); System.out.println("录制已开始，输出至: " + outputFile + "，按Enter键停止..."); System.in.read(); // 等待用户按下回车 // 6. 停止录制 recorder.stop(); System.out.println("录制已停止。"); } }

4. 常见问题、优化与深度排查

在实际使用中，你肯定会遇到各种各样的问题。下面是我在开发和测试过程中总结的一些典型情况及其解决方法。

4.1 性能问题与优化策略

问题表现：录制时CPU占用率过高（例如超过50%），或者实际帧率远低于设定帧率。

排查与解决：

1. 降低捕获分辨率：这是最有效的优化手段。全屏（如3840x2160）捕获的数据量是1080p的4倍。如果不需要超清，可以将捕获区域缩小，或者在捕获后使用BufferedImage.getScaledInstance()进行缩放，再将缩小后的图像传递给编码器。注意：缩放操作本身也有开销，需要在捕获线程外或使用更高效的图像缩放库（如Thumbnailator）进行。
2. 调整FFmpeg编码预设：我们使用了-preset ultrafast，这已经是为了速度牺牲了压缩率。如果CPU依然是瓶颈，可以尝试降低帧率（如从30降到15或10），或者使用更简单的编码器如mpeg4（但文件会变大）。
3. 审视颜色转换：convertImageToRGB24函数中的循环是CPU密集型的。可以尝试以下优化：
   • 使用DataBuffer直接操作：对于已知的BufferedImage类型（如TYPE_INT_RGB），可以直接访问其底层的DataBufferInt，避免getRGB的调用开销。
   • 并行处理：对于大图像，可以将行拆分，用多线程并行进行颜色转换。但要注意线程创建和同步的开销可能抵消收益。
   • 使用JNI调用原生代码：终极优化方案，将转换逻辑用C/C++实现并通过JNI调用。这对于追求极致性能的场景是值得的。

一个简单的分辨率缩放示例：

private BufferedImage scaleImage(BufferedImage original, int targetWidth, int targetHeight) { // 使用平滑缩放模式，质量较好但速度稍慢 Image scaled = original.getScaledInstance(targetWidth, targetHeight, Image.SCALE_SMOOTH); BufferedImage output = new BufferedImage(targetWidth, targetHeight, BufferedImage.TYPE_INT_RGB); Graphics2D g2d = output.createGraphics(); g2d.drawImage(scaled, 0, 0, null); g2d.dispose(); return output; } // 在捕获循环中调用 BufferedImage captured = robot.createScreenCapture(captureArea); BufferedImage scaled = scaleImage(captured, targetWidth, targetHeight); // 然后将scaled图像转换为RGB24

4.2 视频质量问题

问题表现：录制的视频模糊、有拖影、颜色失真或文件异常大。

排查与解决：

1. 模糊与拖影：这通常是因为帧率不足或编码延迟。确保你的帧率（如20-30）对于屏幕操作是足够的。检查-tune zerolatency参数是否已设置，它减少了编码缓冲，降低了延迟。拖影也可能是由于Robot捕获瞬间屏幕正在刷新，可以尝试在捕获前加入极短的延迟（如Thread.sleep(1)），但这会进一步降低帧率。
2. 颜色失真：99%的问题出在像素格式转换上。务必确认：
   • Java端BufferedImage的类型（通常是TYPE_INT_ARGB）。
   • FFmpeg命令中-pixel_format参数设置是否正确（我们用了rgb24）。
   • 转换函数convertImageToRGB24是否正确地将ARGB的字节顺序转换成了RGB。
   • 可以录制一个纯色（红、绿、蓝）屏幕进行测试，用播放器检查颜色。
3. 文件过大：屏幕录制内容（尤其是办公、代码界面）包含大量静态区域，使用H.264默认参数可能压缩率不够。可以尝试：
   • 增加-crf参数（恒定质量因子），范围是0-51，值越大压缩率越高、质量越低。对于屏幕录制，-crf 23到-crf 28是不错的选择。-crf 28的文件会比默认小很多，画质仍可接受。
   • 使用-preset slower可以获得更好的压缩率，但编码速度会慢，不适合实时录制。可以在后期处理非实时录制的文件时使用。

4.3 FFmpeg相关错误排查

FFmpeg进程可能因各种原因失败，其错误信息会输出到标准错误流。我们已经通过redirectErrorStream(true)将其合并到了标准输出流中，方便查看。

常见错误及解决：

调试技巧：在开发阶段，可以在FFmpeg命令中加入-loglevel debug参数，获取更详细的日志。或者，可以先输出到无损格式如-f nut -i - -c:v libx264 -preset ultrafast -f nut -（输出到stdout），虽然不生成文件，但可以测试管道通信是否正常。

4.4 内存与资源管理

问题表现：长时间录制后内存占用持续增长，或出现OutOfMemoryError。

排查与解决：

1. 对象池：在捕获循环中，我们预分配了frameBuffer和pixels数组，这很好。但robot.createScreenCapture()每次都会返回一个新的BufferedImage对象。对于长时间运行，可以考虑重用有限的几个BufferedImage对象（如果Robot类允许的话，但通常它返回新对象）。更实际的做法是确保这些临时对象在每次循环后能被快速垃圾回收。如果帧率很高，可以适当调低。
2. 流关闭：务必在stop()方法中正确关闭ffmpegInput和等待FFmpeg进程终止。否则会导致进程句柄和流资源泄漏。
3. 线程中断：确保在程序退出时，捕获线程能被正确中断 (isRecording.set(false)并thread.interrupt())，防止线程僵尸。

5. 进阶扩展与实用技巧

基础功能实现后，可以考虑以下几个方向来增强其实用性。

5.1 录制系统音频与麦克风

单纯的屏幕录像没有声音，体验是不完整的。通过FFmpeg，我们可以相对容易地加入音频。

思路：启动另一个FFmpeg进程（或同一个进程的另一个输入流）来捕获系统音频输出（扬声器）和麦克风输入，然后将音视频流混合。

• Windows：可以使用dshow（DirectShow）或wasapi设备捕获音频。
  • 查找音频设备：ffmpeg -list_devices true -f dshow -i dummy
  • 捕获系统声音和麦克风可能需要虚拟音频驱动（如VB-Audio Virtual Cable）将系统音频输出重定向为输入设备。
• macOS：使用avfoundation。
  • 查找设备：ffmpeg -f avfoundation -list_devices true -i ""
  • 捕获：-f avfoundation -i ":0"（0通常代表屏幕+系统音频）
• Linux：使用pulse（PulseAudio）或alsa（ALSA）。

复杂性：音频采样率、声道数与视频的同步（音画同步）是一个复杂问题。对于入门项目，一个更简单的方案是后期合成：先录制无声视频，再使用ffmpeg命令将视频文件与另一个单独录制的音频文件合并。这避免了实时同步的麻烦。

5.2 增加鼠标高亮与点击效果

为了让教程更清晰，可以在捕获的帧上实时绘制鼠标位置和点击效果。

private BufferedImage addMouseCursorToImage(BufferedImage original, Point mousePos) { BufferedImage imageWithCursor = new BufferedImage( original.getWidth(), original.getHeight(), BufferedImage.TYPE_INT_ARGB); Graphics2D g2d = imageWithCursor.createGraphics(); // 1. 绘制原始屏幕内容 g2d.drawImage(original, 0, 0, null); // 2. 绘制一个红色的圆圈表示鼠标位置 g2d.setColor(Color.RED); g2d.setStroke(new BasicStroke(2)); int cursorRadius = 5; // 注意：mousePos是全局坐标，需要转换到当前捕获图像的相对坐标 int relativeX = mousePos.x - captureArea.x; int relativeY = mousePos.y - captureArea.y; if (captureArea.contains(mousePos)) { g2d.drawOval(relativeX - cursorRadius, relativeY - cursorRadius, 2 * cursorRadius, 2 * cursorRadius); // 可以在这里根据鼠标按键状态绘制点击动画 } g2d.dispose(); return imageWithCursor; } // 在捕获循环中获取鼠标位置 Point mousePos = MouseInfo.getPointerInfo().getLocation(); BufferedImage captured = robot.createScreenCapture(captureArea); BufferedImage finalImage = addMouseCursorToImage(captured, mousePos); // 对finalImage进行编码

5.3 图形化界面（GUI）封装

对于最终用户，一个图形界面是必不可少的。你可以使用Swing或JavaFX开发一个简单的控制面板，包含：

• 屏幕选择：列出所有屏幕的缩略图，让用户点击选择录制哪个屏幕或区域。
• 区域选择：提供拖拽框选录制区域的功能。
• 参数设置：帧率、输出路径、视频质量（CRF）的下拉菜单或输入框。
• 控制按钮：开始、暂停、停止按钮，以及录制时长、文件大小的显示。

将我们上面实现的核心ScreenRecorder和FFmpegRecorder类作为后台引擎，GUI前端通过事件监听器调用它们的方法即可。注意，长时间的捕获和编码操作一定要放在后台线程（如SwingWorker）中执行，避免阻塞GUI事件调度线程导致界面卡死。

实现这个Java屏幕录制工具的过程，是一次对Java桌面能力、多媒体处理和跨平台开发的深入实践。从最基础的Robot截图，到与FFmpeg的进程通信，再到多屏坐标系的处理，每一步都需要仔细考量性能和兼容性。虽然它可能比不上OBS Studio这样的专业软件功能全面，但其轻量、可集成、可编程的特性，使其成为构建自动化测试、远程协助、操作审计等企业级应用内部工具的绝佳基础组件。最重要的是，通过亲手实现，你真正掌握了屏幕录制背后的原理，下次再遇到相关问题，你就能从容地从原理层面去分析和解决了。