Jaffree Documentation

If a process must be stopped immediately, you can use one of three force-stop methods. Warning: Force-stopping may result in corrupted output media as FFmpeg might not finalize the file correctly.

1. Via ProgressListener: Throw a RuntimeException inside the onProgress method of your ProgressListener.
2. Via FFmpegResultFuture: If using executeAsync(), call future.forceStop().
3. Via Thread Interruption: If using the synchronous execute() method, run it in a separate thread and call thread.interrupt() on that thread.

// Method 1: Throw exception in ProgressListener
final AtomicBoolean stopped = new AtomicBoolean();
ffmpeg.setProgressListener(
        new ProgressListener() {
            @Override
            public void onProgress(FFmpegProgress progress) {
                if (stopped.get()) {
                    throw new RuntimeException("Stopped with exception!");
                }
            }
        }
);

// Method 2: Use forceStop on the future
FFmpegResultFuture future = ffmpeg.executeAsync();
Thread.sleep(5_000);
future.forceStop();

// Method 3: Interrupt the execution thread
Thread thread = new Thread() {
    @Override
    public void run() {
        ffmpeg.execute();
    }
};
thread.start();
Thread.sleep(5_000);
thread.interrupt();

To track progress during re-encoding, first determine the total duration (e.g., by transcoding to NullOutput), then run the actual encoding process using a ProgressListener. You can calculate percentage completion by comparing progress.getTimeMillis() against the total duration.

final AtomicLong duration = new AtomicLong();
FFmpeg.atPath()
    .addInput(UrlInput.fromUrl(pathToSrc))
    .setOverwriteOutput(true)
    .addOutput(new NullOutput())
    .setProgressListener(new ProgressListener() {
        @Override
        public void onProgress(FFmpegProgress progress) {
            duration.set(progress.getTimeMillis());
        }
    })
    .execute();

FFmpeg.atPath()
    .addInput(UrlInput.fromUrl(pathToSrc))
    .setOverwriteOutput(true)
    .addArguments("-movflags", "faststart")
    .addOutput(UrlOutput.toUrl(pathToDst))
    .setProgressListener(new ProgressListener() {
        @Override
        public void onProgress(FFmpegProgress progress) {
            double percents = 100. * progress.getTimeMillis() / duration.get();
            System.out.println("Progress: " + percents + "% ");
        }
    })
    .execute();

Use CaptureInput.captureDesktop() to record the screen. You can configure the frame rate and whether to capture the cursor. It is often best practice to record with a fast preset (like ultrafast) to reduce CPU load, and then perform a second pass to re-encode the file for optimization.

FFmpeg.atPath()
    .addInput(CaptureInput
            .captureDesktop()
            .setCaptureFrameRate(30)
            .setCaptureCursor(true)
    )
    .addOutput(
        UrlOutput
            .toPath(pathToVideo)
            .addArguments("-preset", "ultrafast")
            .setDuration(30, TimeUnit.SECONDS)
    )
    .setOverwriteOutput(true)
    .execute();

// Re-encode for optimization
Path pathToOptimized = pathToVideo.resolveSibling("optimized-" + pathToVideo.getFileName());
FFmpeg.atPath()
    .addInput(UrlInput.fromPath(pathToVideo))
    .addOutput(UrlOutput.toPath(pathToOptimized))
    .execute();

Files.move(pathToOptimized, pathToVideo, StandardCopyOption.REPLACE_EXISTING);

You can generate video content entirely in Java by implementing a FrameProducer. The producer must implement produceStreams() to define the video/audio properties and produce() to return Frame objects. Returning null from produce() signals the end of the stream.

FrameProducer producer = new FrameProducer() {
    private long frameCounter = 0;

    @Override
    public List<Stream> produceStreams() {
        return Collections.singletonList(new Stream()
                .setType(Stream.Type.VIDEO)
                .setTimebase(1000L)
                .setWidth(320)
                .setHeight(240)
        );
    }

    @Override
    public Frame produce() {
        if (frameCounter > 30) {
            return null; // End of Stream
        }

        BufferedImage image = new BufferedImage(320, 240, BufferedImage.TYPE_3BYTE_BGR);
        Graphics2D graphics = image.createGraphics();
        graphics.setPaint(new Color(frameCounter * 1.0f / 30, 0, 0));
        graphics.fillRect(0, 0, 320, 240);
        long pts = frameCounter * 1000 / 10; 
        Frame videoFrame = Frame.createVideoFrame(0, pts, image);
        frameCounter++;

        return videoFrame;
    }
};

FFmpeg.atPath()
    .addInput(FrameInput.withProducer(producer))
    .addOutput(UrlOutput.toUrl(pathToVideo))
    .execute();