jie/mp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

创建线程解析packet并存入队列

Browse Source
This commit is contained in:
jie 2024-02-21 22:34:00 +08:00
parent 39697786c9
commit 659ca4772d
3 changed files with 141 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
include/decoder.h
View File

@ -6,23 +6,15 @@ extern "C" {
#include "libavutil/imgutils.h"
}
#include <queue>
#include <thread>
#include <condition_variable>
#include <mutex>
struct VideoParam
{
AVFormatContext* fmtCtx;
AVCodecContext* codecCtx;
int width;
int height;
int videoStreamIndex;
};
template<typename T>
requires std::is_same_v<T, AVPacket> || std::is_same_v<T, AVFrame>
struct MediaQueue
{
static constexpr int MAX_SIZE = 500;
bool full = false;
std::queue<T> queue;
std::condition_variable cv;
std::mutex mut;
@ -31,6 +23,7 @@ struct MediaQueue
uint32_t count;
MediaQueue() = default;
bool isFill() const { return full; }
bool push(const T* item);
bool pop(T* item, bool block = false, bool quit = false);
};
@ -38,18 +31,22 @@ struct MediaQueue
template <typename T> requires std::is_same_v<T, AVPacket> || std::is_same_v<T, AVFrame>
bool MediaQueue<T>::push(const T* item) {
if (item == nullptr) return false;
if (count >= MAX_SIZE)
return false;
std::unique_lock lock(mut);
if constexpr (std::is_same_v<T, AVPacket>) {
auto temp = av_packet_alloc();
av_packet_ref(temp, item);
queue.push(*temp);
size += temp->size;
count++;
queue.push(*temp);
}else if(std::is_same_v<T, AVFrame>) {
auto temp = av_frame_alloc();
av_frame_ref(temp, item);
queue.push(*temp);
}
count++;
if(count >= MAX_SIZE) {
full = true;
}
cv.notify_all();
return true;
@ -75,6 +72,7 @@ bool MediaQueue<T>::pop(T* item, bool block, bool quit) {
}
queue.pop();
count--;
full = false;
return true;
}
else if (block) {
@ -88,8 +86,22 @@ bool MediaQueue<T>::pop(T* item, bool block, bool quit) {
}
struct VideoParam
{
MediaQueue<AVPacket> queue;
AVFormatContext* fmtCtx;
AVCodecContext* codecCtx;
int width;
int height;
int videoStreamIndex;
bool eof = false;
bool pause = false;
bool quit = false;
};
void InitDecoder(const char* filepath, VideoParam& param);
void RequestPacket(VideoParam& param);
AVFrame* RequestFrame(VideoParam& param);
#endif

26
main.cc
View File

@ -17,11 +17,13 @@ struct OpenglVideoParam
unsigned int texs[3];
};
int InitVideo(SDL_Window*& window, const char* targetFilepath, DecoderParam& decoderParam, OpenglVideoParam& openglVideoParam, ShaderService*& shaderService)
int InitVideo(SDL_Window*& window, const char* targetFilepath, VideoParam& videoParam, OpenglVideoParam& openglVideoParam, ShaderService*& shaderService)
{
InitDecoder(targetFilepath, decoderParam);
const int client_width = decoderParam.width / 2;
const int client_height = decoderParam.height / 2;
InitDecoder(targetFilepath, videoParam);
//FIX: when app exited, the fmtCtx was freed, so need notify decode thread to stop decode and exit.
std::jthread(RequestPacket, std::ref(videoParam)).detach();
const int client_width = videoParam.width / 2;
const int client_height = videoParam.height / 2;
window = SDL_CreateWindow(
"MP",
SDL_WINDOWPOS_UNDEFINED,
@ -121,9 +123,9 @@ void InitImg(SDL_Window*& window, const char* filepath, SDL_Renderer*& renderer,
texture = SDL_CreateTextureFromSurface(renderer, surface);
}
void OpenglRenderVideo(DecoderParam& decoderParam, const OpenglVideoParam& openglVideoParam, ShaderService* shaderService)
void OpenglRenderVideo(VideoParam& videoParam, const OpenglVideoParam& openglVideoParam, ShaderService* shaderService)
{
auto frame = RequestFrame(decoderParam);
auto frame = RequestFrame(videoParam);
if (frame == nullptr)
return;
// TODO: TIMER
@ -169,7 +171,7 @@ int main(int argc, char** const argv)
int client_width, client_height;
SDL_Window* window = nullptr;
DecoderParam decoderParam{};
VideoParam videoParam{};
OpenglVideoParam openglVideoParam{};
ShaderService* shaderService = nullptr;
SDL_Surface* surface = nullptr;
@ -185,8 +187,8 @@ int main(int argc, char** const argv)
{
case FileType::VIDEO:
{
InitVideo(window, targetFilepath, decoderParam, openglVideoParam, shaderService);
const auto stream_frame_rate = decoderParam.fmtCtx->streams[decoderParam.videoStreamIndex]->avg_frame_rate;
InitVideo(window, targetFilepath, videoParam, openglVideoParam, shaderService);
const auto stream_frame_rate = videoParam.fmtCtx->streams[videoParam.videoStreamIndex]->avg_frame_rate;
framerate = static_cast<double>(stream_frame_rate.den) / stream_frame_rate.num;
break;
}
@ -234,7 +236,7 @@ int main(int argc, char** const argv)
switch (fileType)
{
case FileType::VIDEO:
OpenglRenderVideo(decoderParam, openglVideoParam, shaderService);
OpenglRenderVideo(videoParam, openglVideoParam, shaderService);
SDL_GL_SwapWindow(window);
std::this_thread::sleep_until(current_time + std::chrono::milliseconds(static_cast<int>(framerate * 1000)));
current_time = std::chrono::system_clock::now();
@ -247,8 +249,8 @@ int main(int argc, char** const argv)
}
}
avcodec_close(decoderParam.codecCtx);
avformat_close_input(&(decoderParam.fmtCtx));
avcodec_close(videoParam.codecCtx);
avformat_close_input(&(videoParam.fmtCtx));
SDL_GL_DeleteContext(openglVideoParam.glContext);
SDL_DestroyWindow(window);
SDL_Quit();

97
src/decoder.cc
View File

@ -1,6 +1,9 @@
#include "decoder.h"
#include <thread>
#include <chrono>
using namespace std::literals::chrono_literals;
void InitDecoder(const char* filepath, DecoderParam& param) {
void InitDecoder(const char* filepath, VideoParam& param) {
AVFormatContext* fmtCtx = nullptr;
AVCodecContext* codecFmt = nullptr;
auto ret = avformat_open_input(&fmtCtx, filepath, NULL, NULL);
@ -23,7 +26,44 @@ void InitDecoder(const char* filepath, DecoderParam& param) {
param.height = codecFmt->height;
}
AVFrame* RequestFrame(DecoderParam& param) {
void RequestPacket(VideoParam& param) {
const auto& fmtCtx = param.fmtCtx;
const auto& videoStreamIndex = param.videoStreamIndex;
AVPacket* packet = av_packet_alloc();
while (true) {
if(param.queue.isFill()) {
std::this_thread::sleep_for(100ms);
continue;
}
const int ret = av_read_frame(fmtCtx, packet);
if (param.eof) {
std::this_thread::sleep_for(100ms);
return;
}
if (ret == 0) {
if (packet->stream_index == videoStreamIndex) {
param.queue.push(packet);
av_packet_unref(packet);
}
else if (ret == AVERROR_EOF)
{
param.eof = true;
av_packet_unref(packet);
break;
}else {
av_packet_unref(packet);
}
}else if(param.fmtCtx->pb->error == 0) {
std::this_thread::sleep_for(100ms);
}
}
av_packet_unref(packet);
}
AVFrame* RequestFrame(VideoParam& param) {
const auto& fmtCtx = param.fmtCtx;
const auto& codecCtx = param.codecCtx;
const auto& videoStreamIndex = param.videoStreamIndex;
@ -32,9 +72,18 @@ AVFrame* RequestFrame(DecoderParam& param) {
AVFrame* frame = av_frame_alloc();
while (true) {
int ret = av_read_frame(fmtCtx, packet);
if (ret == 0 && packet->stream_index == videoStreamIndex) {
ret = avcodec_send_packet(codecCtx, packet);
if (!param.queue.pop(packet, true, param.quit)) {
if(param.quit)
//NOTE:if no need do something, just return nullptr
return nullptr;
continue;
}
int ret = avcodec_send_packet(codecCtx, packet);
if(ret < 0) {
av_packet_unref(packet);
av_frame_free(&frame);
return nullptr;
}
if (ret == 0) {
ret = avcodec_receive_frame(codecCtx, frame);
if (ret == 0) {
@ -48,8 +97,7 @@ AVFrame* RequestFrame(DecoderParam& param) {
av_packet_free(&packet);
return nullptr;
}
}
else if (ret == AVERROR_EOF)
if (ret == AVERROR_EOF)
{
av_packet_unref(packet);
return nullptr;
@ -57,3 +105,38 @@ AVFrame* RequestFrame(DecoderParam& param) {
av_packet_unref(packet);
}
}
//AVFrame* RequestFrame(VideoParam& param) {
// const auto& fmtCtx = param.fmtCtx;
// const auto& codecCtx = param.codecCtx;
// const auto& videoStreamIndex = param.videoStreamIndex;
//
// AVPacket* packet = av_packet_alloc();
// AVFrame* frame = av_frame_alloc();
//
// while (true) {
// int ret = av_read_frame(fmtCtx, packet);
// if (ret == 0 && packet->stream_index == videoStreamIndex) {
// ret = avcodec_send_packet(codecCtx, packet);
// if (ret == 0) {
// ret = avcodec_receive_frame(codecCtx, frame);
// if (ret == 0) {
// av_packet_unref(packet);
// return frame;
// }
// if (ret == AVERROR(EAGAIN)) {
// continue;
// }
// av_frame_free(&frame);
// av_packet_free(&packet);
// return nullptr;
// }
// }
// else if (ret == AVERROR_EOF)
// {
// av_packet_unref(packet);
// return nullptr;
// }
// av_packet_unref(packet);
// }
//}