FFmpegAndroid wraps FFmpeg in four Android sample apps and explains itself in doc files

Four top-level apps sit on one Gradle skeleton

The top level lists .gitignore, build.gradle, gradle.properties, gradlew and settings.gradle, which is the ordinary Android module skeleton, and then four directory names that read like four separate demos: app/, Live/, NextPlayer/ and CameraFilter/. Nothing states how they relate, whether one depends on another, or whether four modules are declared in settings.gradle. The primary language is recorded as C, so the code worth reading is native rather than Kotlin or Java, and gradlew exists for the Android side of that code. engine/ is the one directory whose name points at where FFmpeg gets called from, yet its contents go undescribed, and extra/ and shell/ are equally unexplained. picture/ is likewise undescribed.

doc/ carries the explanation, README.md only carries the links

README.md is a link list. Eight of its links land inside doc/ on the master branch: FFmpeg_compile_shell.md for the build script, FFmpeg_command_line.md for command line use, FFmpeg_sourcecode.md for source analysis, JNI_develop_practice.md for the native bridge, multimedia_knowledge.md, player_framework.md, multimedia_protocol.md and multimedia_work.md. The single outside link is the official FFmpeg site at ffmpeg.org. That distribution matters when you are deciding whether to adopt anything here, because the substance is Markdown rather than a published interface. What you can take from this repository is knowledge and starting code. There is no API surface documented anywhere that another application could depend on.

https://github.com/xufuji456/FFmpegAndroid/blob/master/doc/FFmpeg_compile_shell.md
https://github.com/xufuji456/FFmpegAndroid/blob/master/doc/FFmpeg_command_line.md
https://github.com/xufuji456/FFmpegAndroid/blob/master/doc/FFmpeg_sourcecode.md
https://github.com/xufuji456/FFmpegAndroid/blob/master/doc/JNI_develop_practice.md
https://github.com/xufuji456/FFmpegAndroid/blob/master/doc/multimedia_knowledge.md
https://github.com/xufuji456/FFmpegAndroid/blob/master/doc/player_framework.md
https://github.com/xufuji456/FFmpegAndroid/blob/master/doc/multimedia_protocol.md
https://github.com/xufuji456/FFmpegAndroid/blob/master/doc/multimedia_work.md

Read in README order, the first four cover compile, then command line, then source analysis, then JNI and NDK.

No release, no LICENSE file, and nothing to depend on

There are no GitHub releases, and the top level has no LICENSE file beside README.md, so the licensing terms are not stated anywhere in the tree. There is also no Maven or Gradle coordinate, no AAR, and no prebuilt binary in the listing. The name invites questions about apks and downloads, and the honest answer is that this repository answers none of them, because the tree holds sources and a build script rather than an artifact. Getting FFmpeg onto a phone means running the native build yourself from doc/FFmpeg_compile_shell.md, wiring the bridge described in doc/JNI_develop_practice.md, and choosing your own ABI set along the way. That is the real cost of entry, and it is why this reads as study notes rather than as a library you link from a build file.

Live/ promises RTMP and H264 push and then stops talking

The project credits itself with local push streaming plus real time live streaming over H264 and RTMP, and that one sentence is the whole of what is said about the Live/ directory. No push URL example, no bitrate or resolution table, no audio track configuration, no reconnect or drop handling, no sample server, and no note about which FFmpeg build options that path requires. The protocol paragraph above it reads as a syllabus rather than a design: RTP, RTMP, RTCP and RTSP as transport protocols, HLS and DASH as streaming application protocols, SDP, ICE, NAT and STUN for WebRTC, H264, HEVC and VVC as codecs, mp4 as the container, C11 and C20 as language standards. Read doc/multimedia_protocol.md before assuming any of it is wired into Live/.

CameraFilter/ is where OpenGL effects meet the capture path

The description pairs OpenGL filter effects with video capture, and CameraFilter/ is the directory that pairing points at. Not one shader, GL context version, surface type or filter list appears in the README, so the available effects cannot be enumerated from it, and there is no way to tell from the outside whether the filters are applied during preview, during recording, or afterwards on the encoded stream. Camera work on Android is precisely where the native side and the Java side have to meet, which makes doc/JNI_develop_practice.md, the README's JNI and NDK development link, the obvious place to start on that boundary. The remaining named jobs, cropping, watermarking, GIF conversion and transcoding, are attached to no directory in the listing at all, so which module implements them is something you answer by opening the code.

Four README headings have nothing underneath them

The file closes with four headings that carry no content: audio and video basics, advanced audio and video growth, open source audio and video libraries, and joining the group to learn FFmpeg. Whatever was meant to sit under them was never committed. That gap is not cosmetic, because those are the headings that would have said who the project is for and which libraries it covers. The work directions paragraph does admit it is one person's own summary of areas that include live streaming, short video, streaming backends, video and music players, audio and video algorithms, editing and image processing. Read the whole map as a private curriculum, and do not plan coverage against it.

Start at doc/FFmpeg_compile_shell.md, since nothing runs before the native library builds

The reading order the tree itself suggests begins with the compile script, because the Java side has nothing to call until FFmpeg exists for your ABI. After that comes doc/JNI_develop_practice.md for the bridge, then doc/FFmpeg_command_line.md for what the built binary can do, then doc/player_framework.md, which covers ijkplayer architecture and may not describe the NextPlayer/ directory at all. The last push on the default master branch was on 2026-10-26. What you can verify before touching any of it is the shape of the tree:

.gitignore
CameraFilter/
Live/
NextPlayer/
app/
build.gradle
doc/
engine/
extra/
gradle.properties
gradle/
gradlew
picture/
settings.gradle
shell/

Compare that against the doc list. Anything you expected to find, a build script under shell/, the native sources under engine/ or extra/, is your first hour of reading, and the README will not save you from it.

Editorial conclusion

Adopt FFmpegAndroid if you want a worked map of the FFmpeg, JNI, RTMP and OpenGL corners of Android and you are willing to build the native library yourself for each ABI. Do not adopt it as a dependency: no released binary, no LICENSE file, no published coordinates. Before you spend time on it, open doc/FFmpeg_compile_shell.md and confirm the script still builds the FFmpeg version your NDK can compile.

Frequently asked questions

Official sources

1. Issues
2. README
3. xufuji456/FFmpegAndroid on GitHub