IJK核心代码剖析2019-06-08

一、总体说明

1.打开ijkplayer，可看到其主要目录结构如下:

tool - 初始化项目工程脚本

config - 编译ffmpeg使用的配置文件

extra - 存放编译ijkplayer所需的依赖源文件, 如ffmpeg、openssl等

ijkmedia - 核心代码

ijkplayer - 播放器数据下载及解码相关

ijksdl - 音视频数据渲染相关

ios - iOS平台上的上层接口封装以及平台相关方法

android - android平台上的上层接口封装以及平台相关方法

在功能的具体实现上，iOS和Android平台的差异主要表现在视频硬件解码以及音视频渲染方面，两者实现的载体区别如下表所示：

Platform HardwareCodec VideoRender AudioOutput

iOS VideoToolBox OpenGL ES AudioQueue

Android MediaCodec OpenGL ES/MediaCodec OpenSL ES/AudioTrack

2.IJK模块

初始化模块：初始化完成的主要工作就是创建IJKMediaPlayer播放器对象，创建图像渲染对象SDL_Vout，创建平台相关的IJKFF_Pipeline对象

核心模块：音视频数据读取、音视频解码、音视频渲染及同步

事件处理：在播放过程中，某些行为的完成或者变化，如prepare完成，开始渲染等，需要以事件形式通知到外部，以便上层作出具体的业务处理

二、初始化流程

在该方法中主要完成了三个动作：

1.创建IJKMediaPlayer对象；

2.创建图像渲染对象SDL_Vout；

3.创建平台相关的IJKFF_Pipeline对象，包括视频解码以及音频输出部分

IjkMediaPlayer *ijkmp_android_create(int(*msg_loop)(void*))//ijkmp_android_create(message_loop)

//(21)通过ffp_create方法创建了FFPlayer对象，并设置消息处理函数

ijkmp_create(msg_loop)

IjkMediaPlayer *mp = (IjkMediaPlayer *) mallocz(sizeof(IjkMediaPlayer));

mp->ffplayer = ffp_create();

mp->msg_loop = msg_loop;

//(22)创建图像渲染对象SDL_Vout

mp->ffplayer->vout = SDL_VoutAndroid_CreateForAndroidSurface();

return SDL_VoutAndroid_CreateForANativeWindow();

SDL_Vout *vout = SDL_Vout_CreateInternal(sizeof(SDL_Vout_Opaque));

//函数指针初始化

vout->opaque_class = &g_nativewindow_class;

vout->create_overlay= func_create_overlay;

vout->free_l   = func_free_l;

vout->display_overlay = func_display_overlay;

//(23)创建平台相关的IJKFF_Pipeline对象，包括视频解码以及音频输出部分

mp->ffplayer->pipeline = ffpipeline_create_from_android(mp->ffplayer);

IJKFF_Pipeline *pipeline = ffpipeline_alloc(&g_pipeline_class, sizeof(IJKFF_Pipeline_Opaque));

//函数指针初始化

pipeline->func_open_video_decoder = func_open_video_decoder;

至此已经完成了ijkplayer播放器初始化的相关流程，简单来说，就是创建播放器对象，完成音视频解码、渲染的准备工作。

static JNINativeMethod g_methods[] = {

  {

   "_setDataSource",

  "(LV",

   !!!(void *) IjkMediaPlayer_setDataSourceAndHeaders

  },

  { "_setDataSourceFd",   "(I)V",  (void *) IjkMediaPlayer_setDataSourceFd },

  { "_setDataSource",  "(Ltv/danmaku/ijk/media/player/misc/IMediaDataSource;)V", (void *)IjkMediaPlayer_setDataSourceCallback },

  { "_setAndroidIOCallback","(Ltv/danmaku/ijk/media/player/misc/IAndroidIO;)V", (void *)IjkMediaPlayer_setAndroidIOCallback },

  { "_setVideoSurface",  "(Landroid/view/Surface;)V", (void *) IjkMediaPlayer_setVideoSurface },

  { "_prepareAsync",   "()V", (void *) IjkMediaPlayer_prepareAsync },//00

  { "_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 },

  { "getCurrentPosition",  "()J", (void *) IjkMediaPlayer_getCurrentPosition },

  { "getDuration",    "()J",  (void *) IjkMediaPlayer_getDuration },

  { "_release",     "()V", (void *) IjkMediaPlayer_release },

  { "_reset",      "()V", (void *) IjkMediaPlayer_reset },

  { "setVolume",    "(FF)V",(void *) IjkMediaPlayer_setVolume },

  { "getAudioSessionId",  "()I",  (void *) IjkMediaPlayer_getAudioSessionId },

  { "native_init",    "()V",  (void *) IjkMediaPlayer_native_init },

  { "native_setup",    "(LV", (void *) IjkMediaPlayer_native_setup },

  { "native_finalize",  "()V", (void *) IjkMediaPlayer_native_finalize },

  { "_setOption",    "(IL IjkMediaPlayer_setOption },

  { "_setOption",    "(ILV",     (void *) IjkMediaPlayer_setOptionLong },

  { "_getColorFormatName", "(I)Ljava/lang/String;", (void *) IjkMediaPlayer_getColorFormatName },

  { "_getVideoCodecInfo",  "()Ljava/lang/String;",  (void *) IjkMediaPlayer_getVideoCodecInfo },

  { "_getAudioCodecInfo",  "()Ljava/lang/String;",  (void *) IjkMediaPlayer_getAudioCodecInfo },

  { "_getMediaMeta",   "()Landroid/os/Bundle;", (void *) IjkMediaPlayer_getMediaMeta },

  { "_setLoopCount",   "(I)V",       (void *) IjkMediaPlayer_setLoopCount },

  { "_getLoopCount",   "()I",      (void *) IjkMediaPlayer_getLoopCount },

  { "_getPropertyFloat",  "(IF)F",      (void *) ijkMediaPlayer_getPropertyFloat },

  { "_setPropertyFloat",  "(IF)V",      (void *) ijkMediaPlayer_setPropertyFloat },

  { "_getPropertyLong",   "(IJ)J",      (void *) ijkMediaPlayer_getPropertyLong },

  { "_setPropertyLong",   "(IJ)V",      (void *) ijkMediaPlayer_setPropertyLong },

  { "_setStreamSelected",  "(IZ)V",      (void *) ijkMediaPlayer_setStreamSelected },

  { "native_profileBegin", "(LV", (void *) IjkMediaPlayer_native_profileBegin },

  { "native_profileEnd",  "()V",       (void *) IjkMediaPlayer_native_profileEnd },

  { "native_setLogLevel",  "(I)V",       (void *) IjkMediaPlayer_native_setLogLevel },

  { "_setFrameAtTime",  "(L IjkMediaPlayer_setFrameAtTime },

};

三、核心代码剖析

//ijkplayer实际上是基于ffplay.c实现的，

//本章节将以该文件为主线，从数据接收（数据读取）、音视频解码、音视频渲染及同步这三大方面进行讲解，要求读者有基本的ffmpeg知识。

IjkMediaPlayer_prepareAsync(JNIEnv *env, jobject thiz)

int ijkmp_prepare_async(IjkMediaPlayer *mp)

static int ijkmp_prepare_async_l(IjkMediaPlayer *mp)

//开始播放时，启动消息线程

mp->msg_thread = SDL_CreateThreadEx(&mp->_msg_thread, ijkmp_msg_loop, mp, "ff_msg_loop");

int ret = mp->msg_loop(arg);

//该方法是启动播放器的入口函数，在此会设置player选项，打开audio output，最重要的是调用stream_open方法。

int ffp_prepare_async_l(FFPlayer *ffp, const char *file_name)

//音频输出：ijkplayer中Android平台使用OpenSL ES或AudioTrack输出音频，iOS平台使用AudioQueue输出音频。

ffp->aout = ffpipeline_open_audio_output(ffp->pipeline, ffp);

return pipeline->func_open_audio_output(pipeline, ffp);

if (ffp->opensles) {

aout = SDL_AoutAndroid_CreateForOpenSLES();

} else {

//默认硬解，主要完成的是创建SDL_Aout对象

//回到ffplay.c中，如果发现待播放的文件中含有音频，那么在调用stream_component_open打开解码器时，该方法里面也调用audio_open打开了audio output设备。

aout = SDL_AoutAndroid_CreateForAudioTrack();

}

static VideoState *stream_open(FFPlayer *ffp, const char *filename, AVInputFormat *iformat)

从代码中可以看出，stream_open主要做了以下几件事情:

(1)创建存放video/audio解码前数据的videoq/audioq

(2)创建存放video/audio解码后数据的pictq/sampq

(3)创建视频渲染线程video_refresh_thread

(4)创建读数据线程read_thread

if (frame_queue_init(&is->pictq, &is->videoq, ffp->pictq_size, 1) < 0)

goto fail;

if (frame_queue_init(&is->subpq, &is->subtitleq, SUBPICTURE_QUEUE_SIZE, 0) < 0)

goto fail;

if (frame_queue_init(&is->sampq, &is->audioq, SAMPLE_QUEUE_SIZE, 1) < 0)

goto fail;

//视频的处理流程:

//1.在decoder_decode_frame 方法中从解码前的video queue中取出一帧数据，

//2.送入decoder进行解码，解码后的数据在ffplay_video_thread中送入pictq,

//3.解码后的数据被送到pictq后,video_image_display2函数会取出最新的解码后的视频数据

//4.然后交给SDL通过openGL来进行渲染

秒开，首先，我们知道在ijkplayer默认视频同步到音频，在video_refresh_thread对视频做了同步，

我们把视频前两帧数据不做同步，即时刷新，这样能大大加快首屏时间，其次我们设置probesize大小，

如果probesize不设置的话，avformat_find_stream_info会消耗很长时间，这里建议如果只是音频，设置1k，

如果是音视频，设置为64k，更进一步的修改是自己设置相关解码属性，不用avformat_find_stream_info获取，

最后我们还可以对前两帧的刷新时机进行进一步优化，现在通过sleep来控制，可以换成信号量，解码之后，

立即通知开始执行渲染，改完这些之后基本上首屏能在500ms内。

is->video_refresh_tid = SDL_CreateThreadEx(&is->_video_refresh_tid, video_refresh_thread, ffp, "ff_vout");

//音视频同步

参考时钟的选择也有多种方式：

选取视频时间戳作为参考时钟源

选取音频时间戳作为参考时钟源

选取外部时间作为参考时钟源

考虑人对视频、和音频的敏感度，在存在音频的情况下，优先选择音频作为主时钟源。

video_refresh(ffp, &remaining_time);

(312)

//lastvp是上一帧，vp是当前帧，//循环队列，看不懂???

//1.frame_queue_peek_last表示从循环队列帧里面取出当前需要显示的上一帧视频

//2.frame_queue_peek表示从循环队列帧里面取出当前需要显示的一帧视频

//3.frame_queue_peek_next表示从循环队列帧里面取出当前需要显示的下一帧视频

//4.frame_queue_next从帧队列中取出帧之后的参数操作

//5.Frame *frame_queue_peek_writable(FrameQueue *f)//返回要填充的frame_queue中的Frame。

//6.frame_queue_push放帧到队列中，frame_queue_peek_writable之后的参数操作，windex++

lastvp = frame_queue_peek_last(&is->pictq);

vp = frame_queue_peek(&is->pictq);

//last_duration则是根据当前帧和上一帧的pts，计算出来上一帧的显示时间，

//经过compute_target_delay方法，计算出显示当前帧需要等待的时间

在compute_target_delay方法中，如果发现当前主时钟源不是video，则计算当前视频时钟与主时钟的差值：

如果当前视频帧落后于主时钟源，则需要减小下一帧画面的等待时间；

如果视频帧超前，并且该帧的显示时间大于显示更新门槛，则显示下一帧的时间为超前的时间差加上上一帧的显示时间

如果视频帧超前，并且上一帧的显示时间小于显示更新门槛，则采取加倍延时的策略。

last_duration = vp_duration(is, lastvp, vp);

delay = compute_target_delay(ffp, last_duration, is);

//frame_timer实际上就是上一帧的播放时间，

//而frame_timer + delay实际上就是当前这一帧的播放时间，

//(312)如果系统时间还没有到当前这一帧的播放时间，直接跳转至display，

//而此时is->force_refresh变量为0，不显示当前帧，

//进入video_refresh_thread中下一次循环，并睡眠等待。

time= av_gettime_relative()/1000000.0;

if (isnan(is->frame_timer) || time < is->frame_timer)

is->frame_timer = time;

if (time < is->frame_timer + delay) {

*remaining_time = FFMIN(is->frame_timer + delay - time, *remaining_time);

goto display;

}

//(313)如果当前这一帧的播放时间已经过了，

//并且其和当前系统时间的差值超过了AV_SYNC_THRESHOLD_MAX，

//则将当前这一帧的播放时间改为系统时间，并在后续判断是否需要丢帧，

//其目的是为后面帧的播放时间重新调整frame_timer，

//如果缓冲区中有更多的数据，并且当前的时间已经大于当前帧的持续显示时间，

//则丢弃当前帧，尝试显示下一帧。

is->frame_timer += delay;

if (delay > 0 && time - is->frame_timer > AV_SYNC_THRESHOLD_MAX)

is->frame_timer = time;

SDL_LockMutex(is->pictq.mutex);

if (!isnan(vp->pts))

update_video_pts(is, vp->pts, vp->pos, vp->serial);

SDL_UnlockMutex(is->pictq.mutex);

if (frame_queue_nb_remaining(&is->pictq) > 1) {

//表示从循环队列帧里面取出当前需要显示的下一帧视频

Frame *nextvp = frame_queue_peek_next(&is->pictq);

duration = vp_duration(is, vp, nextvp);

if(!is->step && (ffp->framedrop > 0 || (ffp->framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) && time > is->frame_timer + duration) {

frame_queue_next(&is->pictq);

goto retry;

}

}

//(314)最后渲染图像的方法

video_display2(ffp);

video_image_display2(ffp);

//数据传递：is->pictq 到 vp->bmp 到 overlay

//(3131)从pictq中读取当前需要显示视频帧//f->rindex

vp = frame_queue_peek_last(&is->pictq);

//(3132)进行绘制////显示每帧图片

SDL_VoutDisplayYUVOverlay(ffp->vout, vp->bmp);

return vout->display_overlay(vout, overlay);

//在ijksdl_vout_android_nativewindow.c/SDL_VoutAndroid_CreateForANativeWindow()函数中

vout->display_overlay = func_display_overlay;

//调用OpengGL绘制图像

int retval = func_display_overlay_l(vout, overlay);

return IJK_EGL_display(opaque->egl, native_window, overlay);

//（or）return SDL_Android_NativeWindow_display_l(native_window, overlay);

//read_thread()调用了如下函数：

1.avformat_open_input()：打开媒体。

2.avformat_find_stream_info()：获得媒体信息。

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

4.stream_component_open()：分别打开视频/音频/字幕解码线程。

5.refresh_thread()：视频刷新线程。

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

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

is->read_tid = SDL_CreateThreadEx(&is->_read_tid, read_thread, ffp, "ff_read");//创建数据读取线程

ic = avformat_alloc_context();//（41）创建上下文结构体，这个结构体是最上层的结构体，表示输入上下文

ic->interrupt_callback.callback = decode_interrupt_cb;//（42）设置中断函数，如果出错或者退出，就可以立刻退出

ic->interrupt_callback.opaque = is;

//（43）打开文件，主要是探测协议类型，如果是网络文件则创建网络链接等

err = avformat_open_input(&ic, is->filename, is->iformat, &ffp->format_opts);

//（44）探测媒体类型，可得到当前文件的封装格式，音视频编码参数等信息

err = avformat_find_stream_info(ic, opts);

//（45）打开ffmpeg视频、音频解码器。在此会打开相应解码器，并创建相应的解码线程。

int stream_component_open(FFPlayer *ffp, int stream_index)

//stream_component_open(ffp, st_index[AVMEDIA_TYPE_AUDIO]);

//ret = stream_component_open(ffp, st_index[AVMEDIA_TYPE_VIDEO]);

//stream_component_open(ffp, st_index[AVMEDIA_TYPE_SUBTITLE]);

codec = avcodec_find_decoder(avctx->codec_id);//获取音视频编码格式

if ((ret = avcodec_open2(avctx, codec, &opts)) < 0) {//用一个编码格式打开一个编码文件

goto fail;

}

switch (avctx->codec_type) {

case AVMEDIA_TYPE_AUDIO:

//（451）打开音频解码器，创建audio解码线程

ret = audio_open(is, channel_layout, nb_channels, sample_rate, &is->audio_tgt)

//(4511)配置了音频输出的相关参数SDL_AudioSpec

SDL_AudioSpec wanted_spec;

wanted_spec.format = AUDIO_S16SYS;

wanted_spec.silence = 0;

wanted_spec.samples = FFMAX(SDL_AUDIO_MIN_BUFFER_SIZE, 2 << av_log2(wanted_spec.freq / SDL_AoutGetAudioPerSecondCallBacks(ffp->aout)));

//(4513)AudioTrack（Android）/AudioQueue（IOS）模块在工作过程中，通过不断的callback来获取pcm数据进行播放

wanted_spec.callback = sdl_audio_callback;

//(4512)用此函数来打开音响设备

while (SDL_AoutOpenAudio(ffp->aout, &wanted_spec, &spec) < 0) {}

return aout->open_audio(aout, desired, obtained);

ret = decoder_start(&is->auddec, audio_thread, ffp, "ff_audio_dec")//audio的解码线程

case AVMEDIA_TYPE_VIDEO:

//（452）创建IJKFF_Pipenode

ffp->node_vdec = ffpipeline_open_video_decoder(ffp->pipeline, ffp);

return pipeline->func_open_video_decoder(pipeline, ffp);//ffpipeline_anroid.c

//iOS平台上硬解使用VideoToolbox，Android平台上使用MediaCodec。ijkplayer中的音频解码只支持软解，暂不支持硬解。

// 根据是否设置mediacodec参数决定是否启用硬解码 //默认软解

if (ffp->mediacodec_all_videos || ffp->mediacodec_avc || ffp->mediacodec_hevc || ffp->mediacodec_mpeg2){

ALOGD("laixh1 ffpipenode_create_video_decoder_from_android_mediacodec()\n");

node = ffpipenode_create_video_decoder_from_android_mediacodec(ffp, pipeline, opaque->weak_vout);

}

if (!node) {//如果ffpipenode_create_video_decoder_from_android_mediacodec返回的node为NULL 那么就会走软解

ALOGD("laixh2 ffpipenode_create_video_decoder_from_ffplay()\n");

node = ffpipenode_create_video_decoder_from_ffplay(ffp);

}

//（453）video的解码线程

//不管视频解码还是音频解码，其基本流程都是从解码前的数据缓冲区中取出一帧数据进行解码，完成后放入相应的解码后的数据缓冲区

ret = decoder_start(&is->viddec, video_thread, ffp, "ff_video_dec")

if (ffp->node_vdec)

{

ret = ffpipenode_run_sync(ffp->node_vdec);

//func_run_sync取决于播放前配置的软硬解。

//软解：调用ffpipenode_ffplay_vdec调用ffpipenode_ffplay_vdec.c中的函数定义；//默认软解

//硬解：调用ffpipenode_ffplay_vdec调用ffpipenode_ffplay_mediacodec.c中的函数定义；

return node->func_run_sync(node);

return ffp_video_thread(opaque->ffp);

return ffplay_video_thread(ffp);//ff_ffplay.c

for (;;) {

//(4531)该方法中从解码前的video queue中取出一帧数据，送入decoder进行解码，

ret = get_video_frame(ffp, frame);

got_picture = decoder_decode_frame(ffp, &is->viddec, frame, NULL)

AVPacket pkt;

for (;;) {

//(45311)从解码前的video queue中取出一帧数据

do {

packet_queue_get_or_buffering(ffp, d->queue, &pkt, &d->pkt_serial, &d->finished) < 0)

while(1){

//获取压缩编码数据(一个AVPacket)

int new_packet = packet_queue_get(q, pkt, 0, serial);

}

}while (d->queue->serial != d->pkt_serial);

//(45312)将流数据输出给解码器进行解码

ffmpeg中解码的API之前的是avcodec_decode_video2()和avcodec_decode_audio4()，

现在使用avcodec_send_packet()/ avcodec_receive_frame()来代替原有的接口

// 1）对于解码，请调用avcodec_send_packet()以在AVPacket中给出解码器原始的压缩数据。

// 2）对于编码，请调用avcodec_send_frame()为编码器提供包含未压缩音频或视频的AVFrame

avcodec_send_packet和avcodec_receive_frame调用关系并不一定是一对一的，

比如一些音频数据一个AVPacket中包含了1秒钟的音频，调用一次avcodec_send_packet之后，

可能需要调用25次 avcodec_receive_frame才能获取全部的解码音频数据

do {

ret = avcodec_receive_frame(d->avctx, frame);

}while (ret != AVERROR(EAGAIN));

avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)

decode_receive_frame_internal(avctx, avci->buffer_frame);

av_packet_unref(&pkt);

}

//(4532)默认MAX_RETRY_CONVERT_IMAGE=3//laixh秒开优化改成1，验证效果???没有效果！！

while (retry_convert_image <= MAX_RETRY_CONVERT_IMAGE) {

ret = convert_image(ffp, frame, (int64_t)pts, frame->width, frame->height);

//FFmpeg里面的sws_scale库可以在一个函数里面同时实现:

//1.图像色彩空间转换;2.分辨率缩放;3.前后图像滤波处理。

//其核心函数主要有三个:sws_getContext()：初始化一个SwsContext；sws_scale()：处理图像数据；sws_freeContext()：释放一个SwsContext。

//初始化一个SwsContext //src_frame->format转AV_PIX_FMT_RGB24

img_info->frame_img_convert_ctx = sws_getContext(width,height,src_frame->format,dst_width,dst_height,AV_PIX_FMT_RGB24,SWS_BICUBIC,NULL, NULL,NULL)

//处理图像数据。

//参数struct SwsContext *c,为上面sws_getContext函数返回值;

//参数const uint8_t *const srcSlice[], const int srcStride[]定义输入图像信息(当前处理区域的每个通道数据指针,每个通道行字节数)

//参数uint8_t *const dst[], const int dstStride[]定义输出图像信息(输出的每个通道数据指针,每个通道行字节数)

ret = sws_scale(img_info->frame_img_convert_ctx,(const uint8_t * const *) src_frame->data,src_frame->linesize,0,src_frame->height,dst_frame->data, dst_frame->linesize);

//avctx：编码器的AVCodecContext；avpkt：编码输出的AVPacket；frame：编码输入的AVFrame；got_packet_ptr：成功编码一个AVPacket的时候设置为1。

//函数返回0代表编码成功。//不是解码吗？为什么还要进行编码???

ret = avcodec_encode_video2(AVCodecContext *avctx, AVPacket *avpkt,const AVFrame *frame, int *got_packet_ptr);

if (ret >= 0 && got_packet > 0) {

fd = open(file_path, O_RDWR | O_TRUNC | O_CREAT, 0600);

write(fd, avpkt.data, avpkt.size);

}

//释放一个SwsContext。

sws_freeContext()

}

//(4533)解码后的数据在ffplay_video_thread中送入pictq

ret = queue_picture(ffp, frame, pts, duration, frame->pkt_pos, is->viddec.pkt_serial);

//返回要填充的frame_queue中的Frame

//Frame *frame_queue_peek_writable(FrameQueue *f)

vp = frame_queue_peek_writable(&is->pictq)

//放帧到队列中//frame_queue_peek_writable之后的参数操作，windex++

frame_queue_push(&is->pictq);

}

}

//重复(46)、(47)步，即可不断获取待播放的数据。

//（46）读取媒体数据，得到的是音视频分离的解码前数据

ret = av_read_frame(ic, pkt);

//(47)将音视频数据分别送入相应的queue中

if (pkt->stream_index == is->audio_stream && pkt_in_play_range) {

packet_queue_put(&is->audioq, pkt);

} else if (pkt->stream_index == is->video_stream && pkt_in_play_range

 && !(is->video_st && (is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC))) {

packet_queue_put(&is->videoq, pkt);

} else if (pkt->stream_index == is->subtitle_stream && pkt_in_play_range) {

packet_queue_put(&is->subtitleq, pkt);

} else {

av_packet_unref(pkt);

}

四、事件处理

//在播放过程中，某些行为的完成或者变化，如prepare完成，开始渲染等，需要以事件形式通知到外部，以便上层作出具体的业务处理。

//ijkplayer支持的事件比较多，具体定义在ijkplayer/ijkmedia/ijkplayer/ff_ffmsg.h中

#define FFP_MSG_FLUSH        0

#define FFP_MSG_ERROR        100 

#define FFP_MSG_PREPARED      200

#define FFP_MSG_COMPLETED      300

#define FFP_MSG_VIDEO_SIZE_CHANGED  400 

#define FFP_MSG_SAR_CHANGED     401 

#define FFP_MSG_VIDEO_RENDERING_START  402

#define FFP_MSG_AUDIO_RENDERING_START  403

#define FFP_MSG_VIDEO_ROTATION_CHANGED 404

#define FFP_MSG_BUFFERING_START    500

#define FFP_MSG_BUFFERING_END     501

#define FFP_MSG_BUFFERING_UPDATE   502

#define FFP_MSG_BUFFERING_BYTES_UPDATE 503

#define FFP_MSG_BUFFERING_TIME_UPDATE  504

#define FFP_MSG_SEEK_COMPLETE     600 

#define FFP_MSG_PLAYBACK_STATE_CHANGED 700

#define FFP_MSG_TIMED_TEXT     800

#define FFP_MSG_VIDEO_DECODER_OPEN  10001

#define MEDIA_INFO_UNKNOWN = 1,

#define MEDIA_INFO_VIDEO_RENDERING_START = 3, // 第一帧视频数据渲染时间

#define MEDIA_INFO_VIDEO_ROTATION_CHANGED = 10001,

#define MEDIA_INFO_AUDIO_RENDERING_START= 10002,

#define MEDIA_INFO_AUDIO_DECODED_START= 10003,

#define MEDIA_INFO_VIDEO_DECODED_START= 10004, //第一帧视频解码完成时间

#define MEDIA_INFO_OPEN_INPUT    = 10005, //avformat_open_input执行完成时间

#define MEDIA_INFO_FIND_STREAM_INFO  = 10006, //avformat_find_stream_info执行完成时间

#define MEDIA_INFO_COMPONENT_OPEN   = 10007, //IO设备操作完成时间

#define MEDIA_INFO_VIDEO_FIRSTPKT_GOT //首帧获取时间

//ijkmp_android_create(message_loop)

IjkMediaPlayer *ijkmp_android_create(int(*msg_loop)(void*))

ijkmp_create(msg_loop)

//(41)消息上报初始化

mp->msg_loop = msg_loop;

mp->ffplayer->vout = SDL_VoutAndroid_CreateForAndroidSurface();

return SDL_VoutAndroid_CreateForANativeWindow();

//函数指针初始化

vout->opaque_class = &g_nativewindow_class;

vout->create_overlay= func_create_overlay;

vout->free_l   = func_free_l;

vout->display_overlay = func_display_overlay;

IjkMediaPlayer_prepareAsync(JNIEnv *env, jobject thiz)

int ijkmp_prepare_async(IjkMediaPlayer *mp)

static int ijkmp_prepare_async_l(IjkMediaPlayer *mp)

//(42)开始播放时，启动消息线程

mp->msg_thread = SDL_CreateThreadEx(&mp->_msg_thread, ijkmp_msg_loop, mp, "ff_msg_loop");

int ret = mp->msg_loop(arg);

message_loop

message_loop_n

while (1) {

//(44)最后是在该方法中读取消息，并采用notification通知到APP上层

int retval = ijkmp_get_msg(mp, &msg, 1);

switch (msg.what) {

case FFP_MSG_VIDEO_RENDERING_START:

MPTRACE("FFP_MSG_VIDEO_RENDERING_START:\n");

post_event(env, weak_thiz, MEDIA_INFO, MEDIA_INFO_VIDEO_RENDERING_START, 0);

break;

case FFP_MSG_OPEN_INPUT:

MPTRACE("FFP_MSG_OPEN_INPUT:\n");

post_event(env, weak_thiz, MEDIA_INFO, MEDIA_INFO_OPEN_INPUT, 0);

break;

case FFP_MSG_FIND_STREAM_INFO:

MPTRACE("FFP_MSG_FIND_STREAM_INFO:\n");

post_event(env, weak_thiz, MEDIA_INFO, MEDIA_INFO_FIND_STREAM_INFO, 0);

break;

}

}

//(43)ffplay.c中上报PREPARED完成

ffp_notify_msg1(ffp, FFP_MSG_PREPARED);

ffp_notify_msg1(ffp, FFP_MSG_VIDEO_RENDERING_START);

//将事件及其参数封装成了AVMessge对象

msg_queue_put_simple3(&ffp->msg_queue, what, 0, 0);

msg_init_msg(&msg);

msg_queue_put(q, &msg);

//消息对象放入消息队列

ret = msg_queue_put_private(q, msg);

预加载接口

  public void doPreload(String url, int tsindex){

   //stop

   _doPreload(url, tsindex);

  }

//预缓存清除接口

  public void deleteCache() {

   _deleteCache();

  }