ffplay流程图.jpg

上图摘自 雷霄骅 雷神的博客 是FFmpeg中 ffplay.c的结构流程图

ijkplayer的ff_ffplay.c是建立在FFmpeg的ffplay.c的基础之上的。

其核心：

read_thread线程负责接收服务器的数据 
video_thread线程负责video decode  
audio_thread负责audio decode
video_refresh_thread线程负责video 的渲染

audio的播放暂时还没有细细的研究 audio_open是关键函数 SDL_OpenAudio()：SDL中打开音频设备的函数。注意它是根据SDL_AudioSpec参数打开音频设备。SDL_AudioSpec中的callback字段指定了音频播放的回调函数sdl_audio_callback()。当音频设备需要更多数据的时候，会调用该回调函数。因此该函数是会被反复调用的。

ffp_prepare_async_l 函数开启read_thread和video_refresh_thread线程。 
read_thread开启audio_thread和video_thread解码线程

ffp_prepare_async_l函数主要调用 ffpipeline_open_audio_output函数和stream_open函数。

ffpipeline_open_audio_output函数调用SDL_AoutIos_CreateForAudioUnit函数

SDL_Aout *SDL_AoutIos_CreateForAudioUnit()
{
    SDL_Aout *aout = SDL_Aout_CreateInternal(sizeof(SDL_Aout_Opaque));
    if (!aout)
        return NULL;

    // SDL_Aout_Opaque *opaque = aout->opaque;

    aout->free_l = aout_free_l;
    aout->open_audio  = aout_open_audio;
    aout->pause_audio = aout_pause_audio;
    aout->flush_audio = aout_flush_audio;
    aout->close_audio = aout_close_audio;

    aout->func_set_playback_rate = aout_set_playback_rate;

    return aout;
}
  

SDL_AoutIos_CreateForAudioUnit函数 实现了函数指针的赋值，用于ffplay回调控制audio output的方法。

stream_open函数进行初始化frame队列 packet队列还有音视频同步相关的clock时钟并且同时开启了read_thread线程和video_refresh_thread线程。

video_refresh_thread：这个线程负责 video 的渲染。

read_thread：

这个线程先进行FFmpeg初始化操作，然后获取视频流信息

avformat_open_input()：打开媒体。

avformat_find_stream_info()：获得媒体信息。这个函数有时候会影响首画的时间，看这个函数的源码发现：这个函数会一直分析视频流的信息，当一直获取不到信息的时候就会一直在这个函数中，一直到它最大的限制，才会出来，会有好几秒的时间。如果网络卡的话，时间会更长。但是我们可以自己给他添加限制，到达我们自己的限制条件的时候就会出来，不会一直在这个函数里面。

ic->probesize这个控制分析视频流的大小，当读的视频流大小达到这个size大小的时候，即使没有获取到信息 也会出来

ic->max_analyze_duration这个事控制视频流信息的大小，同理 当没有获取到信息，读取的视频流的时长达到这个duration的时候 也会出来。

av_dump_format()：输出媒体信息到控制台。

stream_component_open()：分别打开视频/音频/字幕解码线程。(在下面详细讲解该函数)

av_read_frame()：获取一帧压缩编码数据（即一个AVPacket）。

packet_queue_put()：根据压缩编码数据类型的不同（视频/音频/字幕），放到不同的PacketQueue中。

stream_component_open该函数：

1.如果是video：

ffp->node_vdec = ffpipeline_open_video_decoder(ffp->pipeline, ffp);在这个函数中选择硬解码还是软解码，在iOS中实现如下

static IJKFF_Pipenode *func_open_video_decoder(IJKFF_Pipeline *pipeline, FFPlayer *ffp)
{
    IJKFF_Pipenode* node = NULL;
    IJKFF_Pipeline_Opaque *opaque = pipeline->opaque;
    if (ffp->videotoolbox) {
        node = ffpipenode_create_video_decoder_from_ios_videotoolbox(ffp);
    }
    if (node == NULL) {
        ALOGE("vtb fail!!! switch to ffmpeg decode!!!! \n");
        node = ffpipenode_create_video_decoder_from_ffplay(ffp);
        ffp->stat.vdec_type = FFP_PROPV_DECODER_AVCODEC;
        opaque->is_videotoolbox_open = false;
    } else {
        ffp->stat.vdec_type = FFP_PROPV_DECODER_VIDEOTOOLBOX;
        opaque->is_videotoolbox_open = true;
    }
    ffp_notify_msg2(ffp, FFP_MSG_VIDEO_DECODER_OPEN, opaque->is_videotoolbox_open);
    return node;
}

在android中实现如下：

static IJKFF_Pipenode *func_open_video_decoder(IJKFF_Pipeline *pipeline, FFPlayer *ffp)
{
    IJKFF_Pipeline_Opaque *opaque = pipeline->opaque;
    IJKFF_Pipenode        *node = NULL;

    if (ffp->mediacodec_all_videos || ffp->mediacodec_avc || ffp->mediacodec_hevc || ffp->mediacodec_mpeg2)
        node = ffpipenode_create_video_decoder_from_android_mediacodec(ffp, pipeline, opaque->weak_vout);
    if (!node) {
        node = ffpipenode_create_video_decoder_from_ffplay(ffp);
    }

    return node;
}

选择完解码器，然后开始解码

decoder_start(&is->viddec, video_thread, ffp, "ff_video_dec"）创建一个解码线程

static int video_thread(void *arg)
{
    FFPlayer *ffp = (FFPlayer *)arg;
    int       ret = 0;

    if (ffp->node_vdec) {
        ret = ffpipenode_run_sync(ffp->node_vdec);
    }
    return ret;
}

不管是iOS还是android中：

ffpipenode_create_video_decoder_from_ffplay
ffpipenode_create_video_decoder_from_android_mediacodec
ffpipenode_create_video_decoder_from_ios_videotoolbox
这三个方法都是返回node，并node这个结构体中的函数指针赋值。我们解码的时候 调用的就是node->func_run_sync该方法,使用选择的解码器去解码video。

软解码 该方法如下：

static int func_run_sync(IJKFF_Pipenode *node)
{
    IJKFF_Pipenode_Opaque *opaque = node->opaque;

    return ffp_video_thread(opaque->ffp);
}

使用videotoolbox 该方法如下：

static int func_run_sync(IJKFF_Pipenode *node)

{

    IJKFF_Pipenode_Opaque *opaque = node->opaque;

    int ret = videotoolbox_video_thread(opaque);

    if (opaque->context) {

        dealloc_videotoolbox(opaque->context);

        free(opaque->context);

        opaque->context = NULL;

    }
    return ret;
} 

使用mediacodec，该方法如下：

static int func_run_sync(IJKFF_Pipenode *node)
{
    JNIEnv                *env      = NULL;
    IJKFF_Pipenode_Opaque *opaque   = node->opaque;
    FFPlayer              *ffp      = opaque->ffp;
    VideoState            *is       = ffp->is;
    Decoder               *d        = &is->viddec;
    PacketQueue           *q        = d->queue;
    int                    ret      = 0;
    int                    dequeue_count = 0;
    AVFrame               *frame    = NULL;
    int                    got_frame = 0;
    AVRational             tb         = is->video_st->time_base;
    AVRational             frame_rate = av_guess_frame_rate(is->ic, is->video_st, NULL);
    double                 duration;
    double                 pts;
    // int64_t                decode_time = 0;
    if (!opaque->acodec) {
        return ffp_video_thread(ffp);
    }

    if (JNI_OK != SDL_JNI_SetupThreadEnv(&env)) {
        ALOGE("%s: SetupThreadEnv failed\n", __func__);
        return -1;
    }

    frame = av_frame_alloc();
    if (!frame)
        goto fail;

    if (opaque->frame_rotate_degrees == 90 || opaque->frame_rotate_degrees == 270) {
        opaque->frame_width  = opaque->avctx->height;
        opaque->frame_height = opaque->avctx->width;
    } else {
        opaque->frame_width  = opaque->avctx->width;
        opaque->frame_height = opaque->avctx->height;
    }

    opaque->enqueue_thread = SDL_CreateThreadEx(&opaque->_enqueue_thread, enqueue_thread_func, node, "amediacodec_input_thread");
    if (!opaque->enqueue_thread) {
        ALOGE("%s: SDL_CreateThreadEx failed\n", __func__);
        ret = -1;
        goto fail;
    }

    while (!q->abort_request) {
        /*spb add
        if(ffp_frame_queue_nb_remaining(&is->pictq) == 2)
            ffp_frame_queue_next(&is->pictq);
        if (is->videoq.nb_packets == 0)
        {
           av_log(NULL, AV_LOG_INFO, "spb_log videoq is empty\n");
        }
         end*/
        Frame *vp = ffp_frame_queue_peek_writable(&is->pictq);
        int64_t timeUs = opaque->acodec_first_dequeue_output_request ? 0 : AMC_OUTPUT_TIMEOUT_US;
        got_frame = 0;
        // int64_t start_drain = av_gettime()/1000;
        ret = drain_output_buffer(env, node, timeUs, &dequeue_count, frame, &vp->dest_frame, &got_frame);
        // int64_t end_drain = av_gettime()/1000;
        if (opaque->acodec_first_dequeue_output_request) {
            SDL_LockMutex(opaque->acodec_first_dequeue_output_mutex);
            opaque->acodec_first_dequeue_output_request = false;
            SDL_CondSignal(opaque->acodec_first_dequeue_output_cond);
            SDL_UnlockMutex(opaque->acodec_first_dequeue_output_mutex);
        }
        if (ret != 0) {
            ret = -1;
            if (got_frame && frame->opaque)
                SDL_VoutAndroid_releaseBufferProxyP(opaque->weak_vout, (SDL_AMediaCodecBufferProxy **)&frame->opaque, false);
            goto fail;
        }
        if (got_frame) {
            // av_log(NULL, AV_LOG_INFO, "spb_log drain_output_buffer success need time:  %lld,    time : %lld\n", end_drain - start_drain, end_drain - decode_time);
            // decode_time = end_drain;
            duration = (frame_rate.num && frame_rate.den ? av_q2d((AVRational){frame_rate.den, frame_rate.num}) : 0);
            pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb);
            ret = ffp_queue_picture(ffp, frame, pts, duration, av_frame_get_pkt_pos(frame), is->viddec.pkt_serial);
            if (ret) {
                if (frame->opaque)
                    SDL_VoutAndroid_releaseBufferProxyP(opaque->weak_vout, (SDL_AMediaCodecBufferProxy **)&frame->opaque, false);
            }
            av_frame_unref(frame);
        }
    }

fail:
    av_frame_free(&frame);
    SDL_AMediaCodecFake_abort(opaque->acodec);
    if (opaque->n_buf_out) {
        free(opaque->amc_buf_out);
        opaque->n_buf_out = 0;
        opaque->amc_buf_out = NULL;
        opaque->off_buf_out = 0;
        opaque->last_queued_pts = AV_NOPTS_VALUE;
    }
    if (opaque->acodec) {
        SDL_VoutAndroid_invalidateAllBuffers(opaque->weak_vout);
        SDL_LockMutex(opaque->acodec_mutex);
        SDL_AMediaCodec_stop(opaque->acodec);
        SDL_UnlockMutex(opaque->acodec_mutex);
    }
    SDL_WaitThread(opaque->enqueue_thread, NULL);
    SDL_AMediaCodec_decreaseReferenceP(&opaque->acodec);
    ALOGI("MediaCodec: %s: exit: %d", __func__, ret);
    return ret;
#if 0
fallback_to_ffplay:
    ALOGW("fallback to ffplay decoder\n");
    return ffp_video_thread(opaque->ffp);
#endif
}

这个方法代码较多，但是我们能看到 其核心就做了两件事
第一件事 opaque->enqueue_thread = SDL_CreateThreadEx(&opaque->_enqueue_thread, enqueue_thread_func, node, "amediacodec_input_thread"); 创建一个新的线程，在packet queue中不停的取数据 放入硬解码芯片。
第二件事 在下面的while循环中 调用drain_output_buffer这个函数 获取解码后的数据信息。

2.如果是audio：

先执行ret = audio_open(ffp, channel_layout, nb_channels, sample_rate, &is->audio_tgt)，audio_open方法。
并没有详细的研究audio的每一步，audio_open也是在根据获取到的流媒体信息进行audio 解码和播放的初始化操作。
其中 wanted_spec.callback = sdl_audio_callback 是有关audio播放的一个函数指针的赋值。

然后

(ret = decoder_start(&is->auddec, audio_thread, ffp, "ff_audio_dec") 开启线程解码

audio解码使用软解，audio数据量小，算法相对简单没有video复杂，解码对CPU资源占用极小。

ijk销毁函数：iOS调用shutdown，android调用release。

这两个函数本质都是要调用ffplay的 ffp_stop_l和ffp_wait_stop_l函数，
ijk的释放都是在ffp_wait_stop_l函数中，这个函数主要通过调用stream_close函数来释放掉ijk。
stream_close会销毁在ijk初始化时候创建的 队列 流 解码器 线程锁和线程条件变量。

未完待续。