Use Java FFmpeg wrapper, or simply use Java runtime to execute FFmpeg?

I too am looking for something to wrap FFMPEG in Java. While searching, I found this: https://github.com/bramp/ffmpeg-cli-wrapper.

As of today, it seems to have been modified a month ago. So, hopefully it will stick around for a while.

A sample from their docs:

FFmpeg ffmpeg = new FFmpeg("/path/to/ffmpeg");
FFprobe ffprobe = new FFprobe("/path/to/ffprobe");

FFmpegBuilder builder = new FFmpegBuilder()
    .setInput(in)
    .overrideOutputFiles(true)
    .addOutput("output.mp4")
        .setFormat("mp4")
        .setTargetSize(250000)

        .disableSubtitle()

        .setAudioChannels(1)
        .setAudioCodec("libfdk_aac")
        .setAudioRate(48000)
        .setAudioBitrate(32768)

        .setVideoCodec("libx264")
        .setVideoFramerate(Fraction.getFraction(24, 1))
        .setVideoResolution(640, 480)

        .setStrict(FFmpegBuilder.Strict.EXPERIMENTAL)
        .done();

FFmpegExecutor executor = new FFmpegExecutor(ffmpeg, ffprobe);
executor.createTwoPassJob(builder).run();

There are a lot of Java libraries providing FFMPEG wrappers. However, most of these libraries are unfortunately outdated and use old FFMPEG versions which lack some important codecs (e.g. Xuggler, humble video, JavaAV, JavaAVC, and jave). So be careful when using those projects!

However, there is one FFMPEG wrapper that is still actively developed and supports FFMPEG 4:

• JavaCPP FFMPEG - with fully bundled maven artefacts

Alternatively you can use a wrapper for the command line interface of FFMPEG, such as ffmpeg-cli-wrapper. Then it's in your hand to update ffmpeg manually without having to wait for a new release of the wrapper library.

I wrote my own Java ffmpeg command line wrapper: Jaffree. It works with both ffprobe and ffmpeg and supports programmatic video production and consumption. Also it has in my opinion more convenient fluid API.

Here is an ffprobe usage example:

FFprobeResult result = FFprobe.atPath(BIN)
        .setInputPath(VIDEO_MP4)
        .setShowStreams(true)
        .setShowError(true)
        .execute();

if (result.getError() != null) {
    //TODO handle ffprobe error message
    return;
}

for (Stream stream : probe.getStreams().getStream()) {
    //TODO analyze stream data
}

ProgressListener listener = new ProgressListener() {
    @Override
    public void onProgress(FFmpegProgress progress) {
        //TODO handle progress data
    }
};

And this is for ffmpeg:

FFmpegResult result = FFmpeg.atPath(BIN)
        .addInput(Input.fromPath(VIDEO_MP4))
        .addOutput(Output.toPath(outputPath)
                .addCodec(null, "copy")
        )
        .setProgressListener(listener)
        .execute();

Also, as of Xuggler 3.3, Xuggler is LGPL meaning you don't need a commercial license.

you can try jave http://www.sauronsoftware.it/projects/jave

The benefits of using the wrapper would be mainly that it offers more and fine-grained functionality not accessible via the command line (not relevant to you) and makes error handling and status control easier - you'll have to parse the command line tool's standard output and error streams.

i try several ways, the most simple for me is ffmpeg-cli-wrapper, because it use default ffmpeg or specific one, moreover you can configure lot of configuration like scale, bitrate... get duration... JAVE from sauronsoftware make lot of error, XUGGLE and other i found it too complicated

For a real-world app example, see this project on GitHub.

Here is how to use FFmpeg and FFprobe from the org.bytedeco.ffmpeg library.

Add the dependency for your desired operating system (see here for supported OSes):

// The main artifact
implementation("org.bytedeco:ffmpeg:6.1.1-1.5.10")
// The Jar artifact containing executables for the desired OS
implementation("org.bytedeco:ffmpeg:6.1.1-1.5.10:windows-x86_64-gpl")

// OR using Gradle version catalogs
// implementation(libs.ffmpeg)
// implementation(variantOf(libs.ffmpeg) { classifier("windows-x86_64-gpl") })

Java:

import org.bytedeco.ffmpeg.ffmpeg;
import org.bytedeco.javacpp.Loader;
// ...

public class Test {
    private final String ffmpegPath = Loader.load(ffmpeg.class);
    public void executeFFmpeg() throws IOException {
        var ffmpegProcess = new ProcessBuilder()
                .command(
                        ffmpegPath,
                        // OR any options you would pass to FFmpeg CLI
                        "-i", "/absolute/path/to/video.mp4"
                )
                .start();
        try (var reader = new BufferedReader(new InputStreamReader(ffmpegProcess.getErrorStream()))) {
            reader
                    .lines()
                    .forEach(System.out::println);
        }
    }
}

Kotlin:

import org.bytedeco.ffmpeg.ffmpeg
import org.bytedeco.javacpp.Loader
// ...

class Test() {
    private val ffmpegPath = Loader.load(ffmpeg::class.java)
    fun executeFFmpeg() {
        ProcessBuilder()
            .command(ffmpegPath, "-i", "absolute/path/to/video.mp4")
            .runCatching { start() }
            .onFailure { println("Starting the FFmpeg process for probing failed") }
            .getOrNull()
            ?.errorStream
            ?.reader()
            ?.useLines { lines -> lines.forEach(::println) }
    }
}