导入Ffmpeg到项目

目录结构

其中有两个文件非常重要，分别是 native-lib.cpp 、 CMakeLists.txt。

• native-lib.cpp ：是一个 C++ 接口文件，在 MainActivity 中声明的外部方法将在这里得到实现。

#include <jni.h>
#include <string>

extern "C" JNIEXPORT jstring JNICALL
Java_com_ffmpeg_myapplication_MainActivity_stringFromJNI(
        JNIEnv *env,
        jobject /* this */) {
    std::string hello = "Hello from C++";
    return env->NewStringUTF(hello.c_str());
}

可以看到，这个 cpp 文件中的方法命名非常的长，不过其实非常简单。
首先是头部固定写法 extern "C" JNIEXPORT jstring JNICALL：
extern "C" 表示以 C语言 的方式来编译；
jstring 表示该方法返回类型是 Java 层的 String 类型，类似的还是有: void jint等；
然后是 Java 层对应方法的映射，即整个方法命名其实是 Java 层对应方法的绝对路径
Java_com_ffmpeg_myapplication_MainActivity_： 对应的是 com.ffmpeg.myapplication.MainActivity.
stringFromJNI 和 Java 层的方法一致。

最后是两个参数， JNIEnv *env 和 jobject，分别代表 JNI 的上下文环境和调用这个接口的 Java 的类的实例。

• CMakeLists.txt ： 也就是构建脚本

# cmake 最低版本
cmake_minimum_required(VERSION 3.4.1)

# 配置so库编译信息
add_library( 
        # 输出so库的名称
        native-lib

        # 设置生成库的方式，默认为SHARE动态库
        SHARED

        # 列出参与编译的所有源文件
        native-lib.cpp)

# 查找代码中使用到的系统库
find_library( # Sets the name of the path variable.
        log-lib

        # Specifies the name of the NDK library that
        # you want CMake to locate.
        log)

# 指定编译目标库时，cmake要链接的库
target_link_libraries(
        # 指定目标库，native-lib 是在上面 add_library 中配置的目标库
        native-lib

        # 列出所有需要链接的库
        ${log-lib})

CMakeLists.txt 的目的就是配置可以编译出 native-lib so 库的构建信息。

• 在 Gradle 文件中注册 CMake 脚本
  在 第二步 中，已经把构建 so 库的信息配置好了，接下来要把这些信息注册到 Gradle 中，编译器才会去编译它。

app 的 build.gradle 内容如下：

apply plugin: 'com.android.application'
apply plugin: 'kotlin-android'
apply plugin: 'kotlin-android-extensions'

android {
    compileSdkVersion 29
    buildToolsVersion "29.0.3"

    defaultConfig {
        applicationId "com.ffmpeg.myapplication"
        minSdkVersion 16
        targetSdkVersion 29
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"

        externalNativeBuild {
            cmake {
                cppFlags "-std=c++11"
            }
            ndk {
                abiFilters "armeabi-v7a","x86"
            }
        }
    }

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }

    externalNativeBuild {
        cmake {
            path "src/main/cpp/CMakeLists.txt"
            version "3.10.2"
        }
    }
}

dependencies {
    ...
}

最主要的两个地方是两个 externalNativeBuild 。

第 1 个 externalNativeBuild 中，可以做一些优化配置，比如只打包包含 armeabi 架构的 so
第 2 个 externalNativeBuild，主要是配置 CMakeLists.txt 的路径和版本。

Android Studio 为我们生成的关于 C/C++ 支持的主要就是以上三个地方，有了以上配置，就可以在 MainActivity 页面中正常的显示出 Hello from C++ 。

引入 FFmpeg so

将 FFmpeg so 库放到对应的 CPU 架构目录，在 app/src/main/ 目录下，新建文件夹，并命名为 jniLibs（app/src/main/jniLibs 是 Android Studio 默认的放置 so 动态库的目录。），接着，在 jniLibs 目录下，新建 armeabi-v7a 目录。

然后，添加 FFmpeg so 的头文件，在编译 FFmpeg 的时候，除了生成 so 外，还会生成对应的 .h 头文件，也就是 FFmpeg 对外暴露的所有接口。

添加、链接 FFmpeg so 库，上面已经把 so 和 头文件 放置到对应的目录中了，但是编译器是不会把它们编译、链接、并打包到 Apk 中的，我们还需要在 CMakeLists.txt 中显性的把相关的 so 添加和链接起来。完整的 CMakeLists.txt 如下：

cmake_minimum_required(VERSION 3.4.1)

# 支持gnu++11
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++11")

# 1. 定义so库和头文件所在目录，方面后面使用
set(ffmpeg_lib_dir ${CMAKE_SOURCE_DIR}/../jniLibs/${ANDROID_ABI})
set(ffmpeg_head_dir ${CMAKE_SOURCE_DIR}/ffmpeg)

# 2. 添加头文件目录
include_directories(${ffmpeg_head_dir}/include)

# 3. 添加ffmpeg相关的so库
add_library( avutil
        SHARED
        IMPORTED )
set_target_properties( avutil
        PROPERTIES IMPORTED_LOCATION
        ${ffmpeg_lib_dir}/libavutil.so )

add_library( swresample
        SHARED
        IMPORTED )
set_target_properties( swresample
        PROPERTIES IMPORTED_LOCATION
        ${ffmpeg_lib_dir}/libswresample.so )

add_library( avcodec
        SHARED
        IMPORTED )
set_target_properties( avcodec
        PROPERTIES IMPORTED_LOCATION
        ${ffmpeg_lib_dir}/libavcodec.so )

add_library( avfilter
        SHARED
        IMPORTED)
set_target_properties( avfilter
        PROPERTIES IMPORTED_LOCATION
        ${ffmpeg_lib_dir}/libavfilter.so )

add_library( swscale
        SHARED
        IMPORTED)
set_target_properties( swscale
        PROPERTIES IMPORTED_LOCATION
        ${ffmpeg_lib_dir}/libswscale.so )

add_library( avformat
        SHARED
        IMPORTED)
set_target_properties( avformat
        PROPERTIES IMPORTED_LOCATION
        ${ffmpeg_lib_dir}/libavformat.so )

add_library( avdevice
        SHARED
        IMPORTED)
set_target_properties( avdevice
        PROPERTIES IMPORTED_LOCATION
        ${ffmpeg_lib_dir}/libavdevice.so )

# 查找代码中使用到的系统库
find_library( # Sets the name of the path variable.
        log-lib

        # Specifies the name of the NDK library that
        # you want CMake to locate.
        log )

# 配置目标so库编译信息
add_library( # Sets the name of the library.
        native-lib

        # Sets the library as a shared library.
        SHARED

        # Provides a relative path to your source file(s).
        native-lib.cpp
        )

# 指定编译目标库时，cmake要链接的库
target_link_libraries(

        # 指定目标库，native-lib 是在上面 add_library 中配置的目标库
        native-lib

        # 4. 连接 FFmpeg 相关的库
        avutil
        swresample
        avcodec
        avfilter
        swscale
        avformat
        avdevice

        # Links the target library to the log library
        # included in the NDK.
        ${log-lib} )

使用 FFmpeg

要检查 FFmpeg 是否可以使用，可以通过获取 FFmpeg 基础信息来验证。

class FFmpegActivity: AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_ffmpeg_info)
       
        tv.text = ffmpegInfo()
    }

    private external fun ffmpegInfo(): String

    companion object {
        init {
            System.loadLibrary("native-lib")
        }
    }
}

在 native-lib.cpp 中添加对应的 JNI 层方法

#include <jni.h>
#include <string>
#include <unistd.h>

extern "C" {
    #include <libavcodec/avcodec.h>
    #include <libavformat/avformat.h>
    #include <libavfilter/avfilter.h>
    #include <libavcodec/jni.h>

    JNIEXPORT jstring JNICALL
    Java_com_cxp_learningvideo_FFmpegActivity_ffmpegInfo(JNIEnv *env, jobject  /* this */) {

        char info[40000] = {0};
        AVCodec *c_temp = av_codec_next(NULL);
        while (c_temp != NULL) {
            if (c_temp->decode != NULL) {
                sprintf(info, "%sdecode:", info);
            } else {
                sprintf(info, "%sencode:", info);
            }
            switch (c_temp->type) {
                case AVMEDIA_TYPE_VIDEO:
                    sprintf(info, "%s(video):", info);
                    break;
                case AVMEDIA_TYPE_AUDIO:
                    sprintf(info, "%s(audio):", info);
                    break;
                default:
                    sprintf(info, "%s(other):", info);
                    break;
            }
            sprintf(info, "%s[%s]\n", info, c_temp->name);
            c_temp = c_temp->next;
        }
        
        return env->NewStringUTF(info);
    }
}

首先，我们看到代码被包裹在 extern "C" { } 当中，和前面的系统创建的稍微有些不同，通过这个大括号包裹，我们就不需要每个方法都添加单独的 extern "C" 开头了。
另外，由于 FFmpeg 是使用 C 语言编写的，所在 C++ 文件中引用 #include 的时候，也需要包裹在 extern "C" { }，才能正确的编译。
方法的新建就不用说了，和前面介绍的命名方法一致。
在方法中，使用 FFmpeg 提供的方法 av_codec_next，获取到 FFmpeg 的编解码器，然后通过循环遍历，将所有的音视频编解码器信息拼接起来，最后返回给 Java 层。
至此，FFmpeg 加入到工程中，并被调用。