ijkplayer系列(二) —— ijkplayer初始化流程 初始化IMediaPlayer setDataSource(String) prepareAsync() 函數

上一篇文章我們簡單地瞭解了ijkplayer的使用方法，本文準備分析一下ijkplayer初始化的流程。

在這裏我還是建議大家clone下來源碼同步分析，因爲ijkplayer文件太多，我開始看的時候是越看越亂，到最後重新看一點，然後用筆記記一點，纔有了頭緒。

我們上一篇文章有一個示例代碼，爲了方便，我再貼一下：

        // init player
        IjkMediaPlayer.loadLibrariesOnce(null);
        IjkMediaPlayer.native_profileBegin("libijkplayer.so");
        videoView.setVideoURI(Uri.parse("http://106.36.45.36/live.aishang.ctlcdn.com/00000110240001_1/encoder/1/playlist.m3u8"));

        videoView.setOnPreparedListener(new IMediaPlayer.OnPreparedListener() {
            @Override
            public void onPrepared(IMediaPlayer mp) {
                videoView.start();
            }
        });

OK,現在我們就從初始化的第一句分析起，在loadLibrariesOnce（null）中加載了我們編譯出來的幾個so文件，如下：

libLoader.loadLibrary("ijkffmpeg");
libLoader.loadLibrary("ijksdl");
libLoader.loadLibrary("ijkplayer");

這裏直接把libLoader看成System.loadLibrary(libname)就行,雖然看起來沒什麼，挺正常的，但是分析到後面發現，java層調用的函數在c層找不到0.0。之後google了下發現:

JNI在加載時，會調用JNI_OnLoad()，而卸載時會調用JNI_UnLoad()，我們可以利用這兩個方法來動態方式實現JNI。

然後趕快找找C代碼中有沒有JNI_OnLoad()方法。

果然，在ijkplayer_jni.c中找到了JNI_OnLoad()方法：

JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void *reserved)
{
    JNIEnv* env = NULL;

    g_jvm = vm;
    if ((*vm)->GetEnv(vm, (void**) &env, JNI_VERSION_1_4) != JNI_OK) {
        return -1;
    }
    assert(env != NULL);

    pthread_mutex_init(&g_clazz.mutex, NULL );

    // FindClass returns LocalReference
    IJK_FIND_JAVA_CLASS(env, g_clazz.clazz, JNI_CLASS_IJKPLAYER);
    (*env)->RegisterNatives(env, g_clazz.clazz, g_methods, NELEM(g_methods) );

    ijkmp_global_init();
    ijkmp_global_set_inject_callback(inject_callback);

    FFmpegApi_global_init(env);

    return JNI_VERSION_1_4;
}

這個方法裏面，初始化了很多內容，首先RegisterNatives註冊g_methods中的native方法，其中包括：

static JNINativeMethod g_methods[] = {
    {
        "_setDataSource",
        "(Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/String;)V",
        (void *) IjkMediaPlayer_setDataSourceAndHeaders
    },
    { "_setDataSourceFd",       "(I)V",     (void *) IjkMediaPlayer_setDataSourceFd },
    { "_setDataSource",         "(Ltv/danmaku/ijk/media/player/misc/IMediaDataSource;)V", (void *)IjkMediaPlayer_setDataSourceCallback },
//...
    { "_setVideoSurface",       "(Landroid/view/Surface;)V", (void *) IjkMediaPlayer_setVideoSurface },
    { "_prepareAsync",          "()V",      (void *) IjkMediaPlayer_prepareAsync },
    { "_start",                 "()V",      (void *) IjkMediaPlayer_start },
    { "_stop",                  "()V",      (void *) IjkMediaPlayer_stop },
    { "seekTo",                 "(J)V",     (void *) IjkMediaPlayer_seekTo },
    { "_pause",                 "()V",      (void *) IjkMediaPlayer_pause },
    { "isPlaying",              "()Z",      (void *) IjkMediaPlayer_isPlaying },
    { "getAudioSessionId",      "()I",      (void *) IjkMediaPlayer_getAudioSessionId },
    { "native_init",            "()V",      (void *) IjkMediaPlayer_native_init },
    { "native_setup",           "(Ljava/lang/Object;)V", (void *) IjkMediaPlayer_native_setup },
//......
    { "native_profileBegin",    "(Ljava/lang/String;)V",    (void *) IjkMediaPlayer_native_profileBegin },
    { "native_profileEnd",      "()V",                      (void *) IjkMediaPlayer_native_profileEnd },
};

註冊後，相當於java層聲明爲native方法的函數與c層有一個映射關係；舉個栗子，當我們java裏面調用_start()方法的時候，其實調用的是c層中的IjkMediaPlayer_start()方法；對應地，作者在java層聲明瞭一個修飾java方法的annotation，這些函數也會在這裏註冊，實現後面在C層也能調用java層的函數。是不是很神奇？？

接着還調用了幾個init方法：
**ffp_global_init() **-->主要是ffmpeg的初始化工作, 前面說過ijkplayer是基於ffmpeg的。
FFmpegApi_global_init(env)-->初始化FFmpegApi#av_base64_encode函數。

後面調用的IjkMediaPlayer.native_profileBegin("libijkplayer.so");發現並沒有什麼作用的樣子，至少我註釋了還是能成功運行。看來這裏要留坑了。

然後我們再看到videoView.setVideoURI()；,這裏的url支持本地視頻和在線視頻，接着我們繼續看到它的實現：

 private void openVideo() {
        if (mUri == null || mSurfaceHolder == null) {
            // not ready for playback just yet, will try again later
            return;
        }
        // we shouldn't clear the target state, because somebody might have
        // called start() previously
        release(false);

        AudioManager am = (AudioManager) mAppContext.getSystemService(Context.AUDIO_SERVICE);
        am.requestAudioFocus(null, AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN);

        try {
            mMediaPlayer = createPlayer(mSettings.getPlayer());
            mMediaPlayer.setOnPreparedListener(mPreparedListener);
            //這裏省略一大波setListener......
            mCurrentBufferPercentage = 0;
            if (Build.VERSION.SDK_INT > Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
                mMediaPlayer.setDataSource(mAppContext, mUri, mHeaders);
            } else {
                mMediaPlayer.setDataSource(mUri.toString());
            }
            bindSurfaceHolder(mMediaPlayer, mSurfaceHolder);
            mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
            mMediaPlayer.setScreenOnWhilePlaying(true);
            mMediaPlayer.prepareAsync();
            if (mHudViewHolder != null)
                mHudViewHolder.setMediaPlayer(mMediaPlayer);

            // REMOVED: mPendingSubtitleTracks

            // we don't set the target state here either, but preserve the
            // target state that was there before.
            mCurrentState = STATE_PREPARING;
            attachMediaController();
        } catch (IOException ex) {
           ...
        } catch (IllegalArgumentException ex) {
          ...
        } finally {
            
        }
    }

在這裏， 做了下面幾件事：

• 獲得AudioManager
• 通過setting獲取player的類型
• 初始化IMediaPlayer (createPlayer()函數)
• 然後調用setDataSource(String)
• 屏幕常亮等
• 設置MediaController
• mMediaPlayer.prepareAsync()

初始化IMediaPlayer

這裏只講一下IjkMediaPlayer，其實我們除了使用IjkMediaPlayer，還可以使用IjkExoMediaPlayer或者AndroidMediaPlayer。只需要修改一下createPlayer(int playerType)的參數就行了。

在IjkMediaPlayer初始化過程中，做了好多好多事，我們來一一看一下：

 public IjkMediaPlayer(IjkLibLoader libLoader) {
        initPlayer(libLoader);
    }

    private void initPlayer(IjkLibLoader libLoader) {
        loadLibrariesOnce(libLoader);
        initNativeOnce();

        Looper looper;
        if ((looper = Looper.myLooper()) != null) {
            mEventHandler = new EventHandler(this, looper);
        } else if ((looper = Looper.getMainLooper()) != null) {
            mEventHandler = new EventHandler(this, looper);
        } else {
            mEventHandler = null;
        }

        /*
         * Native setup requires a weak reference to our object. It's easier to
         * create it here than in C++.
         */
        native_setup(new WeakReference<IjkMediaPlayer>(this));
    }

由於之前調用了一次loadLibrariesOnce(),所以這裏並沒有什麼用。

initNativeOnce()經過幾次跳轉調用了native方法的native_init函數，這裏跳轉到C代碼裏面，對應調用了IjkMediaPlayer_native_init()，不過看起來並沒有什麼操作。接着初始化了一個handler，後面在c層通過調用java的方法來post message。

這裏最後調用了native方法native_setup(new WeakReference<IjkMediaPlayer>(this));對應C語言的IjkMediaPlayer_native_setup()方法，也在ijkplayer_jni.c文件裏面：

static void
IjkMediaPlayer_native_setup(JNIEnv *env, jobject thiz, jobject weak_this)
{
    MPTRACE("%s\n", __func__);
    IjkMediaPlayer *mp = ijkmp_android_create(message_loop);
    JNI_CHECK_GOTO(mp, env, "java/lang/OutOfMemoryError", "mpjni: native_setup: ijkmp_create() failed", LABEL_RETURN);

    jni_set_media_player(env, thiz, mp);
    ijkmp_set_weak_thiz(mp, (*env)->NewGlobalRef(env, weak_this));
    ijkmp_set_inject_opaque(mp, ijkmp_get_weak_thiz(mp));
    ijkmp_android_set_mediacodec_select_callback(mp, mediacodec_select_callback, (*env)->NewGlobalRef(env, weak_this));

LABEL_RETURN:
    ijkmp_dec_ref_p(&mp);
}

先看ijkmp_android_create(message_loop);/ijkplayer_android.c:

IjkMediaPlayer *ijkmp_android_create(int(*msg_loop)(void*))
{
    IjkMediaPlayer *mp = ijkmp_create(msg_loop);
    if (!mp)
        goto fail;

    mp->ffplayer->vout = SDL_VoutAndroid_CreateForAndroidSurface(); //視頻輸出設備創建
    if (!mp->ffplayer->vout)
        goto fail;

    mp->ffplayer->pipeline = ffpipeline_create_from_android(mp->ffplayer);    
    if (!mp->ffplayer->pipeline)
        goto fail;

    ffpipeline_set_vout(mp->ffplayer->pipeline, mp->ffplayer- >vout);  

    return mp;

fail:
    ijkmp_dec_ref_p(&mp);
    return NULL;
}

首先創建一個IJKMediaPlayer類型的player吧，先貼出IJKPlayerMediaPlayer的結構:

struct IjkMediaPlayer {
    volatile int ref_count;
    pthread_mutex_t mutex;  //這是一個互斥鎖，因爲後面有很多多線程操作，同步少不了
    FFPlayer *ffplayer;    //ffplayer

    int (*msg_loop)(void*);    //msg的一個處理函數
    SDL_Thread *msg_thread;
    SDL_Thread _msg_thread;

    int mp_state;
    char *data_source;    //數據源
    void *weak_thiz;

    int restart;
    int restart_from_beginning;
    int seek_req;
    long seek_msec;
};

在create_ijkplayer(ijkmp_create(msg_loop)函數)的同時，也給它指定了msg的處理函數和ffplayer。

接下來就是對ijkplayer結構體中的ffplayer進行設置，剛剛通過SDL_VoutAndroid_CreateForAndroidSurface()創建了輸出設備vout，後面在ffpipeline_set_vout()裏面：mp->ffplayer->opaque->weak_vout = vout。

然後再jni_set_media_player()，這裏基本就結束了。

其實細細分析還有的地方沒有分析到，比如在SDL_VoutAndroid_CreateForAndroidSurface()創建視頻輸出設備的時候，跟蹤函數跳轉發現，硬解用的mediacidec，軟解用的ffmpeg:

static SDL_VoutOverlay *func_create_overlay_l(int width, int height, int frame_format, SDL_Vout *vout)
{
    switch (frame_format) {
    case IJK_AV_PIX_FMT__ANDROID_MEDIACODEC:
        return SDL_VoutAMediaCodec_CreateOverlay(width, height, vout);
    default:
        return SDL_VoutFFmpeg_CreateOverlay(width, height, frame_format, vout);
    }
}

還有渲染視頻設備用的ANativeWindow,對接surface等。還有一些地方是設置了函數指針，現在分析的話，後面可能會懵，這些放到後面再來分析。

OK，現在返回java層，剛剛分析到了IJKMediaPlayer的構造函數，作者在構造函數裏面做了很多事情的樣子。

setDataSource(String)

接着我們設置了視頻源，在JNI層對應IjkMediaPlayer_setDataSourceAndHeaders()/ijkplayer_jni.c。同樣代碼跟蹤到了ijkmp_set_data_source_l()：

   //...
    freep((void**)&mp->data_source);
    mp->data_source = strdup(url);
   //...
    ijkmp_change_state_l(mp, MP_STATE_INITIALIZED);
   //...

在ijkmp_change_state_l裏面封裝了一個what爲MP_STATE_INITIALIZED的AVMessage，最後把其放入ijkplayer->ffplayer->msg_queue中，然後調用：

int SDL_CondSignal(SDL_cond *cond)
{
    assert(cond);
    if (!cond)
        return -1;

    return pthread_cond_signal(&cond->id);
}

cond->id其實是ijkplayer->ffplayer->msg_queue->cond->id，類型爲pthread_cond_t。

那麼pthread_cond_signal這個函數是幹嘛的呢？

其實在liunx裏面,pthread_cond_signal函數的作用是發送一個信號給另外一個正在處於阻塞等待狀態的線程,使其脫離阻塞狀態,繼續執行，當某個線程繼續執行的時候發現msg_queue中有msg的時候會有相應操作。到底這裏把是發給誰呢？請繼續往下面讀。

prepareAsync() 函數

其中調用了IjkMediaPlayer_prepareAsync/ijkplayer_jni.c，我們繼續看它做了哪些操作。

同樣，這個函數最終調用了ijkmp_prepare_async_l（）：

static int ijkmp_prepare_async_l(IjkMediaPlayer *mp)
{
    assert(mp);

   //...
    assert(mp->data_source);

    ijkmp_change_state_l(mp, MP_STATE_ASYNC_PREPARING);

    msg_queue_start(&mp->ffplayer->msg_queue);

    // released in msg_loop
    ijkmp_inc_ref(mp);
    mp->msg_thread = SDL_CreateThreadEx(&mp->_msg_thread, ijkmp_msg_loop, mp, "ff_msg_loop");
    // msg_thread is detached inside msg_loop
    // TODO: 9 release weak_thiz if pthread_create() failed;

    int retval = ffp_prepare_async_l(mp->ffplayer, mp->data_source);
    if (retval < 0) {
        ijkmp_change_state_l(mp, MP_STATE_ERROR);
        return retval;
    }

    return 0;
}

和上面一樣，ijkmp_change_state_l()向msg_queue發送一個FFP_MSG_PLAYBACK_STATE_CHANGED狀態

咦？這裏又發送了一個狀態FFP_MSG_FLUSH，然而函數名是msg_queue_start(),這是什麼意思呢？

然後接下來就創建了一個msg_loop的消息循環線程，線程入口爲ijkmp_msg_loop。這裏其實就是上面放進msg_queue的message的處理線程。後面再具體分析各個線程做了什麼。

在最後，這裏繼續調用ffp_prepare_async_l().然而在這個函數裏面:

int ffp_prepare_async_l(FFPlayer *ffp, const char *file_name)
{
//....

    av_log(NULL, AV_LOG_INFO, "===== versions =====\n");
    ffp_show_version_str(ffp, "FFmpeg",         av_version_info());
    ffp_show_version_int(ffp, "libavutil",      avutil_version());
    ffp_show_version_int(ffp, "libavcodec",     avcodec_version());
    ffp_show_version_int(ffp, "libavformat",    avformat_version());
    ffp_show_version_int(ffp, "libswscale",     swscale_version());
    ffp_show_version_int(ffp, "libswresample",  swresample_version());
    av_log(NULL, AV_LOG_INFO, "===== options =====\n");
    ffp_show_dict(ffp, "player-opts", ffp->player_opts);
    ffp_show_dict(ffp, "format-opts", ffp->format_opts);
    ffp_show_dict(ffp, "codec-opts ", ffp->codec_opts);
    ffp_show_dict(ffp, "sws-opts   ", ffp->sws_dict);
    ffp_show_dict(ffp, "swr-opts   ", ffp->swr_opts);
    av_log(NULL, AV_LOG_INFO, "===================\n");
//...
    VideoState *is = stream_open(ffp, file_name, NULL);
//...

    ffp->is = is;
    ffp->input_filename = av_strdup(file_name);
    return 0;
}

看到這一大波log信息沒有，要是大家運行了上一篇的demo，會發現這不就是打印的log麼？

然後繼續跟蹤代碼：

static VideoState *stream_open(FFPlayer *ffp, const char *filename, AVInputFormat *iformat)
{
  //...
    /* start video display */
    if (frame_queue_init(&is->pictq, &is->videoq, ffp->pictq_size, 1) < 0)
        goto fail;
//...
  
    is->video_refresh_tid = SDL_CreateThreadEx(&is->_video_refresh_tid, video_refresh_thread, ffp, "ff_vout");
//...
    is->read_tid = SDL_CreateThreadEx(&is->_read_tid, read_thread, ffp, "ff_read");
    //...
}

上面函數裏面只留下了重要的代碼，這裏創建了兩個線程，一個是以video_refresh_thread爲入口的視頻顯示線程。還有一個是以read_thread爲入口的網絡數據或者本地文件的數據讀取線程。

其實在read_thread裏面還向msg_queue發送了一個消息，那就是ffp_notify_msg1(ffp, FFP_MSG_PREPARED);，消息循環線程收到這個消息後，會調用java層的函數，向handler發送個MEDIA_PREPARED消息，然後在handler的handleMessage函數裏面會處理這個消息：

    case MEDIA_PREPARED:
                player.notifyOnPrepared();
                return;

最終會調用我們上一文設置的:

videoView.setOnPreparedListener(new IMediaPlayer.OnPreparedListener() {
            @Override
            public void onPrepared(IMediaPlayer mp) {
                videoView.start();
            }
        });

的onPrepared()函數，然後初始化好了，接下來就可以播放了。

** 如果大家還想了解ijkplayer的工作流程的話，可以關注下android下的ijkplayer。**