ffmpeg综合项目：mp4播放器（项目代码已上传到码云）
0、系列文章：
ffmpeg音视频编码入门：视频解码
ffmpeg音视频编码入门：音频解码（acc/mp3 转 pcm）
ffmpeg —— SDL2播放yuv文件（使用事件驱动和多线程，支持按键暂停/退出）
ffmpeg —— SDL2播放pcm音频
ffmpeg 视频文件解封装，提取mp4中的h264码流和aac码流
1、mp4播放器主体框架：
项目思路：
- 创建两个环形队列，用来存放处理后的h264码流数据和AAC码流；
- 创建一个解封装线程，不断demuxer并进行过滤/添加adts头处理码流，将数据入队；
- 创建音频和视频解码播放线程，从队列中取码流数据，然后解码播放。
2、Gitee项目代码：mp4_player
2.1 文件介绍(相关结构体)
- packet_queue.h 提供环形缓冲区的数据管理机制(支持多线程)，不涉及数据块的创建和销毁
- stream.h 提供解封装线程，包含StreamState,MediaState结构的定义和初始化
- audio_video_thread.h 提供音频和视频码流的解码播放线程，包含AudioState,VideoState结构的定义和初始化
- play_mp4.c 提供主线程，播放控制线程，定时刷新事件线程
2.2 结构层次
MediaState描述了媒体文件的信息，是最顶层的结构；
struct MediaState {
AVFormatContext *fmt_ctx; // 输入流的格式上下文
struct VideoState *video_state; // 视频结构
struct AudioState *audio_state; // 音频结构
SDL_Thread *demuxer_tid; // 解封装线程
SDL_Thread *playback_control_tid; // 播放控制线程
SDL_Event event; // 按键事件，播放/暂停/退出
};
StreamState描述了解码器和码流管理，是最底层的结构；
struct StreamState {
int stream_index; // 码流下标
AVCodecContext *cod_ctx; // 解码器上下文
AVCodec *cod; // 解码器
float fps; // 视频播放延时为1/fps
struct myqueue *que; // 可播放的码流队列
// 优化队列的管理：解封装完成，队列空时不需要等待数据
int writer_count; // 写者数量，对应解封装线程
int reader_count; // 读者数量，对应取数据解码线程
};
VideoState和AudioState描述了音频和视频码流解码播放的相关信息。
struct AudioState {
// 解码相关
struct StreamState *stream_state;
int pcmbuf_size;
uint8_t **pcmbuffer;
struct SwrContext *swr_ctx;
// 播放相关
SDL_AudioSpec spec;
unsigned int audio_len;
unsigned char *audio_chunk;
unsigned char *audio_pos;
SDL_Thread *audio_tid;
};
struct VideoState {
struct StreamState *stream_state;
AVBSFContext *bsf_ctx;
SDL_Window *window;
SDL_Renderer *renderer;
SDL_Texture *texture;
SDL_Rect rect;
SDL_Thread *video_tid;
};
2.3 主要的线程
int demuxer_thread(void *p) {
struct MediaState *media = (struct MediaState *)p;
struct VideoState *video = media->video_state;
struct AudioState *audio = media->audio_state;
// 读取一帧编码数据
while (1) {
HANDLE_EVENT(media->event.type);
AVPacket *packet = av_packet_alloc();
if (av_read_frame(media->fmt_ctx, packet) != 0) break;
/*************** 处理码流 *******************/
if (packet->stream_index == video->stream_state->stream_index) {
// 过滤器处理视频码流
if (av_bsf_send_packet(video->bsf_ctx, packet) != 0) {
printf("failed to send packet to bitstream filter\n");
break;
}
if (av_bsf_receive_packet(video->bsf_ctx, packet) != 0) {
printf("failed to receive packet from bitstream filter\n");
break;
}
// 将码流数据放到队列中管理
if (enqueue(video->stream_state->que, packet, video->stream_state->reader_count) < 0) {
break; // 解码线程退出时才会出现返回-1的情况
}
} else if (packet->stream_index == audio->stream_state->stream_index) {
// 添加ADTS头
AVPacket *tmp = av_packet_alloc();
tmp->size = packet->size + 7;;
tmp->data = malloc(tmp->size);
memcpy(tmp->data, adts_header_gen(tmp->size), 7);
memcpy(tmp->data + 7, packet->data, packet->size);
av_packet_free(&packet);
if (enqueue(audio->stream_state->que, tmp, audio->stream_state->reader_count) < 0) {
break;
}
} else {
printf("unkown stream\n");
av_packet_free(&packet);
break;
}
// 视频24fps，40ms播放一帧，音频44100/1024 = 42fps，22ms播放一帧
// 当大于缓冲区一半时，延时使消耗大于产出，que->size减小
if (video->stream_state->que->size > MAX_QUEUE/2)
SDL_Delay(5*video->stream_state->que->size);
}
audio->stream_state->writer_count = 0;
video->stream_state->writer_count = 0;
printf("demuxer_thread end\n");
}
int playback_control_thread(void *p) {
struct MediaState *media = (struct MediaState *)p;
media->audio_state->audio_tid = SDL_CreateThread(audio_thread, NULL, media);
media->video_state->video_tid = SDL_CreateThread(video_thread, NULL, media);
SDL_Thread *refresh_tid = SDL_CreateThread(refresh_thread, NULL, NULL);
while (1) {
if (media->event.type == SDL_KEYDOWN) {
// 空格键暂停，ESC键退出
if (media->event.key.keysym.sym == SDLK_SPACE) {
thread_stop = !thread_stop;
} else if (media->event.key.keysym.sym == SDLK_ESCAPE) {
thread_quit = 1;
}
} else if (media->event.type == SDL_QUIT || media->event.type == QUIT_EVENT) {
break;
}
// 等待刷新，刷新间隔越小，实时性越好
SDL_WaitEvent(&media->event);
}
SDL_WaitThread(refresh_tid, NULL);
SDL_WaitThread(media->audio_state->audio_tid, NULL);
SDL_WaitThread(media->video_state->video_tid, NULL);
printf("playback_control_thread end\n");
}
int audio_thread(void *p) {
struct MediaState *media = (struct MediaState *)p;
struct AudioState *audio = media->audio_state;
AVFrame *frame = av_frame_alloc();
// 启动播放
SDL_PauseAudio(0);
while (1) {
HANDLE_EVENT(media->event.type);
// 从码流队列中取数据, 解缓冲区无数据且封装已完成时退出
AVPacket *packet = dequeue(audio->stream_state->que, audio->stream_state->writer_count);
if (packet == NULL) break;
int ret = decodec_packet_to_frame(audio->stream_state->cod_ctx, packet, frame);
if (ret == EAGAIN) continue;
else if (ret == EINVAL) break;
SDL_play_pcm(audio, frame);
av_packet_free(&packet); // 播放完一帧后清理
av_frame_unref(frame);
}
av_frame_free(&frame);
audio->stream_state->reader_count--;
//queue_wakeup(audio->stream_state->que);
printf("audio_thread end\n");
}
3、不足与优化：
问题：暂停操作正常，但解封装线程无法中途退出，导致主线程一直卡在SDL_WaitThread(media->demuxer_tid, NULL)。
猜测原因是队列操作的影响（使用了条件变量，而取数据解码的速度总是慢于解封装码流入队的速度，所以经常队列满，卡在pthread_wait_cond）。
虽然添加了读者写者的条件，但因为没有数据变化的广播，所以解封装线程被阻塞在入队函数中的pthread_cond_wait位置。
int enqueue(struct myqueue *q, Elem_t t, int reader_count) {
if (reader_count <= 0) return -1; // 读者不存在，存数据到队列没有意义
pthread_mutex_lock(&q->mut);
while (q->size == MAX_QUEUE && reader_count > 0) {
pthread_cond_wait(&q->cond, &q->mut);
}
q->buffer[q->tail] = t;
q->tail = next_pos(q->tail);
q->size++;
pthread_cond_broadcast(&q->cond);
pthread_mutex_unlock(&q->mut);
return 0;
}
①可以考虑添加一个周期检测读者/写者是否都存在的线程，如果有一方缺失，则调用pthread_cond_broadcast，唤醒被阻塞的线程。（加一个管理线程/每个队列都拥有一个检测线程？未尝试）
②在解码线程退出时，更新读者数量，并用广播唤醒被阻塞的线程，退出时手动调用pthread_cond_broadcast并没有唤醒解封装线程。
③经常卡在pthread_wait_cond，这是读写速度差异太大导致的。可以适当减慢一下解码的速度，从而避免队列满的情况。但只是固定延时的话，无法杜绝被阻塞的情况。（只要速度不均衡，最终还是会走向队列满，越往后越拥塞）。
④根据缓冲区大小，及音视频播放帧率，动态调整延时。缓冲区中的码流数据越多，延时越久，从而使que->size保持在一个稳定范围，以避免线程被阻塞。最好是初期不延时，当数据过半时，使其快速稳定。（自动控制原理？2333）
问题2：只是用多线程，并发的解码播放音频和视频，没有提供自适应的同步机制。
问题3：可以尝试抽象统一音频和视频的码流方法。其它：。。。（解耦，封装与抽象）