接下来就是通过stream_open函数创建的read_thread线程的实现开始分析：
一、read_thread函数
此处只简要分析一下主要函数的调用，对于一些参数的初始化就不作过多赘述。
- 首先创建一个 AVFormatContext 结构体对象 ic，并分配内存空间。如果分配失败，则输出错误日志并跳转到 fail 标签。
- 设置 ic 对象的中断回调函数，以及回调函数的相关数据（在这里是 is 对象）。
- 打开输入视频流，其中使用了之前分配的 AVFormatContext 对象 ic、文件名和输入格式 is->iformat。还传递了 format_opts 字典作为选项。如果打开失败，则输出错误信息并跳转到 fail 标签。
- 接下来把ic赋值给is作为其一部分在本文件中进行传递。
/* AVFormatContext结构体用于存储音视频封装格式相关的信息，包括了输入/输出文件的格式、编解码器、流信息等。 */
/* 边数据是与音视频流相关的附加信息，可以用于存储字幕、章节、标签等内容。 */
ic = avformat_alloc_context();
if (!ic) {
av_log(NULL, AV_LOG_FATAL, "Could not allocate context.\n");
ret = AVERROR(ENOMEM);
goto fail;
}
ic->interrupt_callback.callback = decode_interrupt_cb;
ic->interrupt_callback.opaque = is;
if (!av_dict_get(format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
av_dict_set(&format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
scan_all_pmts_set = 1;
}
err = avformat_open_input(&ic, is->filename, is->iformat, &format_opts);
if (err < 0) {
print_error(is->filename, err);
ret = -1;
goto fail;
}
is->ic = ic;
- 接下来会通过av_format_inject_global_side_data(ic) 函数，向输入视频流中注入全局辅助数据。这个函数的作用是在打开视频流后，尽可能多地收集并注入全局辅助数据，以便后续的解码和处理过程可以使用这些数据来提供更强大和准确的功能。
- 通过 if (find_stream_info) 条件判断来决定是否要查找流的相关信息。该变量是一个全局变量，默认值为1，可以由用户传参选择是否查找流信息。该函数在调用过程中会调用一次解码器获取相关的流数据信息，具体过程后面的文章会给出解释。
- 这段代码的目的是在打开视频流后，获取流的相关信息，例如视频的编码参数、音频的采样率等。这些信息对于后续的解码和处理操作非常重要。
av_format_inject_global_side_data(ic);
if (find_stream_info) {
AVDictionary **opts = setup_find_stream_info_opts(ic, codec_opts);
int orig_nb_streams = ic->nb_streams;
err = avformat_find_stream_info(ic, opts);
for (i = 0; i < orig_nb_streams; i++)
av_dict_free(&opts[i]);
av_freep(&opts);
if (err < 0) {
av_log(NULL, AV_LOG_WARNING,
"%s: could not find codec parameters\n", is->filename);
ret = -1;
goto fail;
}
}
- 通过 if (start_time != AV_NOPTS_VALUE) 条件判断判断是否存在起始时间。如果输入视频流（ic）的起始时间（ic->start_time）不等于 AV_NOPTS_VALUE（即已设置），则将其加到 timestamp 中。这是为了考虑到整个视频流的起始时间偏移。
- 调用 avformat_seek_file() 函数进行定位操作。该函数用于在视频流中寻找指定的时间戳位置。
- 调用 is_realtime(ic) 函数，判断输入流是否为实时流，并将结果赋值给变量 is->realtime。
/* if seeking requested, we execute it */
if (start_time != AV_NOPTS_VALUE) {
int64_t timestamp;
timestamp = start_time;
/* add the stream start time */
if (ic->start_time != AV_NOPTS_VALUE)
timestamp += ic->start_time;
ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, INT64_MAX, 0);
if (ret < 0) {
av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
is->filename, (double)timestamp / AV_TIME_BASE);
}
}
is->realtime = is_realtime(ic);
- 根据show_status变量决定是否在控制台打印媒体信息，也是个全局变量可由用户控制，默认为1.
- 遍历输入流的所有流（ic->streams）和所有媒体类型。
- 如果未禁用视频（!video_disable） / 音频（!audio_disable），则调用 av_find_best_stream() 函数查找最佳的视频流 / 音频流，并将相应的流索引保存在 st_index 数组中。
if (show_status)
av_dump_format(ic, 0, is->filename, 0);
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);
- 如果音频（视频）流存在（st_index[AVMEDIA_TYPE_AUDIO] >= 0）（st_index[AVMEDIA_TYPE_VIDEO] >= 0），则调用 stream_component_open() 函数打开对应流组件，并传入该流的索引。
- 如果显示模式为 SHOW_MODE_NONE，则根据 ret 的值来决定显示模式：视频还是实时傅里叶变换（Real-time Discrete Fourier Transform，RDFT）的方式显示。
- 这里面涉及到了一个重要函数stream_component_open() ，该函数实现了解码器的查找打开操作并创建了相关的解码和显示线程。
/* 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]);
}
if (is->video_stream < 0 && is->audio_stream < 0) {
av_log(NULL, AV_LOG_FATAL, "Failed to open file '%s' or configure filtergraph\n",
is->filename);
ret = -1;
goto fail;
}
if (infinite_buffer < 0 && is->realtime)
infinite_buffer = 1;
接下来就是read_thread读取数据的代码实现部分了，该部分的实现定义了一个无限for循环用于数据的读取，并添加了线程的一些处理以及音视频同步等操作。
大致流程查看代码的注释：
/* 循环读取数据 */
for (;;) {
if (is->abort_request) // 是否退出
break;
if (is->paused != is->last_paused) { // 是否暂停/继续
is->last_paused = is->paused;
if (is->paused)
is->read_pause_return = av_read_pause(ic); // 这里的暂停、继续只是对网络流的时候有作用
else
av_read_play(ic);
}
#if CONFIG_RTSP_DEMUXER || CONFIG_MMSH_PROTOCOL
if (is->paused &&
(!strcmp(ic->iformat->name, "rtsp") ||
(ic->pb && !strncmp(input_filename, "mmsh:", 5)))) {
/* wait 10 ms to avoid trying to get another packet */
/* XXX: horrible */
SDL_Delay(10);
continue;
}
#endif
if (is->seek_req) { // 是否需要seek
int64_t seek_target = is->seek_pos;
/* 修复+-2是由于生成时未按正确方向进行舍入seek_pos/seek_rel变量的 */
int64_t seek_min = is->seek_rel > 0 ? seek_target - is->seek_rel + 2: INT64_MIN;
int64_t seek_max = is->seek_rel < 0 ? seek_target - is->seek_rel - 2: INT64_MAX;
/* 注意：mp4可以seek到指定的时间戳，ts是seek到文件的某个position，而不能直接seek到指定时间点 */
ret = avformat_seek_file(is->ic, -1, seek_min, seek_target, seek_max, is->seek_flags);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR,
"%s: error while seeking\n", is->ic->url);
} else {
/* 清空音频、视频、字幕队列节点和数据，同时发送flush_pkt清空解码器缓存 */
if (is->audio_stream >= 0)
packet_queue_flush(&is->audioq);
if (is->subtitle_stream >= 0)
packet_queue_flush(&is->subtitleq);
if (is->video_stream >= 0)
packet_queue_flush(&is->videoq);
if (is->seek_flags & AVSEEK_FLAG_BYTE) {
set_clock(&is->extclk, NAN, 0);
} else {
set_clock(&is->extclk, seek_target / (double)AV_TIME_BASE, 0);
}
}
is->seek_req = 0;
is->queue_attachments_req = 1;
is->eof = 0;
if (is->paused) // 如果本身是pause状态，则显示一帧继续暂停
step_to_next_frame(is);
}
if (is->queue_attachments_req) {
if (is->video_st && is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC) {
if ((ret = av_packet_ref(pkt, &is->video_st->attached_pic)) < 0)
goto fail;
packet_queue_put(&is->videoq, pkt);
packet_queue_put_nullpacket(&is->videoq, pkt, is->video_stream);
}
is->queue_attachments_req = 0;
}
/* PacketQueue队列缓冲区已满，最大值为MAX_QUEUE_SIZE 15M，不需要继续读取数据 */
if (infinite_buffer<1 &&
(is->audioq.size + is->videoq.size + is->subtitleq.size > MAX_QUEUE_SIZE
|| (stream_has_enough_packets(is->audio_st, is->audio_stream, &is->audioq) &&
stream_has_enough_packets(is->video_st, is->video_stream, &is->videoq) &&
stream_has_enough_packets(is->subtitle_st, is->subtitle_stream, &is->subtitleq)))) {
/* wait 10 ms */
SDL_LockMutex(wait_mutex);
SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10); // 如果没有唤醒，则超时10ms退出
SDL_UnlockMutex(wait_mutex);
continue;
}
if (!is->paused &&
(!is->audio_st || (is->auddec.finished == is->audioq.serial && frame_queue_nb_remaining(&is->sampq) == 0)) &&
(!is->video_st || (is->viddec.finished == is->videoq.serial && frame_queue_nb_remaining(&is->pictq) == 0))) {
if (loop != 1 && (!loop || --loop)) {
stream_seek(is, start_time != AV_NOPTS_VALUE ? start_time : 0, 0, 0);
} else if (autoexit) {
ret = AVERROR_EOF;
goto fail;
}
}
/* 读取数据包，不会释放其数据，要自己去释放 */
ret = av_read_frame(ic, pkt);
if (ret < 0) {
if ((ret == AVERROR_EOF || avio_feof(ic->pb)) && !is->eof) { // 数据读取完毕，往队列添加nullpacket
if (is->video_stream >= 0)
packet_queue_put_nullpacket(&is->videoq, pkt, is->video_stream);
if (is->audio_stream >= 0)
packet_queue_put_nullpacket(&is->audioq, pkt, is->audio_stream);
if (is->subtitle_stream >= 0)
packet_queue_put_nullpacket(&is->subtitleq, pkt, is->subtitle_stream);
is->eof = 1;
}
if (ic->pb && ic->pb->error) {
if (autoexit)
goto fail;
else
break;
}
SDL_LockMutex(wait_mutex);
SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
SDL_UnlockMutex(wait_mutex);
continue;
} else {
is->eof = 0;
}
/* 检查数据包是否在指定的播放范围内，然后入队，否则丢弃 */
stream_start_time = ic->streams[pkt->stream_index]->start_time; // 获取流的起始时间
pkt_ts = pkt->pts == AV_NOPTS_VALUE ? pkt->dts : pkt->pts; // 读取到pkt的时间戳
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);
}
}
上面说到了read_thread中调用了一个重要的函数用于解码器的操作，接下来就是简要说明一下该函数的函数调用流程：
二、stream_component_open函数
- 初始化解码器上下文并查找解码器。
/* 分配解码器上下文 */
avctx = avcodec_alloc_context3(NULL);
if (!avctx)
return AVERROR(ENOMEM);
/* 将码流中解码参数拷贝到新分配的解码器上下文结构体 */
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 = 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;
}
- 打开并配置解码器选项参数。
- 调用 filter_codec_opts() 函数根据解码器的选项和媒体流的信息生成一个过滤后的选项集合，并将返回的选项集合赋给变量 opts。codec_opts 是解码器选项，avctx->codec_id 是解码器的 ID，ic 是输入容器（AVFormatContext），ic->streams[stream_index] 是指定媒体流，codec 是解码器本身。
opts = filter_codec_opts(codec_opts, avctx->codec_id, ic, ic->streams[stream_index], codec);
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 ((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;
}
- 如果不出现问题的画会在此处成功打开解码器并进行解码器的打开操作，接下来就是对音视频流根据类型进行音视频的操作了。
- 在音频部分：调用 audio_open() 函数准备音频输出。该函数接受音频通道布局、采样率等参数，并返回音频硬件缓冲区大小。该函数调用了SDL的函数并注册了音频播放的回调函数以及重采样信息的配置。如果要在此处不调用SDL库使用其他的音频播放比如linux下调用alsa进行视频播放的话此处需要将一些参数进行配置并将is->audio_tgt置为空，否则会引起多线程导致的一些问题。
- 将返回的音频硬件缓冲区大小赋值给 is->audio_hw_buf_size。将目标音频参数（is->audio_tgt）复制给音频源参数（is->audio_src）
- 调用 decoder_init() 函数初始化音频解码器（is->auddec）。该函数接受解码器上下文（avctx）、音频队列（is->audioq）等参数，并返回初始化结果。
- 调用 decoder_start() 函数启动音频解码线程，并返回启动结果。
- 使用 SDL_PauseAudioDevice() 函数恢复音频设备的播放，将参数 audio_dev 设置为0表示继续播放音频。
代码以略过可配置部分，只展示重要的配置
switch (avctx->codec_type) {
case AVMEDIA_TYPE_AUDIO:
/* 准备音频输出 */
if ((ret = audio_open(is, &ch_layout, sample_rate, &is->audio_tgt)) < 0)
goto fail;
is->audio_hw_buf_size = ret;
is->audio_src = is->audio_tgt;
is->audio_buf_size = 0;
is->audio_buf_index = 0;
/* 初始平均滤波器 */
is->audio_diff_avg_coef = exp(log(0.01) / AUDIO_DIFF_AVG_NB);
is->audio_diff_avg_count = 0;
/* 由于没有精确的anough音频FIFO充满度，只有当大于此阈值时，才更正音频同步 */
is->audio_diff_threshold = (double)(is->audio_hw_buf_size) / is->audio_tgt.bytes_per_sec;
is->audio_stream = stream_index;
is->audio_st = ic->streams[stream_index];
/* 初始化音频解码器 */
if ((ret = decoder_init(&is->auddec, avctx, &is->audioq, is->continue_read_thread)) < 0)
goto fail;
if ((is->ic->iformat->flags & (AVFMT_NOBINSEARCH | AVFMT_NOGENSEARCH | AVFMT_NO_BYTE_SEEK)) && !is->ic->iformat->read_seek) {
is->auddec.start_pts = is->audio_st->start_time;
is->auddec.start_pts_tb = is->audio_st->time_base;
}
if ((ret = decoder_start(&is->auddec, audio_thread, "audio_decoder", is)) < 0)
goto out;
SDL_PauseAudioDevice(audio_dev, 0);
break;
视频部分也是类似的操作：
case AVMEDIA_TYPE_VIDEO:
is->video_stream = stream_index; // 获取video的stream索引
is->video_st = ic->streams[stream_index]; // 获取video的stream指针
/* 初始化视频解码器 */
if ((ret = decoder_init(&is->viddec, avctx, &is->videoq, is->continue_read_thread)) < 0)
goto fail;
if ((ret = decoder_start(&is->viddec, video_thread, "video_decoder", is)) < 0)
goto out;
is->queue_attachments_req = 1;
break;
上述两部分会创建audio_thread和video_thread两个线程，分别用于音视频的解码和播放。
解码线程以video_thread线程为例进行简单分析：
三、video_thread函数
以下代码已简略滤波器部分的代码。
/* ffplay的解码线程独立于数据读取线程，并且每种类型的流都有各自的解码线程。 */
static int video_thread(void *arg)
{
VideoState *is = arg;
AVFrame *frame = av_frame_alloc(); // 分配解码帧
double pts;
double duration; // 帧持续时间
int ret;
AVRational tb = is->video_st->time_base; // 获取stream timebase
AVRational frame_rate = av_guess_frame_rate(is->ic, is->video_st, NULL);// 获取帧率
if (!frame)
return AVERROR(ENOMEM);
/* 循环取出解码的帧数据 */
for (;;) {
/* 里面包含了从PacketQueue取一个pkt，avcodec_send_packet发送到解码器、
* avcodec_receive_frame从解码器读取到图像帧的解码过程 */
ret = get_video_frame(is, frame);
if (ret < 0)
goto the_end; // 解码结束
if (!ret)
continue; // 没有解码得到画面
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); // 根据AVStream timebase计算出pts值，单位为秒
ret = queue_picture(is, frame, pts, duration, frame->pkt_pos, is->viddec.pkt_serial); // 将解码后的视频帧插入队列
av_frame_unref(frame);
}
}
for循环内部循环调用get_video_frame函数用于发送和获取解码帧，该函数的实现如下：
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;
/* 分析得到的帧是否要drop掉，目的是在放入frameQueue前，drop掉过时的帧 */
if (got_picture) {
double dpts = NAN;
if (frame->pts != AV_NOPTS_VALUE)
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);
/* framedrop为1则始终判断是否要丢帧，为0则始终不丢帧，为-1则在同步时钟不是按video时钟时，判断是否要丢帧 */
/* 如果刚解出来的帧就落后主时钟，就没必要放入队列，进行后面的播放 */
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);
/* 计算当前pts和主时钟的差值，!isnan(diff)差值有效，fabs(diff)差值在范围内 */
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;
}
其中最主要的就是函数decoder_decode_frame，其他只为实现时间序列以及包的索引的更新用于音视频的同步等操作。
decoder_decode_frame函数包含了音频和视频的解码实现，其中最主要的调用就是函数avcodec_send_packet发送到解码器和函数avcodec_receive_frame从解码器读取到图像帧
static int decoder_decode_frame(Decoder *d, AVFrame *frame, AVSubtitle *sub) {
int ret = AVERROR(EAGAIN);
for (;;) {
/* 1.流连续情况下获取解码帧 */
if (d->queue->serial == d->pkt_serial) {
do {
if (d->queue->abort_request)
return -1; // 是否请求退出
switch (d->avctx->codec_type) {
case AVMEDIA_TYPE_VIDEO:
ret = avcodec_receive_frame(d->avctx, frame); // 从视频解码器中读取一帧
if (ret >= 0) {
if (decoder_reorder_pts == -1) {
frame->pts = frame->best_effort_timestamp;
} else if (!decoder_reorder_pts) {
frame->pts = frame->pkt_dts;
}
}
break;
case AVMEDIA_TYPE_AUDIO:
ret = avcodec_receive_frame(d->avctx, frame); // 从音频解码器中读取一帧
if (ret >= 0) {
AVRational tb = (AVRational){1, frame->sample_rate};
if (frame->pts != AV_NOPTS_VALUE) // 如果frame->pts正常则先将其从pkt_timebase 转成{1, frame->sample_rate}
frame->pts = av_rescale_q(frame->pts, d->avctx->pkt_timebase, tb);
else if (d->next_pts != AV_NOPTS_VALUE) // 如果frame->pts不正常则使⽤上⼀帧更新的next_ pts和next_pts_tb 转成 {1, frame->sample_rate}
frame->pts = av_rescale_q(d->next_pts, d->next_pts_tb, tb);
if (frame->pts != AV_NOPTS_VALUE) { // 根据当前帧的pts和nb_samples预估下⼀帧的pts
d->next_pts = frame->pts + frame->nb_samples;
d->next_pts_tb = tb;
}
}
break;
}
if (ret == AVERROR_EOF) { // 解码器内没有帧可读了，解码结束
d->finished = d->pkt_serial;
avcodec_flush_buffers(d->avctx); // 清解码器缓存
return 0;
}
if (ret >= 0)
return 1; // 读取到解码帧
} while (ret != AVERROR(EAGAIN));
}
/* 2.获取一个packet，如果播放序列不一致，则过滤掉过时的pkt */
do {
if (d->queue->nb_packets == 0) // 如果没有数据可读，则唤醒数据读取线程read_thread
SDL_CondSignal(d->empty_queue_cond);
if (d->packet_pending) { // 如果之前有缓存的d->pkt，则把之前缓存的d->pkt拷贝到pkt，然后立马发送给编码器
d->packet_pending = 0;
} else { // 没有缓存，则从PacketQueue中获取
int old_serial = d->pkt_serial;
if (packet_queue_get(d->queue, d->pkt, 1, &d->pkt_serial) < 0)
return -1;
if (old_serial != d->pkt_serial) {
avcodec_flush_buffers(d->avctx); // 清空解码器里面的缓存
d->finished = 0;
d->next_pts = d->start_pts;
d->next_pts_tb = d->start_pts_tb;
}
}
/* 序列一致，退出循环 */
if (d->queue->serial == d->pkt_serial)
break;
av_packet_unref(d->pkt); // 释放过滤的pkt
} while (1);
if (d->avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
int got_frame = 0;
ret = avcodec_decode_subtitle2(d->avctx, sub, &got_frame, d->pkt);
if (ret < 0) {
ret = AVERROR(EAGAIN);
} else {
if (got_frame && !d->pkt->data) {
d->packet_pending = 1;
}
ret = got_frame ? 0 : (d->pkt->data ? AVERROR(EAGAIN) : AVERROR_EOF);
}
av_packet_unref(d->pkt);
} else {
if (avcodec_send_packet(d->avctx, d->pkt) == AVERROR(EAGAIN)) {
/* 发送一个packet到解码器中 */
/* 返回EAGAIN解码器没有收到pkt，说明还要继续调用avcodec_send_packet将frame读取，再avcodec_send_packet发送该pkt */
/* 由于解码器没有收到pkt，但又没办法放回PacketQueue，所以就缓存到自个封装的Decoder的pkt，并将d->packet_pending=1，以备下次继续使用该pkt */
av_log(d->avctx, AV_LOG_ERROR, "Receive_frame and send_packet both returned EAGAIN, which is an API violation.\n");
d->packet_pending = 1; // 说明send_packet失败时，需要重新发送
} else {
av_packet_unref(d->pkt); // 发送到解码器后，释放pkt
}
}
}
}
还记得在video_thread线程中解码后会调用ret = queue_picture(is, frame, pts, duration, frame->pkt_pos, is->viddec.pkt_serial); 函数，该函数将解码后的视频帧插入队列并将vp->uploaded 赋值为0。该标志表示当前帧未被显示过，那么在显示线程中会根据该标志位进行显示判断。
四、event_loop函数
该函数定义了一个事件循环，用于处理 SDL 事件。它会等待事件的发生，然后根据不同的事件类型进行相应的操作。
该函数中主要查看refresh_loop_wait_event函数用于视频显示。
/* 处理GUI发送的事件 */
static void event_loop(VideoState *cur_stream)
{
SDL_Event event;
double incr, pos, frac;
for (;;) {
double x;
refresh_loop_wait_event(cur_stream, &event); // video显示
/* 按键事件 */
switch (event.type) {
case SDL_KEYDOWN:
if (exit_on_keydown || event.key.keysym.sym == SDLK_ESCAPE || event.key.keysym.sym == SDLK_q) {
do_exit(cur_stream);
break;
}
// If we don't yet have a window, skip all key events, because read_thread might still be initializing...
if (!cur_stream->width)
continue;
switch (event.key.keysym.sym) {
case SDLK_f:
toggle_full_screen(cur_stream);
cur_stream->force_refresh = 1;
break;
case SDLK_p:
case SDLK_SPACE:
toggle_pause(cur_stream);
break;
......
......
- 定义了一个变量 remaining_time，用于记录剩余的时间。
- 调用 SDL_PumpEvents() 函数来处理所有未处理的事件。
- 进入一个循环，直到收到一个 SDL 事件为止。使用 SDL_PeepEvents() 函数来检查是否有新的事件，如果没有则继续循环。在循环中，首先判断光标是否隐藏，并且距离上次显示光标的时间是否超过了设定的延迟时间（CURSOR_HIDE_DELAY）。如果满足条件，则调用 SDL_ShowCursor(0) 函数隐藏光标，并将 cursor_hidden 设置为1表示光标已隐藏。
- 如果 remaining_time 大于0.0，则调用 av_usleep() 函数让线程休眠一段时间，以保持稳定的画面输出。
- 将 REFRESH_RATE 赋值给 remaining_time，表示下一轮应当 sleep 的时间。
- 如果当前显示模式不是 SHOW_MODE_NONE，并且视频未暂停或者强制刷新标志被设置，则调用 video_refresh() 函数刷新画面，并传递 remaining_time 参数以确保稳定的画面输出。
- 调用 SDL_PumpEvents() 函数来处理所有未处理的事件（包括刷新画面期间产生的新事件）。
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); // 显示画面，remaining_time：下⼀轮应当sleep的时间，以保持稳定的画⾯输出
SDL_PumpEvents();
}
}
video_refresh函数的作用是根据音频时钟和视频时钟的差值来控制视频的播放速度，并将解码后的视频图像显示出来。
/* 调用以显示每帧 */
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) { // 帧队列是否为空
/* 队列中没有图像可显示 */
} else {
double last_duration, duration, delay;
Frame *vp, *lastvp;
/* 从队列取出上一个Frame */
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;
/* last_duration 计算上一帧应显示的时长 */
last_duration = vp_duration(is, lastvp, vp);
/* 经过compute_target_delay方法，计算出待显示帧vp需要等待的时间
* 如果以video同步，则delay直接等于last_duration。
* 如果以audio或外部时钟同步，则需要比对主时钟调整待显示帧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;
}
/* 走到这一步，说明已经到了或过了该显示的时间，待显示帧vp的状态变更为当前要显示的帧 */
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); // 更新video时钟
SDL_UnlockMutex(is->pictq.mutex);
/* 丢帧逻辑 ============>>>>>>>>>>>> */
if (frame_queue_nb_remaining(&is->pictq) > 1) { // 有nextvp才会检测是否该丢帧
Frame *nextvp = frame_queue_peek_next(&is->pictq);
duration = vp_duration(is, vp, nextvp);
if(!is->step // 非逐帧模式才检测是否需要丢帧 is->step==1 为逐帧播放
&& (framedrop>0 // cpu解帧过慢
|| (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; // 回到函数开始位置，继续重试
}
}
......
display:
/* 显示图片 */
if (!display_disable && is->force_refresh && is->show_mode == SHOW_MODE_VIDEO && is->pictq.rindex_shown)
video_display(is); // 重点是显示
}
is->force_refresh = 0;
......
/* 显示当前图片（如果有） */
static void video_display(VideoState *is)
{
if (!is->width)
video_open(is);
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
SDL_RenderClear(renderer); // 清理render
if (is->audio_st && is->show_mode != SHOW_MODE_VIDEO)
video_audio_display(is); // 音频显示（显示的方式根据SHOW_MODE_VIDEO的值）
else if (is->video_st)
video_image_display(is); // 图像显示
SDL_RenderPresent(renderer);
}
主要看一下video_image_display函数（省略SDL显示的逻辑，便于用户根据平台进行扩展）：
static void video_image_display(VideoState *is)
{
Frame *vp;
Frame *sp = NULL;
SDL_Rect rect;
vp = frame_queue_peek_last(&is->pictq); // 取要显示的视频帧
if (is->subtitle_st) { // 字幕显示
if (frame_queue_nb_remaining(&is->subpq) > 0) {
sp = frame_queue_peek(&is->subpq);
if (vp->pts >= sp->pts + ((float) sp->sub.start_display_time / 1000)) {
if (!sp->uploaded) {
/* 视频显示操作，可自定义播放逻辑 */
sp->uploaded = 1;
}
}
}
}
差不多到这儿图像显示部分就结束了，总的来说比较繁琐，需要根据代码去梳理逻辑会更好一些。
接下来就可以根据ffplay来进行自定义函数的实现逻辑，在此基础上进行优化封装成库文件供应用程序去调用实现属于自己风格的播放器了~
953
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
