这一章，我们来讲解播放器解复用(从文件中读取数据包)的流程。在讲解播放器的读数据包流程之前，我们先定义一个播放器状态结构体，用来记录播放器的各种状态。
播放器状态结构体
首先，我们定义一个结构体，用于记录播放器的开始、暂停、定位等各种状态标志，以及重置结构体的方法：
/**
* 播放器状态结构体
*/
typedef struct PlayerState {
AVDictionary *sws_dict; // 视频转码option参数
AVDictionary *swr_opts; //
AVDictionary *format_opts; // 解复用option参数
AVDictionary *codec_opts; // 解码option参数
AVDictionary *resample_opts; // 重采样option参数
const char *audioCodecName; // 指定音频解码器名称
const char *videoCodecName; // 指定视频解码器名称
int abortRequest; // 退出标志
int pauseRequest; // 暂停标志
SyncType syncType; // 同步类型
int64_t startTime; // 播放起始位置
int64_t duration; // 播放时长
int realTime; // 判断是否实时流
int audioDisable; // 是否禁止音频流
int videoDisable; // 是否禁止视频流
int displayDisable; // 是否禁止显示
int fast; // 解码上下文的AV_CODEC_FLAG2_FAST标志
int genpts; // 解码上下文的AVFMT_FLAG_GENPTS标志
int lowres; // 解码上下文的lowres标志
float playbackRate; // 播放速度
float playbackPitch; // 播放音调
int seekByBytes; // 是否以字节定位
int seekRequest; // 定位请求
int seekFlags; // 定位标志
int64_t seekPos; // 定位位置
int64_t seekRel; // 定位偏移
int autoExit; // 是否自动退出
int loop; // 循环播放
int mute; // 静音播放
int frameDrop; // 舍帧操作
} PlayerState;
/**
* 重置播放器状态结构体
* @param state
*/
inline void resetPlayerState(PlayerState *state) {
av_opt_free(state);
av_dict_free(&state->sws_dict);
av_dict_free(&state->swr_opts);
av_dict_free(&state->format_opts);
av_dict_free(&state->codec_opts);
av_dict_free(&state->resample_opts);
av_dict_set(&state->sws_dict, "flags", "bicubic", 0);
if (state->audioCodecName != NULL) {
av_freep(&state->audioCodecName);
state->audioCodecName = NULL;
}
if (state->videoCodecName != NULL) {
av_freep(&state->videoCodecName);
state->videoCodecName = NULL;
}
state->abortRequest = 1;
state->pauseRequest = 0;
state->seekByBytes = 0;
state->syncType = AV_SYNC_AUDIO;
state->startTime = AV_NOPTS_VALUE;
state->duration = AV_NOPTS_VALUE;
state->realTime = 0;
state->audioDisable = 0;
state->videoDisable = 0;
state->displayDisable = 0;
state->fast = 0;
state->genpts = 0;
state->lowres = 0;
state->playbackRate = 1.0;
state->playbackPitch = 1.0;
state->seekRequest = 0;
state->seekFlags = 0;
state->seekPos = 0;
state->seekRel = 0;
state->seekRel = 0;
state->autoExit = 0;
state->loop = 0;
state->frameDrop = 0;
}
播放器状态结构体的作用是用来给解复用、解码、同步等流程共享状态的，方便统一播放器的状态。
初始化以及解复用
我们在播放器调用prepare()时创建一个线程用来初始化解码器、打开音视频输出设备和音视频同步渲染线程等出来了，在准备完成后，等待播放器调用start()方法更新PlayerState的pauseRequest标志，进入读数据包流程。读数据包线程执行逻辑如下：
初始化流程
- 利用avformat_alloc_context()方法创建解复用上下文并设置解复用中断回调
- 利用 avformat_open_input()方法打开url，url可以是本地文件，也可以使网络媒体流
- 在成功打开文件之后，我们需要利用avformat_find_stream_info()方法查找媒体流信息
- 如果开始播放的位置不是AV_NOPTS_VALUE，即从文件开头开始的话，需要先利用avformat_seek_file方法定位到播放的起始位置
- 查找音频流、视频流索引，然后根据是否禁用音频流、视频流判断的设置，分别准备解码器对象
- 当我们准备好解码器之后，通过媒体播放器回调播放器已经准备。
- 判断音频解码器是否存在，通过openAudioDevice方法打开音频输出设备
- 判断视频解码器是否存在，打开视频同步输出设备
其中，第7、第8步骤，我们需要根据实际情况，重新设定同步类型。同步有三种类型，同步到音频时钟、同步到视频时钟、同步到外部时钟。默认是同步到音频时钟，如果音频解码器不存在，则根据需求同步到视频时钟还是外部时钟。
解复用流程
经过前面的初始化之后，我们就可以进入读数据包流程。读数据包流程如下：
- 判断是否退出播放器
- 判断暂停状态是否发生改变，设置解复用是否暂停还是播放 —— av_read_pause 和 av_read_play
- 处理定位状态。利用avformat_seek_file()方法定位到实际的位置，如果定位成功，我们需要清空音频解码器、视频解码器中待解码队列的数据。处理完前面的逻辑，我们需要更新外部时钟，并且更新视频同步刷新的时钟
- 根据是否设置attachmentRequest标志，从视频流取出attached_pic的数据包
- 判断解码器待解码队列的数据包如果大于某个数量，则等待解码器消耗
- 读数据包
- 判断数据包是否读取成功。如果没成功，则判断读取的结果是否AVERROR_EOF，即结尾标志。如果到了结尾，则入队一个空的数据包。如果读取出错，则直接退出读数据包流程。如果都不是，则判断解码器中的待解码数据包、待输出帧是否存在数据，如果都不存在数据，则判断是否跳转至起始位置还是判断是否自动退出，或者是继续下一轮读数据包流程。
- 根据取得的数据包判断是否在播放范围内的数据包。如果在播放范围内，则根据数据包的媒体流索引判断是否入队数据包舍弃。
至此，解复用流程就完成了。
整个线程执行体的代码如下：
int MediaPlayer::readPackets() {
int ret = 0;
AVDictionaryEntry *t;
AVDictionary **opts;
int scan_all_pmts_set = 0;
// 准备解码器
mMutex.lock();
do {
// 创建解复用上下文
pFormatCtx = avformat_alloc_context();
if (!pFormatCtx) {
av_log(NULL, AV_LOG_FATAL, "Could not allocate context.\n");
ret = AVERROR(ENOMEM);
break;
}
// 设置解复用中断回调
pFormatCtx->interrupt_callback.callback = avformat_interrupt_cb;
pFormatCtx->interrupt_callback.opaque = playerState;
if (!av_dict_get(playerState->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
av_dict_set(&playerState->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
scan_all_pmts_set = 1;
}
// 设置rtmp/rtsp的超时值
if (av_stristart(url, "rtmp", NULL) || av_stristart(url, "rtsp", NULL)) {
// There is total different meaning for 'timeout' option in rtmp
av_log(NULL, AV_LOG_WARNING, "remove 'timeout' option for rtmp.\n");
av_dict_set(&playerState->format_opts, "timeout", NULL, 0);
}
// 打开文件
ret = avformat_open_input(&pFormatCtx, url, NULL, &playerState->format_opts);
if (ret < 0) {
printError(url, ret);
ret = -1;
break;
}
if (scan_all_pmts_set) {
av_dict_set(&playerState->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
}
if ((t = av_dict_get(playerState->format_opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
ret = AVERROR_OPTION_NOT_FOUND;
break;
}
if (playerState->genpts) {
pFormatCtx->flags |= AVFMT_FLAG_GENPTS;
}
av_format_inject_global_side_data(pFormatCtx);
opts = setupStreamInfoOptions(pFormatCtx, playerState->codec_opts);
// 查找媒体流信息
ret = avformat_find_stream_info(pFormatCtx, opts);
if (opts != NULL) {
for (int i = 0; i < pFormatCtx->nb_streams; i++) {
if (opts[i] != NULL) {
av_dict_free(&opts[i]);
}
}
av_freep(&opts);
}
if (ret < 0) {
av_log(NULL, AV_LOG_WARNING,
"%s: could not find codec parameters\n", url);
ret = -1;
break;
}
// 文件时长(秒)
if (pFormatCtx->duration != AV_NOPTS_VALUE) {
mDuration = (int)(pFormatCtx->duration / AV_TIME_BASE);
}
if (pFormatCtx->pb) {
pFormatCtx->pb->eof_reached = 0;
}
// 判断是否以字节方式定位
playerState->seekByBytes = !!(pFormatCtx->iformat->flags & AVFMT_TS_DISCONT)
&& strcmp("ogg", pFormatCtx->iformat->name);
// 设置最大帧间隔
mediaSync->setMaxDuration((pFormatCtx->iformat->flags & AVFMT_TS_DISCONT) ? 10.0 : 3600.0);
// 如果不是从头开始播放，则跳转到播放位置
if (playerState->startTime != AV_NOPTS_VALUE) {
int64_t timestamp;
timestamp = playerState->startTime;
if (pFormatCtx->start_time != AV_NOPTS_VALUE) {
timestamp += pFormatCtx->start_time;
}
ret = avformat_seek_file(pFormatCtx, -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",
url, (double)timestamp / AV_TIME_BASE);
}
}
// 判断是否实时流，判断是否需要设置无限缓冲区
playerState->realTime = isRealTime(pFormatCtx);
if (playerState->infiniteBuffer < 0 && playerState->realTime) {
playerState->infiniteBuffer = 1;
}
// 查找媒体流信息
int audioIndex = -1;
int videoIndex = -1;
for (int i = 0; i < pFormatCtx->nb_streams; ++i) {
if (pFormatCtx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
if (audioIndex == -1) {
audioIndex = i;
}
} else if (pFormatCtx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
if (videoIndex == -1) {
videoIndex = i;
}
}
}
// 如果不禁止视频流，则查找最合适的视频流索引
if (!playerState->videoDisable) {
videoIndex = av_find_best_stream(pFormatCtx, AVMEDIA_TYPE_VIDEO,
videoIndex, -1, NULL, 0);
} else {
videoIndex = -1;
}
// 如果不禁止音频流，则查找最合适的音频流索引(与视频流关联的音频流)
if (!playerState->audioDisable) {
audioIndex = av_find_best_stream(pFormatCtx, AVMEDIA_TYPE_AUDIO,
audioIndex, videoIndex, NULL, 0);
} else {
audioIndex = -1;
}
// 如果音频流和视频流都没有找到，则直接退出
if (audioIndex == -1 && videoIndex == -1) {
av_log(NULL, AV_LOG_WARNING,
"%s: could not find audio and video stream\n", url);
ret = -1;
break;
}
// 根据媒体流索引准备解码器
if (audioIndex >= 0) {
prepareDecoder(audioIndex);
}
if (videoIndex >= 0) {
prepareDecoder(videoIndex);
}
if (!audioDecoder && !videoDecoder) {
av_log(NULL, AV_LOG_WARNING,
"failed to create audio and video decoder\n");
ret = -1;
break;
}
ret = 0;
} while (false);
mMutex.unlock();
// 出错返回
if (ret < 0) {
if (playerCallback) {
playerCallback->onError(0x01, "prepare decoder failed!");
}
return -1;
}
// 准备完成回调
if (playerCallback) {
playerCallback->onPrepared();
}
// 视频解码器开始解码
if (videoDecoder != NULL) {
videoDecoder->start();
} else {
if (playerState->syncType == AV_SYNC_VIDEO) {
playerState->syncType = AV_SYNC_AUDIO;
}
}
// 音频解码器开始解码
if (audioDecoder != NULL) {
audioDecoder->start();
} else {
if (playerState->syncType == AV_SYNC_AUDIO) {
playerState->syncType = AV_SYNC_EXTERNAL;
}
}
// 打开音频输出设备
if (audioDecoder != NULL) {
AVCodecContext *avctx = audioDecoder->getCodecContext();
ret = openAudioDevice(avctx->channel_layout, avctx->channels,
avctx->sample_rate);
if (ret < 0) {
av_log(NULL, AV_LOG_WARNING, "could not open audio device\n");
// 如果音频设备打开失败，则调整时钟的同步类型
if (playerState->syncType == AV_SYNC_AUDIO) {
if (videoDecoder != NULL) {
playerState->syncType = AV_SYNC_VIDEO;
} else {
playerState->syncType = AV_SYNC_EXTERNAL;
}
}
} else {
// 启动音频输出设备
audioDevice->start();
}
}
if (videoDecoder) {
if (playerState->syncType == AV_SYNC_AUDIO) {
videoDecoder->setMasterClock(mediaSync->getAudioClock());
} else if (playerState->syncType == AV_SYNC_VIDEO) {
videoDecoder->setMasterClock(mediaSync->getVideoClock());
} else {
videoDecoder->setMasterClock(mediaSync->getExternalClock());
}
}
// 开始同步
mediaSync->start(videoDecoder, audioDecoder);
// 读数据包流程
eof = 0;
ret = 0;
AVPacket pkt1, *pkt = &pkt1;
int64_t stream_start_time;
int playInRange = 0;
int64_t pkt_ts;
for (;;) {
// 退出播放器
if (playerState->abortRequest) {
break;
}
// 是否暂停
if (playerState->pauseRequest != lastPaused) {
lastPaused = playerState->pauseRequest;
if (playerState->pauseRequest) {
av_read_pause(pFormatCtx);
} else {
av_read_play(pFormatCtx);
}
}
#if CONFIG_RTSP_DEMUXER || CONFIG_MMSH_PROTOCOL
if (playerState->pauseRequest &&
(!strcmp(pFormatCtx->iformat->name, "rtsp") ||
(pFormatCtx->pb && !strncmp(url, "mmsh:", 5)))) {
continue;
}
#endif
// 定位处理
if (playerState->seekRequest) {
int64_t seek_target = playerState->seekPos;
int64_t seek_min = playerState->seekRel > 0 ? seek_target - playerState->seekRel + 2: INT64_MIN;
int64_t seek_max = playerState->seekRel < 0 ? seek_target - playerState->seekRel - 2: INT64_MAX;
// 定位
ret = avformat_seek_file(pFormatCtx, -1, seek_min, seek_target, seek_max, playerState->seekFlags);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "%s: error while seeking\n", url);
} else {
if (audioDecoder) {
audioDecoder->flush();
}
if (videoDecoder) {
videoDecoder->flush();
}
if (audioDevice) {
audioDevice->flush();
}
// 更新外部时钟值
if (playerState->seekFlags & AVSEEK_FLAG_BYTE) {
mediaSync->updateExternalClock(NAN);
} else {
mediaSync->updateExternalClock(seek_target / (double)AV_TIME_BASE);
}
mediaSync->refreshVideoTimer();
}
attachmentRequest = 1;
playerState->seekRequest = 0;
eof = 0;
}
// 取得封面数据包
if (attachmentRequest) {
if (videoDecoder && (videoDecoder->getStream()->disposition
& AV_DISPOSITION_ATTACHED_PIC)) {
AVPacket copy;
if ((ret = av_copy_packet(©, &videoDecoder->getStream()->attached_pic)) < 0) {
break;
}
videoDecoder->pushPacket(©);
videoDecoder->pushNullPacket();
}
attachmentRequest = 0;
}
// 如果队列中存在足够的数据包，则等待消耗
// 备注：这里要等待一定时长的缓冲队列，要不然会导致OpenSLES播放音频出现卡顿等现象
if (playerState->infiniteBuffer < 1 &&
((audioDecoder ? audioDecoder->getMemorySize() : 0) + (videoDecoder ? videoDecoder->getMemorySize() : 0) > MAX_QUEUE_SIZE
|| (!audioDecoder || audioDecoder->hasEnoughPackets()) && (!videoDecoder || videoDecoder->hasEnoughPackets()))) {
continue;
}
// 读出数据包
ret = av_read_frame(pFormatCtx, pkt);
if (ret < 0) {
// 如果没能读出裸数据包，判断是否是结尾
if ((ret == AVERROR_EOF || avio_feof(pFormatCtx->pb)) && !eof) {
if (videoDecoder != NULL) {
videoDecoder->pushNullPacket();
}
if (audioDecoder != NULL) {
audioDecoder->pushNullPacket();
}
eof = 1;
}
// 读取出错，则直接退出
if (pFormatCtx->pb && pFormatCtx->pb->error) {
ret = -1;
break;
}
// 如果不处于暂停状态，并且队列中所有数据都没有，则判断是否需要
if (!playerState->pauseRequest && (!audioDecoder || audioDecoder->getPacketSize() == 0)
&& (!videoDecoder || (videoDecoder->getPacketSize() == 0
&& videoDecoder->getFrameSize() == 0))) {
if (playerState->loop) {
seekTo(playerState->startTime != AV_NOPTS_VALUE ? playerState->startTime : 0);
} else if (playerState->autoExit) {
ret = AVERROR_EOF;
break;
}
}
continue;
} else {
eof = 0;
}
// 计算pkt的pts是否处于播放范围内
stream_start_time = pFormatCtx->streams[pkt->stream_index]->start_time;
pkt_ts = pkt->pts == AV_NOPTS_VALUE ? pkt->dts : pkt->pts;
// 播放范围
playInRange = playerState->duration == AV_NOPTS_VALUE
|| (pkt_ts - (stream_start_time != AV_NOPTS_VALUE ? stream_start_time : 0)) *
av_q2d(pFormatCtx->streams[pkt->stream_index]->time_base)
- (double)(playerState->startTime != AV_NOPTS_VALUE ? playerState->startTime : 0) / 1000000
<= ((double)playerState->duration / 1000000);
if (playInRange && audioDecoder && pkt->stream_index == audioDecoder->getStreamIndex()) {
audioDecoder->pushPacket(pkt);
} else if (playInRange && videoDecoder && pkt->stream_index == videoDecoder->getStreamIndex()) {
videoDecoder->pushPacket(pkt);
} else {
av_packet_unref(pkt);
}
}
if (ret < 0) {
if (playerCallback) {
playerCallback->onError(0x02, "error when reading packets!");
}
} else { // 播放完成
if (playerCallback) {
playerCallback->onComplete();
}
}
ALOGD("read packets thread exit!");
return ret;
}
完整代码请参考本人的播放器项目：CainPlayer