# andorid_ffmpeg_so_play

**Repository Path**: young16a/andorid_ffmpeg_so_play

## Basic Information

- **Project Name**: andorid_ffmpeg_so_play
- **Description**: 编译ffmpeg动态库so文件，然后安卓中调用播放视频
- **Primary Language**: Java
- **License**: GPL-3.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 1
- **Forks**: 0
- **Created**: 2024-07-17
- **Last Updated**: 2024-09-01

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

1、首先编译出ffmpeg的动态库so文件

> 1）先修改configure文件中so文件命名格式，如下
>
> ```
> # 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)'
> # 替换成如下
> SLIBNAME_WITH_MAJOR='$(SLIBPREF)$(FULLNAME)-$(LIBMAJOR)$(SLIBSUF)'
> LIB_INSTALL_EXTRA_CMD='$$(RANLIB)"$(LIBDIR)/$(LIBNAME)"'
> SLIB_INSTALL_NAME='$(SLIBNAME_WITH_MAJOR)'
> SLIB_INSTALL_LINKS='$(SLIBNAME)'
> ```
>
> 2）编写build.sh，文件来生成动态库，文件内容如下
>
> ```shell
> NDK=/home/ubuntu2204/Android/Sdk/ndk/21.3.6528147
> ARCH=x64
> CPU=x64
> PREFIX=$(pwd)/android/$ARCH/$CPU
> ADDI_CFLAGS="-marm -mno-stackrealign"
> TOOLCHAIN=$NDK/toolchains/arm-linux-androideabi-4.9
> ANDROID_TOOLCHAINS_PATH=$NDK/toolchains/llvm/prebuilt/linux-x86_64
> CROSS_PREFIX=$ANDROID_TOOLCHAINS_PATH/bin/x86_64-linux-android-
> SYSROOT=$ANDROID_TOOLCHAINS_PATH/sysroot
> #用CC变量和CXX变量指定Cmake使用的编译器
> #没有export，就相当于脚本的临时变量
> #加了export，就变成了当前会话的环境变量
> export CC=$ANDROID_TOOLCHAINS_PATH/bin/x86_64-linux-android21-clang
> export CXX=$ANDROID_TOOLCHAINS_PATH/bin/x86_64-linux-android21-clang++
> #执行 .configure文件
> ./configure --prefix=$PREFIX \
> 	--enable-gpl \
> 	--disable-static \
> 	--enable-shared \
> 	--enable-small \
> 	--disable-programs \
> 	--disable-ffmpeg \
> 	--disable-ffplay \
> 	--disable-ffprobe \
> 	--disable-doc \
> 	--arch=$ARCH \
> 	--cpu=$CPU \
> 	--cross-prefix=$CROSS_PREFIX \
> 	--enable-cross-compile \
> 	--sysroot=$SYSROOT \
> 	--target-os=linux \
> 	--extra-cflags="-Os -fpic $ADDI_CFLAGS" \
> 	--extra-ldflags="$ADDI_LDFLAGS" \
> 	--cc=$CC \
> 	--cxx=$CXX \
> 	--disable-x86asm \
> #运行 Makefile
> make clean
> make
> make install
> ```
>
> 3）将生成的so库文件和头文件都拿出来，拿到android中使用；

2、在AS中新建一个项目，然后在main文件夹下新建一个“myLibs”目录放动态库和头文件，如下图所示：

![image](https://partner-gitlab.mioffice.cn/nj-trainingcollege/miclassroom240706/cppgroup1/yugang/day11/-/raw/master/images/day11_03_01.png?inline=false)

3、修改CMakeLists.txt将动态链接库链接起来，这样就能调用ffmpeg的方法了，CMakeLists.txt内容如下：

```shell
cmake_minimum_required(VERSION 3.22.1)
project("ffmpegcpp")
#yg 引入库的头文件
INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/myLibs/include)
#yg 引入so库
add_library( avcodec-58 SHARED IMPORTED)
#TODO 设置编译的库文件存放的目录
set_target_properties( avcodec-58 PROPERTIES IMPORTED_LOCATION ${CMAKE_SOURCE_DIR}/myLibs/${ANDROID_ABI}/libavcodec-58.so)

add_library( avdevice-58 SHARED IMPORTED)
set_target_properties( avdevice-58 PROPERTIES IMPORTED_LOCATION ${CMAKE_SOURCE_DIR}/myLibs/${ANDROID_ABI}/libavdevice-58.so)

add_library( avfilter-7 SHARED IMPORTED)
set_target_properties( avfilter-7 PROPERTIES IMPORTED_LOCATION ${CMAKE_SOURCE_DIR}/myLibs/${ANDROID_ABI}/libavfilter-7.so)

add_library( avformat-58 SHARED IMPORTED)
set_target_properties( avformat-58 PROPERTIES IMPORTED_LOCATION ${CMAKE_SOURCE_DIR}/myLibs/${ANDROID_ABI}/libavformat-58.so)

add_library( avutil-56 SHARED IMPORTED)
set_target_properties( avutil-56 PROPERTIES IMPORTED_LOCATION ${CMAKE_SOURCE_DIR}/myLibs/${ANDROID_ABI}/libavutil-56.so)

add_library( postproc-55 SHARED IMPORTED)
set_target_properties( postproc-55 PROPERTIES IMPORTED_LOCATION ${CMAKE_SOURCE_DIR}/myLibs/${ANDROID_ABI}/libpostproc-55.so)

add_library( swresample-3 SHARED IMPORTED)
set_target_properties( swresample-3 PROPERTIES IMPORTED_LOCATION ${CMAKE_SOURCE_DIR}/myLibs/${ANDROID_ABI}/libswresample-3.so)

add_library( swscale-5 SHARED IMPORTED)
set_target_properties( swscale-5 PROPERTIES IMPORTED_LOCATION ${CMAKE_SOURCE_DIR}/myLibs/${ANDROID_ABI}/libswscale-5.so)

add_library(${CMAKE_PROJECT_NAME} SHARED
        # List C/C++ source files with relative paths to this CMakeLists.txt.
        cpp/native-lib.cpp)
target_link_libraries(${CMAKE_PROJECT_NAME}
        # List libraries link to the target library
        avcodec-58 avdevice-58 avfilter-7 avformat-58 avutil-56 postproc-55 swresample-3 swscale-5
        android
        log)
```

4、修改build.gradle文件，让其能够定位到这个库，在`defaultConfig`下加入以下内容(名字与so所在文件夹对应)：

```cmake
ndk{
    abiFilters "x86_64"
}
```

我这里还修改了CMakeLists.txt文件的位置，所以在build.gradle中也要修改一下；

5、在cpp下的native-lib.cpp中调用库函数，首先导入所用头文件：

```C++
extern "C" {
#include <libswresample/swresample.h>
#include <libavutil/imgutils.h>
#include <libavutil/samplefmt.h>
#include <libavutil/timestamp.h>
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>
#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"
};
```

6、然后先调用avcodec_configuration()这个方法测试库有没有成功链接，成功打印在控制台，表明通了，接下来编写主要代码播放视频；

7、首先编写布局文件，如下：

```xml
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:app="http://schemas.android.com/apk/res-auto"
        xmlns:tools="http://schemas.android.com/tools"
        android:orientation="vertical"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        tools:context=".MainActivity">
        <SurfaceView
            android:id="@+id/sfv_player"
            android:layout_width="match_parent"
            android:layout_height="300dp"/>
        <Button
            android:id="@+id/bt_play"
            android:text="播放"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"/>
    </LinearLayout>
```

8、接下来编写主函数（java），在其中绑定方法，如下：

MainActivity.java:

```java
static {
        System.loadLibrary("native-lib");
        System.loadLibrary("avcodec-58");
        System.loadLibrary("avdevice-58");
        System.loadLibrary("avfilter-7");
        System.loadLibrary("avformat-58");
        System.loadLibrary("avutil-56");
        System.loadLibrary("postproc-55");
        System.loadLibrary("swresample-3");
        System.loadLibrary("swscale-5");
    }
    private SurfaceView surfaceView;
    private Button button;
    private SurfaceHolder mHolder;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        surfaceView = findViewById(R.id.sfv_player);
        button = findViewById(R.id.bt_play);
        button.setOnClickListener(v->{
            copyAssetToFile(this, "test.mp4");
            File video = new File(getFilesDir(), "test.mp4");
            //子线程进行视频渲染
            new Thread(new Runnable() {
                @Override
                public void run() {
                    native_start_play(video.getAbsolutePath(),mHolder.getSurface());
                }
            }).start();
        });
        initSurfaceHolder();
    }
    private void copyAssetToFile(Context context, String fileName) {
        AssetManager assetManager = context.getAssets();
        try {
            InputStream inputStream = assetManager.open(fileName);
            File outFile = new File(context.getFilesDir(), fileName);
            FileOutputStream outputStream = new FileOutputStream(outFile);

            byte[] buffer = new byte[1024];
            int length;
            while ((length = inputStream.read(buffer)) > 0) {
                outputStream.write(buffer, 0, length);
            }

            inputStream.close();
            outputStream.close();
            Log.d("FileCopy", "文件已复制到：" + outFile.getAbsolutePath());
        } catch (IOException e) {
            Log.e("FileCopy", "无法复制文件：", e);
        }
    }
    private void initSurfaceHolder() {
        mHolder = surfaceView.getHolder();
        mHolder.setFormat(PixelFormat.RGBA_8888);
    }
    public native void native_start_play(String path, Surface surface);
```

9、在native-lib.cpp中编写解码视频的方法，如下：

```c++
extern "C"
JNIEXPORT void JNICALL
Java_com_example_ffmpegcpp_MainActivity_native_1start_1play(JNIEnv *env, jobject thiz, jstring path,
                                                            jobject surface) {
    ANativeWindow *a_native_window = ANativeWindow_fromSurface(env,surface);
    //转换视频路径字符串为C中可用的
    const char *video_path = env->GetStringUTFChars(path,0);
    //网络模块初始化（可以播放Url）
    avformat_network_init();
    //获取用于获取视频文件中各种流（视频流、音频流、字幕流等）的上下文：AVFormatContext
    AVFormatContext *av_format_context = avformat_alloc_context();
    //配置信息
    AVDictionary *options = NULL;
    av_dict_set(&options,"timeout","3000000",0);
    //打开视频文件
    //第一个参数：AVFormatContext的二级指针
    //第二个参数：视频路径
    //第三个参数：非NULL的话就是设置输入格式，NULL就是自动
    //第四个参数：配置项
    //返回值是是否打开成功，0是成功其他为失败
    int open_result = avformat_open_input(&av_format_context, video_path, NULL, &options);
    //如果打开失败就返回
    if(open_result){
        return;
    }
    //让FFmpeg将流解析出来,并找到视频流对应的索引
    avformat_find_stream_info(av_format_context, NULL);
    int video_stream_index = 0;
    for(int i = 0; i < av_format_context->nb_streams ; i++){
        //如果当前流是视频流的话保存索引
        if(av_format_context->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO){
            video_stream_index = i;
            break;
        }
    }
    //获取视频流的解码参数（宽高等信息）
    AVCodecParameters * av_codec_parameters = av_format_context->streams[video_stream_index]->codecpar;
    //获取视频流的解码器
    AVCodec *av_codec = avcodec_find_decoder(av_codec_parameters->codec_id);
    //获取解码上下文
    AVCodecContext * av_codec_context = avcodec_alloc_context3(av_codec);
    //将解码器参数复制到解码上下文(因为解码上下文目前还没有解码器参数)
    avcodec_parameters_to_context(av_codec_context,av_codec_parameters);
    //进行解码
    avcodec_open2(av_codec_context,av_codec,NULL);
    //因为YUV数据被封装在了AVPacket中，因此我们需要用AVPacket去获取数据
    AVPacket *av_packet = av_packet_alloc();
    //获取转换上下文（把解码后的YUV数据转换为RGB数据才能在屏幕上显示）
    SwsContext *sws_context = sws_getContext(av_codec_context->width,av_codec_context->height,av_codec_context->pix_fmt,
                                             av_codec_context->width,av_codec_context->height,AV_PIX_FMT_RGBA,SWS_BILINEAR,
                                             0,0,0);
    //设置NativeWindow绘制的缓冲区
    ANativeWindow_setBuffersGeometry(a_native_window,av_codec_context->width,av_codec_context->height,
                                     WINDOW_FORMAT_RGBA_8888);
    //绘制时，用于接收的缓冲区
    ANativeWindow_Buffer a_native_window_buffer;
    //计算出转换为RGB所需要的容器的大小
    //接收的容器
    uint8_t *dst_data[4];
    //每一行的首地址（R、G、B、A四行）
    int dst_line_size[4];
    //进行计算
    av_image_alloc(dst_data,dst_line_size,av_codec_context->width,av_codec_context->height,
                   AV_PIX_FMT_RGBA,1);
    //从视频流中读数据包，返回值小于0的时候表示读取完毕
    while (av_read_frame(av_format_context,av_packet) >= 0){
        //将取出的数据发送出来
        avcodec_send_packet(av_codec_context,av_packet);
        AVFrame *av_frame = av_frame_alloc();
        int av_receive_result = avcodec_receive_frame(av_codec_context,av_frame);
        if(av_receive_result == AVERROR(EAGAIN)){
            continue;
        } else if(av_receive_result < 0){
            break;
        }
        sws_scale(sws_context,av_frame->data,av_frame->linesize,0,av_frame->height,
                  dst_data,dst_line_size);
        ANativeWindow_lock(a_native_window,&a_native_window_buffer,0);
        uint8_t *first_window = static_cast<uint8_t *>(a_native_window_buffer.bits);
        uint8_t *src_data = dst_data[0];
        //拿到每行有多少个RGBA字节
        int dst_stride = a_native_window_buffer.stride * 4;
        int src_line_size = dst_line_size[0];
        //循环遍历所得到的缓冲区数据
        for(int i = 0; i < a_native_window_buffer.height;i++){
            //内存拷贝进行渲染
            memcpy(first_window+i*dst_stride,src_data+i*src_line_size,dst_stride);
        }
        //绘制完解锁
        ANativeWindow_unlockAndPost(a_native_window);
        //40000微秒之后解析下一帧(这个是根据视频的帧率来设置的，我这播放的视频帧率是25帧/秒)
        usleep(1000 * 40);
        //释放资源
        av_frame_free(&av_frame);
        av_free_packet(av_packet);
    }
    env->ReleaseStringUTFChars(path,video_path);
}
```

10、自此就可以正常播放了