FFmpeg 代码 version 3.3:
ffplay中的线程模型
ffplay线程模型-视频为例.png
概述
ffplay.c 中线程模型简单命令。主要是有如下几个线程：
1. 渲染的线程-主线程
简单的理解，来说就是main方法运行所在的线程。（注意：在Android中这里是SDLThread）
实际上是SDL_CreateWindow 调用所在的线程。以Android为例(笔者比较熟悉)，创建的是OpenGL的Surface。也就是EGLContext所在的线程了。
在EventLoop中，将会负责下面两个功能
负责将解码后的数据送显
从解码后的队列中，取得数据。经过同步时间钟的同步，睡眠后（需要同步的话），然后通过SDL_UpdateTexture/SDL_RenderCopy/SDL_RenderPresent,更新纹理数据，送显。对按键进行相应
2. 读取线程-read_thread
在main方法中会启动的读取的线程。
- 循环读取
这个线程中，会进行读取的循环。不断的通过av_read_frame方法，读取解码前的数据packet。 - 送入队列
最后将得到的数据，送入对应的流的packet队列（视频/音频/字幕都对应视频流自己的队列）
3. 对应流的解码线程-decode thread
在读取线程中，对AVFormatContext进行初始化，获取AVStream信息后，对应不同的码流会开启对应的解码线程Decode Thread。
ffplay中这里包括了3种流。视频流。音频流和字幕流。
以视频流为例子。
循环读取
会从对应流的packet队列中，得到数据。
然后送入解码器通过avcodec_decode_video2(旧的API)进行解码。送入队列
解码之后，得到解码前的数据AVFrame,并确定对应的pts。
最后然后其再次送入队列当中。
整体的流程就是这样简单。
ffplay初始化(main_thread)
注意：在Android中这里是SDLThread
1. 对FFmpeg的初始化
调用av_register_all和avformat_network_init。
如果有AVDevice 和AVFilter也会对其进行初始化。
/* register all codecs, demux and protocols */
#if CONFIG_AVDEVICE
avdevice_register_all();
#endif
#if CONFIG_AVFILTER
avfilter_register_all();
#endif
av_register_all();
avformat_network_init();
2. 对传递的参数进行初始化
parse_options(NULL, argc, argv, options, opt_input_file);
这个方法就是去解析我们传入的参数的。具体的方法写在cmdutils.h 中。
ffplay支持的参数类型，可以在定义的地方看到。
static const OptionDef options[] //这个数组中,有许多选项，不是重点，暂时不做详细的介绍了。
3. SDL的初始化
SDL会先初始化SDL_init 进行初始化。
flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
if (audio_disable)
flags &= ~SDL_INIT_AUDIO;
else {
/* Try to work around an occasional ALSA buffer underflow issue when the
* period size is NPOT due to ALSA resampling by forcing the buffer size. */
if (!SDL_getenv("SDL_AUDIO_ALSA_SET_BUFFER_SIZE"))
SDL_setenv("SDL_AUDIO_ALSA_SET_BUFFER_SIZE","1", 1);
}
if (display_disable)
flags &= ~SDL_INIT_VIDEO;
if (SDL_Init (flags)) {
av_log(NULL, AV_LOG_FATAL, "Could not initialize SDL - %s\n", SDL_GetError());
av_log(NULL, AV_LOG_FATAL, "(Did you set the DISPLAY variable?)\n");
exit(1);
}
后续的创建SDL_Window/SDL_Renderer/SDL_texture 的部分，会在后续初始化。
4. 通过stream_open函数，开启read_thread读取线程
is = stream_open(input_filename, file_iformat);
通过 stream_open函数，会对VideoState进行初始化，包括解码数据队列(PacketQueue)和解码后数据队列(FrameQueue)和时间钟(Clock)等的初始化，并且开启read_thread。
-
VideoState 结构体
这个结构体相当于一个全局的变量都囊括在一起了。
从源码中可以看到。
包括几个方面的参数。
- 视频操作类的暂停，运行和seek
- 三种同步的时间钟
- 三种码流对应的
FrameQueue/Decoder/AVStream/PacketQueue,以及对应码流各自的信息。 - 用来
Render的一些变量。如SDL_Texture，窗口的位置参数等 -
read_thread和SDL_cond *continue_read_thread条件锁 - 还有些中间变量
// 视频状态结构
typedef struct VideoState {
SDL_Thread *read_tid; // 读取线程
AVInputFormat *iformat; // 输入格式
int abort_request; // 请求取消
int force_refresh; // 强制刷新
int paused; // 停止
int last_paused; // 最后停止
int queue_attachments_req; // 队列附件请求
int seek_req; // 查找请求
int seek_flags; // 查找标志
int64_t seek_pos; // 查找位置
int64_t seek_rel; //
int read_pause_return; // 读停止返回
AVFormatContext *ic; // 解码格式上下文
int realtime; // 是否实时码流
Clock audclk; // 音频时钟
Clock vidclk; // 视频时钟
Clock extclk; // 外部时钟
FrameQueue pictq; // 视频队列
FrameQueue subpq; // 字幕队列
FrameQueue sampq; // 音频队列
Decoder auddec; // 音频解码器
Decoder viddec; // 视频解码器
Decoder subdec; // 字幕解码器
int audio_stream; // 音频码流Id
int av_sync_type; // 同步类型
double audio_clock; // 音频时钟
int audio_clock_serial; // 音频时钟序列
double audio_diff_cum; // 用于音频差分计算 /* used for AV difference average computation */
double audio_diff_avg_coef; //
double audio_diff_threshold; // 音频差分阈值
int audio_diff_avg_count; // 平均差分数量
AVStream *audio_st; // 音频码流
PacketQueue audioq; // 音频包队列
int audio_hw_buf_size; // 硬件缓冲大小
uint8_t *audio_buf; // 音频缓冲区
uint8_t *audio_buf1; // 音频缓冲区1
unsigned int audio_buf_size; // 音频缓冲大小 /* in bytes */
unsigned int audio_buf1_size; // 音频缓冲大小1
int audio_buf_index; // 音频缓冲索引 /* in bytes */
int audio_write_buf_size; // 音频写入缓冲大小
int audio_volume; // 音量
int muted; // 是否静音
struct AudioParams audio_src; // 音频参数
#if CONFIG_AVFILTER
struct AudioParams audio_filter_src; // 音频过滤器
#endif
struct AudioParams audio_tgt; // 音频参数
struct SwrContext *swr_ctx; // 音频转码上下文
int frame_drops_early; //
int frame_drops_late; //
enum ShowMode { // 显示类型
SHOW_MODE_NONE = -1, // 无显示
SHOW_MODE_VIDEO = 0, // 显示视频
SHOW_MODE_WAVES, // 显示波浪，音频
SHOW_MODE_RDFT, // 自适应滤波器
SHOW_MODE_NB //
} show_mode;
int16_t sample_array[SAMPLE_ARRAY_SIZE]; // 采样数组
int sample_array_index; // 采样索引
int last_i_start; // 上一开始
RDFTContext *rdft; // 自适应滤波器上下文
int rdft_bits; // 自使用比特率
FFTSample *rdft_data; // 快速傅里叶采样
int xpos; //
double last_vis_time; //
SDL_Texture *vis_texture; // 音频Texture
SDL_Texture *sub_texture; // 字幕Texture
SDL_Texture *vid_texture; // 视频Texture
int subtitle_stream; // 字幕码流Id
AVStream *subtitle_st; // 字幕码流
PacketQueue subtitleq; // 字幕包队列
double frame_timer; // 帧计时器
double frame_last_returned_time; // 上一次返回时间
double frame_last_filter_delay; // 上一个过滤器延时
int video_stream; // 视频码流Id
AVStream *video_st; // 视频码流
PacketQueue videoq; // 视频包队列
double max_frame_duration; // 最大帧显示时间 // maximum duration of a frame - above this, we consider the jump a timestamp discontinuity
struct SwsContext *img_convert_ctx; // 视频转码上下文
struct SwsContext *sub_convert_ctx; // 字幕转码上下文
int eof; // 结束标志
char *filename; // 文件名
int width, height, xleft, ytop; // 宽高，其实坐标
int step; // 步进
#if CONFIG_AVFILTER
int vfilter_idx; // 过滤器索引
AVFilterContext *in_video_filter; // 第一个视频滤镜 // the first filter in the video chain
AVFilterContext *out_video_filter; // 最后一个视频滤镜 // the last filter in the video chain
AVFilterContext *in_audio_filter; // 第一个音频过滤器 // the first filter in the audio chain
AVFilterContext *out_audio_filter; // 最后一个音频过滤器 // the last filter in the audio chain
AVFilterGraph *agraph; // 音频过滤器 // audio filter graph
#endif
// 上一个视频码流Id、上一个音频码流Id、上一个字幕码流Id
int last_video_stream, last_audio_stream, last_subtitle_stream;
SDL_cond *continue_read_thread; // 连续读线程
} VideoState;
5. 开启EventLoop
refresh_loop_wait_event(cur_stream, &event);
static void refresh_loop_wait_event(VideoState *is, SDL_Event *event) {
double remaining_time = 0.0;
//取出事件
SDL_PumpEvents();
// 如果事件不是要处理的，就会进行渲染的判断，然后继续取出事件的循环
while (!SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT)) {
//是否显示鼠标
if (!cursor_hidden && av_gettime_relative() - cursor_last_shown > CURSOR_HIDE_DELAY) {
SDL_ShowCursor(0);
cursor_hidden = 1;
}
//使用av_usleep来控制视频刷新的帧率
if (remaining_time > 0.0)
av_usleep((int64_t)(remaining_time * 1000000.0));
remaining_time = REFRESH_RATE;
//通知刷新的话。is->force_refresh==1.
if (is->show_mode != SHOW_MODE_NONE && (!is->paused || is->force_refresh))
//进入绘制
video_refresh(is, &remaining_time);
//继续下一个事件循环
SDL_PumpEvents();
}
}
通过这个方法，不断的来取出SDL的事件。同时通过这样的事件循环，不断video_refresh送显绘制。
读取线程read_thread
如上部分所示，通过stream_open方法，开启read_thread
初始化参数
read_thread作为读取线程。
- 需要初始化
AVformatContext和AVStream。 - 同时，在得到对应的
AVStream之后，它还负责初始化好对应的AVCodec和AVCodecContext,然后开启对应的解码线程。 - 最后，通过不断的
av_read_frame,将数据读取出，送入队列。等待解码。
需要初始化AVformatContext和AVStream。
1. 显示先创建 AVformatContext
ic = avformat_alloc_context();
2. 设置解码中断回调方法
这个方法，会在网络中断的时候，发生调用
ic->interrupt_callback.callback = decode_interrupt_cb;
// 设置中断回调参数
ic->interrupt_callback.opaque = is;
decode_interrupt_cb 方法
static int decode_interrupt_cb(void *ctx)
{
VideoState *is = ctx;
return is->abort_request;
}
3. 打开avformat_open_input
err = avformat_open_input(&ic, is->filename, is->iformat, &format_opts);
//同时，将其注入成全局的一个变量。但是具体如何使用呢？？
av_format_inject_global_side_data(ic);
4. 查找AVStream
找到不同的AVStream,并将其放入对应的数组中。等待后续使用。
找到视频流之后，还会再次同步显示的比例和视频的长宽
for (i = 0; i < ic->nb_streams; i++) {
AVStream *st = ic->streams[i];
enum AVMediaType type = st->codecpar->codec_type;
st->discard = AVDISCARD_ALL;
if (type >= 0 && wanted_stream_spec[type] && st_index[type] == -1)
if (avformat_match_stream_specifier(ic, st, wanted_stream_spec[type]) > 0)
st_index[type] = i;
}
for (i = 0; i < AVMEDIA_TYPE_NB; i++) {
if (wanted_stream_spec[i] && st_index[i] == -1) {
av_log(NULL, AV_LOG_ERROR, "Stream specifier %s does not match any %s stream\n", wanted_stream_spec[i], av_get_media_type_string(i));
st_index[i] = INT_MAX;
}
}
if (!video_disable)
st_index[AVMEDIA_TYPE_VIDEO] =
av_find_best_stream(ic, AVMEDIA_TYPE_VIDEO,
st_index[AVMEDIA_TYPE_VIDEO], -1, NULL, 0);
if (!audio_disable)
st_index[AVMEDIA_TYPE_AUDIO] =
av_find_best_stream(ic, AVMEDIA_TYPE_AUDIO,
st_index[AVMEDIA_TYPE_AUDIO],
st_index[AVMEDIA_TYPE_VIDEO],
NULL, 0);
if (!video_disable && !subtitle_disable)
st_index[AVMEDIA_TYPE_SUBTITLE] =
av_find_best_stream(ic, AVMEDIA_TYPE_SUBTITLE,
st_index[AVMEDIA_TYPE_SUBTITLE],
(st_index[AVMEDIA_TYPE_AUDIO] >= 0 ?
st_index[AVMEDIA_TYPE_AUDIO] :
st_index[AVMEDIA_TYPE_VIDEO]),
NULL, 0);
is->show_mode = show_mode;
//找到视频流之后，还会再次同步显示的比例和视频的长宽
if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
AVStream *st = ic->streams[st_index[AVMEDIA_TYPE_VIDEO]];
AVCodecParameters *codecpar = st->codecpar;
AVRational sar = av_guess_sample_aspect_ratio(ic, st, NULL);
if (codecpar->width)
set_default_window_size(codecpar->width, codecpar->height, sar);
}
开启对应的解码线程
打开stream_component_open对应的AVStream。打开解码线程。
ffplay中对应三种码流。（视频、音频和字幕，对应打开自己的解码线程）
/* open the streams */
if (st_index[AVMEDIA_TYPE_AUDIO] >= 0) {
stream_component_open(is, st_index[AVMEDIA_TYPE_AUDIO]);
}
ret = -1;
if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
ret = stream_component_open(is, st_index[AVMEDIA_TYPE_VIDEO]);
}
if (is->show_mode == SHOW_MODE_NONE)
is->show_mode = ret >= 0 ? SHOW_MODE_VIDEO : SHOW_MODE_RDFT;
if (st_index[AVMEDIA_TYPE_SUBTITLE] >= 0) {
stream_component_open(is, st_index[AVMEDIA_TYPE_SUBTITLE]);
}
开启对应的线程之前，会初始化好每个码流的AVCodec和AVCodecContext
- 初始化
AVCodec和AVCodecContext
//创建AVCodecContext
avctx = avcodec_alloc_context3(NULL);
if (!avctx)
return AVERROR(ENOMEM);
//从找到对应的流中的codecpar，codecpar其实是avcodec_parameters，
// 然后将它完全复制到创建的AVCodecContext
ret = avcodec_parameters_to_context(avctx, ic->streams[stream_index]->codecpar);
if (ret < 0)
goto fail;
avctx->pkt_timebase = ic->streams[stream_index]->time_base;
//根据codec_id找出最合适的codec
codec = avcodec_find_decoder(avctx->codec_id);
switch(avctx->codec_type){
case AVMEDIA_TYPE_AUDIO : is->last_audio_stream = stream_index; forced_codec_name = audio_codec_name; break;
case AVMEDIA_TYPE_SUBTITLE: is->last_subtitle_stream = stream_index; forced_codec_name = subtitle_codec_name; break;
case AVMEDIA_TYPE_VIDEO : is->last_video_stream = stream_index; forced_codec_name = video_codec_name; break;
}
//强制通过解码器的名字，来打开对应的解码器
if (forced_codec_name)
codec = avcodec_find_decoder_by_name(forced_codec_name);
if (!codec) {
if (forced_codec_name) av_log(NULL, AV_LOG_WARNING,
"No codec could be found with name '%s'\n", forced_codec_name);
else av_log(NULL, AV_LOG_WARNING,
"No codec could be found with id %d\n", avctx->codec_id);
ret = AVERROR(EINVAL);
goto fail;
}
avctx->codec_id = codec->id;
// 下面是设置属性，也不大懂。。这些属性的意思
if (stream_lowres > codec->max_lowres) {
av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
codec->max_lowres);
stream_lowres = codec->max_lowres;
}
avctx->lowres = stream_lowres;
if (fast)
avctx->flags2 |= AV_CODEC_FLAG2_FAST;
opts = filter_codec_opts(codec_opts, avctx->codec_id, ic, ic->streams[stream_index], codec);
//av_dict_set方法，传入参数的效果，等同于我们用命令行时 - 的传递方式
if (!av_dict_get(opts, "threads", NULL, 0))
av_dict_set(&opts, "threads", "auto", 0);
if (stream_lowres)
av_dict_set_int(&opts, "lowres", stream_lowres, 0);
if (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
av_dict_set(&opts, "refcounted_frames", "1", 0);
if ((ret = avcodec_open2(avctx, codec, &opts)) < 0) {
goto fail;
}
if ((t = av_dict_get(opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
ret = AVERROR_OPTION_NOT_FOUND;
goto fail;
}
- 初始化对应的解码线程
有了AVCodecContext 和AVCodec 之后，就可以初始化解码线程了
对解码器的参数再次配置(音频需要)，
然后decoder_init方法初始化Decoder结构体
static void decoder_init(Decoder *d, AVCodecContext *avctx, PacketQueue *queue, SDL_cond *empty_queue_cond) {
memset(d, 0, sizeof(Decoder));
d->avctx = avctx;
d->queue = queue;
d->empty_queue_cond = empty_queue_cond;
d->start_pts = AV_NOPTS_VALUE;
d->pkt_serial = -1;
}
和decoder_start 正式开启线程。
static int decoder_start(Decoder *d, int (*fn)(void *), void *arg)
{
packet_queue_start(d->queue);
d->decoder_tid = SDL_CreateThread(fn, "decoder", arg);
if (!d->decoder_tid) {
av_log(NULL, AV_LOG_ERROR, "SDL_CreateThread(): %s\n", SDL_GetError());
return AVERROR(ENOMEM);
}
return 0;
}
packet_queue_start 开启线程之前，将flush_pkt送入PacketQueue队列当中。
static void packet_queue_start(PacketQueue *q)
{
SDL_LockMutex(q->mutex);
q->abort_request = 0;
packet_queue_put_private(q, &flush_pkt);
SDL_UnlockMutex(q->mutex);
}
不断的av_read_frame,将数据读取出，送入队列
ps:快进的逻辑后面分析
读取av_read_frame
ret = av_read_frame(ic, pkt);
读取失败，各个流中送入空包，同时锁住continue_read_thread,等待10ms
if (ret < 0) {
// 读取结束或失败。会想各个流，送入一个空的packet.为什么要送入空的packet??
if ((ret == AVERROR_EOF || avio_feof(ic->pb)) && !is->eof) {
if (is->video_stream >= 0)
packet_queue_put_nullpacket(&is->videoq, is->video_stream);
if (is->audio_stream >= 0)
packet_queue_put_nullpacket(&is->audioq, is->audio_stream);
if (is->subtitle_stream >= 0)
packet_queue_put_nullpacket(&is->subtitleq, is->subtitle_stream);
is->eof = 1;
}
if (ic->pb && ic->pb->error)
break;
//读取失败的话，读取失败的原因有很多，其他地方可能会重新Signal这个锁condition。如果没有singal这个condition的话，就会等待10ms之后，再释放，重新循环读取. 那这个continue_read_thread 到底是锁了哪呢？
SDL_LockMutex(wait_mutex);
SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
SDL_UnlockMutex(wait_mutex);
continue;
} else {
is->eof = 0;
}
todo:continue_read_thread 等同于队列中的empty_queue_cond???
读取成功，送入队列
变量pkt中就是我们读取到的数据。
/* check if packet is in play range specified by user, then queue, otherwise discard */
//记录stream_start_time
stream_start_time = ic->streams[pkt->stream_index]->start_time;
//如果没有pts, 就用dts
pkt_ts = pkt->pts == AV_NOPTS_VALUE ? pkt->dts : pkt->pts;
//判断是否在范围内。如果duration还没被定义的话，通过
//或者在定义的duration内才可以，用当前的pts-start_time .
//duration 会在解码器打开之后，才会被初始化
pkt_in_play_range = duration == AV_NOPTS_VALUE ||
(pkt_ts - (stream_start_time != AV_NOPTS_VALUE ? stream_start_time : 0)) *
av_q2d(ic->streams[pkt->stream_index]->time_base) -
(double)(start_time != AV_NOPTS_VALUE ? start_time : 0) / 1000000
<= ((double)duration / 1000000);
// 将解复用得到的数据包添加到对应的待解码队列中
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->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);
}
最后退出时，需要关闭对应资源
这个线程关闭的时候。会清空AVFormatContext 和锁资源
if (ic && !is->ic)
avformat_close_input(&ic);
if (ret != 0) {
SDL_Event event;
event.type = FF_QUIT_EVENT;
event.user.data1 = is;
SDL_PushEvent(&event);
}
SDL_DestroyMutex(wait_mutex);
return 0;
入列的操作
整体的流程如上，让我们在特别关注一下，具体的入列的操作
MyAVPacketList结构体
PacketList中存储的单元是自己定义的MyAVPacketList结构体
typedef struct MyAVPacketList {
AVPacket pkt;
struct MyAVPacketList *next;
int serial;
} MyAVPacketList;
结构体中主要是保存了AVPacket数据和队列的下一个的指针。
同时还保留了一个serial变量。它可以理解成操作数。在初始化和快进的时候，会增加操作数。小于的操作数，在下一次显示的时候，会直接被抛弃。
队列操作packet_queue_put
static int packet_queue_put(PacketQueue *q, AVPacket *pkt)
{
int ret;
//锁住队列中的互斥锁。这个锁是每个队列自己的
SDL_LockMutex(q->mutex);
ret = packet_queue_put_private(q, pkt);
SDL_UnlockMutex(q->mutex);
// 如果不是flush类型的包，并且没有成功入队，则销毁当前的包
if (pkt != &flush_pkt && ret < 0)
av_packet_unref(pkt);
return ret;
}
static int packet_queue_put_private(PacketQueue *q, AVPacket *pkt)
{
MyAVPacketList *pkt1;
// 如果队列本身处于舍弃状态，则直接返回-1
if (q->abort_request)
return -1;
// 创建一个包
pkt1 = av_malloc(sizeof(MyAVPacketList));
if (!pkt1)
return -1;
pkt1->pkt = *pkt;
pkt1->next = NULL;
// 判断包是否数据flush类型，调整包序列
// 在创建decoder thread时，会刷入一个flush_pkt,这个时候会提高serial
if (pkt == &flush_pkt)
q->serial++;
pkt1->serial = q->serial;
// 调整指针。存入队尾，若没有队尾，就放在开头。
if (!q->last_pkt)
q->first_pkt = pkt1;
else
q->last_pkt->next = pkt1;
q->last_pkt = pkt1;
q->nb_packets++;
q->size += pkt1->pkt.size + sizeof(*pkt1);
q->duration += pkt1->pkt.duration;
/* XXX: should duplicate packet data in DV case */
// 条件信号
//通知读的部分，有数据了，可以继续读取了
//q->cond 在读取的时候，如果没有数据就会锁住，这样，生产了数据，就会通知读取。相等于一个读锁
SDL_CondSignal(q->cond);
return 0;
}
队列操作packet_queue_put_nullpacket
在读取错误时，也会丢入一个空白。
static int packet_queue_put_nullpacket(PacketQueue *q, int stream_index)
{
// 创建一个空数据的包
AVPacket pkt1, *pkt = &pkt1;
av_init_packet(pkt);
pkt->data = NULL;
pkt->size = 0;
pkt->stream_index = stream_index;
return packet_queue_put(q, pkt);
}
弄清楚q->mutex 是什么锁
主线程初始化中，进行初始化的，是每个PacketQueue 都有一个自己的互斥锁和条件锁的。
static int packet_queue_init(PacketQueue *q)
{
// 为一个包队列分配内存
memset(q, 0, sizeof(PacketQueue));
// 创建互斥锁
q->mutex = SDL_CreateMutex();
if (!q->mutex) {
av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
return AVERROR(ENOMEM);
}
// 创建条件锁
q->cond = SDL_CreateCond();
if (!q->cond) {
av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
return AVERROR(ENOMEM);
}
// 默认情况舍弃入队的数据
q->abort_request = 1;
return 0;
}
条件锁q->cond在读取的时候，如果没有数据就会锁住，这样，生产了数据，就会通知读取。相等于一个读锁
取数据packet_queue_get
取数据的时候，根据是否需要阻塞，在空队列的时候，会用上面的条件锁，锁住。当产生新的数据时，如果阻塞的话，会通知解锁。
/* return < 0 if aborted, 0 if no packet and > 0 if packet. */
static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block, int *serial)
{
MyAVPacketList *pkt1;
int ret;
SDL_LockMutex(q->mutex);
for (;;) {
if (q->abort_request) {
ret = -1;
break;
}
pkt1 = q->first_pkt;
if (pkt1) {
q->first_pkt = pkt1->next;
if (!q->first_pkt)
q->last_pkt = NULL;
q->nb_packets--;
q->size -= pkt1->pkt.size + sizeof(*pkt1);
q->duration -= pkt1->pkt.duration;
*pkt = pkt1->pkt;
if (serial)
*serial = pkt1->serial;
av_free(pkt1);
ret = 1;
break;
} else if (!block) {
ret = 0;
break;
} else {
SDL_CondWait(q->cond, q->mutex);
}
}
SDL_UnlockMutex(q->mutex);
return ret;
}
视频解码线程video_thread
在read_thread的中对应视频流时，初始化好了AVCodec和AVCodecContext。通过decoder_start方法，开启了video_thread。
在video_thread中需要创建AVFrame来接受解码后的数据，确定视频的帧率。
然后开启解码循环。
不断的从队列中获取解码前的数据，然后送入解码器解码。
再得到解码后的数据，在送入对应的队列当中。
初始化参数
创建AVFrame和得到大致的视频帧率
//创建AVFrame
AVFrame *frame = av_frame_alloc();
//设置好time_base和frame_rate
AVRational tb = is->video_st->time_base;
// 猜测视频帧率
AVRational frame_rate = av_guess_frame_rate(is->ic, is->video_st, NULL);
开始循环解码
从队列中取得解码器的数据packet_queue_get
取到要解码的数据，放到 &d->pkt_temp上
do {
int ret = -1;
// 如果处于舍弃状态，直接返回
if (d->queue->abort_request)
return -1;
// 如果当前没有包在等待，或者队列的序列不相同时，取出下一帧
if (!d->packet_pending || d->queue->serial != d->pkt_serial) {
AVPacket pkt;
do {
// 队列为空
if (d->queue->nb_packets == 0)
//当队列为空的时候，就会通知释放这个条件锁。之前在读取线程，读取失败的时候，也有锁住这个锁进行等待。
SDL_CondSignal(d->empty_queue_cond);
// 从队列中取数据
if (packet_queue_get(d->queue, &pkt, 1, &d->pkt_serial) < 0)
return -1;
// 如果是第一个数据，则会把数据清空一遍。然后开始获取
if (pkt.data == flush_pkt.data) {
//重置解码器的状态，因为第一次开始解码或者快进的时候，会先存入一个flush_data,当取到这个的时候，就需要去/重置解码器的状态
//Reset the internal decoder state / flush internal buffers. Should be called
avcodec_flush_buffers(d->avctx);
d->finished = 0;
d->next_pts = d->start_pts;
d->next_pts_tb = d->start_pts_tb;
}
} while (pkt.data == flush_pkt.data || d->queue->serial != d->pkt_serial);
// 释放包
av_packet_unref(&d->pkt);
// 更新包
d->pkt_temp = d->pkt = pkt;
// 包等待
d->packet_pending = 1;
}
得到pkt_temp之后，送入解码器进行解码
解码成功后，还需要得去对应的pts。
这里有个值得注意的地方是，视频的帧的时间戳，可以通过av_frame_get_best_effort_timestamp来计算。
而音频部分的时间戳，则是直接通过time_base来计算。
// 根据解码器类型判断是音频还是视频还是字幕
switch (d->avctx->codec_type) {
// 视频解码
case AVMEDIA_TYPE_VIDEO:
// 解码视频
ret = avcodec_decode_video2(d->avctx, frame, &got_frame, &d->pkt_temp);
// 解码成功，更新时间戳
if (got_frame) {
//这里需要注意的是，默认下decoder_reorder_pts =-1.
if (decoder_reorder_pts == -1) {
//所以默认情况下，frame的pts可以通过av_frame_get_best_effort_timestamp来取的
frame->pts = av_frame_get_best_effort_timestamp(frame);
} else if (!decoder_reorder_pts) { // 如果不重新排列时间戳，则需要更新帧的pts
frame->pts = frame->pkt_dts;
}
}
break;
// 音频解码
case AVMEDIA_TYPE_AUDIO:
// 音频解码
ret = avcodec_decode_audio4(d->avctx, frame, &got_frame, &d->pkt_temp);
// 音频解码完成，更新时间戳
if (got_frame) {
AVRational tb = (AVRational){1, frame->sample_rate};
// 更新帧的时间戳
if (frame->pts != AV_NOPTS_VALUE)
//音频解码的pts,则只能自己通过time_base进行计算
frame->pts = av_rescale_q(frame->pts, av_codec_get_pkt_timebase(d->avctx), tb);
else if (d->next_pts != AV_NOPTS_VALUE)
frame->pts = av_rescale_q(d->next_pts, d->next_pts_tb, tb);
// 更新下一时间戳
if (frame->pts != AV_NOPTS_VALUE) {
d->next_pts = frame->pts + frame->nb_samples;
d->next_pts_tb = tb;
}
}
break;
// 字幕解码
case AVMEDIA_TYPE_SUBTITLE:
ret = avcodec_decode_subtitle2(d->avctx, sub, &got_frame, &d->pkt_temp);
break;
}
// 判断是否解码成功
// 如果解码失败的话，包继续等待
if (ret < 0) {
d->packet_pending = 0;
} else {
d->pkt_temp.dts =
d->pkt_temp.pts = AV_NOPTS_VALUE;
//下面这个操作不明白？？？
if (d->pkt_temp.data) {
if (d->avctx->codec_type != AVMEDIA_TYPE_AUDIO)
ret = d->pkt_temp.size;
d->pkt_temp.data += ret;
d->pkt_temp.size -= ret;
if (d->pkt_temp.size <= 0)
d->packet_pending = 0;
} else {
if (!got_frame) {
d->packet_pending = 0;
d->finished = d->pkt_serial;
}
}
}
得到pkt_temp之后，还需要判断，是否需要抛弃
static int get_video_frame(VideoState *is, AVFrame *frame)
{
int got_picture;
// 解码视频帧
if ((got_picture = decoder_decode_frame(&is->viddec, frame, NULL)) < 0)
return -1;
// 判断是否解码成功
if (got_picture) {
double dpts = NAN;
if (frame->pts != AV_NOPTS_VALUE)
//通过 pts*av_q2d(timebase)可以得到准确的时间
dpts = av_q2d(is->video_st->time_base) * frame->pts;
//重新得到视频的比例
frame->sample_aspect_ratio = av_guess_sample_aspect_ratio(is->ic, is->video_st, frame);
// 判断是否需要舍弃该帧。如果当前的不是用视频的时间为主，则会开始考虑丢帧。因为太慢了，所以才会进行丢帧，所以diff小于阀值的话，就会去丢帧 10.0
if (framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) {
if (frame->pts != AV_NOPTS_VALUE) {
//得到的是当前的时间和时间钟之间的差值。
double diff = dpts - get_master_clock(is);
if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD &&
diff - is->frame_last_filter_delay < 0 &&
is->viddec.pkt_serial == is->vidclk.serial &&
is->videoq.nb_packets) {
is->frame_drops_early++;
av_frame_unref(frame);
got_picture = 0;
}
}
}
}
return got_picture;
}
计算时间和入列
这里的帧的长度就是用上面预计得到的frame_rate进行计算。
// 计算帧的pts、duration等
//每一帧的时长，应该就是等于帧率的倒数。
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 = queue_picture(is, frame, pts, duration, av_frame_get_pkt_pos(frame), is->viddec.pkt_serial);
av_frame_unref(frame);
将已经解码的数据放到队列当中queue_picture
static int queue_picture(VideoState *is, AVFrame *src_frame, double pts, double duration, int64_t pos, int serial)
{
Frame *vp;
#if defined(DEBUG_SYNC)
printf("frame_type=%c pts=%0.3f\n",
av_get_picture_type_char(src_frame->pict_type), pts);
#endif
//先从队列中取。因为要queue的大小有限，所以先判断是否可以继续写入
if (!(vp = frame_queue_peek_writable(&is->pictq)))
return -1;
vp->sar = src_frame->sample_aspect_ratio;
vp->uploaded = 0;
vp->width = src_frame->width;
vp->height = src_frame->height;
vp->format = src_frame->format;
vp->pts = pts;
vp->duration = duration;
vp->pos = pos;
vp->serial = serial;
set_default_window_size(vp->width, vp->height, vp->sar);
//将src中的数据送入vp当中，并且重置src
av_frame_move_ref(vp->frame, src_frame);
//重新推入
frame_queue_push(&is->pictq);
return 0;
}
/**
* 查找可写帧
* @param f [description]
* @return [description]
*/
static Frame *frame_queue_peek_writable(FrameQueue *f)
{
/* wait until we have space to put a new frame */
SDL_LockMutex(f->mutex);
// 如果帧队列大于最大
while (f->size >= f->max_size &&
!f->pktq->abort_request) {
SDL_CondWait(f->cond, f->mutex);
}
SDL_UnlockMutex(f->mutex);
if (f->pktq->abort_request)
return NULL;
//writable index 是 windex
return &f->queue[f->windex];
}
static void frame_queue_push(FrameQueue *f)
{
//会将可写的index偏移
if (++f->windex == f->max_size)
f->windex = 0;
SDL_LockMutex(f->mutex);
f->size++;
SDL_CondSignal(f->cond);
SDL_UnlockMutex(f->mutex);
}
已放入队列，最后
av_frame_unref(frame) 原来的创建的frame就可以了释放了。
其他
attached_pic入列
attached_pic的意思是有附带的图片。比如说一些MP3，AAC音频文件附带的专辑封面。所以，就是如果有，就去显示吧。
is->queue_attachments_req = 1;
主线程视频显示部分
在主线程的EventLoop开启之后，会进行绘制。先会根据主的时间钟进行同步，然后进行显示。这里我们因为只分析视频部分。所以就不关注时间钟的同步了。
视频的显示
同步后时间，取到具体的frame时，就送入显示。
/* display the current picture, if any */
static void video_display(VideoState *is)
{
//当window还没创建的时候，就是第一次，会去初始化
if (!window)
video_open(is);
//SDL常规操作两则
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
SDL_RenderClear(renderer);
if (is->audio_st && is->show_mode != SHOW_MODE_VIDEO)
video_audio_display(is);
else if (is->video_st)
//video走这里
video_image_display(is);
//送显
SDL_RenderPresent(renderer);
}
1.第一次会进入video_open
先去创建SDL_Window和SDL_Renderer。
举Android的例子来说，在Android中SDL使用的是OpenGL。
SDL_CreateWindow就是通过ANativeWindow 来创建一个GL Surface。同时创建GLContext。
SDL_CreateRenderer 就是glmakeCurrent, 同时对Renderer的各个方法进行初始化，以供后面调用。
2.视频的延迟
视频需要根据pts来显示，之间有间隔，正常进行的话，还需要间隔固定的时间。
这里就是remaining_time
static void refresh_loop_wait_event(VideoState *is, SDL_Event *event) {
double remaining_time = 0.0;
SDL_PumpEvents();
while (!SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT)) {
if (!cursor_hidden && av_gettime_relative() - cursor_last_shown > CURSOR_HIDE_DELAY) {
SDL_ShowCursor(0);
cursor_hidden = 1;
}
if (remaining_time > 0.0)
av_usleep((int64_t)(remaining_time * 1000000.0));
remaining_time = REFRESH_RATE;
if (is->show_mode != SHOW_MODE_NONE && (!is->paused || is->force_refresh))
video_refresh(is, &remaining_time);
SDL_PumpEvents();
}
}
/* called to display each frame */
static void video_refresh(void *opaque, double *remaining_time)
{
VideoState *is = opaque;
double time;
Frame *sp, *sp2;
if (!is->paused && get_master_sync_type(is) == AV_SYNC_EXTERNAL_CLOCK && is->realtime)
check_external_clock_speed(is);
if (!display_disable && is->show_mode != SHOW_MODE_VIDEO && is->audio_st) {
time = av_gettime_relative() / 1000000.0;
if (is->force_refresh || is->last_vis_time + rdftspeed < time) {
video_display(is);
is->last_vis_time = time;
}
*remaining_time = FFMIN(*remaining_time, is->last_vis_time + rdftspeed - time);
}
if (is->video_st) {
retry:
if (frame_queue_nb_remaining(&is->pictq) == 0) {
// nothing to do, no picture to display in the queue
} else {
double last_duration, duration, delay;
Frame *vp, *lastvp;
/* dequeue the picture */
lastvp = frame_queue_peek_last(&is->pictq);
vp = frame_queue_peek(&is->pictq);
if (vp->serial != is->videoq.serial) {
frame_queue_next(&is->pictq);
goto retry;
}
if (lastvp->serial != vp->serial)
is->frame_timer = av_gettime_relative() / 1000000.0;
if (is->paused)
goto display;
/* compute nominal last_duration */
last_duration = vp_duration(is, lastvp, vp);
delay = compute_target_delay(last_duration, is);
time= av_gettime_relative()/1000000.0;
if (time < is->frame_timer + delay) {
*remaining_time = FFMIN(is->frame_timer + delay - time, *remaining_time);
goto display;
}
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 && (framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) && time > is->frame_timer + duration){
is->frame_drops_late++;
frame_queue_next(&is->pictq);
goto retry;
}
}
if (is->subtitle_st) {
while (frame_queue_nb_remaining(&is->subpq) > 0) {
sp = frame_queue_peek(&is->subpq);
if (frame_queue_nb_remaining(&is->subpq) > 1)
sp2 = frame_queue_peek_next(&is->subpq);
else
sp2 = NULL;
if (sp->serial != is->subtitleq.serial
|| (is->vidclk.pts > (sp->pts + ((float) sp->sub.end_display_time / 1000)))
|| (sp2 && is->vidclk.pts > (sp2->pts + ((float) sp2->sub.start_display_time / 1000))))
{
if (sp->uploaded) {
int i;
for (i = 0; i < sp->sub.num_rects; i++) {
AVSubtitleRect *sub_rect = sp->sub.rects[i];
uint8_t *pixels;
int pitch, j;
if (!SDL_LockTexture(is->sub_texture, (SDL_Rect *)sub_rect, (void **)&pixels, &pitch)) {
for (j = 0; j < sub_rect->h; j++, pixels += pitch)
memset(pixels, 0, sub_rect->w << 2);
SDL_UnlockTexture(is->sub_texture);
}
}
}
frame_queue_next(&is->subpq);
} else {
break;
}
}
}
frame_queue_next(&is->pictq);
is->force_refresh = 1;
if (is->step && !is->paused)
stream_toggle_pause(is);
}
display:
/* display picture */
if (!display_disable && is->force_refresh && is->show_mode == SHOW_MODE_VIDEO && is->pictq.rindex_shown)
video_display(is);
}
is->force_refresh = 0;
if (show_status) {
static int64_t last_time;
int64_t cur_time;
int aqsize, vqsize, sqsize;
double av_diff;
cur_time = av_gettime_relative();
if (!last_time || (cur_time - last_time) >= 30000) {
aqsize = 0;
vqsize = 0;
sqsize = 0;
if (is->audio_st)
aqsize = is->audioq.size;
if (is->video_st)
vqsize = is->videoq.size;
if (is->subtitle_st)
sqsize = is->subtitleq.size;
av_diff = 0;
if (is->audio_st && is->video_st)
av_diff = get_clock(&is->audclk) - get_clock(&is->vidclk);
else if (is->video_st)
av_diff = get_master_clock(is) - get_clock(&is->vidclk);
else if (is->audio_st)
av_diff = get_master_clock(is) - get_clock(&is->audclk);
av_log(NULL, AV_LOG_INFO,
"%7.2f %s:%7.3f fd=%4d aq=%5dKB vq=%5dKB sq=%5dB f=%"PRId64"/%"PRId64" \r",
get_master_clock(is),
(is->audio_st && is->video_st) ? "A-V" : (is->video_st ? "M-V" : (is->audio_st ? "M-A" : " ")),
av_diff,
is->frame_drops_early + is->frame_drops_late,
aqsize / 1024,
vqsize / 1024,
sqsize,
is->video_st ? is->viddec.avctx->pts_correction_num_faulty_dts : 0,
is->video_st ? is->viddec.avctx->pts_correction_num_faulty_pts : 0);
fflush(stdout);
last_time = cur_time;
}
}
}
视频的延迟和丢包
视频的延迟如果不需要进行同步的情况下，其实应该就是等于两个pts之间的差距，或者就是当前帧的duration。
丢包的情况是，当前时间都已经超过了一帧可能需要的时间。这种情况下，就需要进行丢包。
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 && (framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) && time > is->frame_timer + duration){
is->frame_drops_late++;
frame_queue_next(&is->pictq);
goto retry;
}
}
视频解码后显示的简要流程.png
3.确认打开做好SDL_Window和SDL_Renderer之后，就会调用
video_image_display进行显示。
static void video_image_display(VideoState *is)
{
Frame *vp;
Frame *sp = NULL;
SDL_Rect rect;
vp = frame_queue_peek_last(&is->pictq);
//省略了关于字幕的部分...
//计算SDL_Rect 就是当前显示的范围
calculate_display_rect(&rect, is->xleft, is->ytop, is->width, is->height, vp->width, vp->height, vp->sar);
//如果这一帧还没显示过
if (!vp->uploaded) {
int sdl_pix_fmt = vp->frame->format == AV_PIX_FMT_YUV420P ? SDL_PIXELFORMAT_YV12 : SDL_PIXELFORMAT_ARGB8888;
//如果需要重新创建纹理的话
if (realloc_texture(&is->vid_texture, sdl_pix_fmt, vp->frame->width, vp->frame->height, SDL_BLENDMODE_NONE, 0) < 0)
return;
//刷新纹理
if (upload_texture(is->vid_texture, vp->frame, &is->img_convert_ctx) < 0)
return;
vp->uploaded = 1;
vp->flip_v = vp->frame->linesize[0] < 0;
}
SDL_RenderCopyEx(renderer, is->vid_texture, NULL, &rect, 0, NULL, vp->flip_v ? SDL_FLIP_VERTICAL : 0);
if (sp) {
#if USE_ONEPASS_SUBTITLE_RENDER
SDL_RenderCopy(renderer, is->sub_texture, NULL, &rect);
#else
int i;
double xratio = (double)rect.w / (double)sp->width;
double yratio = (double)rect.h / (double)sp->height;
for (i = 0; i < sp->sub.num_rects; i++) {
SDL_Rect *sub_rect = (SDL_Rect*)sp->sub.rects[i];
SDL_Rect target = {.x = rect.x + sub_rect->x * xratio,
.y = rect.y + sub_rect->y * yratio,
.w = sub_rect->w * xratio,
.h = sub_rect->h * yratio};
SDL_RenderCopy(renderer, is->sub_texture, sub_rect, &target);
}
#endif
}
}
通过calculate_display_rectton这里的就是计算需要显示的区域。
然后如果还没创建纹理的话，在realloc_texture内调用SDL_CreateTexture来创建纹理。
在upload_texture内调用SDL_UpdateTexture来更新纹理。
最后是进行SDL_RendererCopy.或者SDL_RendererCopyEx(SDL_RendererCopy的加强版，可以通知显示区域和翻转)。
然后送显SDL_CreateTexture。
这里可以看到依旧是SDL视频送显的经典套路。
SDL视频送显的经典套路.png
处理按键的事件
这部分暂时掠过...
总结
整体的流程.jpg
image.png
