本篇作为 Android 音视频实战系列的第二篇文章，主要介绍视频解码与渲染过程。本系列文章目录如下：

Android 音视频基础知识
Android 音视频播放器 Demo（一）—— 视频解码与渲染
Android 音视频播放器 Demo（二）—— 音频解码与音视频同步
RTMP 直播推流 Demo（一）——项目配置与视频预览
RTMP 直播推流 Demo（二）——音频推流与视频推流

1、项目概述

1.1 项目配置

FFmpeg 的交叉编译我们在前面介绍过，这里就不再赘述了，有需要可以去参考NDK 编译（二）—— NDK 编译与集成 FFmpeg。

这里主要介绍 FFmpeg 的环境配置，分三步：

1. FFmpeg 编译产物的静态库（6 个 .a 文件）复制到 libs/armeabi-v7a 下，include 文件夹复制到 src/main/cpp 目录下

2. 更改 app 模块下的 build.gradle 文件，添加 abiFilter 只编译 arm-v7a：

   android {
       defaultConfig {
           externalNativeBuild {
               cmake {
                   abiFilters 'armeabi-v7a'
               }
           }
           ndk {
               abiFilters 'armeabi-v7a'
           }
       }
   }
   

3. 修改 CMakeLists.txt：

   # 定义源文件
   file(GLOB sources *.cpp)
   
   # 定义 FFmpeg 路径
   set(FFMPEG ${CMAKE_SOURCE_DIR}/ffmpeg)
   
   # 导入 FFmpeg 头文件
   include_directories("${FFMPEG}/include")
   
   # 添加 FFmpeg 库文件路径到编译标记中
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -L${FFMPEG}/lib/${CMAKE_ANDROID_ARCH_ABI}")
   
   add_library(
           video-player
           SHARED
           ${sources})
   
   target_link_libraries(
           video-player
           # FFmpeg 源码编译出的 6 个静态库
           avcodec avfilter avformat avutil swresample swscale
           log
           z
           # 在 Native 进行视频渲染时要用到 ANativeWindow
           android
           # 在 Native 进行音频播放所需的库
           OpenSLES)
   

在 cmake 块中的 abiFilters 用于指定 CMake 构建系统编译和构建的 ABI。例如，如果在 abiFilters 中设置为 “armeabi-v7a”，则 CMake 将只为 armeabi-v7a 架构编译和构建本机代码。


类似地，在 ndk 块中的 abiFilters 用于指定 NDK 构建系统编译和构建的 ABI。如果在 abiFilters 中设置为 “armeabi-v7a”，则 NDK 将只为 armeabi-v7a 架构编译和构建本机代码。

1.2 Demo 结构

视频播放器 Demo 可以分为上下两层：

1. 上层：主要是 UI 方面的，提供 SurfaceView 进行视频渲染。此外，还需要根据生命周期调用 Native 方法控制底层的播放
2. Native 层：Native 层接收上层发来的播放指令，还需要通过 CallbackHelper 通知上层播放状态。此外，Native 层需要抽离出一个控制层，对音视频解码线程进行控制，接收解码的数据后要渲染到屏幕/麦克风上

Native 控制层示意图如下：

控制层的主要作用：

• 初始化 FFmpeg 参数
• 控制播放进度（播放、停止、控制播放速度等）
• 从视频文件（视频流）中解析出 AVPacket 存入视频/音频队列

可以看到音视频各有一个保存 AVPacket 的队列，由于 AVPacket 是压缩数据，我们需要从队列中取出 AVPacket 解压为 AVFrame 再存入队列，因此 AVFrame 也是有一个队列的：

视频层作用：

• 不断地从 Packet 队列中取出 AVPacket 解压为 AVFrame 后存入 AVFrame 队列。这是通过死循环进行的耗时操作，因此需要放入特定的解压线程中操作
• 不断地从 AVFrame 队列中取出 AVFrame 放入播放线程的 buffer 中，最终要回到控制层将 AVFrame 渲染到屏幕上

音频层类似：

解压后的音频数据通过 OpenSLES 进行播放。

AudioTrack 底层实际上也是使用的 OpenSLES。

最后来介绍一下实现步骤：

1. 准备阶段：
   • 实现 Native 反射调用上层的机制 JNICallbackHelper
   • 初始化 FFmpeg 解码器
2. 视频解码：
   • 创建一个同步队列 SafeQueue 用于承载 AVPacket 和 AVFrame 数据
   • 创建专门处理视频解码工作的通道 VideoChannel，读取 AVPacket 并解码为 AVFrame
3. 视频渲染：
   • 将上层 SurfaceView 的 Surface 传给 Native 控制层，设置好 Native 层的窗口对象 ANativeWindow
   • 将 VideoChannel 解码后的帧数据回调给 Native 控制层，渲染在 ANativeWindow 上
4. 音频解码与渲染：
   • 创建专门处理音频解码工作的通道 AudioChannel 进行音频解码，具体方式与视频解码几乎一致
   • 将解码后的音频数据交给 OpenSLES 进行播放
   • 创建一个通道的基类 BaseChannel 用于定义视频通道 VideoChannel 和音频通道 AudioChannel 的共同操作
5. 音视频同步
6. 添加进度条与播放时间

2、准备阶段

准备阶段的主要工作是打开 FFmpeg 的解码器。在这个过程中，我们需要建立 Native 回调上层方法的机制 JNICallbackHelper，这样 Native 才能将播放器的准备状态、播放状态通知给上层。

2.1 代码框架

简单说一下代码结构：

• Activity 布局主要有一个负责渲染视频的 SurfaceView 和控制播放进度的 SeekBar，对视频的控制都通过 VideoPlayer 类完成
• VideoPlayer 是上层与 Native 交互的桥梁，定义了很多控制播放的 Native 方法，此外还有 Native 为了通知播放器状态要回调的方法
• Native 层的入口在 native-lib，负责创建 Native 层的 VideoPlayer 并将上层的请求转交给它
• Native 的 VideoPlayer 负责 FFmpeg 解码器的创建以及相关操作，还要把视频流和音频流交给对应的通道进行解码处理

还是先从 Activity 开始，布局如下：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context=".MainActivity">

    <SurfaceView
        android:id="@+id/surfaceView"
        android:layout_width="match_parent"
        android:layout_height="200dp" />

    <!-- 进度条 -->
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="30dp"
        android:layout_margin="5dp">

        <TextView
            android:id="@+id/tv_time"
            android:layout_width="wrap_content"
            android:layout_height="match_parent"
            android:gravity="center"
            android:text="@string/init_time"
            android:visibility="gone" />

        <SeekBar
            android:id="@+id/seekBar"
            android:layout_width="0dp"
            android:layout_height="match_parent"
            android:layout_weight="1"
            android:max="100"
            android:visibility="gone" />
    </LinearLayout>
</LinearLayout>

代码端命令 VideoPlayer 执行准备工作：

class MainActivity : AppCompatActivity() {

    private lateinit var binding: ActivityMainBinding
    private lateinit var videoPlayer: VideoPlayer

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 设置屏幕常亮
        window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)

        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)

        checkPermissionAndFile()

        videoPlayer = VideoPlayer()
        videoPlayer.setOnPreparedListener(object : VideoPlayer.OnPreparedListener {
            override fun onPrepared() {
                runOnUiThread {
                    Toast.makeText(this@MainActivity, "准备就绪", Toast.LENGTH_LONG).show()
                }
            }
        })
        videoPlayer.setOnErrorListener(object : VideoPlayer.OnErrorListener {
            override fun onError(errorMsg: String) {
                runOnUiThread {
                    Toast.makeText(this@MainActivity, errorMsg, Toast.LENGTH_LONG).show()
                }
            }
        })
        // 准备工作
        videoPlayer.prepare(file_path)
    }
}

VideoPlayer 将准备工作转交给 Native 层，同时还为外界提供了播放器准备就绪的监听器 OnPreparedListener 和发生错误的监听器 OnErrorListener：

class VideoPlayer {

    private lateinit var surfaceHolder: SurfaceHolder
    private var onPreparedListener: OnPreparedListener? = null
    private var onErrorListener: OnErrorListener? = null

    fun setSurfaceHolder(surfaceHolder: SurfaceHolder) {
        this.surfaceHolder = surfaceHolder
    }

    /**
     * 准备工作，让 Native 层对解码器进行初始化
     */
    fun prepare(dataSource: String) {
        nativePrepare(dataSource)
    }

    /**
     * 供 Native 回调上层通知解码器准备就绪的方法
     */
    fun onPrepared() {
        onPreparedListener?.onPrepared()
    }

    /**
     * 供 Native 回调上层通知解码器初始化发生错误的方法
     */
    fun onError(errorCode: Int) {
        onErrorListener?.onError(getMsgFromCode(errorCode))
    }

    private fun getMsgFromCode(errorCode: Int): String = when (errorCode) {
        Constants.FFMPEG_CAN_NOT_OPEN_URL -> "打不开视频"
        Constants.FFMPEG_CAN_NOT_FIND_STREAMS -> "找不到流媒体"
        Constants.FFMPEG_FIND_DECODER_FAIL -> "找不到解码器"
        Constants.FFMPEG_ALLOC_CODEC_CONTEXT_FAIL -> "无法根据解码器创建上下文"
        Constants.FFMPEG_CODEC_CONTEXT_PARAMETERS_FAIL -> "根据流信息配置上下文参数失败"
        Constants.FFMPEG_OPEN_DECODER_FAIL -> "打开解码器失败"
        Constants.FFMPEG_NO_MEDIA -> "没有音视频"
        else -> "未知错误"
    }

    fun setOnPreparedListener(onPreparedListener: OnPreparedListener) {
        this.onPreparedListener = onPreparedListener
    }

    fun setOnErrorListener(onErrorListener: OnErrorListener) {
        this.onErrorListener = onErrorListener
    }

    private external fun nativePrepare(dataSource: String)

    interface OnPreparedListener {
        fun onPrepared()
    }

    interface OnErrorListener {
        fun onError(errorMsg: String)
    }
}

在 Native 层的入口，也是控制层 native-lib.cpp 中创建 nativePrepare() 对应的 Native 函数：

extern "C"
JNIEXPORT void JNICALL
Java_com_video_player_VideoPlayer_nativePrepare(JNIEnv *env, jobject thiz, jstring data_source) {
    // 创建 Native 层的 VideoPlayer 并将准备工作交给它
}

VideoPlayer 执行准备工作时需要将结果通知给上层，因此到这里我们先来看 JNICallbackHelper 的实现。

2.2 JNICallbackHelper

JNICallbackHelper 是一个在 Native 层调用上层方法的帮助类，在进行解码器初始化时需要通过它告知上层解码器的初始化状态。

首先我们要了解，Native 如何调用上层方法。实际上跟 Java/Kotlin 反射类似：

• 获取到上层方法所在的类对象 jclass
• 根据上层方法的名字和签名，获取该方法的 jmethodID
• 调用 JNI 提供的函数 JNIEnv->CallVoidMethod(jclass,jmethodID,methodArgs) 就可调用上层方法了

在上层的 VideoPlayer 中提供了 onPrepared() 和 onError() 供 Native 通知解码器初始化完成或者发生了错误：

class VideoPlayer {
    /**
     * 供 Native 回调上层通知解码器准备就绪的方法
     */
    fun onPrepared() {
        onPreparedListener?.onPrepared()
    }

    /**
     * 供 Native 回调上层通知解码器初始化发生错误的方法
     */
    fun onError(errorCode: Int) {
        onErrorListener?.onError(getMsgFromCode(errorCode))
    }
}

为了帮助 Native 回调 onPrepared() 和 onError()，JNICallbackHelper 可以这样实现：

JNICallbackHelper::JNICallbackHelper(JavaVM *jvm, JNIEnv *jEnv, jobject jObj) {
    javaVM = jvm;
    jniEnv = jEnv;
    // jobject 默认作用域就在当前函数内，不能跨越线程和函数，必须声明为全局引用才可以
    jObject = jEnv->NewGlobalRef(jObj);
    // 反射获取上层方法对象需要方法所在的类对象
    jclass clazz = jEnv->GetObjectClass(jObject);
    // 获取要反射的方法 ID，实际上是拿到了方法的 ArtMethod 结构体
    onPreparedId = jEnv->GetMethodID(clazz, "onPrepared", "()V");
    onErrorId = jEnv->GetMethodID(clazz, "onError", "(I)V");
}

/**
 * 释放成员，从作用域小的开始释放
 */
JNICallbackHelper::~JNICallbackHelper() {
    if (jObject) {
        jniEnv->DeleteGlobalRef(jObject);
        jObject = nullptr;
    }

    if (jniEnv) {
        delete jniEnv;
        jniEnv = nullptr;
    }

    if (javaVM) {
        delete javaVM;
        javaVM = nullptr;
    }
}

/**
 * 回调上层的 onPrepared()，通知 Native 这边已经完成了
 * 解码器初始化
 */
void JNICallbackHelper::onPrepared(int thread_mode) {
    if (thread_mode == MAIN_THREAD) {
        // 在主线程中，可以直接使用主线程的 JNIEnv 调用上层方法
        jniEnv->CallVoidMethod(jObject, onPreparedId);
    } else {
        // 在子线程中，需要先获取子线程的 JNIEnv 再调用上层方法
        JNIEnv *childEnv;
        javaVM->AttachCurrentThread(&childEnv, nullptr);
        childEnv->CallVoidMethod(jObject, onPreparedId);
        javaVM->DetachCurrentThread();
    }
}

/**
 * 回调上侧的 onError()，通知上层在初始化解码器时发生了错误
 * @param thread_mode 运行在主线程还是子线程中
 * @param error_code 错误码，上层根据不同的错误码返回响应的提示
 */
void JNICallbackHelper::onError(int thread_mode, int error_code) {
    if (thread_mode == MAIN_THREAD) {
        // 在主线程中，可以直接使用主线程的 JNIEnv 调用上层方法
        jniEnv->CallVoidMethod(jObject, onErrorId, error_code);
    } else {
        // 在子线程中，需要先获取子线程的 JNIEnv 再调用上层方法
        JNIEnv *childEnv;
        javaVM->AttachCurrentThread(&childEnv, nullptr);
        childEnv->CallVoidMethod(jObject, onErrorId, error_code);
        javaVM->DetachCurrentThread();
    }
}

你能看到在 onPrepared() 和 onError() 会对所在线程加以区分，这是因为，初始化解码器是耗时操作要放在子线程中执行，而 JNIEnv 是与线程绑定的，不同线程的 JNIEnv 不同，因此在子线程中执行时，需要切换到子线程的 JNIEnv 再执行 CallVoidMethod()。

类似的情况还有 jobject，它不仅不能跨越线程，还不能跨越函数，因此在 JNICallbackHelper 的构造函数中，是将其声明为全局变量后才保存到成员变量中；而 JavaVM 作为全局唯一的表示虚拟机对象的变量，它的作用域最大，可以跨越线程，需要通过固定函数获取它：

JavaVM *javaVm = nullptr;

/**
 * 获取全局的 JavaVm
 */
jint JNI_OnLoad(JavaVM *jvm, void *args) {
    javaVm = jvm;
    return JNI_VERSION_1_6;
}

有了它我们就可以在 native-lib 中创建 JNICallbackHelper 对象，然后在初始化解码器时使用它。

2.3 初始化解码器

上层的 VideoPlayer 提供 prepare() 供外界发出初始化解码器的请求，然后通过 Native 方法把这个请求转发到 Native 层：

	/**
     * 准备工作，让 Native 层对解码器进行初始化
     */
    fun prepare(dataSource: String) {
        nativePrepare(dataSource)
    }

	private external fun nativePrepare(dataSource: String)

native-lib 接收到请求，要创建 Native 层的 VideoPlayer 并让它来初始化解码器：

extern "C"
JNIEXPORT void JNICALL
Java_com_video_player_VideoPlayer_nativePrepare(JNIEnv *env, jobject thiz, jstring data_source) {
    const char *dataSource = env->GetStringUTFChars(data_source, nullptr);
    auto jniCallbackHelper = new JNICallbackHelper(javaVm, env, thiz);
    // 当前 VideoPlayer 需要数据源以及回调帮助对象
    videoPlayer = new VideoPlayer(dataSource, jniCallbackHelper);
    videoPlayer->prepare();
    env->ReleaseStringUTFChars(data_source, dataSource);
}

VideoPlayer 初始化时要对数据源进行深拷贝：

VideoPlayer::VideoPlayer(const char *data_source, JNICallbackHelper *helper) {
    // 由于参数传入的 data_source 指针在调用完当前构造函数后会被回收，
    // 为了避免 dataSource 成为悬空指针，需要对 data_source 进行深拷贝，
    // 声明 char 数组时不要忘记为 \0 预留出一个字节的空间
    dataSource = new char[strlen(data_source) + 1];
    strcpy(dataSource, data_source);

    jniCallbackHelper = helper;
}

由于初始化解码器是一个耗时操作，不能放在主线程中进行，因此我们开辟一个子线程进行准备工作：

/**
 * 我们在 Activity 的主线程中开启准备工作，因此 prepare()
 * 是在主线程中运行的，该函数的任务是解析数据源，不论是本地文件
 * 还是网络地址，解析过程都是耗时操作，因此要放在子线程中进行
 */
void VideoPlayer::prepare() {
    pthread_create(&pid_prepare, nullptr, task_prepare, this);
}

线程的任务并没有直接开始初始化解码器，因为线程环境访问不到数据源，还是要在 VideoPlayer 的成员函数中进行：

void *task_prepare(void *args) {
    // 因为我们现在是在子线程环境中，不是 VideoPlayer 的成员函数，不能
    // 直接访问 dataSource，因此绕一圈，在新的成员函数中做具体的准备工作
    auto videoPlayer = static_cast<VideoPlayer *>(args);
    videoPlayer->prepareInChildThread();
    // 线程的任务函数一定要返回 nullptr，否则运行会崩溃
    return nullptr;
}

调用 FFmpeg 的 API 去初始化解码器需要按照固定的步骤，已经在注释中用标号给出。解码器初始化完毕后，就要查找媒体流，如果找到了音视频流就创建对应的通道分开处理：

/**
 * 在子线程中做具体的准备工作，初始化解码器
 */
void VideoPlayer::prepareInChildThread() {
    /*
     * 1.打开数据源
     */
    // 总上下文
    AVFormatContext *avFormatContext = avformat_alloc_context();
    // 字典，可以以键值对形式添加参数
    AVDictionary *avDictionary = nullptr;
    // 设置超时时间为 3 秒
    av_dict_set(&avDictionary, "timeout", "3000000", 0);
    // 打开视频数据源，成功则返回 0
    int result = avformat_open_input(&avFormatContext, dataSource, nullptr, &avDictionary);
    // 及时回收用完的变量
    av_dict_free(&avDictionary);
    // 打开失败的话要通知上层
    if (result) {
        if (jniCallbackHelper) {
            jniCallbackHelper->onError(CHILD_THREAD, FFMPEG_CAN_NOT_OPEN_URL);
        }
        // 打开失败需要回收上下文
        avformat_close_input(&avFormatContext);
        LOGE("无法打开数据源");
        return;
    }

    /*
     * 2.查找媒体中的音视频流信息存入 AVFormatContext
     */
    result = avformat_find_stream_info(avFormatContext, nullptr);
    if (result < 0) {
        if (jniCallbackHelper) {
            jniCallbackHelper->onError(CHILD_THREAD, FFMPEG_CAN_NOT_FIND_STREAMS);
        }
        avformat_close_input(&avFormatContext);
        // 实际上 FFmpeg 也提供了根据错误码转换成字符串的函数
        char *errorMsg = av_err2str(result);
        LOGE("%s", errorMsg);
        return;
    }

    // 获取视频的时长信息
    // avformat_find_stream_info() 会去尝试获取所有视频格式的总时长，
    // 因此在它之后使用 mAVFormatContext->duration 才更加合适，如果在
    // 它之前使用，则可以获取 mp4 格式的时长，但无法获取 flv 等格式的
    int duration = avFormatContext->duration / AV_TIME_BASE;

    /*
     * 3.打开解码器，对音视频流分别创建对应的处理通道
     */
    // 编解码器上下文
    AVCodecContext *avCodecContext = nullptr;
    for (int i = 0; i < avFormatContext->nb_streams; ++i) {
        // 3.1 根据媒体流的信息获取相应的解码器，流的类型可能是音频、视频、字幕
        AVStream *stream = avFormatContext->streams[i];
        // 获取这个流的编解码参数
        AVCodecParameters *codecParameters = stream->codecpar;
        // 根据参数获取对应的解码器
        AVCodec *codec = avcodec_find_decoder(codecParameters->codec_id);
        if (!codec) {
            if (jniCallbackHelper) {
                jniCallbackHelper->onError(CHILD_THREAD, FFMPEG_FIND_DECODER_FAIL);
            }
            avformat_close_input(&avFormatContext);
            LOGE("获取解码器失败");
            return;
        }

        // 3.2 有了解码器才能获取解码器上下文
        avCodecContext = avcodec_alloc_context3(codec);
        if (!avCodecContext) {
            if (jniCallbackHelper) {
                jniCallbackHelper->onError(CHILD_THREAD, FFMPEG_ALLOC_CODEC_CONTEXT_FAIL);
            }
            // 从这开始比之前多释放一个解码器上下文 AVCodecContext，它会同时帮你释放解码器 AVCodec
            avcodec_free_context(&avCodecContext);
            avformat_close_input(&avFormatContext);
            LOGE("获取解码器上下文失败");
            return;
        }

        // 3.3 根据解码器上下文参数填充解码器上下文 AVCodecContext
        result = avcodec_parameters_to_context(avCodecContext, codecParameters);
        if (result < 0) {
            if (jniCallbackHelper) {
                jniCallbackHelper->onError(CHILD_THREAD, FFMPEG_CODEC_CONTEXT_PARAMETERS_FAIL);
            }
            avcodec_free_context(&avCodecContext);
            avformat_close_input(&avFormatContext);
            LOGE("设置解码器上下文失败");
            return;
        }

        // 3.4 打开解码器
        result = avcodec_open2(avCodecContext, codec, nullptr);
        if (result < 0) {
            if (jniCallbackHelper) {
                jniCallbackHelper->onError(CHILD_THREAD, FFMPEG_OPEN_DECODER_FAIL);
            }
            avcodec_free_context(&avCodecContext);
            avformat_close_input(&avFormatContext);
            LOGD("打开解码器失败");
            return;
        }

        // 3.5 根据媒体流的类型创建对应的处理通道
        if (codecParameters->codec_type == AVMEDIA_TYPE_VIDEO) {
            // 有的视频类型只有一帧封面图片，这种情况需要跳过
            if (stream->disposition & AV_DISPOSITION_ATTACHED_PIC) {
                continue;
            }
            // 创建视频通道
            videoChannel = new VideoChannel;
        } else if (codecParameters->codec_type == AVMEDIA_TYPE_AUDIO) {
            // 创建音频通道
            audioChannel = new AudioChannel;
        } else if (codecParameters->codec_type == AVMEDIA_TYPE_SUBTITLE) {
            // 创建字幕通道...省略
        }
    }

    // 3.6 健壮性校验
    if (!videoChannel && !audioChannel) {
        if (jniCallbackHelper) {
            jniCallbackHelper->onError(CHILD_THREAD, FFMPEG_NO_MEDIA);
        }
        if (avCodecContext) {
            avcodec_free_context(&avCodecContext);
        }
        avformat_close_input(&avFormatContext);
        LOGE("媒体文件没有音视频流");
        return;
    }

    /*
     * 4.回调上层方法，通知准备就绪
     */
    if (jniCallbackHelper) {
        jniCallbackHelper->onPrepared(CHILD_THREAD);
        LOGD("准备完成");
    }
}

到这里解码器初始化就完成了。

3、视频解码

在 1.2 节介绍 Demo 结构时我们放了一张图，就是要从视频文件中不断读取 AVPacket 然后存放到 AVPacket 队列中。解码时不断地从 AVPacket 队列中取出 AVPacket 解码为 AVFrame 再存入 AVFrame 的队列。

由于上述两步都是循环的耗时操作，因此要放在子线程中操作。由于是在多线程环境中，因此保存 AVPacket 与 AVFrame 的队列需要是一个线程安全的队列，我们首先来实现这个队列。

3.1 SafeQueue

SafeQueue 这个队列主要存放 AVPacket 和 AVFrame，因此将其设计为模板类。此外，由于释放队列元素的具体方法在 SafeQueue 内部是无法知晓的，只能通过回调接口，将释放元素的操作交给知道具体类型的对象如何释放的外部代码。参考代码如下：

/**
 * 线程安全队列，主要用于存放 AVFrame 和 AVPacket
 * 除了线程锁之外，还有两点需要注意：
 * 1. 由于使用泛型，需要释放队列元素时不知道具体类型该如何
 * 释放，因此需要通过 ReleaseCallback 回调给外部释放
 * 2.队列通过 enable 控制是否工作。比如存入元素时，如果
 * 队列不工作，那么需要丢弃并回收该元素
 *
 * 此外，还需注意，模板类的实现需要和头文件包含在同一个文件中，
 * 以便在编译时能够正确实例化模板类的具体类型。因此实现也放在
 * 头文件中，而没有分离到 cpp 文件中
 */
template<class T>
class SafeQueue {

    // 释放 T 的回调类型，因为 SafeQueue 内部不知道 T 的具体类型，
    // 也就不知道具体的释放方式
    typedef void (*ReleaseCallback)(T *value);

private:
    std::queue<T> queue;
    pthread_mutex_t mutex;
    pthread_cond_t cond;
    bool enabled = false;
    ReleaseCallback releaseCallback;

public:
    SafeQueue() {
        pthread_mutex_init(&mutex, nullptr);
        pthread_cond_init(&cond, nullptr);
    }

    ~SafeQueue() {
        pthread_mutex_destroy(&mutex);
        pthread_cond_destroy(&cond);
    }

    void setEnable(bool enable) {
        this->enabled = enable;
    }

    /**
    * 向队列中存入元素，如果队列不在工作状态，就要丢弃该元素
    */
    void put(T value) {
        pthread_mutex_lock(&mutex);
        if (enabled) {
            queue.push(value);
            pthread_cond_signal(&cond);
        } else {
            if (releaseCallback) {
                releaseCallback(&value);
            }
        }
        pthread_mutex_unlock(&mutex);
    }

    /**
    * 获取元素，成功则返回 true。
    * 参数是一个入参出参，采用引用形式，避免了参数的复制，
    * 将元素赋给形参就会直接给到实参
    */
    bool get(T &value) {
        bool success = false;
        pthread_mutex_lock(&mutex);
        // 阻塞函数，如果队列中没有元素就等着
        while (enabled && queue.empty()) {
            pthread_cond_wait(&cond, &mutex);
        }

        if (!queue.empty()) {
            value = queue.front();
            queue.pop();
            success = true;
        }
        pthread_mutex_unlock(&mutex);
        return success;
    }

    void clear() {
        pthread_mutex_lock(&mutex);
        while (!queue.empty()) {
            T value = queue.front();
            if (releaseCallback) {
                releaseCallback(&value);
            }
            queue.pop();
        }
        pthread_mutex_unlock(&mutex);
    }

    /**
    * 因为函数指针不包含 this 指针，因此带有隐藏的 this 指针的成员函数无法直接转换
    * 为函数指针。而静态函数不依赖于特定对象也没有 this 指针，它可以直接转换为函数
    * 指针。因此，方法参数可以传静态函数，而不能传成员函数，否则会报 "Reference to
    * non-static member function must be called" 的错误
    */
    void setReleaseCallback(ReleaseCallback callback) {
        releaseCallback = callback;
    }

    bool isEmpty() {
        return queue.empty();
    }

    int size() {
        return queue.size();
    }
};

当然，这不是 SafeQueue 的最终形态，因为后续在做音视频同步需要丢包时，还要向 SafeQueue 中添加丢包的操作逻辑。

3.2 BaseChannel

由于 VideoChannel 和 AudioChannel 会有很多类似的操作以及属性，因此我们考虑抽取出 BaseChannel 作为它们的父类：

class BaseChannel {

public:
    BaseChannel(int stream_index, AVCodecContext *codecContext);

    virtual ~BaseChannel();

    static void releaseAVPacket(AVPacket **packet);

    static void releaseAVFrame(AVFrame **frame);

    // 解码器上下文
    AVCodecContext *avCodecContext;
    // 是否在播放中
    bool isPlaying;
    // 媒体流对应的索引
    int stream_index;
    // 压缩数据 AVPacket 队列
    SafeQueue<AVPacket *> packets;
    // 解压后数据 AVFrame 队列
    SafeQueue<AVFrame *> frames;
};

成员函数的实现如下：

BaseChannel::BaseChannel(int stream_index, AVCodecContext *avCodecContext) :
        stream_index(stream_index), avCodecContext(avCodecContext) {
    // 设置释放 AVPacket 和 AVFrame 的函数
    packets.setReleaseCallback(releaseAVPacket);
    frames.setReleaseCallback(releaseAVFrame);
}

BaseChannel::~BaseChannel() {
    packets.clear();
    frames.clear();
}

void BaseChannel::releaseAVPacket(AVPacket **packet) {
    if (*packet) {
        av_packet_free(packet);
        *packet = nullptr;
    }
}

void BaseChannel::releaseAVFrame(AVFrame **frame) {
    if (*frame) {
        av_frame_free(frame);
        *frame = nullptr;
    }
}

VideoChannel 继承 BaseChannel，做出相应修改：

class VideoChannel : public BaseChannel {
    ...
}

源文件需要修改构造函数：

VideoChannel::VideoChannel(int stream_index, AVCodecContext *avCodecContext)
        : BaseChannel(stream_index, avCodecContext) {

}

AudioChannel 也是类似的修改。当然，这不是 BaseChannel 的最终形态，后续还会添加功能。

是否对 BaseChannel 的 releaseAVPacket() 和 releaseAVFrame() 两个成员函数声明为 static 有所疑问？因为 SafeQueue.setReleaseCallback() 的参数是函数指针，因此参数必须是或者可以转为函数指针。由于函数指针没有 this，而成员函数是有隐藏 this 的，所以成员函数不能直接转换为函数指针。只能是静态函数、全局函数或 C++11 以上的 Lambda 表达式可以转换，我们就使用了静态函数的方案。

3.3 解码

之前我们完成了解码器的初始化，因为我们设置了 Native 对上层的回调，在准备就绪后会通知上层的 VideoPlayer，我们的解码工作就从这里开始：

	override fun onCreate(savedInstanceState: Bundle?) {
        ...
        videoPlayer.setOnPreparedListener(object : VideoPlayer.OnPreparedListener {
            override fun onPrepared() {
                runOnUiThread {
                    Toast.makeText(this@MainActivity, "准备就绪", Toast.LENGTH_LONG).show()
                }
                // 开始解码
                videoPlayer.start()
            }
        })
        ...
    }

VideoPlayer 直接交给 Native 层处理：

	fun start() {
        nativeStart()
    }

	private external fun nativeStart()

native-lib 将请求转发给底层的 VideoPlayer：

extern "C"
JNIEXPORT void JNICALL
Java_com_video_player_VideoPlayer_nativeStart(JNIEnv *env, jobject thiz) {
    videoPlayer->start();
}

解码的操作包含两部分：

1. 首先从媒体流中读取出 AVPacket，既可能是音频，也可能是视频，区分类型后存入相应通道的 AVPacket 队列中
2. 从 AVPacket 队列中取出 AVPacket 解码为 AVFrame 存入队列

很明显，由于第一步需要区分音视频，因此它应该在 VideoPlayer 内进行，而第二步则在各自通道内进行。那么 VideoPlayer 的 start() 就需要开启子线程执行第一步，驱动 VideoChannel 执行第二步：

void VideoPlayer::start() {
    isPlaying = true;

    if (videoChannel) {
        videoChannel->start();
    }

    pthread_create(&pid_start, nullptr, task_start, this);
}

读取 AVPacket

读取 AVPacket 是一个耗时操作，所以要放在子线程中。在 task_start() 内将具体操作交给 VideoPlayer 的 startInChildThread() 以便访问成员变量：

void *task_start(void *args) {
    auto videoPlayer = static_cast<VideoPlayer *>(args);
    videoPlayer->startInChildThread();
    return nullptr;
}

/**
 * 解码器从媒体流中读取出 AVPacket 存入对应通道的 AVPacket 队列中
 */
void VideoPlayer::startInChildThread() {
    int result;
    while (isPlaying) {
        // 因为将 AVPacket 存入队列的速度远远快于取出 AVPacket 解码的速度，
        // 因此需要添加速度控制以防队列体积过大而撑爆内存
        if (videoChannel && videoChannel->packets.size() > 100) {
            // 休眠 10 毫秒
            av_usleep(10 * 1000);
            continue;
        }
        if (audioChannel && audioChannel->packets.size() > 100) {
            av_usleep(10 * 1000);
            continue;
        }
        // 不要想着将 packet 拿到 while 外面复用，因为在当前方法只会将其存入
        // AVPacket 队列，在 Channel 那边取出 AVPacket 使用完并释放之前就
        // 复用，会导致 Channel 那边解码失败
        AVPacket *packet = av_packet_alloc();
        // 读取一帧，AVPacket 可能是视频帧，也可能是音频帧，加以区分后存入相应的队列中
        result = av_read_frame(avFormatContext, packet);
        if (!result) {
            // 读取成功，将其加入相应通道的队列中
            if (videoChannel && videoChannel->stream_index == packet->stream_index) {
                videoChannel->packets.put(packet);
            } else if (audioChannel && audioChannel->stream_index == packet->stream_index) {
                audioChannel->packets.put(packet);
            }
        } else if (result == AVERROR_EOF) {
            // 如果读取到文件末尾了，那就等音视频通道的 AVPacket 队列都为空后再跳出循环结束播放
            if (videoChannel && videoChannel->packets.isEmpty() &&
                audioChannel && audioChannel->packets.isEmpty()) {
                break;
            }
        } else {
            // 其他情况就是读取错误，直接结束循环
            break;
        }
    }

    // 结束播放
    isPlaying = false;
    if (videoChannel) {
        videoChannel->stop();
    }

    if (audioChannel) {
        audioChannel->stop();
    }
}

整个过程的核心 API 就是先用 av_packet_alloc() 创建一个 AVPacket 对象再传入 av_read_frame() 读取出 AVPacket 的内容。

此外，需要注意的是，由于 SafeQueue 内没有进行容量限制，并且 AVPacket 的入队速度远远快于出队速度，因此需要进行速度控制以免内存爆炸。如果不添加速度控制，在播放长一点的视频时，程序会崩溃。

将 AVPacket 解码为 AVFrame

VideoChannel 的 start() 会启动两个线程，一个负责将 AVPacket 解码为 AVFrame，一个负责取出 AVFrame 的像素数据回调给控制层进行屏幕渲染：

void VideoChannel::start() {
    // 是否在解码和渲染过程中
    isPlaying = true;
    // 开启两个队列
    packets.setEnable(true);
    frames.setEnable(true);
    // 开启解码和渲染线程
    pthread_create(&pid_decode, nullptr, task_decode, this);
    pthread_create(&pid_play, nullptr, task_play, this);
}

这一节我们只看解码线程。主要步骤是：

1. 从 AVPacket 队列中不断取出 AVPacket，先通过 avcodec_send_packet() 将其发送给解码器
2. 通过 av_frame_alloc() 创建一个 AVFrame，再通过 avcodec_receive_frame() 读取到解码后的 AVFrame
3. 将 AVFrame 存入队列，通过 av_packet_unref() 将 AVFrame 的引用计数减 1，最后回收 AVFrame

void *task_decode(void *args) {
    auto videoChannel = static_cast<VideoChannel *>(args);
    videoChannel->decode();
    return nullptr;
}

/**
 * 解码就是从 AVPacket 队列中的 AVPacket 解码
 * 为 AVFrame 再存入 AVFrame 队列中
 */
void VideoChannel::decode() {
    // 由于从队列中取出的 AVPacket 在使用完后直接
    // 就释放了，因此可以放在 while 外复用
    AVPacket *packet = nullptr;
    int result;
    while (isPlaying) {
        // 由于解码速度要快于音视频的渲染/播放速度，因此需要控制
        // frames 队列的入队速度，以防队列过大而撑爆内存
        if (isPlaying && frames.size() > 100) {
            av_usleep(10 * 1000);
            continue;
        }
        // 从队列中取出一个 AVPacket
        result = packets.get(packet);

        // 如果此时已经设置停止播放，则跳出循环
        if (!isPlaying) {
            break;
        }
        // 如果取 AVPacket 失败，可能是因为队列中尚未有
        // AVPacket，继续循环等待 AVPacket 被读取到队列中
        if (!result) {
            continue;
        }

        // 将 AVPacket 发送给解码器
        result = avcodec_send_packet(avCodecContext, packet);
        if (result != 0) {
            break;
        }

        // 从解码器中获取解码后的 AVFrame 存入 frames 队列中，av_frame_alloc()
        // 会在堆区开辟内存空间，使用完毕需要回收
        AVFrame *frame = av_frame_alloc();
        result = avcodec_receive_frame(avCodecContext, frame);
        LOGD("解码结果：%d", result);
        if (!result) {
            frames.put(frame);
            // 每当调用 av_read_frame() 时就会对相应的 AVPacket 引用计数加一，
            // 对 AVPacket 的 *data 指向的内存区域的引用计数减 1，减到 0 时会回收
            av_packet_unref(packet);
            // 回收 AVPacket 指针本身
            releaseAVPacket(&packet);
        } else if (result == AVERROR(EAGAIN)) {
            continue;
        } else {
            // 解码失败，但是 AVFrame 有值，需要释放
            if (frame) {
                releaseAVFrame(&frame);
            }
            break;
        }
        LOGD("解码，mFrames 中完成解码的帧数：%d", frames.size());
    }
    // 对于从 while 循环 break 出来的情况还要再回收一次 AVPacket
    av_packet_unref(packet);
    releaseAVPacket(&packet);
}

这样解码就完成了。

4、视频渲染

视频渲染要从两个方向上看：

• 一方面，从上至下，我们要将上层的 SurfaceView 传递给 Native 层的 native-lib，因为我们要在 Native 层进行渲染
• 另一方面，从下至上，解码后的 AVFrame 队列保存在 VideoChannel 中，而渲染屏幕的对象在 native-lib 中，需要将 AVFrame 回调给 native-lib

4.1 窗口设置

在 Activity 中将 SurfaceHolder 传递给 VideoPlayer：

	override fun onCreate(savedInstanceState: Bundle?) {
        ...
        videoPlayer.setSurfaceHolder(binding.surfaceView.holder)
        ...
    }

VideoPlayer 需要实现 SurfaceHolder.Callback 以便在 SurfaceView 窗口尺寸发生变化时将新的窗口传递到 Native 层：

class VideoPlayer : SurfaceHolder.Callback {
    private var surfaceHolder: SurfaceHolder? = null
    
    fun setSurfaceHolder(surfaceHolder: SurfaceHolder) {
        this.surfaceHolder?.removeCallback(this)
        this.surfaceHolder = surfaceHolder
        this.surfaceHolder?.addCallback(this)
    }
    
    // SurfaceHolder.Callback start
    // 只在创建时回调
    override fun surfaceCreated(holder: SurfaceHolder) {

    }

    // 创建时回调，Surface 的格式与尺寸变化时也会回调
    override fun surfaceChanged(holder: SurfaceHolder, format: Int, width: Int, height: Int) {
        nativeSetSurface(holder.surface)
    }

    override fun surfaceDestroyed(holder: SurfaceHolder) {

    }
    // SurfaceHolder.Callback end
    
    private external fun nativeSetSurface(surface: Surface)
}

native-lib 接收 Surface 并创建 Native 层的 ：

// 创建窗口和渲染时需要用锁，这里采用静态初始化方式
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
ANativeWindow *window = nullptr;

extern "C"
JNIEXPORT void JNICALL
Java_com_video_player_VideoPlayer_nativeSetSurface(JNIEnv *env, jobject thiz, jobject surface) {
    pthread_mutex_lock(&mutex);
    // 先销毁之前的 ANativeWindow
    if (window) {
        ANativeWindow_release(window);
        window = nullptr;
    }
    // 再创建新的 ANativeWindow
    window = ANativeWindow_fromSurface(env, surface);
    pthread_mutex_unlock(&mutex);
}

4.2 回调绘制数据与渲染

这次我们来看 VideoChannel 的渲染线程：

void *task_play(void *args) {
    auto videoChannel = static_cast<VideoChannel *>(args);
    videoChannel->play();
    return nullptr;
}

/**
 * 播放任务，实际上就是要将 AVFrame 内的像素数据取出，回调给负责进行
 * 渲染的 native-lib。具体操作有：
 * 1.将 AVFrame 队列中的 AVFrame 取出，将像素数据转为 RGB 格式
 * 2.将转换后的数据保存到矩阵中，回调给上一层的 VideoPlayer，后者
 * 再次回调给持有 ANativeWindow 的 native-lib 进行绘制
 */
void VideoChannel::play() {
    // 存放 RGBA 数据的指针数组
    uint8_t *dst_data[4];
    // 存放 dst_data 四个指针首地址的数组
    int dst_lineSize[4];
    // 根据图片的宽高和格式为其分配内存，并为 dst_data 和 dst_lineSize 赋值
    // 比如一张 1920*1080 使用 AV_PIX_FMT_RGBA，即 RGBA 8:8:8:8, 32bpp, RGBARGBA...
    // 的图片，其内存占用为 1920*1080*4≈8MB
    av_image_alloc(dst_data, dst_lineSize, avCodecContext->width, avCodecContext->height,
                   AV_PIX_FMT_RGBA, 1);
    // 转换上下文，将 YUV 转换为 RGB 所需的上下文
    SwsContext *swsContext = sws_getContext(
            avCodecContext->width, avCodecContext->height, avCodecContext->pix_fmt,
            avCodecContext->width, avCodecContext->height, AV_PIX_FMT_RGBA,
            SWS_BILINEAR, nullptr, nullptr, nullptr);

    AVFrame *frame = nullptr;
    int result;
    while (isPlaying) {
        result = frames.get(frame);
        if (!isPlaying) {
            break;
        }
        if (!result) {
            continue;
        }

        // 执行 YUV -> RGBA 转换，转换后的数据保存在 dst_data 和 dst_lineSize 中
        sws_scale(swsContext, frame->data, frame->linesize, 0,
                  avCodecContext->height, dst_data, dst_lineSize);

        renderCallback(dst_data[0], avCodecContext->width, avCodecContext->height, dst_lineSize[0]);
        // 释放 AVFrame
        av_frame_unref(frame);
        releaseAVFrame(&frame);
    }

    av_frame_unref(frame);
    releaseAVFrame(&frame);
    isPlaying = false;
    av_free(&dst_data[0]);
    sws_freeContext(swsContext);
}

VideoChannel 通过 renderCallback 将绘制所需数据先回调给它的直接上层 VideoPlayer，VideoPlayer 做同样的操作回调给 native-lib，渲染只需将数据拷贝到 ANativeWindow_Buffer 中即可，后续的渲染工作无需我们操作：

/**
 * 渲染
 */
void renderFrame(uint8_t *src_data, int width, int height, int src_lineSize) {
    pthread_mutex_lock(&mutex);
    if (!window) {
        // 如果 ANativeWindow 不存在要释放锁避免死锁
        pthread_mutex_unlock(&mutex);
        return;
    }

    // 设置 ANativeWindow 的宽高以及图像格式
    ANativeWindow_setBuffersGeometry(window, width, height, WINDOW_FORMAT_RGBA_8888);
    ANativeWindow_Buffer window_buffer;

    // 渲染之前要对 ANativeWindow 上锁，如果上锁失败要结束渲染过程
    if (ANativeWindow_lock(window, &window_buffer, nullptr)) {
        ANativeWindow_release(window);
        window = nullptr;

        pthread_mutex_unlock(&mutex);
        return;
    }

    // 将像素数据填入 ANativeWindow_Buffer 就算渲染完成了
    auto *dst_data = static_cast<uint8_t *>(window_buffer.bits);
    int dst_lineSize = window_buffer.stride * 4;

    // 行遍历
    for (int i = 0; i < window_buffer.height; ++i) {
        // 从 src_data 拷贝一行数据到 dst_data 中
        memcpy(dst_data + i * dst_lineSize, src_data + i * src_lineSize, dst_lineSize);
    }

    // 数据刷新
    ANativeWindow_unlockAndPost(window);

    pthread_mutex_unlock(&mutex);
}

在底层的绘制都是通过缓冲区进行绘制的。ANativeWindow 自带一个相同大小的缓冲区，OpenCV、WebRTC、FFmpeg 都是通过这样的缓冲区进行绘制的。缓冲区实际上是一个字节数组，将像素数据赋值给字节数组，就完成了渲染。因此，底层的渲染，实际上就是一个内存的拷贝。

渲染这里要注意空间的分配与回收问题，否则长时间播放可能会耗尽内存导致应用崩溃。可能的原因是解码速度远远快于渲染速度，导致解码队列溢出了，所以我们才添加了对 VideoChannel 与 AudioChannel 内 AVPacket 和 AVFrame 队列的流量控制，队列容量大于 100 的时候进行休眠。

到这里，可以顺利播放视频了，但是由于音频解码与渲染还没做，因此当前视频无声。下一篇文章我们再介绍音频如何处理。