The main problem is this:

FFMPEG is a binary, and there are no nice, user-friendly libraries that mimick it's behaviour out there...

One attempt is this: https://github.com/RkShaRkz/android-ffmpeg (the avatar gives me away)

Another one is this: https://sourceforge.net/projects/ffmpeg4android/files/20121012/

Alot of "solutions" revolve around either 1) launching the FFMPEG binary (process) and piping commands to it. 2) calling into FFMPEG libraries

But noone has yet made a nice FFMPEG-alike SDK library which lets you use everything it offers programatically in Java nor Android.

This was too long for a comment so thats why i posted it as an answer, i hope this doesn't get downvoted to oblivion for not providing a concrete answer/solution to your question.

There's a very easy solution for this, There's a precompiled library for android, as below https://github.com/WritingMinds/ffmpeg-android-java Simply include this as a gradle project in your code and add few methods as per their documentation and you are done with FFMPEG commands in android. This library is not very updated and have some missing features but still its good to use for many simple tasks.

The latest version of FFMPEG is 3.1.1, Just released before 12 days. So i think there is no readily available demo like this old one.

We need to build the FFMPEG library on our own. Some questions i found just pasting here that might help you. (Not tested)

How to Build FFmpeg for Android

1. Compiling FFmpeg 2.3 with Android NDK r10
2. How to compile ffmpeg-2.5.3 on windows with android-ndk-r10d
3. How to compile ffmpeg-2.2.2 on windows with cygwin and android ndk r9c
4. How to buid ffmpeg with android-ndk-r10d in windows

You need to compile it on your own the by downloading Android NDK & Latest Version of FFMPEG.

One tutorial is also there : How to Build FFmpeg for Android. This is quite old so you just need to change the versions mentioned here. For FFMPEG it will be 3.1.1 & NDK it will be r12b.

Building FFMPEG with NDK r12b:

1. Download Android NDK : The latest version of Android NDK can be downloaded at Android NDK website. At the time of writing this answer, the newest version is NDK r12. simply decompress the archive

2. Download ffmpeg source code : FFMPEG source code can be downloaded from the ffmpeg website. The latest stable release is 3.1.1 (at the time of writing). Download the source code and decompress it to $NDK/sources folder.

3. Update configure file : Open ffmpeg-3.1.1/configure file with a text editor, and locate the following lines.

   SLIBNAME_WITH_MAJOR='$(SLIBNAME).$(LIBMAJOR)'
   LIB_INSTALL_EXTRA_CMD='$$(RANLIB) "$(LIBDIR)/$(LIBNAME)"'
   SLIB_INSTALL_NAME='$(SLIBNAME_WITH_VERSION)'
   SLIB_INSTALL_LINKS='$(SLIBNAME_WITH_MAJOR) $(SLIBNAME)'
   

   This cause ffmpeg shared libraries to be compiled to libavcodec.so. (e.g. libavcodec.so.55), which is not compatible with Android build system. Therefore we’ll need to replace the above lines with the following lines.

   SLIBNAME_WITH_MAJOR='$(SLIBPREF)$(FULLNAME)-$(LIBMAJOR)$(SLIBSUF)'
   LIB_INSTALL_EXTRA_CMD='$$(RANLIB) "$(LIBDIR)/$(LIBNAME)"'
   SLIB_INSTALL_NAME='$(SLIBNAME_WITH_MAJOR)'
   SLIB_INSTALL_LINKS='$(SLIBNAME)
   

4. Build ffmpeg : Copy the following text to a text editor and save it as build_android.sh in ffmpeg_3.1.1 folder.

       #!/bin/bash
       NDK=$HOME/Desktop/adt/android-ndk-r9
       SYSROOT=$NDK/platforms/android-9/arch-arm/
       TOOLCHAIN=$NDK/toolchains/arm-linux-androideabi-4.8/prebuilt/linux-x86_64
       function build_one
       {
           ./configure
               --prefix=$PREFIX
               --enable-shared
               --disable-static
           --disable-doc
                   --disable-ffmpeg
               --disable-ffplay
               --disable-ffprobe
               --disable-ffserver
               --disable-avdevice
               --disable-doc
               --disable-symver
               --cross-prefix=$TOOLCHAIN/bin/arm-linux-androideabi-
               --target-os=linux
               --arch=arm
               --enable-cross-compile
               --sysroot=$SYSROOT
               --extra-cflags="-Os -fpic $ADDI_CFLAGS"
               --extra-ldflags="$ADDI_LDFLAGS"
           $ADDITIONAL_CONFIGURE_FLAG
           make clean
           make
           make install
       }
       CPU=arm
       PREFIX=$(pwd)/android/$CPU
       ADDI_CFLAGS="-marm"
       build_one
   

   Once the file is saved, go to the directory where this file lies & execute the command below,

   sudo chmod +x build_android.sh
   

   Then execute the script by the command,

   ./build_android.sh
   

5. Build Output : The build can take a while to finish depending on your computer speed. Once it’s done, you should be able to find a folder $NDK/sources/ffmpeg-3.1.1/android, which contains arm/lib and arm/include folders.

6. Make ffmpeg Libraries available for Your Projects

Steps above are fully tested and i performed them on my machine and the build was successful. For writing this answer i have took the reference from this article How to Build ffmpeg with NDK r9 but as it was for older version i have made some corrections on my own.

Open for asking any doubts.

Here are the steps I went through in getting ffmpeg to work on Android:

1. Build static libraries of ffmpeg for Android. This was achieved by building olvaffe's ffmpeg android port (libffmpeg) using the Android Build System. Simply place the sources under /external and make away. You'll need to extract bionic(libc) and zlib(libz) from the Android build as well, as ffmpeg libraries depend on them.

2. Create a dynamic library wrapping ffmpeg functionality using the Android NDK. There's a lot of documentation out there on how to work with the NDK. Basically you'll need to write some C/C++ code to export the functionality you need out of ffmpeg into a library java can interact with through JNI. The NDK allows you to easily link against the static libraries you've generated in step 1, just add a line similar to this to Android.mk: LOCAL_STATIC_LIBRARIES := libavcodec libavformat libavutil libc libz

3. Use the ffmpeg-wrapping dynamic library from your java sources. There's enough documentation on JNI out there, you should be fine.

Regarding using ffmpeg for playback, there are many examples (the ffmpeg binary itself is a good example), here's a basic tutorial. The best documentation can be found in the headers.

Good luck :)

I personally would not prefer to add the full FFMPEG SDK, as it increases the app size exponentially, however using Arthenica's FFMPEG-KIT seems the easiest way to get FFMPEG into a project

implementation "com.arthenica:ffmpeg-kit-min-gpl:5.1.LTS"

This new FFMPEG-KIT not only has a reduction in size, but the commands also execute quicker and have better async support and much easier implementation.

To use you just have to import

import com.arthenica.ffmpegkit.FFmpegKit
import com.arthenica.ffmpegkit.ReturnCode

and then :

FFmpegKit.executeAsync(cmdString , {
    when {
        ReturnCode.isSuccess(it.returnCode) -> {
            println("FFMPEG SUCCESS :${it.state.name}")
        }

        ReturnCode.isCancel(it.returnCode) -> {
            println("FFMPEG CANCELLED :${it.returnCode}")
        }

        it.returnCode.isValueError -> {
            println("FFMPEG ERROR :${it.logs.last()}")
        }
    }
} , {
    println("FFMEPG LOG :${it.message}")
} , {
    println("FFMEPG STATS :${it.speed}")
})

here cmdString, is a string of commands, your commands should work but the only issue I ran into was that I had to use -y -i instead of -f which seemed to run the commands.