ijkplayer 源码分析（2）：消息分发处理机制-Toy模板网

这篇具有很好参考价值的文章主要介绍了ijkplayer 源码分析（2）：消息分发处理机制。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

ijkplayer 源码分析（2）：消息分发处理机制

一、引言

上篇博客 ijkplayer 源码分析（1）：初始化流程的 4.1.1 ijkmp_create() 的部分简要说明了下 ijkplayer 的消息处理机制，本文再根据源码进行详细分析，搞清楚其消息机制及处理流程。

播放器是一个较为复杂的多线程工程，如数据读取线程、音频解码线程、视频解码线程、视频播放线程等。各个线程都需要产生事件，如状态改变、出错等，需要传递给控制层和业务层去处理。因此需要一个消息处理机制来完成这些工作，把各个线程产生的事件转化成消息来处理。当然也可以通过接口回调的方式来处理，但样式繁多的事件会需要极其庞大复杂的接口，会很难维护和扩展。因此消息机制是一个很不错的方案。

通过分析 ijkplayer 源码会发现，ijkplayer 实现的消息处理机制和 Android 端的 Handler、Looper、Message、MessageQueue 的消息分发和处理机制很类似。下面我们就详细分析下 ijkplayer 的消息分发处理机制。

本文是基于 A4ijkplayer 项目进行 ijkplayer 源码分析，该项目是将 ijkplayer 改成基于 CMake 编译，可导入 Android Studio 编译运行，方便代码查找、函数跳转、单步调试、调用栈跟踪等。

二、消息分发处理机制

1、Android 的消息分发处理机制

我们先来回顾下 Android 端 Handler、Looper、Message、MessageQueue 的消息分发和处理机制，这有助于我们理解 ijkplayer 的消息处理机制。

Android 的消息分发处理机制如下：

通过 Handler 的 sendMessage() 方法发送一个消息
Looper 将该消息加入到消息队列 MessageQueue 中
Looper 所在线程循环遍历 MessageQueue 从中取出消息分发，如果没有消息则挂起等待
分发到 Handler 执行 handleMessage() 处理消息
以上就完成了消息的发送和处理流程

2、ijkplayer 的消息分发处理机制

ijkplayer 源码分析（2）：消息分发处理机制
如上图，ijkplayer 的消息分发处理机制和 Android 类似，采用的生产者—消费者模式。生产者（可以是多个）从任意线程生产消息，将其加入到消息队列中，消费者（只有一个）在一个独立的线程循环从消息队列取出消息进行分发处理，如果队列为空则等待。
ijkplayer 中的消息结构体为 AVMessage，消息队列结构体为 MessageQueue，均位于 ijkmedia/ijkplayer/ff_ffmsg_queue.h 文件中，结构如下，可以看到跟 Android 的 Message 很像。

typedef struct AVMessage {
    int what;
    int arg1;
    int arg2;
    void *obj;
    void (*free_l)(void *obj);
    struct AVMessage *next;
} AVMessage;

typedef struct MessageQueue {
    AVMessage *first_msg, *last_msg;
    int nb_messages;
    int abort_request;
    SDL_mutex *mutex;
    SDL_cond *cond;

    AVMessage *recycle_msg;
    int recycle_count;
    int alloc_count;
} MessageQueue;

2.1 Message 提供的消息相关的处理函数：

// 初始化消息体，实际就是调用 memeset 重置内存
inline static void msg_init_msg(AVMessage *msg)

// 释放 msg 的参数 obj 内存，并将其置空，注：不是释放 msg 内存
inline static void msg_free_res(AVMessage *msg)

2.2 MessageQueue 提供的消息队列相关的处理函数：

// 初始化 MessageQueue
inline static void msg_queue_init(MessageQueue *q)
// 释放 MessageQueue 内所有 Message 内存及内部的 Mutex、Condition 内存，并不释放 MessageQueue 本身内存，需外部 free 或 delete
inline static void msg_queue_destroy(MessageQueue *q)

// 启用 MessageQueue 并填入一个 FFP_MSG_FLUSH 消息
inline static void msg_queue_start(MessageQueue *q)
// 终止使用 MessageQueue，调用后可通过 msg_queue_start 重新启用
inline static void msg_queue_abort(MessageQueue *q)

// 以下 put 系列是向 MessageQueue 添加消息，只是参数不同
inline static int msg_queue_put(MessageQueue *q, AVMessage *msg)
inline static void msg_queue_put_simple1(MessageQueue *q, int what)
inline static void msg_queue_put_simple2(MessageQueue *q, int what, int arg1)
inline static void msg_queue_put_simple3(MessageQueue *q, int what, int arg1, int arg2)
inline static void msg_queue_put_simple4(MessageQueue *q, int what, int arg1, int arg2, void *obj, int obj_len)

// 从队列队首取出消息
inline static int msg_queue_get(MessageQueue *q, AVMessage *msg, int block)

// 移除指定 msg.what 的消息
inline static void msg_queue_remove(MessageQueue *q, int what)

// 清空 MessageQueue
inline static void msg_queue_flush(MessageQueue *q)

2.3 创建和销毁 MessageQueue 的使用方法

 // 创建、初始化和启用 MessageQueue
MessageQueue* q = (MessageQueue*)malloc(sizeof(MessageQueue);
msg_queue_init(q);
msg_queue_start(q);

// put 消息
// get 消息

// 终止、销毁和释放 MessageQueue，创建时的逆过程
msg_queue_abort(q);
msg_queue_destroy(q);
free(q);
q = NULL;

三、ijkplayer 消息机制与流程详解

跟进并分析 ijkplayer 源码，我们来梳理下 ijkplayer 消息机制的创建流程。如下图：
ijkplayer 源码分析（2）：消息分发处理机制

1、IjkMediaPlayer_native_setup()

根据上篇博客 ijkplayer 源码分析（1）：初始化流程可知，消息机制最开始是在 Java 层构造函数中调用 native_setup() 然后调用到 native 层的 IjkMediaPlayer_native_setup() 时开始创建的。

static void
IjkMediaPlayer_native_setup(JNIEnv *env, jobject thiz, jobject weak_this)
{
    IjkMediaPlayer *mp = ijkmp_android_create(message_loop);
    // ...
}

调用 ijkmp_create() 传入函数指针 message_loop，message_loop 函数内容会在后面分析。

IjkMediaPlayer *ijkmp_android_create(int(*msg_loop)(void*))
{
    IjkMediaPlayer *mp = ijkmp_create(msg_loop);
    // ...
}

接着看 ijkmp_create() 函数，这里调用 ffp_create()，并保存 msg_loop 函数指针，后面再 prepareAsync 的时候通过 IjkMediaPlayer 区到 msg_loop 函数，放入消息处理线程中执行。

IjkMediaPlayer *ijkmp_create(int (*msg_loop)(void*))
{
    IjkMediaPlayer *mp = (IjkMediaPlayer *) mallocz(sizeof(IjkMediaPlayer));
    // ...
    mp->ffplayer = ffp_create(); // 创建 FFPlayer
    // ...
    mp->msg_loop = msg_loop; // 保存 msg_loop 函数指针
}

接着看 ffp_create() 函数，和消息相关的是初始化消息队列，并情况队列。

FFPlayer *ffp_create()
{
    // ...
    FFPlayer* ffp = (FFPlayer*) av_mallocz(sizeof(FFPlayer));
    // ...
    msg_queue_init(&ffp->msg_queue); // 初始化消息队列
    // ...
    ffp_reset_internal(ffp); // 内部会执行 msg_queue_flush() 清空消息队列
    return ffp;
}

以上在 native_setup() 函数中就创建好并初始化了 MessageQueue，并将 message_loop 函数指针保存到了 IjkMediaPlayer 中。那消息队列和消息处理线程是什么时候启用和流转起来的呢？

2、IjkMediaPlayer_prepareAsync()

分析 ijkplayer 源码，发现其是在 prepareAsync() 中启用的。

static void
IjkMediaPlayer_prepareAsync(JNIEnv *env, jobject thiz)
{
	// ...
    retval = ijkmp_prepare_async(mp);
	// ...
}

int ijkmp_prepare_async(IjkMediaPlayer *mp)
{
	...
    int retval = ijkmp_prepare_async_l(mp);
	...
}

在 ijkmp_prepare_async_l() 中做了两件事：

启用消息队列
调用 msg_queue_start() 启用消息队列，并添加一个 FFP_MSG_FLUSH 消息（在切换资源后调用 prepareAsync() 后会清空消息队列）。
创建和启动消息处理线程
线程名为： ff_msg_loop，线程执行的函数体为：ijkmp_msg_loop()，其内部实际是之前在 native_setup() 函数中传入并保存的 msg_loop 函数指针，也就是 message_loop() 函数，如下：

static int ijkmp_msg_loop(void *arg)
{
    IjkMediaPlayer *mp = arg;
    int ret = mp->msg_loop(arg);
    return ret;
}

static int ijkmp_prepare_async_l(IjkMediaPlayer *mp)
{
	// ...
	// 启用消息队列
    msg_queue_start(&mp->ffplayer->msg_queue); 
	// ...
	// 创建消息队列处理线程
    mp->msg_thread = SDL_CreateThreadEx(&mp->_msg_thread, ijkmp_msg_loop, mp, "ff_msg_loop");
	//...
    return 0;
}

inline static void msg_queue_start(MessageQueue *q)
{
    SDL_LockMutex(q->mutex);
    // 启用消息队列
    q->abort_request = 0;

    // 添加一个 FFP_MSG_FLUSH 消息
    AVMessage msg;
    msg_init_msg(&msg);
    msg.what = FFP_MSG_FLUSH;
    msg_queue_put_private(q, &msg);
    SDL_UnlockMutex(q->mutex);
}

3、ijkplayer 消息的消费与分发

我们看下 message_loop() 函数，在 ijkmedia/ijkplayer/android/ijkplayer_jni.c 文件中，如下：

static int message_loop(void *arg)
{
    // ...
    message_loop_n(env, mp);
    // ...
}

static void message_loop_n(JNIEnv *env, IjkMediaPlayer *mp)
{
    jobject weak_thiz = (jobject) ijkmp_get_weak_thiz(mp);
    while (1) {
        AVMessage msg;
        // 从消息队列取消息
        int retval = ijkmp_get_msg(mp, &msg, 1);
        if (retval < 0)
            break;
        switch (msg.what) {
            // ...
            case FFP_MSG_FLUSH:
            	// 发送消息到上层
            	post_event(env, weak_thiz, MEDIA_NOP, 0, 0);
            	break;
            case FFP_MSG_PREPARED:
                post_event(env, weak_thiz, MEDIA_PREPARED, 0, 0);
                break;
            // ...
        }
        // 释放消息的参数内存
        msg_free_res(&msg);
    }
}

这里主要有两个函数：

ijkmp_get_msg()
post_event()。

我们先看 ijkmp_get_msg() 从消息队列取消息：

int ijkmp_get_msg(IjkMediaPlayer *mp, AVMessage *msg, int block)
{
    while (1) {
        int continue_wait_next_msg = 0;
        // 从消息队列的队首取一个消息
        int retval = msg_queue_get(&mp->ffplayer->msg_queue, msg, block);
        if (retval <= 0)
            return retval;
        switch (msg->what) {...}
        if (continue_wait_next_msg) {
            msg_free_res(msg);
            continue;
        }
        return retval;
    }
    return -1;
}

我们再看 post_event() 函数：
在上面的 message_loop_n() 函数中，取到在 msg_queue_start() 时添加的 FFP_MSG_FLUSH 消息（消息队列启用后的第一个消息）后会调用 post_event() 函数发送 msg.what = MEDIA_NOP 的事件：

case FFP_MSG_FLUSH:
     // 发送消息到上层
     post_event(env, weak_thiz, MEDIA_NOP, 0, 0);
     break;

inline static void post_event(JNIEnv *env, jobject weak_this, int what, int arg1, int arg2)
{
    J4AC_IjkMediaPlayer__postEventFromNative(env, weak_this, what, arg1, arg2, NULL);
}

J4AC_IjkMediaPlayer__postEventFromNative 是在 ijkmedia/ijkj4a/j4a/class/tv/danmaku/ijk/media/player/IjkMediaPlayer.h 文件中定义的宏，实际调用的是下面函数：

void J4AC_tv_danmaku_ijk_media_player_IjkMediaPlayer__postEventFromNative(JNIEnv *env, jobject weakThiz, jint what, jint arg1, jint arg2, jobject obj)
{
    (*env)->CallStaticVoidMethod(env, class_J4AC_tv_danmaku_ijk_media_player_IjkMediaPlayer.id, class_J4AC_tv_danmaku_ijk_media_player_IjkMediaPlayer.method_postEventFromNative, weakThiz, what, arg1, arg2, obj);
}

method_postEventFromNative 的相关定义是在 ijkmedia/ijkj4a/j4a/class/tv/danmaku/ijk/media/player/IjkMediaPlayer.c 文件中，如下：

    class_id = class_J4AC_tv_danmaku_ijk_media_player_IjkMediaPlayer.id;
    name     = "postEventFromNative";
    sign     = "(Ljava/lang/Object;IIILjava/lang/Object;)V";
    class_J4AC_tv_danmaku_ijk_media_player_IjkMediaPlayer.method_postEventFromNative = J4A_GetStaticMethodID__catchAll(env, class_id, name, sign);

其对应的是 Java 层的静态函数 postEventFromNative()，也就是底层调用 post_envent() 最终会通过 JNI 回调到 Java 层 postEventFromNative() 函数(在 IjkMediaPlayer.java 中)。

@CalledByNative
private static void postEventFromNative(Object weakThiz, int what,
        int arg1, int arg2, Object obj) {
    // ...
    if (mp.mEventHandler != null) {
        Message m = mp.mEventHandler.obtainMessage(what, arg1, arg2, obj);
        mp.mEventHandler.sendMessage(m);
    }
}

然后会被发送到 EventHandler 中由其 handleMessage() 处理，这里会接受到 native 启用消息队列后的第一个 msg.what = MEDIA_NOP 的消息，Java 忽略了该消息：

private static class EventHandler extends Handler {
    // ...
    @Override
    public void handleMessage(Message msg) {
        // ...
        switch (msg.what) {
        case MEDIA_PREPARED:
            player.notifyOnPrepared();
            return;
        case MEDIA_NOP: // interface test message - ignore
            break;
        // ...
    }
}