ffmpeg解码

42 阅读 0 评论 28 点赞

我是靠谱客的博主风中白云，最近开发中收集的这篇文章主要介绍ffmpeg解码，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

本文分别介绍软解和硬解两种方式，同时将获取的每一帧，转换成二进制或者图片格式
本文只是介绍如何解码，

硬解码，这个类中将每一帧转换成二进制格式，然后存放到队列中，注意硬解码需要安装cuda，百度一下你就知道，

#include "hw_video_decoder.h"
#include <cstdio>
#include <QDebug>
#include <QDateTime>
AVPixelFormat HWVideoDecoder::hw_pix_fmt;
bool HWVideoDecoder::init(SharedQueue<VideoFrame>* frameQueue, const QString& path)
{
this->frameQueue = frameQueue;
bRunning = true;
// 初始化解码对象
hw_device_ctx = nullptr;
input_ctx = nullptr;
decoder_ctx = nullptr;
decoder = nullptr;
// 查找对应的硬件解码设备
const char* device_name = "cuda";
AVHWDeviceType hw_device_type = av_hwdevice_find_type_by_name(device_name);
if (hw_device_type == AV_HWDEVICE_TYPE_NONE) {
qDebug() << "Device name %s is not supported" << device_name;
qDebug() << "Available device types:";
while ((hw_device_type = av_hwdevice_iterate_types(hw_device_type)) != AV_HWDEVICE_TYPE_NONE)
qDebug() << av_hwdevice_get_type_name(hw_device_type);
return false;
}
// 打开输入视频文件
AVDictionary *options = nullptr;
av_dict_set(&options, "rtsp_transport", "tcp", 0);
input_ctx = avformat_alloc_context();
const char* input_file = path.toStdString().c_str();
if (avformat_open_input(&input_ctx, input_file, nullptr, &options) != 0) {
qDebug() << "Cannot open input file" << input_file;
return false;
}
// 查找流信息
if (avformat_find_stream_info(input_ctx, nullptr) < 0) {
qDebug() << "Cannot find input stream information";
return false;
}
// 查找视频流信息
result = av_find_best_stream(input_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &decoder, 0);
if (result < 0) {
qDebug() << "Cannot find a video stream in the input file";
return false;
}
stream_index = result;
// 判断硬件解码设备是否兼容视频解码器
for (int i = 0;; i++) {
const AVCodecHWConfig *config = avcodec_get_hw_config(decoder, i);
if (!config) {
qDebug() << "Decoder does not support device hw_device_type"
<< decoder->name << av_hwdevice_get_type_name(hw_device_type);
return false;
}
// 得到硬件解码像素格式
if (config->methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX &&
config->device_type == hw_device_type) {
hw_pix_fmt = config->pix_fmt;
break;
}
}
// 得到解码器管理器
if (!(decoder_ctx = avcodec_alloc_context3(decoder)))
return (bool)AVERROR(ENOMEM);
// 得到视频流对象
stream = input_ctx->streams[stream_index];
if (avcodec_parameters_to_context(decoder_ctx, stream->codecpar) < 0)
return false;
// 设置解码器管理器的像素格式回调函数
decoder_ctx->get_format = get_hw_format;
// 初始化硬件解码器
if ((result = av_hwdevice_ctx_create(&hw_device_ctx, hw_device_type, nullptr, nullptr, 0)) < 0) {
qDebug() << "Failed to create specified HW device.";
return false;
}
decoder_ctx->hw_device_ctx = av_buffer_ref(hw_device_ctx);
// 打开解码器流
if ((result = avcodec_open2(decoder_ctx, decoder, nullptr)) < 0) {
qDebug() << "Failed to open codec for stream" << stream_index;
return false;
}
// 初始化帧缓存
ping_frame = av_frame_alloc();
pong_frame = av_frame_alloc();
yuv_frame = av_frame_alloc();
frame = nullptr;
// 初始化帧转换数据
input_fmt = AV_PIX_FMT_NV12;
output_fmt = AV_PIX_FMT_BGR32;
size = av_image_get_buffer_size(output_fmt, decoder_ctx->width, decoder_ctx->height, 1);
buffer = (uint8_t *)av_malloc(size);
av_image_fill_arrays(yuv_frame->data, yuv_frame->linesize, buffer, output_fmt, decoder_ctx->width, decoder_ctx->height, 1);
swsContext = sws_getContext(
decoder_ctx->width, decoder_ctx->height, input_fmt,
decoder_ctx->width, decoder_ctx->height, output_fmt,
SWS_BICUBIC, NULL, NULL, NULL);
return true;
}
void HWVideoDecoder::stop()
{
bRunning = false;
wait();
destroy();
}
bool HWVideoDecoder::destroy()
{
packet.data = nullptr;
packet.size = 0;
av_packet_unref(&packet);
av_freep(&buffer);
av_frame_free(&ping_frame);
av_frame_free(&pong_frame);
avcodec_free_context(&decoder_ctx);
avformat_close_input(&input_ctx);
av_buffer_unref(&hw_device_ctx);
return true;
}
void HWVideoDecoder::run()
{
static const int kWaitTime = 50;
static const int kMaxQueueSize = 16;
std::chrono::milliseconds duration(kWaitTime);
while (bRunning)
{
if (frameQueue->size() > kMaxQueueSize)
{
std::this_thread::sleep_for(duration);
continue;
}
result = av_read_frame(input_ctx, &packet);
if (result == AVERROR_EOF)
{
avio_seek(input_ctx->pb, 0, SEEK_SET);
avformat_seek_file(input_ctx, stream_index, 0, 0, stream->duration, 0);
continue;
}
if (result < 0)
{
qDebug() << "Failed to read frame!";
return;
}
if (stream_index == packet.stream_index)
{
result = avcodec_send_packet(decoder_ctx, &packet);
if (result < 0)
{
//qDebug() << "Failed to send packet" << result;
continue;
}
result = avcodec_receive_frame(decoder_ctx, ping_frame);
if (result == AVERROR(EAGAIN) || result == AVERROR_EOF || result < 0)
{
qDebug() << "Failed to receive frame";
return;
}
if (ping_frame->format == hw_pix_fmt)
{
/* retrieve data from GPU to CPU */
if (av_hwframe_transfer_data(pong_frame, ping_frame, 0) < 0)
{
qDebug() << "Failed to transfer the data to system memory";
return;
}
frame = pong_frame;
}
else
{
frame = ping_frame;
}
// 转换成yuv格式
result = sws_scale(swsContext, (const uint8_t* const*)frame->data, frame->linesize, 0,
decoder_ctx->height, yuv_frame->data, yuv_frame->linesize);
// 填充到帧缓存队列中
VideoFrame frame;
frame.width = decoder_ctx->width;
frame.height = decoder_ctx->height;
frame.data = QByteArray((char *)buffer, size * sizeof(uint8_t));
frameQueue->push_back(frame);
}
//av_packet_unref(&packet);
av_free_packet(&packet);
}
}
int HWVideoDecoder::getFrameTimeMs()
{
return (int)(1000.0 / av_q2d(stream->avg_frame_rate));
}
AVPixelFormat HWVideoDecoder::get_hw_format(AVCodecContext *, const AVPixelFormat *pix_fmts)
{
const AVPixelFormat *p;
for (p = pix_fmts; *p != -1; p++) {
if (*p == hw_pix_fmt)
return *p;
}
//qDebug() << "Failed to get HW surface format";
return AV_PIX_FMT_NONE;
}

软解码，将每一帧转换成二进制和图片格式，

#include "video_decoder.h"
#include <QDebug>
#include <QDateTime>
#include <thread>
bool VideoDecoder::init(SharedQueue<VideoFrame>* frameQueue, const QString& path)
{
this->frameQueue = frameQueue;
bRunning = true;
nowPath = path;
avformat_network_init();
av_register_all(); //注册所有容器格式
pFormatCtx = avformat_alloc_context();
AVDictionary *avdic = NULL;
char option_key[] = "rtsp_transport";
char option_value[] = "tcp";
av_dict_set(&avdic, option_key, option_value, 0);
char option_key2[] = "max_delay";
char option_value2[] = "100";
av_dict_set(&avdic, option_key2, option_value2, 0);
if (avformat_open_input(&pFormatCtx, path.toStdString().c_str(), NULL, &avdic) != 0)
{
qDebug() << "can't open the file:" << path;
return false;
}
if (avformat_find_stream_info(pFormatCtx, NULL) < 0)
{
qDebug() << "can't find stream infomation";
return false;
}
videoStreamIndex = -1;
for (unsigned int i = 0; i < pFormatCtx->nb_streams; i++)
{
if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
{
videoStreamIndex = i;
}
}
if (videoStreamIndex == -1)
{
qDebug() << "can't find a video stream";
return false;
}
pCodecCtx = pFormatCtx->streams[videoStreamIndex]->codec;
pCodecCtx->thread_count = 4;
pCodecCtx->flags |= AV_CODEC_FLAG_LOW_DELAY;
pCodec = findCodec(pCodecCtx);
if (pCodec == NULL)
{
qDebug() << "can't find a codec";
return false;
}
if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0)
{
qDebug() << "can't open a codec";
return false;
}
pFrame = av_frame_alloc();
pFrameBGR = av_frame_alloc();
imgConvertCtx = sws_getContext(pCodecCtx->width, pCodecCtx->height,
pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height,
AV_PIX_FMT_BGR32, SWS_BICUBIC, NULL, NULL, NULL);
byteNum = avpicture_get_size(AV_PIX_FMT_BGR32, pCodecCtx->width, pCodecCtx->height);
outBuffer = (uint8_t *)av_malloc(byteNum * sizeof(uint8_t));
avpicture_fill((AVPicture *)pFrameBGR, outBuffer, AV_PIX_FMT_BGR32,
pCodecCtx->width, pCodecCtx->height);
packet = (AVPacket *)malloc(sizeof(AVPacket));
av_new_packet(packet, pCodecCtx->width * pCodecCtx->height);
return true;
}
void VideoDecoder::stop()
{
bRunning = false;
wait();
destroy();
}
void VideoDecoder::run()
{
static const int kWaitTime = 5;
static const int kMaxQueueSize = 30;
std::chrono::milliseconds duration(kWaitTime);
//int frameIndex = 0;
while (bRunning)
{
if (frameQueue->size() > kMaxQueueSize)
{
std::this_thread::sleep_for(duration);
continue;
}
int nextFrame = av_read_frame(pFormatCtx, packet);
if (nextFrame == AVERROR_EOF)
{
auto stream = pFormatCtx->streams[videoStreamIndex];
avio_seek(pFormatCtx->pb, 0, SEEK_SET);
avformat_seek_file(pFormatCtx, videoStreamIndex, 0, 0, stream->duration, 0);
continue;
}
if (nextFrame < 0)
{
qDebug() << "read frame error";
bRunning = false;
break;
}
if (packet->stream_index == videoStreamIndex)
{
int got_picture = 0;
int ret = avcodec_decode_video2(pCodecCtx, pFrame, &got_picture, packet);
if (ret < 0)
{
qDebug() << "decode error";
break;
}
if (got_picture)
{
sws_scale(imgConvertCtx,
(uint8_t const * const *)pFrame->data,
pFrame->linesize, 0, pCodecCtx->height, pFrameBGR->data,
pFrameBGR->linesize);
VideoFrame frame;
frame.width = pFrame->width;
frame.height = pFrame->height;
frame.data = QByteArray((char *)outBuffer, byteNum * sizeof(uint8_t));
QImage tmpImg((uchar *)outBuffer, pCodecCtx->width, pCodecCtx->height, QImage::Format_RGB32);
frame.img = tmpImg.convertToFormat(QImage::Format_RGB888, Qt::NoAlpha);
lastTime = currentTime;
frameQueue->push_back(frame);
}
}
av_free_packet(packet);
std::this_thread::sleep_for(duration);
}
}
void VideoDecoder::destroy()
{
av_free(outBuffer);
av_free(pFrameBGR);
avcodec_close(pCodecCtx);
avformat_close_input(&pFormatCtx);
}
int VideoDecoder::getFrameTimeMs()
{
return (int)(1000.0 / av_q2d(pCodecCtx->framerate));
}
AVCodec* VideoDecoder::findCodec(AVCodecContext *codecCtx)
{
pCodec = avcodec_find_decoder(codecCtx->codec_id);//软解
return pCodec;
}