前言

我是一名打算走音视频路线的android开发者。以此系列文章开始，记录我的音视频开发学习之路

ijkplayer系列文章目录：
理解ijkplayer（一）：开始

理解ijkplayer（二）项目结构分析

理解ijkplayer（三）从Java层开始初始化

理解ijkplayer（四）拉流

理解ijkplayer（五）解码、播放

由于篇幅的原因，因此这一篇文章是接着上一篇继续写的。

上一篇文章分析完了：

  1. JNI_Onload()
  2. native_init()
  3. native_setup()
  4. _setDataSource()
  5. _setVideoSurface

1 _prepareAsync()

播放器的异步准备。这是初始化阶段中最复杂，最重要的函数。

  1. //    ijkmedia/ijkplayer/android/ijkplayer_jni.c
  2. static void
  3. IjkMediaPlayer_prepareAsync(JNIEnv *env, jobject thiz)
  4. {
  5.     MPTRACE("%s\n", __func__);
  6.     int retval = 0;
  7.     IjkMediaPlayer *mp = jni_get_media_player(env, thiz);
  8.     JNI_CHECK_GOTO(mp, env, "java/lang/IllegalStateException", "mpjni: prepareAsync: null mp", LABEL_RETURN);
  10.     retval = ijkmp_prepare_async(mp);
  11.     IJK_CHECK_MPRET_GOTO(retval, env, LABEL_RETURN);
  13. LABEL_RETURN:
  14.     ijkmp_dec_ref_p(&mp);
  15. }
  1. //    ijkmedia/ijkplayer/ijkplayer.c
  2. int ijkmp_prepare_async(IjkMediaPlayer *mp)
  3. {
  4.     assert(mp);
  5.     MPTRACE("ijkmp_prepare_async()\n");
  6.     pthread_mutex_lock(&mp->mutex);
  7.     int retval = ijkmp_prepare_async_l(mp);
  8.     pthread_mutex_unlock(&mp->mutex);
  9.     MPTRACE("ijkmp_prepare_async()=%d\n", retval);
  10.     return retval;
  11. }
  1. static int ijkmp_prepare_async_l(IjkMediaPlayer *mp)
  2. {
  3.     assert(mp);
  5.     MPST_RET_IF_EQ(mp->mp_state, MP_STATE_IDLE);
  6.     // MPST_RET_IF_EQ(mp->mp_state, MP_STATE_INITIALIZED);
  7.     MPST_RET_IF_EQ(mp->mp_state, MP_STATE_ASYNC_PREPARING);
  8.     MPST_RET_IF_EQ(mp->mp_state, MP_STATE_PREPARED);
  9.     MPST_RET_IF_EQ(mp->mp_state, MP_STATE_STARTED);
  10.     MPST_RET_IF_EQ(mp->mp_state, MP_STATE_PAUSED);
  11.     MPST_RET_IF_EQ(mp->mp_state, MP_STATE_COMPLETED);
  12.     // MPST_RET_IF_EQ(mp->mp_state, MP_STATE_STOPPED);
  13.     MPST_RET_IF_EQ(mp->mp_state, MP_STATE_ERROR);
  14.     MPST_RET_IF_EQ(mp->mp_state, MP_STATE_END);
  15.     //声明url不为空
  16.     assert(mp->data_source);
  17.     //改变播放器状态到MP_STATE_ASYNC_PREPARING
  18.     ijkmp_change_state_l(mp, MP_STATE_ASYNC_PREPARING);
  19.     //消息队列开始
  20.     msg_queue_start(&mp->ffplayer->msg_queue);
  22.     // released in msg_loop
  23.     ijkmp_inc_ref(mp);
  24.     //创建并启动消息线程，开启循环来读取消息队列的消息。
  25.     mp->msg_thread = SDL_CreateThreadEx(&mp->_msg_thread, ijkmp_msg_loop, mp, "ff_msg_loop");
  26.     // msg_thread is detached inside msg_loop
  27.     // TODO: 9 release weak_thiz if pthread_create() failed;
  28.     //逻辑跳转到ff_ffplay.c
  29.     int retval = ffp_prepare_async_l(mp->ffplayer, mp->data_source);
  30.     if (retval < 0) {
  31.         //出错，则抛出MP_STATE_ERROR
  32.         ijkmp_change_state_l(mp, MP_STATE_ERROR);
  33.         return retval;
  34.     }
  36.     return 0;
  37. }

看到创建消息线程的那一句的ijkmp_msg_loop函数

  1. //这句函数会在线程被启动的时候调用，类似于Thread中的Runnable
  2. static int ijkmp_msg_loop(void *arg)
  3. {
  4.     IjkMediaPlayer *mp = arg;
  5.       //调用mp的msg_loop函数。
  6.     int ret = mp->msg_loop(arg);
  7.     return ret;
  8. }

mp->msg_loop这个函数，在前面播放器被创建的时候被赋值，在3.3.2中。

那么这时开启了消息循环线程，并且prepare的逻辑跳转到了ff_ffplay.c中

  1. //    ijkmedia/ijkplayer/ff_ffplay.c
  2. int ffp_prepare_async_l(FFPlayer *ffp, const char *file_name)
  3. {
  4.     assert(ffp);
  5.     assert(!ffp->is);
  6.     assert(file_name);
  7.     //针对rtmp和rtsp协议，移除选项”timeout“
  8.     if (av_stristart(file_name, "rtmp", NULL) ||
  9.         av_stristart(file_name, "rtsp", NULL)) {
  10.         // There is total different meaning for 'timeout' option in rtmp
  11.         av_log(ffp, AV_LOG_WARNING, "remove 'timeout' option for rtmp.\n");
  12.         av_dict_set(&ffp->format_opts, "timeout", NULL, 0);
  13.     }
  15.     /* there is a length limit in avformat */
  16.     if (strlen(file_name) + 1 > 1024) {
  17.         av_log(ffp, AV_LOG_ERROR, "%s too long url\n", __func__);
  18.         if (avio_find_protocol_name("ijklongurl:")) {
  19.             av_dict_set(&ffp->format_opts, "ijklongurl-url", file_name, 0);
  20.             file_name = "ijklongurl:";
  21.         }
  22.     }
  23.     //打印版本信息
  24.     av_log(NULL, AV_LOG_INFO, "===== versions =====\n");
  25.     ffp_show_version_str(ffp, "ijkplayer",      ijk_version_info());
  26.     ffp_show_version_str(ffp, "FFmpeg",         av_version_info());
  27.     ffp_show_version_int(ffp, "libavutil",      avutil_version());
  28.     ffp_show_version_int(ffp, "libavcodec",     avcodec_version());
  29.     ffp_show_version_int(ffp, "libavformat",    avformat_version());
  30.     ffp_show_version_int(ffp, "libswscale",     swscale_version());
  31.     ffp_show_version_int(ffp, "libswresample",  swresample_version());
  32.     av_log(NULL, AV_LOG_INFO, "===== options =====\n");
  33.     ffp_show_dict(ffp, "player-opts", ffp->player_opts);
  34.     ffp_show_dict(ffp, "format-opts", ffp->format_opts);
  35.     ffp_show_dict(ffp, "codec-opts ", ffp->codec_opts);
  36.     ffp_show_dict(ffp, "sws-opts   ", ffp->sws_dict);
  37.     ffp_show_dict(ffp, "swr-opts   ", ffp->swr_opts);
  38.     av_log(NULL, AV_LOG_INFO, "===================\n");
  39.     //设置播放器选项
  40.     av_opt_set_dict(ffp, &ffp->player_opts);
  41.     //如果ffplayer->aout==null，那么久打开音频输出设备。前面的初始化代码是没有为这个赋值过的，所以第一次调用肯定会返回true.
  42.     if (!ffp->aout) {
  43.         ffp->aout = ffpipeline_open_audio_output(ffp->pipeline, ffp);
  44.         if (!ffp->aout)
  45.             return -1;
  46.     }
  48. #if CONFIG_AVFILTER
  49.     if (ffp->vfilter0) {
  50.         GROW_ARRAY(ffp->vfilters_list, ffp->nb_vfilters);
  51.         ffp->vfilters_list[ffp->nb_vfilters - 1] = ffp->vfilter0;
  52.     }
  53. #endif
  54.         //打开流，并返回一个VideoState的结构体
  55.     VideoState *is = stream_open(ffp, file_name, NULL);
  56.     if (!is) {
  57.         av_log(NULL, AV_LOG_WARNING, "ffp_prepare_async_l: stream_open failed OOM");
  58.         return EIJK_OUT_OF_MEMORY;
  59.     }
  61.     ffp->is = is;
  62.     ffp->input_filename = av_strdup(file_name);
  63.     return 0;
  64. }

2 打开音频输出设备

  1. //如果ffplayer->aout==null，那么久打开音频输出设备。前面的初始化代码是没有为这个赋值过的，所以第一次调用肯定会返回true.
  2.     if (!ffp->aout) {
  3.         ffp->aout = ffpipeline_open_audio_output(ffp->pipeline, ffp);
  4.         if (!ffp->aout)
  5.             return -1;
  6.     }
  1. SDL_Aout *ffpipeline_open_audio_output(IJKFF_Pipeline *pipeline, FFPlayer *ffp)
  2. {
  3.     //借助pipeline的方法
  4.     return pipeline->func_open_audio_output(pipeline, ffp);
  5. }

而ffp->pipeline是在创建播放器IjkMediaPlayer的时候，在创建完ffplayer，和ffplyaer->vout一起创建的，在3.3.2有如下的代码：

  1. //    ijkmedia/ijkplayer/android/ijkplayer_android.c
  2. IjkMediaPlayer *ijkmp_android_create(int(*msg_loop)(void*))
  3. {
  4.     //创建IjkMediaPlayer
  5.     IjkMediaPlayer *mp = ijkmp_create(msg_loop);
  6.     if (!mp)
  7.         goto fail;
  8.     //创建视频输出设备，会根据根据硬解还是软件，硬解用MediaCodec创建，软解用FFmpeg创建
  9.     mp->ffplayer->vout = SDL_VoutAndroid_CreateForAndroidSurface();
  10.     if (!mp->ffplayer->vout)
  11.         goto fail;
  12.     //暂时不太理解这个叫做”管道“的东西是什么
  13.     mp->ffplayer->pipeline = ffpipeline_create_from_android(mp->ffplayer);
  14.     if (!mp->ffplayer->pipeline)
  15.         goto fail;
  16.     //将创建的视频输出设备vout，赋值到ffplayer->pipeline中
  17.     ffpipeline_set_vout(mp->ffplayer->pipeline, mp->ffplayer->vout);
  19.     return mp;
  21. fail:
  22.     ijkmp_dec_ref_p(&mp);
  23.     return NULL;
  24. }

那么我们看到pipeline->func_open_audio_output(pipeline, ffp);的这个方法：我一点进去直接跳转到IJKFF_Pipeline的结构体的定义来了。

  1. struct IJKFF_Pipeline {
  2.     SDL_Class             *opaque_class;
  3.     IJKFF_Pipeline_Opaque *opaque;
  5.     void            (*func_destroy)             (IJKFF_Pipeline *pipeline);
  6.     IJKFF_Pipenode *(*func_open_video_decoder)  (IJKFF_Pipeline *pipeline, FFPlayer *ffp);
  7.       //我们要看的是这个方法，名叫：打开音频输出设备。
  8.     SDL_Aout       *(*func_open_audio_output)   (IJKFF_Pipeline *pipeline, FFPlayer *ffp);
  9.     IJKFF_Pipenode *(*func_init_video_decoder)  (IJKFF_Pipeline *pipeline, FFPlayer *ffp);
  10.     int           (*func_config_video_decoder)  (IJKFF_Pipeline *pipeline, FFPlayer *ffp);
  11. };

这个函数应该是在某个地方被赋值了，我们得找一下，全局搜索关键字：func_open_audio_output

理解ijkplayer（四）拉流 - 图1

全局搜索中出现了3个对func_open_audio_output赋值的语句，分别出现在

  1. ffpipleline_android.c
  2. ffpipeline_ffplay.c
  3. ffpipeline_ios.c

其中貌似android和ios平台有各自的赋值规则，然后又一个中立的赋值的地方，我们先看这个平台无关的中立的赋值的地方：

  1. static SDL_Aout *func_open_audio_output(IJKFF_Pipeline *pipeline, FFPlayer *ffp)
  2. {    
  3.       //返回NULL
  4.     return NULL;
  5. }
  7. IJKFF_Pipeline *ffpipeline_create_from_ffplay(FFPlayer *ffp)
  8. {
  9.     IJKFF_Pipeline *pipeline = ffpipeline_alloc(&g_pipeline_class, sizeof(IJKFF_Pipeline_Opaque));
  10.     if (!pipeline)
  11.         return pipeline;
  13.     IJKFF_Pipeline_Opaque *opaque = pipeline->opaque;
  14.     opaque->ffp                   = ffp;
  16.     pipeline->func_destroy            = func_destroy;
  17.     pipeline->func_open_video_decoder = func_open_video_decoder;
  18.       //在这里
  19.     pipeline->func_open_audio_output  = func_open_audio_output;
  21.     return pipeline;
  22. }

这个平台无关的函数赋值语句赋值的函数返回了NULL。而我再全局搜索一下这个ffpipeline_create_from_ffplay，发现没有调用这个的地方。那么这个函数应该只是一个示范函数，让Android和ios平台去各自实现。

那么看下android这边的：

  1. IJKFF_Pipeline *ffpipeline_create_from_android(FFPlayer *ffp)
  2. {
  3.     ALOGD("ffpipeline_create_from_android()\n");
  4.     IJKFF_Pipeline *pipeline = ffpipeline_alloc(&g_pipeline_class, sizeof(IJKFF_Pipeline_Opaque));
  5.     if (!pipeline)
  6.         return pipeline;
  8.     IJKFF_Pipeline_Opaque *opaque = pipeline->opaque;
  9.     opaque->ffp                   = ffp;
  10.     opaque->surface_mutex         = SDL_CreateMutex();
  11.     opaque->left_volume           = 1.0f;
  12.     opaque->right_volume          = 1.0f;
  13.     if (!opaque->surface_mutex) {
  14.         ALOGE("ffpipeline-android:create SDL_CreateMutex failed\n");
  15.         goto fail;
  16.     }
  18.     pipeline->func_destroy              = func_destroy;
  19.     pipeline->func_open_video_decoder   = func_open_video_decoder;
  20.       //打开音频输出设备
  21.     pipeline->func_open_audio_output    = func_open_audio_output;
  22.     pipeline->func_init_video_decoder   = func_init_video_decoder;
  23.     pipeline->func_config_video_decoder = func_config_video_decoder;
  25.     return pipeline;
  26. fail:
  27.     ffpipeline_free_p(&pipeline);
  28.     return NULL;
  29. }

注意，这个ffpipeline_create_from_android方法被调用的地方，是在创建完ffplayer播放器后，和ffplayer->vout一起创建的，在3.3.2中有示例代码。

继续看func_open_audio_output函数：

  1. static SDL_Aout *func_open_audio_output(IJKFF_Pipeline *pipeline, FFPlayer *ffp)
  2. {
  3.     SDL_Aout *aout = NULL;
  4.     if (ffp->opensles) {
  5.           //如果打开了opensles，则用OpenSLES来创建音频输出设备
  6.         aout = SDL_AoutAndroid_CreateForOpenSLES();
  7.     } else {
  8.           //否则，使用Android平台的AudioTrack来创建音频输出设备
  9.         aout = SDL_AoutAndroid_CreateForAudioTrack();
  10.     }
  11.     if (aout)
  12.         SDL_AoutSetStereoVolume(aout, pipeline->opaque->left_volume, pipeline->opaque->right_volume);
  13.     return aout;
  14. }

那么这个ffp->opensles的返回值就很关键了，通过全局搜索，我看到在

inline static void ffp_reset_internal(*FFPlayer* **ffp*)函数中有：

  1.     ffp->opensles                       = 0; // option

即opensles是默认关闭的，除非用了option去打开它。

而option的定义位于：ijkmedia/ijkplayer/ff_ffplay_options.h。option是如何发挥作用的，后面再分析。

对于ijkplayer是如何利用AudioTrack来播放解码后的pcm音频数据的，这里也暂不分析。

3 打开流

  1.     VideoState *is = stream_open(ffp, file_name, NULL);

单看这一句，感觉是：根据file_name(url)打开对应的视频流，并返回一个VideoState(视频状态)

而这个VideoState是保存在FFPlayer里面的

  1. typedef struct FFPlayer {
  2.     const AVClass *av_class;
  4.     /* ffplay context */
  5.     VideoState *is;
  6.       //...
  7. }

而这个FFPlayer则是IikMediaPlayer中真正的播放器对象。

即一个播放器对应一个VideoState对象。

那么先看一下VideoState的结构体：

  1. typedef struct VideoState {
  2.     SDL_Thread *read_tid;//读线程
  3.     SDL_Thread _read_tid;
  4.     AVInputFormat *iformat;//输入格式
  5.     int abort_request;//停止请求
  6.     int force_refresh;//强制刷新
  7.     int paused;//暂停
  8.     int last_paused;
  9.     int queue_attachments_req;
  10.     int seek_req;
  11.     int seek_flags;
  12.     int64_t seek_pos;
  13.     int64_t seek_rel;
  14. #ifdef FFP_MERGE
  15.     int read_pause_return;
  16. #endif
  17.     AVFormatContext *ic;
  18.     int realtime;
  20.     Clock audclk;//音频时钟
  21.     Clock vidclk;//视频时钟
  22.     Clock extclk;//外部时钟
  24.     FrameQueue pictq;//图片帧队列：解码后的视频数据
  25.     FrameQueue subpq;//字幕帧队列：解码后的字幕数据
  26.     FrameQueue sampq;//音频帧队列：解码后的音频数据
  28.     Decoder auddec;//音频解码器
  29.     Decoder viddec;//视频解码器
  30.     Decoder subdec;//字幕解码器
  32.     int audio_stream;//音频流
  34.     int av_sync_type;
  35.     void *handle;
  36.     double audio_clock;
  37.     int audio_clock_serial;
  38.     double audio_diff_cum; /* used for AV difference average computation */
  39.     double audio_diff_avg_coef;
  40.     double audio_diff_threshold;
  41.     int audio_diff_avg_count;
  42.     AVStream *audio_st;
  43.     PacketQueue audioq;//音频包数据：未解码的音频数据，从demuxers输出
  44.     int audio_hw_buf_size;
  45.     uint8_t *audio_buf;
  46.     uint8_t *audio_buf1;
  47.     short *audio_new_buf;  /* for soundtouch buf */
  48.     unsigned int audio_buf_size; /* in bytes */
  49.     unsigned int audio_buf1_size;
  50.     unsigned int audio_new_buf_size;
  51.     int audio_buf_index; /* in bytes */
  52.     int audio_write_buf_size;
  53.     int audio_volume;
  54.     int muted;
  55.     struct AudioParams audio_src;
  56. #if CONFIG_AVFILTER
  57.     struct AudioParams audio_filter_src;
  58. #endif
  59.     struct AudioParams audio_tgt;
  60.     struct SwrContext *swr_ctx;
  61.     int frame_drops_early;
  62.     int frame_drops_late;
  63.     int continuous_frame_drops_early;
  65.     enum ShowMode {
  66.         SHOW_MODE_NONE = -1, SHOW_MODE_VIDEO = 0, SHOW_MODE_WAVES, SHOW_MODE_RDFT, SHOW_MODE_NB
  67.     } show_mode;
  68.     int16_t sample_array[SAMPLE_ARRAY_SIZE];
  69.     int sample_array_index;
  70.     int last_i_start;
  71. #ifdef FFP_MERGE
  72.     RDFTContext *rdft;
  73.     int rdft_bits;
  74.     FFTSample *rdft_data;
  75.     int xpos;
  76. #endif
  77.     double last_vis_time;
  78. #ifdef FFP_MERGE
  79.     SDL_Texture *vis_texture;
  80.     SDL_Texture *sub_texture;
  81. #endif
  83.     int subtitle_stream;
  84.     AVStream *subtitle_st;
  85.     PacketQueue subtitleq;//未解码的字幕数据：从demuxser输出
  87.     double frame_timer;
  88.     double frame_last_returned_time;
  89.     double frame_last_filter_delay;
  90.     int video_stream;
  91.     AVStream *video_st;
  92.     PacketQueue videoq;//未解码的视频数据：从demuxsers输出
  93.     double max_frame_duration;      // maximum duration of a frame - above this, we consider the jump a timestamp discontinuity
  94.     struct SwsContext *img_convert_ctx;
  95. #ifdef FFP_SUB
  96.     struct SwsContext *sub_convert_ctx;
  97. #endif
  98.     int eof;
  100.     char *filename;
  101.     int width, height, xleft, ytop;//视频的：宽、高、左上角x坐标，左上角y坐标。和ffmpeg里面的是对应的。
  102.     int step;
  104. #if CONFIG_AVFILTER
  105.     int vfilter_idx;
  106.     AVFilterContext *in_video_filter;   // the first filter in the video chain
  107.     AVFilterContext *out_video_filter;  // the last filter in the video chain
  108.     AVFilterContext *in_audio_filter;   // the first filter in the audio chain
  109.     AVFilterContext *out_audio_filter;  // the last filter in the audio chain
  110.     AVFilterGraph *agraph;              // audio filter graph
  111. #endif
  113.     int last_video_stream, last_audio_stream, last_subtitle_stream;
  115.     SDL_cond *continue_read_thread;
  117.     /* extra fields */
  118.     SDL_mutex  *play_mutex; // only guard state, do not block any long operation
  119.     SDL_Thread *video_refresh_tid;
  120.     SDL_Thread _video_refresh_tid;
  122.     int buffering_on;
  123.     int pause_req;
  125.     int dropping_frame;
  126.     int is_video_high_fps; // above 30fps
  127.     int is_video_high_res; // above 1080p
  129.     PacketQueue *buffer_indicator_queue;
  131.     volatile int latest_video_seek_load_serial;
  132.     volatile int latest_audio_seek_load_serial;
  133.     volatile int64_t latest_seek_load_start_at;
  135.     int drop_aframe_count;
  136.     int drop_vframe_count;
  137.     int64_t accurate_seek_start_time;
  138.     volatile int64_t accurate_seek_vframe_pts;
  139.     volatile int64_t accurate_seek_aframe_pts;
  140.     int audio_accurate_seek_req;
  141.     int video_accurate_seek_req;
  142.     SDL_mutex *accurate_seek_mutex;
  143.     SDL_cond  *video_accurate_seek_cond;
  144.     SDL_cond  *audio_accurate_seek_cond;
  145.     volatile int initialized_decoder;
  146.     int seek_buffering;
  147. } VideoState;

我针对我理解了的字段做了一些注释。

那么现在看到返回VideoState结构体的方法openstream

  1. static VideoState *stream_open(FFPlayer *ffp, const char *filename, AVInputFormat *iformat)
  2. {
  3.     assert(!ffp->is);
  4.     VideoState *is;
  5.     //创建VideoState结构体
  6.     is = av_mallocz(sizeof(VideoState));
  7.     if (!is)
  8.         return NULL;
  9.     //给VideoState结构体中的属性赋值
  10.     is->filename = av_strdup(filename);
  11.     if (!is->filename)
  12.         goto fail;
  13.     is->iformat = iformat;
  14.     is->ytop    = 0;
  15.     is->xleft   = 0;
  16. #if defined(__ANDROID__)
  17.     //android平台下的soundtouch，不太清楚是做什么的
  18.     if (ffp->soundtouch_enable) {
  19.         is->handle = ijk_soundtouch_create();
  20.     }
  21. #endif
  23.     /* start video display */
  24.     //初始化3个帧队列（解码后帧的队列）
  25.     if (frame_queue_init(&is->pictq, &is->videoq, ffp->pictq_size, 1) < 0)
  26.         goto fail;
  27.     if (frame_queue_init(&is->subpq, &is->subtitleq, SUBPICTURE_QUEUE_SIZE, 0) < 0)
  28.         goto fail;
  29.     if (frame_queue_init(&is->sampq, &is->audioq, SAMPLE_QUEUE_SIZE, 1) < 0)
  30.         goto fail;
  31.     //初始化3个包队列（解码前的帧队列,不过是demuxer输出的数据了）
  32.     if (packet_queue_init(&is->videoq) < 0 ||
  33.         packet_queue_init(&is->audioq) < 0 ||
  34.         packet_queue_init(&is->subtitleq) < 0)
  35.         goto fail;
  37.     //以下3个创建SDL_cond的函数，不太清楚他们的作用是什么，暂不分析
  38.     if (!(is->continue_read_thread = SDL_CreateCond())) {
  39.         av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
  40.         goto fail;
  41.     }
  43.     if (!(is->video_accurate_seek_cond = SDL_CreateCond())) {
  44.         av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
  45.         ffp->enable_accurate_seek = 0;
  46.     }
  48.     if (!(is->audio_accurate_seek_cond = SDL_CreateCond())) {
  49.         av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
  50.         ffp->enable_accurate_seek = 0;
  51.     }
  52.     //初始化音频时钟，视频时钟，外部时钟
  53.     init_clock(&is->vidclk, &is->videoq.serial);
  54.     init_clock(&is->audclk, &is->audioq.serial);
  55.     init_clock(&is->extclk, &is->extclk.serial);
  56.     is->audio_clock_serial = -1;
  57.     //初始化播放器的初始音量
  58.     if (ffp->startup_volume < 0)
  59.         av_log(NULL, AV_LOG_WARNING, "-volume=%d < 0, setting to 0\n", ffp->startup_volume);
  60.     if (ffp->startup_volume > 100)
  61.         av_log(NULL, AV_LOG_WARNING, "-volume=%d > 100, setting to 100\n", ffp->startup_volume);
  62.     ffp->startup_volume = av_clip(ffp->startup_volume, 0, 100);
  63.     ffp->startup_volume = av_clip(SDL_MIX_MAXVOLUME * ffp->startup_volume / 100, 0, SDL_MIX_MAXVOLUME);
  64.     is->audio_volume = ffp->startup_volume;
  65.     is->muted = 0;
  66.     is->av_sync_type = ffp->av_sync_type;
  67.     //初始化播放器互斥锁
  68.     is->play_mutex = SDL_CreateMutex();
  69.     is->accurate_seek_mutex = SDL_CreateMutex();
  70.     ffp->is = is;
  71.     //如果start_on_prepared=false，那么当prepare完之后要暂停，不能直接播放。
  72.     is->pause_req = !ffp->start_on_prepared;
  73.     //创建视频渲染线程
  74.     is->video_refresh_tid = SDL_CreateThreadEx(&is->_video_refresh_tid, video_refresh_thread, ffp, "ff_vout");
  75.     if (!is->video_refresh_tid) {
  76.         av_freep(&ffp->is);
  77.         return NULL;
  78.     }
  79.     //********开始初始化解码器
  80.     is->initialized_decoder = 0;
  81.     //创建读取线程
  82.     is->read_tid = SDL_CreateThreadEx(&is->_read_tid, read_thread, ffp, "ff_read");
  83.     if (!is->read_tid) {
  84.         av_log(NULL, AV_LOG_FATAL, "SDL_CreateThread(): %s\n", SDL_GetError());
  85.         goto fail;
  86.     }
  88.     if (ffp->async_init_decoder && !ffp->video_disable && ffp->video_mime_type && strlen(ffp->video_mime_type) > 0
  89.                     && ffp->mediacodec_default_name && strlen(ffp->mediacodec_default_name) > 0) {
  90.         if (ffp->mediacodec_all_videos || ffp->mediacodec_avc || ffp->mediacodec_hevc || ffp->mediacodec_mpeg2) {
  91.             decoder_init(&is->viddec, NULL, &is->videoq, is->continue_read_thread);
  92.             ffp->node_vdec = ffpipeline_init_video_decoder(ffp->pipeline, ffp);
  93.         }
  94.     }
  95.     //********初始化解码器完成
  96.     is->initialized_decoder = 1;
  98.     return is;
  99. fail:
  100.     is->initialized_decoder = 1;
  101.     is->abort_request = true;
  102.     if (is->video_refresh_tid)
  103.         SDL_WaitThread(is->video_refresh_tid, NULL);
  104.     stream_close(ffp);
  105.     return NULL;
  106. }

他的逻辑大致为：

  1. 创建VideoState对象，并初始化他的一些默认属性。
  2. 初始化视频、音频、字幕的解码后的帧队列。
  3. 初始化视频、音频、字幕的解码前的包队列。
  4. 初始化播放器音量。
  5. 创建视频渲染线程。
  6. 创建视频数据读取线程（从网络读取或者从文件读取，io操作）。
  7. 初始化解码器。（ffmpeg应该会在内部创建解码线程）。

因此，在openstream()方法中完成了最主要的3个线程的创建。

4 视频读取线程

在stream_open这个打开流的函数中，在开启了视频渲染线程后，接着就开启了视频读取线程。

  1. static VideoState *stream_open(FFPlayer *ffp, const char *filename, AVInputFormat *iformat){
  2.       //...
  3.         is->read_tid = SDL_CreateThreadEx(&is->_read_tid, read_thread, ffp, "ff_read");
  4.       //...
  5. }

通过创建单独的线程，专门用于读取Packet，在read_thread()函数中。而这个函数非常长，做了很多事情，先放出一个浓缩版的：

简略版代码：

  1. static int read_thread(void *arg)
  2. {
  3.        //Open an input stream and read the header. The codecs are not opened.
  4.     //The stream must be closed with avformat_close_input().
  5.     //打开输入流，并读取文件头部，解码器还未打开。主要作用是探测流的协议，如http还是rtmp等。
  6.     err = avformat_open_input(&ic, is->filename, is->iformat, &ffp->format_opts);
  8.     // Read packets of a media file to get stream information. This
  9.     // is useful for file formats with no headers such as MPEG. This
  10.     // function also computes the real framerate in case of MPEG-2 repeat
  11.     // frame mode.
  12.     // The logical file position is not changed by this function;
  13.     // examined packets may buffered for later processing. 
  14.     //探测文件封装格式，音视频编码参数等信息。
  15.     err = avformat_find_stream_info(ic, opts);
  17.     // Find the "best" stream in the file.
  18.     // The best stream is determined according to various heuristics as the most
  19.     // likely to be what the user expects.
  20.     // If the decoder parameter is non-NULL, av_find_best_stream will find the
  21.     // default decoder for the stream's codec; streams for which no decoder can
  22.     // be found are ignored.
  23.     //根据 AVFormatContext，找到最佳的流。
  24.     av_find_best_stream(ic, AVMEDIA_TYPE_VIDEO,
  25.                         st_index[AVMEDIA_TYPE_VIDEO], -1, NULL, 0);
  27.       //内部分别开启audio,video,subtitle的解码器的线程，开始各自的解码的工作。在稍后的3.6.5解码线程中分析这里的内容
  28.     stream_component_open(ffp, st_index[AVMEDIA_TYPE_AUDIO]);
  29.     stream_component_open(ffp, st_index[AVMEDIA_TYPE_VIDEO]);
  30.     stream_component_open(ffp, st_index[AVMEDIA_TYPE_SUBTITLE]);
  32.       //开始无限循环,调用ffmpeg的av_read_frame()读取AVPacket，并入队。
  33.       for (;;) {
  34.       //AVPacket pkt;
  36.       ret = av_read_frame(ic, pkt);
  38.       //把网络读取到并解封装到的pkt包入队列。（稍后在解码线程会拿到这些pkt包去解码。）
  40.             //如果是音频流的包
  41.       packet_queue_put(&is->audioq, pkt);
  42.       //如果是视频流的包
  43.       packet_queue_put(&is->videoq, pkt);
  44.       //如果是字幕流的包
  45.       packet_queue_put(&is->subtitleq, pkt);
  46.     }  
  47. }

完整版代码：

那么详细的全部的源码（600行）如下，做了部分注释。

  1. /* this thread gets the stream from the disk or the network */
  2. static int read_thread(void *arg)
  3. {
  4.     FFPlayer *ffp = arg;
  5.     VideoState *is = ffp->is;
  6.     AVFormatContext *ic = NULL;
  7.     int err, i, ret __unused;
  8.     int st_index[AVMEDIA_TYPE_NB];
  9.     AVPacket pkt1, *pkt = &pkt1;
  10.     int64_t stream_start_time;
  11.     int completed = 0;
  12.     int pkt_in_play_range = 0;
  13.     AVDictionaryEntry *t;
  14.     SDL_mutex *wait_mutex = SDL_CreateMutex();
  15.     int scan_all_pmts_set = 0;
  16.     int64_t pkt_ts;
  17.     int last_error = 0;
  18.     int64_t prev_io_tick_counter = 0;
  19.     int64_t io_tick_counter = 0;
  20.     int init_ijkmeta = 0;
  22.     if (!wait_mutex) {
  23.         av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
  24.         ret = AVERROR(ENOMEM);
  25.         goto fail;
  26.     }
  28.     memset(st_index, -1, sizeof(st_index));
  29.     is->last_video_stream = is->video_stream = -1;
  30.     is->last_audio_stream = is->audio_stream = -1;
  31.     is->last_subtitle_stream = is->subtitle_stream = -1;
  32.     is->eof = 0;
  33.     //初始化AVFormatContext
  34.     ic = avformat_alloc_context();
  35.     if (!ic) {
  36.         av_log(NULL, AV_LOG_FATAL, "Could not allocate context.\n");
  37.         ret = AVERROR(ENOMEM);
  38.         goto fail;
  39.     }
  40.     //为AVFormatContext设置中断回调
  41.     ic->interrupt_callback.callback = decode_interrupt_cb;
  42.     ic->interrupt_callback.opaque = is;
  43.     if (!av_dict_get(ffp->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
  44.         av_dict_set(&ffp->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
  45.         scan_all_pmts_set = 1;
  46.     }
  47.     if (av_stristart(is->filename, "rtmp", NULL) ||
  48.         av_stristart(is->filename, "rtsp", NULL)) {
  49.         // There is total different meaning for 'timeout' option in rtmp
  50.         av_log(ffp, AV_LOG_WARNING, "remove 'timeout' option for rtmp.\n");
  51.         av_dict_set(&ffp->format_opts, "timeout", NULL, 0);
  52.     }
  54.     if (ffp->skip_calc_frame_rate) {
  55.         av_dict_set_int(&ic->metadata, "skip-calc-frame-rate", ffp->skip_calc_frame_rate, 0);
  56.         av_dict_set_int(&ffp->format_opts, "skip-calc-frame-rate", ffp->skip_calc_frame_rate, 0);
  57.     }
  59.     if (ffp->iformat_name)
  60.         //找到视频格式:AVInputFormat
  61.         is->iformat = av_find_input_format(ffp->iformat_name);
  62.     //Open an input stream and read the header. The codecs are not opened.
  63.     //The stream must be closed with avformat_close_input().
  64.     //打开输入流，并读取文件头部，解码器还未打开。主要作用是探测流的协议，如http还是rtmp等。
  65.     err = avformat_open_input(&ic, is->filename, is->iformat, &ffp->format_opts);
  66.     if (err < 0) {
  67.         print_error(is->filename, err);
  68.         ret = -1;
  69.         goto fail;
  70.     }
  71.     ffp_notify_msg1(ffp, FFP_MSG_OPEN_INPUT);
  73.     if (scan_all_pmts_set)
  74.         av_dict_set(&ffp->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
  76.     if ((t = av_dict_get(ffp->format_opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
  77.         av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
  78. #ifdef FFP_MERGE
  79.         ret = AVERROR_OPTION_NOT_FOUND;
  80.         goto fail;
  81. #endif
  82.     }
  83.     is->ic = ic;
  85.     if (ffp->genpts)
  86.         ic->flags |= AVFMT_FLAG_GENPTS;
  88.     av_format_inject_global_side_data(ic);
  89.     //
  90.     //AVDictionary **opts;
  91.     //int orig_nb_streams;
  92.     //opts = setup_find_stream_info_opts(ic, ffp->codec_opts);
  93.     //orig_nb_streams = ic->nb_streams;
  96.     if (ffp->find_stream_info) {
  97.         AVDictionary **opts = setup_find_stream_info_opts(ic, ffp->codec_opts);
  98.         int orig_nb_streams = ic->nb_streams;
  100.         do {
  101.             if (av_stristart(is->filename, "data:", NULL) && orig_nb_streams > 0) {
  102.                 for (i = 0; i < orig_nb_streams; i++) {
  103.                     if (!ic->streams[i] || !ic->streams[i]->codecpar || ic->streams[i]->codecpar->profile == FF_PROFILE_UNKNOWN) {
  104.                         break;
  105.                     }
  106.                 }
  108.                 if (i == orig_nb_streams) {
  109.                     break;
  110.                 }
  111.             }
  112.             // Read packets of a media file to get stream information. This
  113.             // is useful for file formats with no headers such as MPEG. This
  114.             // function also computes the real framerate in case of MPEG-2 repeat
  115.             // frame mode.
  116.             // The logical file position is not changed by this function;
  117.             // examined packets may buffered for later processing. 
  118.             //探测文件封装格式，音视频编码参数等信息。
  119.             err = avformat_find_stream_info(ic, opts);
  120.         } while(0);
  121.         ffp_notify_msg1(ffp, FFP_MSG_FIND_STREAM_INFO);
  123.         for (i = 0; i < orig_nb_streams; i++)
  124.             av_dict_free(&opts[i]);
  125.         av_freep(&opts);
  127.         if (err < 0) {
  128.             av_log(NULL, AV_LOG_WARNING,
  129.                    "%s: could not find codec parameters\n", is->filename);
  130.             ret = -1;
  131.             goto fail;
  132.         }
  133.     }
  134.     if (ic->pb)
  135.         ic->pb->eof_reached = 0; // FIXME hack, ffplay maybe should not use avio_feof() to test for the end
  137.     if (ffp->seek_by_bytes < 0)
  138.         ffp->seek_by_bytes = !!(ic->iformat->flags & AVFMT_TS_DISCONT) && strcmp("ogg", ic->iformat->name);
  140.     is->max_frame_duration = (ic->iformat->flags & AVFMT_TS_DISCONT) ? 10.0 : 3600.0;
  141.     is->max_frame_duration = 10.0;
  142.     av_log(ffp, AV_LOG_INFO, "max_frame_duration: %.3f\n", is->max_frame_duration);
  144. #ifdef FFP_MERGE
  145.     if (!window_title && (t = av_dict_get(ic->metadata, "title", NULL, 0)))
  146.         window_title = av_asprintf("%s - %s", t->value, input_filename);
  148. #endif
  149.     //处理seek
  150.     /* if seeking requested, we execute it */
  151.     if (ffp->start_time != AV_NOPTS_VALUE) {
  152.         int64_t timestamp;
  154.         timestamp = ffp->start_time;
  155.         /* add the stream start time */
  156.         if (ic->start_time != AV_NOPTS_VALUE)
  157.             timestamp += ic->start_time;
  158.         ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, INT64_MAX, 0);
  159.         if (ret < 0) {
  160.             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
  161.                     is->filename, (double)timestamp / AV_TIME_BASE);
  162.         }
  163.     }
  165.     is->realtime = is_realtime(ic);
  166.     //打印详细的格式信息
  167.     av_dump_format(ic, 0, is->filename, 0);
  169.     int video_stream_count = 0;
  170.     int h264_stream_count = 0;
  171.     int first_h264_stream = -1;
  172.     for (i = 0; i < ic->nb_streams; i++) {
  173.         AVStream *st = ic->streams[i];
  174.         enum AVMediaType type = st->codecpar->codec_type;
  175.         st->discard = AVDISCARD_ALL;
  176.         if (type >= 0 && ffp->wanted_stream_spec[type] && st_index[type] == -1)
  177.             if (avformat_match_stream_specifier(ic, st, ffp->wanted_stream_spec[type]) > 0)
  178.                 st_index[type] = i;
  180.         // choose first h264
  182.         if (type == AVMEDIA_TYPE_VIDEO) {
  183.             enum AVCodecID codec_id = st->codecpar->codec_id;
  184.             video_stream_count++;
  185.             if (codec_id == AV_CODEC_ID_H264) {
  186.                 h264_stream_count++;
  187.                 if (first_h264_stream < 0)
  188.                     first_h264_stream = i;
  189.             }
  190.         }
  191.     }
  192.     if (video_stream_count > 1 && st_index[AVMEDIA_TYPE_VIDEO] < 0) {
  193.         st_index[AVMEDIA_TYPE_VIDEO] = first_h264_stream;
  194.         av_log(NULL, AV_LOG_WARNING, "multiple video stream found, prefer first h264 stream: %d\n", first_h264_stream);
  195.     }
  197.     //*****对视频，音频，和字幕，调用av_find_best_stream，找到对应的stream的下标，并填充在st_index数组中
  198.     if (!ffp->video_disable)
  199.         st_index[AVMEDIA_TYPE_VIDEO] =
  200.             // Find the "best" stream in the file.
  201.             // The best stream is determined according to various heuristics as the most
  202.             // likely to be what the user expects.
  203.             // If the decoder parameter is non-NULL, av_find_best_stream will find the
  204.             // default decoder for the stream's codec; streams for which no decoder can
  205.             // be found are ignored.
  206.             //根据AVFormatContext，找到最佳的流。
  207.             av_find_best_stream(ic, AVMEDIA_TYPE_VIDEO,
  208.                                 st_index[AVMEDIA_TYPE_VIDEO], -1, NULL, 0);
  209.     if (!ffp->audio_disable)
  210.         st_index[AVMEDIA_TYPE_AUDIO] =
  211.             av_find_best_stream(ic, AVMEDIA_TYPE_AUDIO,
  212.                                 st_index[AVMEDIA_TYPE_AUDIO],
  213.                                 st_index[AVMEDIA_TYPE_VIDEO],
  214.                                 NULL, 0);
  215.     if (!ffp->video_disable && !ffp->subtitle_disable)
  216.         st_index[AVMEDIA_TYPE_SUBTITLE] =
  217.             av_find_best_stream(ic, AVMEDIA_TYPE_SUBTITLE,
  218.                                 st_index[AVMEDIA_TYPE_SUBTITLE],
  219.                                 (st_index[AVMEDIA_TYPE_AUDIO] >= 0 ?
  220.                                  st_index[AVMEDIA_TYPE_AUDIO] :
  221.                                  st_index[AVMEDIA_TYPE_VIDEO]),
  222.                                 NULL, 0);
  224.     is->show_mode = ffp->show_mode;
  225. #ifdef FFP_MERGE // bbc: dunno if we need this
  226.     if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
  227.         AVStream *st = ic->streams[st_index[AVMEDIA_TYPE_VIDEO]];
  228.         AVCodecParameters *codecpar = st->codecpar;
  229.         AVRational sar = av_guess_sample_aspect_ratio(ic, st, NULL);
  230.         if (codecpar->width)
  231.             set_default_window_size(codecpar->width, codecpar->height, sar);
  232.     }
  233. #endif
  235.     //******打开3个流 start
  236.     /* open the streams */
  237.     if (st_index[AVMEDIA_TYPE_AUDIO] >= 0) {
  238.         stream_component_open(ffp, st_index[AVMEDIA_TYPE_AUDIO]);
  239.     } else {
  240.         ffp->av_sync_type = AV_SYNC_VIDEO_MASTER;
  241.         is->av_sync_type  = ffp->av_sync_type;
  242.     }
  244.     ret = -1;
  245.     if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
  246.         ret = stream_component_open(ffp, st_index[AVMEDIA_TYPE_VIDEO]);
  247.     }
  248.     if (is->show_mode == SHOW_MODE_NONE)
  249.         is->show_mode = ret >= 0 ? SHOW_MODE_VIDEO : SHOW_MODE_RDFT;
  251.     if (st_index[AVMEDIA_TYPE_SUBTITLE] >= 0) {
  252.         stream_component_open(ffp, st_index[AVMEDIA_TYPE_SUBTITLE]);
  253.     }
  254.     //******打开3个流 end
  256.     ffp_notify_msg1(ffp, FFP_MSG_COMPONENT_OPEN);
  258.     if (!ffp->ijkmeta_delay_init) {
  259.         ijkmeta_set_avformat_context_l(ffp->meta, ic);
  260.     }
  262.     ffp->stat.bit_rate = ic->bit_rate;
  263.     if (st_index[AVMEDIA_TYPE_VIDEO] >= 0)
  264.         ijkmeta_set_int64_l(ffp->meta, IJKM_KEY_VIDEO_STREAM, st_index[AVMEDIA_TYPE_VIDEO]);
  265.     if (st_index[AVMEDIA_TYPE_AUDIO] >= 0)
  266.         ijkmeta_set_int64_l(ffp->meta, IJKM_KEY_AUDIO_STREAM, st_index[AVMEDIA_TYPE_AUDIO]);
  267.     if (st_index[AVMEDIA_TYPE_SUBTITLE] >= 0)
  268.         ijkmeta_set_int64_l(ffp->meta, IJKM_KEY_TIMEDTEXT_STREAM, st_index[AVMEDIA_TYPE_SUBTITLE]);
  270.     if (is->video_stream < 0 && is->audio_stream < 0) {
  271.         av_log(NULL, AV_LOG_FATAL, "Failed to open file '%s' or configure filtergraph\n",
  272.                is->filename);
  273.         ret = -1;
  274.         goto fail;
  275.     }
  277.     //初始化缓冲指示器队列，优先使用音频packetQueue，找不到就使用视频packetQueue。
  278.     if (is->audio_stream >= 0) {
  279.         is->audioq.is_buffer_indicator = 1;
  280.         is->buffer_indicator_queue = &is->audioq;
  281.     } else if (is->video_stream >= 0) {
  282.         is->videoq.is_buffer_indicator = 1;
  283.         is->buffer_indicator_queue = &is->videoq;
  284.     } else {
  285.         assert("invalid streams");
  286.     }
  288.     //如果是直播流，则播放器使用无限缓存
  289.     if (ffp->infinite_buffer < 0 && is->realtime)
  290.         ffp->infinite_buffer = 1;
  292.     if (!ffp->render_wait_start && !ffp->start_on_prepared)
  293.         toggle_pause(ffp, 1);
  294.     if (is->video_st && is->video_st->codecpar) {
  295.         AVCodecParameters *codecpar = is->video_st->codecpar;
  296.         //发送VIDEO_SIZE_CHANGED回调和SAR_CHANGED回调
  297.         ffp_notify_msg3(ffp, FFP_MSG_VIDEO_SIZE_CHANGED, codecpar->width, codecpar->height);
  298.         ffp_notify_msg3(ffp, FFP_MSG_SAR_CHANGED, codecpar->sample_aspect_ratio.num, codecpar->sample_aspect_ratio.den);
  299.     }
  300.     ffp->prepared = true;
  301.     //发送PREPARED回调
  302.     ffp_notify_msg1(ffp, FFP_MSG_PREPARED);
  303.     if (!ffp->render_wait_start && !ffp->start_on_prepared) {
  304.         while (is->pause_req && !is->abort_request) {
  305.             SDL_Delay(20);
  306.         }
  307.     }
  308.     if (ffp->auto_resume) {
  309.         ffp_notify_msg1(ffp, FFP_REQ_START);
  310.         ffp->auto_resume = 0;
  311.     }
  312.     /* offset should be seeked*/
  313.     if (ffp->seek_at_start > 0) {
  314.         ffp_seek_to_l(ffp, (long)(ffp->seek_at_start));
  315.     }
  317.     //开始无限循环,调用ffmpeg的av_read_frame()读取AVPacket，并入队。
  318.     for (;;) {
  319.         //如果中断请求，则跳出循环
  320.         if (is->abort_request)
  321.             break;
  322. #ifdef FFP_MERGE
  323.         if (is->paused != is->last_paused) {
  324.             is->last_paused = is->paused;
  325.             if (is->paused)
  326.                 is->read_pause_return = av_read_pause(ic);
  327.             else
  328.                 av_read_play(ic);
  329.         }
  330. #endif
  331. #if CONFIG_RTSP_DEMUXER || CONFIG_MMSH_PROTOCOL
  332.         if (is->paused &&
  333.                 (!strcmp(ic->iformat->name, "rtsp") ||
  334.                  (ic->pb && !strncmp(ffp->input_filename, "mmsh:", 5)))) {
  335.             /* wait 10 ms to avoid trying to get another packet */
  336.             /* XXX: horrible */
  337.             SDL_Delay(10);
  338.             continue;
  339.         }
  340. #endif
  341.         //如果是seek 请求
  342.         if (is->seek_req) {
  343.             int64_t seek_target = is->seek_pos;
  344.             int64_t seek_min    = is->seek_rel > 0 ? seek_target - is->seek_rel + 2: INT64_MIN;
  345.             int64_t seek_max    = is->seek_rel < 0 ? seek_target - is->seek_rel - 2: INT64_MAX;
  346. // FIXME the +-2 is due to rounding being not done in the correct direction in generation
  347. //      of the seek_pos/seek_rel variables
  349.             ffp_toggle_buffering(ffp, 1);
  350.             ffp_notify_msg3(ffp, FFP_MSG_BUFFERING_UPDATE, 0, 0);
  351.             //ffmepg 中处理seek
  352.             ret = avformat_seek_file(is->ic, -1, seek_min, seek_target, seek_max, is->seek_flags);
  353.             if (ret < 0) {
  354.                 av_log(NULL, AV_LOG_ERROR,
  355.                        "%s: error while seeking\n", is->ic->filename);
  356.             } else {
  357.                 if (is->audio_stream >= 0) {
  358.                     packet_queue_flush(&is->audioq);
  359.                     packet_queue_put(&is->audioq, &flush_pkt);
  360.                     // TODO: clear invaild audio data
  361.                     // SDL_AoutFlushAudio(ffp->aout);
  362.                 }
  363.                 if (is->subtitle_stream >= 0) {
  364.                     packet_queue_flush(&is->subtitleq);
  365.                     packet_queue_put(&is->subtitleq, &flush_pkt);
  366.                 }
  367.                 if (is->video_stream >= 0) {
  368.                     if (ffp->node_vdec) {
  369.                         ffpipenode_flush(ffp->node_vdec);
  370.                     }
  371.                     packet_queue_flush(&is->videoq);
  372.                     packet_queue_put(&is->videoq, &flush_pkt);
  373.                 }
  374.                 if (is->seek_flags & AVSEEK_FLAG_BYTE) {
  375.                    set_clock(&is->extclk, NAN, 0);
  376.                 } else {
  377.                    set_clock(&is->extclk, seek_target / (double)AV_TIME_BASE, 0);
  378.                 }
  380.                 is->latest_video_seek_load_serial = is->videoq.serial;
  381.                 is->latest_audio_seek_load_serial = is->audioq.serial;
  382.                 is->latest_seek_load_start_at = av_gettime();
  383.             }
  384.             ffp->dcc.current_high_water_mark_in_ms = ffp->dcc.first_high_water_mark_in_ms;
  385.             is->seek_req = 0;
  386.             is->queue_attachments_req = 1;
  387.             is->eof = 0;
  388. #ifdef FFP_MERGE
  389.             if (is->paused)
  390.                 step_to_next_frame(is);
  391. #endif
  392.             completed = 0;
  393.             SDL_LockMutex(ffp->is->play_mutex);
  394.             if (ffp->auto_resume) {
  395.                 is->pause_req = 0;
  396.                 if (ffp->packet_buffering)
  397.                     is->buffering_on = 1;
  398.                 ffp->auto_resume = 0;
  399.                 stream_update_pause_l(ffp);
  400.             }
  401.             if (is->pause_req)
  402.                 step_to_next_frame_l(ffp);
  403.             SDL_UnlockMutex(ffp->is->play_mutex);
  405.             if (ffp->enable_accurate_seek) {
  406.                 is->drop_aframe_count = 0;
  407.                 is->drop_vframe_count = 0;
  408.                 SDL_LockMutex(is->accurate_seek_mutex);
  409.                 if (is->video_stream >= 0) {
  410.                     is->video_accurate_seek_req = 1;
  411.                 }
  412.                 if (is->audio_stream >= 0) {
  413.                     is->audio_accurate_seek_req = 1;
  414.                 }
  415.                 SDL_CondSignal(is->audio_accurate_seek_cond);
  416.                 SDL_CondSignal(is->video_accurate_seek_cond);
  417.                 SDL_UnlockMutex(is->accurate_seek_mutex);
  418.             }
  420.             ffp_notify_msg3(ffp, FFP_MSG_SEEK_COMPLETE, (int)fftime_to_milliseconds(seek_target), ret);
  421.             ffp_toggle_buffering(ffp, 1);
  422.         }
  423.         if (is->queue_attachments_req) {
  424.             if (is->video_st && (is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
  425.                 AVPacket copy = { 0 };
  426.                 if ((ret = av_packet_ref(&copy, &is->video_st->attached_pic)) < 0)
  427.                     goto fail;
  428.                 packet_queue_put(&is->videoq, &copy);
  429.                 packet_queue_put_nullpacket(&is->videoq, is->video_stream);
  430.             }
  431.             is->queue_attachments_req = 0;
  432.         }
  434.         /* if the queue are full, no need to read more */
  435.         if (ffp->infinite_buffer<1 && !is->seek_req &&
  436. #ifdef FFP_MERGE
  437.               (is->audioq.size + is->videoq.size + is->subtitleq.size > MAX_QUEUE_SIZE
  438. #else
  439.               (is->audioq.size + is->videoq.size + is->subtitleq.size > ffp->dcc.max_buffer_size
  440. #endif
  441.                     //内部逻辑为queue->nb_packets > min_frames
  442.             || (   stream_has_enough_packets(is->audio_st, is->audio_stream, &is->audioq, MIN_FRAMES)
  443.                 && stream_has_enough_packets(is->video_st, is->video_stream, &is->videoq, MIN_FRAMES)
  444.                 && stream_has_enough_packets(is->subtitle_st, is->subtitle_stream, &is->subtitleq, MIN_FRAMES)))) {
  445.             if (!is->eof) {
  446.                 ffp_toggle_buffering(ffp, 0);
  447.             }
  448.             /* wait 10 ms */
  449.             SDL_LockMutex(wait_mutex);
  450.             SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
  451.             SDL_UnlockMutex(wait_mutex);
  452.             //进入到下一次循环
  453.             continue;
  454.         }
  455.         //处理播放结束
  456.         if ((!is->paused || completed) &&
  457.             (!is->audio_st || (is->auddec.finished == is->audioq.serial && frame_queue_nb_remaining(&is->sampq) == 0)) &&
  458.             (!is->video_st || (is->viddec.finished == is->videoq.serial && frame_queue_nb_remaining(&is->pictq) == 0))) {
  459.             if (ffp->loop != 1 && (!ffp->loop || --ffp->loop)) {
  460.                 stream_seek(is, ffp->start_time != AV_NOPTS_VALUE ? ffp->start_time : 0, 0, 0);
  461.             } else if (ffp->autoexit) {
  462.                 ret = AVERROR_EOF;
  463.                 goto fail;
  464.             } else {
  465.                 ffp_statistic_l(ffp);
  466.                 if (completed) {
  467.                     av_log(ffp, AV_LOG_INFO, "ffp_toggle_buffering: eof\n");
  468.                     SDL_LockMutex(wait_mutex);
  469.                     // infinite wait may block shutdown
  470.                     while(!is->abort_request && !is->seek_req)
  471.                         SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 100);
  472.                     SDL_UnlockMutex(wait_mutex);
  473.                     if (!is->abort_request)
  474.                         continue;
  475.                 } else {
  476.                     completed = 1;
  477.                     ffp->auto_resume = 0;
  479.                     // TODO: 0 it's a bit early to notify complete here
  480.                     ffp_toggle_buffering(ffp, 0);
  481.                     toggle_pause(ffp, 1);
  482.                     if (ffp->error) {
  483.                         av_log(ffp, AV_LOG_INFO, "ffp_toggle_buffering: error: %d\n", ffp->error);
  484.                         ffp_notify_msg1(ffp, FFP_MSG_ERROR);
  485.                     } else {
  486.                         av_log(ffp, AV_LOG_INFO, "ffp_toggle_buffering: completed: OK\n");
  487.                         ffp_notify_msg1(ffp, FFP_MSG_COMPLETED);
  488.                     }
  489.                 }
  490.             }
  491.         }
  492.         pkt->flags = 0;
  493.         //读帧，读到这个pkt包里面？
  494.         //0 if OK, < 0 on error or end of file
  495.         ret = av_read_frame(ic, pkt);
  496.         if (ret < 0) {
  497.             int pb_eof = 0;
  498.             int pb_error = 0;
  499.             //EOF表示：end of file
  500.             if ((ret == AVERROR_EOF || avio_feof(ic->pb)) && !is->eof) {
  501.                 ffp_check_buffering_l(ffp);
  502.                 pb_eof = 1;
  503.                 // check error later
  504.             }
  505.             if (ic->pb && ic->pb->error) {
  506.                 pb_eof = 1;
  507.                 pb_error = ic->pb->error;
  508.             }
  509.             if (ret == AVERROR_EXIT) {
  510.                 pb_eof = 1;
  511.                 pb_error = AVERROR_EXIT;
  512.             }
  514.             if (pb_eof) {
  515.                 if (is->video_stream >= 0)
  516.                     packet_queue_put_nullpacket(&is->videoq, is->video_stream);
  517.                 if (is->audio_stream >= 0)
  518.                     packet_queue_put_nullpacket(&is->audioq, is->audio_stream);
  519.                 if (is->subtitle_stream >= 0)
  520.                     packet_queue_put_nullpacket(&is->subtitleq, is->subtitle_stream);
  521.                 is->eof = 1;
  522.             }
  523.             if (pb_error) {
  524.                 if (is->video_stream >= 0)
  525.                     packet_queue_put_nullpacket(&is->videoq, is->video_stream);
  526.                 if (is->audio_stream >= 0)
  527.                     packet_queue_put_nullpacket(&is->audioq, is->audio_stream);
  528.                 if (is->subtitle_stream >= 0)
  529.                     packet_queue_put_nullpacket(&is->subtitleq, is->subtitle_stream);
  530.                 is->eof = 1;
  531.                 ffp->error = pb_error;
  532.                 av_log(ffp, AV_LOG_ERROR, "av_read_frame error: %s\n", ffp_get_error_string(ffp->error));
  533.                 // break;
  534.             } else {
  535.                 ffp->error = 0;
  536.             }
  537.             if (is->eof) {
  538.                 ffp_toggle_buffering(ffp, 0);
  539.                 SDL_Delay(100);
  540.             }
  541.             SDL_LockMutex(wait_mutex);
  542.             SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
  543.             SDL_UnlockMutex(wait_mutex);
  544.             ffp_statistic_l(ffp);
  545.             continue;
  546.         } else {
  547.             is->eof = 0;
  548.         }
  550.         //flush_pkt是用来做什么的？
  551.         if (pkt->flags & AV_PKT_FLAG_DISCONTINUITY) {
  552.             if (is->audio_stream >= 0) {
  553.                 packet_queue_put(&is->audioq, &flush_pkt);
  554.             }
  555.             if (is->subtitle_stream >= 0) {
  556.                 packet_queue_put(&is->subtitleq, &flush_pkt);
  557.             }
  558.             if (is->video_stream >= 0) {
  559.                 packet_queue_put(&is->videoq, &flush_pkt);
  560.             }
  561.         }
  563.         /* check if packet is in play range specified by user, then queue, otherwise discard */
  564.         stream_start_time = ic->streams[pkt->stream_index]->start_time;
  565.         pkt_ts = pkt->pts == AV_NOPTS_VALUE ? pkt->dts : pkt->pts;
  566.         pkt_in_play_range = ffp->duration == AV_NOPTS_VALUE ||
  567.                 (pkt_ts - (stream_start_time != AV_NOPTS_VALUE ? stream_start_time : 0)) *
  568.                 av_q2d(ic->streams[pkt->stream_index]->time_base) -
  569.                 (double)(ffp->start_time != AV_NOPTS_VALUE ? ffp->start_time : 0) / 1000000
  570.                 <= ((double)ffp->duration / 1000000);
  571.         if (pkt->stream_index == is->audio_stream && pkt_in_play_range) {
  572.             packet_queue_put(&is->audioq, pkt);
  573.         } else if (pkt->stream_index == is->video_stream && pkt_in_play_range
  574.                    && !(is->video_st && (is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC))) {
  575.             packet_queue_put(&is->videoq, pkt);
  576.         } else if (pkt->stream_index == is->subtitle_stream && pkt_in_play_range) {
  577.             packet_queue_put(&is->subtitleq, pkt);
  578.         } else {
  579.             av_packet_unref(pkt);
  580.         }
  582.         ffp_statistic_l(ffp);
  584.         if (ffp->ijkmeta_delay_init && !init_ijkmeta &&
  585.                 (ffp->first_video_frame_rendered || !is->video_st) && (ffp->first_audio_frame_rendered || !is->audio_st)) {
  586.             ijkmeta_set_avformat_context_l(ffp->meta, ic);
  587.             init_ijkmeta = 1;
  588.         }
  590.         if (ffp->packet_buffering) {
  591.             io_tick_counter = SDL_GetTickHR();
  592.             if ((!ffp->first_video_frame_rendered && is->video_st) || (!ffp->first_audio_frame_rendered && is->audio_st)) {
  593.                 if (abs((int)(io_tick_counter - prev_io_tick_counter)) > FAST_BUFFERING_CHECK_PER_MILLISECONDS) {
  594.                     prev_io_tick_counter = io_tick_counter;
  595.                     ffp->dcc.current_high_water_mark_in_ms = ffp->dcc.first_high_water_mark_in_ms;
  596.                     ffp_check_buffering_l(ffp);
  597.                 }
  598.             } else {
  599.                 if (abs((int)(io_tick_counter - prev_io_tick_counter)) > BUFFERING_CHECK_PER_MILLISECONDS) {
  600.                     prev_io_tick_counter = io_tick_counter;
  601.                     ffp_check_buffering_l(ffp);
  602.                 }
  603.             }
  604.         }
  605.     }
  607.     ret = 0;
  608.  fail:
  609.     if (ic && !is->ic)
  610.         avformat_close_input(&ic);
  612.     if (!ffp->prepared || !is->abort_request) {
  613.         ffp->last_error = last_error;
  614.         ffp_notify_msg2(ffp, FFP_MSG_ERROR, last_error);
  615.     }
  616.     SDL_DestroyMutex(wait_mutex);
  617.     return 0;
  618. }

小结：

总结一下：视频读取线程大致做的事情就是：

  1. ffmpeg进行协议探测，封装格式探测等网络请求，为创建解码器做准备。
  2. 创建video，audio，subtitle解码器并开启相应的解码线程。
  3. for循环不断地调用av_read_frame()去从ffmpeg内部维护的网络包缓存去取出下载好的AVPacket，并放入相应的队列中，供稍后解码线程取出解码。