ffmpeg实现通用的解码类

最新推荐文章于 2025-05-09 15:24:19 发布
最新推荐文章于 2025-05-09 15:24:19 发布
阅读量470 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： ffmpeg C++ 文章标签： 音视频
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/fantasy_ARM9/article/details/125440403
本文介绍了在使用FFmpeg进行视频解码时应注意的事项，强调了解码参数不应随意设置，应从AVStream的codecpar中获取。作者分享了一个通用的解码类实现，该实现能支持不同数据帧类型的解码。通过初始化AVFormatContext，然后使用AVStream初始化解码器，并从AVCodecContext复制解码参数。文章还提供了详细的代码示例，包括解码器的初始化、解码过程和错误处理等。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一 很多同学刚开始接触ffmpeg，会犯一些错误，比如如何创建解码上下文。

1.1 要记住一点，解码参数不要自己随便填，ffmpeg已经帮你解析了参数了，存放在AVStream里面的codecpar里面，你需要拿来初始化解码器，这样才能正常解码，不要自己alloc AVCodecContext之后，自己随便填参数。

二 这里我分享一个我之前实现的通用的解码类实现，任何数据帧类型都支持。

大概的方法是

2.1 先读取视频文件，拿到AVFormatContext。

第一步先demux视频文件，demux详细实现就不写了

 

用AVCodecContext上下文初始化通用解码器 

2.2 拿到AVFormatContext后用AVFormatContext中的AVStream去初始化解码器。

解码参数要从传进来的AVCodecContext copy过来，老得ffmpeg版本，AVStream中就有AVCodecContext，可以直接拿来用。不过新版本，这个已经过时了。

三 上代码：

#include "comm_decoder.h"
#include "log.h"
#include "transcode_monitor.h"
#include <memory>

#define DECODER_CODECID_ERROR (-101)
#define DECODER_FIND_FAILED (-102)
#define DECODER_GETCTX_FAILED (-103)
#define DECODER_ALLOCCTX_FAILED (-104)
#define DECODER_COPYCTX_FAILED (-105)
#define DECODER_OPENCTX_FAILED (-106)
#define DECODER_ALLOCFRAME_FAILED (-107)
#define DECODER_DECODE_FAILED (-108)
#define DECODER_READQUEUE_FAILED (-109)
#define DECIDER_DECODEPKT_FAILED (-110)
#define DECODER_PASSTHROUGH_FAIELD (-111)
#define DECODER_AUDIO_PASS_FAILED (-112)
#define DECODER_FLUSH_DECODER_FAILED (-113)
#define DECODER_FLUSH_ALLFRAME_FAILED (-114)
#define DECODER_FLUSH_EOF (0)
#define DECODER_FLUSH_SEND_FAIELD (-115)
#define DECODER_FLUSH_RECV_FAILED (-116)
#define DECODER_SET_STOP (-117)
#define DECODER_UNKONW_MEDIA_TYPE (-118)
#define DECODER_FLUSH_FAILED (-119)
#define DECODER_CODECCONTEXT_NULL (-120)
#define DECODER_MEDIACUT_FAILED  (-121)

static const char nalu_head_[4] = {0x0, 0x0, 0x0, 0x1};

int CommDecoder::Init(const AVCodecContext *inctx, const MediaType &t, const bool &async)
{
    int ret = 0;
    AVCodecContext *ctx = NULL;
    defer[&] {
        if (ret < 0 && ctx) {
            avcodec_free_context(&ctx);
            ctx = NULL;
        }
    }; 

    if (!inctx) {
        LLOG_ERROR("inctx null, init avc decoder failed,");
        ret = DECODER_GETCTX_FAILED;
        lastState_ = DECODER_CODECID_ERROR;
        return ret;
    }

    AVCodec *dcodec = avcodec_find_decoder(inctx->codec_id);
    if (dcodec == NULL) {
        ret = DECODER_FIND_FAILED;
        lastState_ = DECODER_FIND_FAILED;
        return ret;
    }

    if ((ctx = avcodec_alloc_context3(dcodec)) == NULL) {
        ret = DECODER_ALLOCCTX_FAILED;
        lastState_ = DECODER_ALLOCCTX_FAILED;
        return ret;
    }

    if ((avcodec_copy_context(ctx, inctx)) < 0) {
        ret = DECODER_COPYCTX_FAILED;
        lastState_ = DECODER_COPYCTX_FAILED;
        return ret;
    }

    ctx->refcounted_frames = 1;
    if (avcodec_open2(ctx, dcodec, NULL) < 0) {
        ret = DECODER_OPENCTX_FAILED;
        lastState_ = DECODER_OPENCTX_FAILED;
        return ret;
    }

    ctx_.reset(ctx, [](AVCodecContext *p) {
        if (p) {
            avcodec_free_context(&p);
            p = NULL;
        }
    });
    ctx = NULL;

    if (async) {
        InitProcessor();
    }
    type_ = t;
    firstPts_ = UNINIT_PTS;
    if (t == MediaType::MediaType_Video) {
        SetName("vdecoder");
        duration_ = 30;
    }else if (t == MediaType::MediaType_Audio){
        SetName("adecoder");
        duration_ = 20;
    }
    LLOG_INFO("init decdoer %s success", name_.c_str());
    return ret;
} 

int CommDecoder::DecodePacket(std::shared_ptr<AVPacket> &in,
                          std::shared_ptr<AVFrame> &frm) 
{
    int64_t pkt_pts = 0;
    int ret = 0;
    AVFrame *p = NULL;
    defer[&] {
        if (ret != 0 && p) {
            av_frame_free(&p);
            p = NULL;
        }
    };

    if ((p = av_frame_alloc()) == NULL) {
        ret = DECODER_ALLOCFRAME_FAILED;
        lastState_ = DECODER_ALLOCFRAME_FAILED;
        LLOG_ERROR("DECODER_ALLOCFRAME_FAILED,");
        return ret;
    }
    GetSeiData(in.get());

    int got = 0;
    if (type_ == MediaType::MediaType_Video) {
        if (avcodec_decode_video2(ctx_.get(), p, &got, in.get()) <= 0) {
            ret = DECODER_DECODE_FAILED;
            lastState_ = DECODER_DECODE_FAILED;
            LLOG_ERROR("avcodec_decode_video2 fail,");
            return ret;
        }
    } else {
        pkt_pts = in->pts;
        if (avcodec_decode_audio4(ctx_.get(), p, &got, in.get()) <= 0) {
            ret = DECODER_DECODE_FAILED;
            lastState_ = DECODER_DECODE_FAILED;
            LLOG_ERROR("avcodec_decode_audio4 fail,");
            return ret; 
        }
    }

    if (got != 1) {
        ret = 2;
        LLOG_ERROR("decode but not got frame name %s,", name_.c_str());
        return ret;
    } else {
        if (ctx_->codec_id == AV_CODEC_ID_MP3) {
            p->pts = pkt_pts;
        }

        if (firstPts_ == UNINIT_PTS) {
            LLOG_INFO("media file first pts  %ld, type:%s,", p->pts, type_ == MediaType::MediaType_Video?"video":"audio");
            firstPts_ = p->pts;
        }
        p->pts -= firstPts_;

       
        if (lastFramePts_ >= p->pts) {
            LLOG_ERROR("video timestamp exception lastFramePts_ %ld p->pts %ld duration %ld", lastFramePts_, p->pts, p->pkt_duration);
            p->pts = lastFramePts_ + (p->pkt_duration?p->pkt_duration:duration_);
            LLOG_ERROR("adjust p->pts:%d",p->pts);
        }

        lastFramePts_ = p->pts;
        duration_ = (p->pkt_duration? p->pkt_duration:duration_);
        LLOG_INFO("decoded frame pts %ld,duration %ld name %s w %d h %d nb_samples %d,endTime_:%d,startTime_:%d", 
			p->pts, p->pkt_duration, name_.c_str(), p->width, p->height, p->nb_samples, endTime_, startTime_);
/*
        if ((ret = dropPackets(p)) == 2) {
            LLOG_ERROR("got frame but time not reach ,ignore it pts %ld, startTime_ %ld", p->pts, startTime_);
	    }
*/
        if( name_ == "vdecoder" ) {
            pFrames_++;
        }
        frm.reset(p, [](AVFrame *pp) {
            if (pp) {
                av_frame_free(&pp);
                pp = NULL;
            }
        });
	p = NULL;


	return ret;
    }
    return ret;
}

int CommDecoder::Close() 
{
    ctx_.reset();
    TranscodeMonitor::Instance()->MonitorAll<ProcessPipeBase>(this);
    return 0;
}

int CommDecoder::Process(const PNode &n) 
{
    int ret = 0;
    defer[&] {
        if (ret < 0) {
            //PassThrough(MakeEnd());
            // PNode end = MakeEnd();
            // PassThrough(end);
	        LLOG_ERROR("decode process failed, ret %d", ret);
        }
    };

    if (GetStop()) {
        LLOG_ERROR("set it stop,");
        ret = DECODER_SET_STOP;
        return ret;
    }

    if (!ctx_) {
        ret = DECODER_CODECCONTEXT_NULL;
        LLOG_ERROR("vctx is null,yet");
        return ret;
    }

    if (!n) {
        LLOG_ERROR("its null pnode,");
        return 2;		
    }  

    if (n->mtype == MediaType::MediaType_End) {
        if (name_ == "vdecoder")
            FlushDecoder();
        LLOG_INFO("decoder process end, pFrames_ :%d", pFrames_);	
        return PassThrough(n);     	
    }
    if (n->mtype != MediaType::MediaType_Audio && n->mtype != MediaType::MediaType_Video) {
        LLOG_ERROR("unknow media type ,");
        return 0;
    }

    if (!n->p) {
	    LLOG_ERROR("type %d, packet is null,", n->mtype);
        return 2;
    }

    PAVFrame f;
    if ((ret = DecodePacket(n->p, f)) < 0) {
        LLOG_ERROR("decoder error,");
        ret = DECIDER_DECODEPKT_FAILED;
        lastState_ = DECIDER_DECODEPKT_FAILED;
        LLOG_ERROR("DECIDER_DECODEPKT_FAILED,");
        return ret;
    }

    
    n->f = f;
    n->dtype = DataType::DataType_frame;

    if (ret == 2) {
        ret = 0;
        return ret;
    }

    ret = PassThrough(n);
    return ret;
}

int CommDecoder::ProcessLoop() 
{
    int ret = 0;
    if (!ctx_) {
        return 0;
    }

    while (true) {
        if (GetStop()) {
            LLOG_ERROR("state except exit,");
            ret = -1001;
            lastState_ = COMM_SET_STOP;
            break;
        }
        PNode n = in_->GetNode();
        if ((ret = Process(n)) < 0) {
            LLOG_ERROR("decoder process ret %d,", ret);
            return ret;
        }

        if (ret == 1) {
            LLOG_INFO("decoder to end,");
            return ret;
        }
    }
    return ret;
}

int CommDecoder::FlushDecoder() 
{
    int ret = 0;
    AVFrame *p = NULL;
    defer[&] {
        if (ret != 0 && p) {
            av_frame_free(&p);
            p = NULL;
        }
    };

    if (!ctx_) {
        return 0;
    }
    while (true) {
        if (GetStop()) {
            LLOG_ERROR("set it stop,");
            ret = -1001;
            lastState_ = COMM_SET_STOP;
            break;
        }
        p = av_frame_alloc();
        if (p == NULL) {
            ret = DECODER_FLUSH_ALLFRAME_FAILED;
            lastState_ = DECODER_FLUSH_ALLFRAME_FAILED;
            break;
        }

        if ((ret = avcodec_receive_frame(ctx_.get(), p)) < 0) {
            if (ret == AVERROR_EOF) {
                LLOG_INFO("decode frame end,");
                ret = 1;
                lastState_ = DECODER_FLUSH_EOF;
                break;
            } else if (ret == AVERROR(EAGAIN)) {
                if (p) {
                    av_frame_free(&p);
                    p = NULL;
                }
                if (avcodec_send_packet(ctx_.get(), NULL) != 0) {
                    ret = DECODER_FLUSH_FAILED;
                    LLOG_ERROR("flush decoder send null packet failed,");
                    break;
                }
                continue;
            }

            LLOG_ERROR("flush decoder failed, ret %d\n", ret);
            ret = DECODER_FLUSH_FAILED;
            break;
        }

        if (firstPts_ == UNINIT_PTS) {
            LLOG_INFO("media file first pts  %ld, type:%s,", p->pts, type_ == MediaType::MediaType_Video?"video":"audio");
            firstPts_ = p->pts;
        }
        p->pts -= firstPts_;

       
        if (lastFramePts_ >= p->pts) {
            LLOG_ERROR("video timestamp exception lastFramePts_ %ld p->pts %ld duration %ld", lastFramePts_, p->pts, p->pkt_duration);
            p->pts = lastFramePts_ + (p->pkt_duration?p->pkt_duration:duration_);
            LLOG_ERROR("adjust p->pts:%d",p->pts);
        }

        lastFramePts_ = p->pts;
        duration_ = (p->pkt_duration? p->pkt_duration:duration_);
        LLOG_INFO("flush vdecoder,decoded frame pts %ld,duration %ld name %s w %d h %d nb_samples %d,endTime_:%d,startTime_:%d", 
			p->pts, p->pkt_duration, name_.c_str(), p->width, p->height, p->nb_samples, endTime_, startTime_);

        if ((ret = dropPackets(p)) == 2) {
            LLOG_ERROR("got frame but time not reach ,ignore it pts %ld, startTime_ %ld", p->pts, startTime_);
            av_frame_free(&p);
            p = NULL;
            continue;
        }

        std::shared_ptr<AVFrame> pfrm(p, [](AVFrame *p) {
            if (p) {
                av_frame_free(&p);
                p = NULL;
            }
        });
        p = NULL;


        pFrames_++;
       
        PNode ef = MakeNodeByFrame(pfrm, MediaType::MediaType_Video);
        if ((PassThrough(ef)) != 0) {
            LLOG_ERROR("flush decoder failed,");
            ret = DECODER_FLUSH_RECV_FAILED;
            lastState_ = DECODER_FLUSH_RECV_FAILED;
            break;
        }
    }
    return 0;
}

int CommDecoder::dropPackets(AVFrame *f)
{
    int ret = 0;
    if (f->pts < startTime_) {
        LLOG_INFO("type:%s, %s ,discarded  frame,frame pts %d", 
			(type_ == MediaType::MediaType_Video?"video":type_ == MediaType::MediaType_Audio?"audio":"unknown"),
			"smaller startTime",
			f->pts);
        ret = 2;
        return ret;
    } else if (f->pts >= startTime_) {
        if (type_ == MediaType::MediaType_Audio) {
            f->pts = f->pts - startTime_;
        }
        if (type_ == MediaType::MediaType_Video) {
            f->pts = f->pts - startTime_;
	}
        LLOG_INFO("type:%s media cut,frame pts %d", (type_ == MediaType::MediaType_Video?"video":type_ == MediaType::MediaType_Audio?"audio":"unknown"),
	                f->pts);
    }

    return ret;
}

void CommDecoder::SetDuration(const int64_t &start, const int64_t &end) 
{
    if (start >= 0) {  
        startTime_ = start;
    }
    if (end > 0) {
        endTime_ = end;
    }
}

int CommDecoder::MonitorAll(Json::Value &rt) 
{
    LLOG_INFO("seiCount_: %d\n", seiCount_);
    rt["srcSeiCount"] = seiCount_;
    int ret = 0;
    return ret;
}

void CommDecoder::GetSeiData(AVPacket *p)
{
    if (memcmp(p->data, nalu_head_, 4) == 0 || memcmp(p->data, nalu_head_+1, 3) == 0) {
        GetAnnexbSeiData(p);
    } else {
        GetMp4SeiData(p);
    }
}

void CommDecoder::GetMp4SeiData(AVPacket *p)
{
    unsigned int parse_off = 0;
    int len = p->size;
    uint8_t *data = p->data;

    while (parse_off + sizeof(int) + 4 < len) {
        unsigned int cur_size = ((data[parse_off + 0] << 24) & 0xff000000) | ((data[parse_off + 1] << 16) & 0xff0000)
               | ((data[parse_off + 2] << 8) & 0xff00) | (data[parse_off + 3] & 0xff);

        parse_off += 4;
        int parse_start = parse_off;
        if (data[parse_off] != 0x6) {
            parse_off = parse_start + cur_size;
            continue;
        }
        if (cur_size + parse_off > len) {
            LLOG_ERROR("sei parse nalu size invalid, cur_size %d, parse_off %d len %d dts %ld,", cur_size, parse_off, len, p->dts);
            return;
        }
        parse_off++;

        int type, pay_size, uuid_off;
        if (ParseSei(data + parse_off, len - parse_off, type, pay_size, uuid_off) < 0) {
            LLOG_ERROR("sei parse err, pts %lld", p->pts);
            return;
        }
        seiCount_++;
        parse_off = parse_start + cur_size;
    }
    return;
}

void CommDecoder::GetAnnexbSeiData(AVPacket *p)
{
    int off = 0;
    int parse_off = 0;
    int len = p->size;
    uint8_t *data = p->data;

    while ((off = KmpSearch((const char*)data + parse_off, len - parse_off, nalu_head_ + 1, 3)) >= 0
               && parse_off + off + 4 < len) {
        parse_off += off +3;
        if (data[parse_off++] != 0x6) {
            continue;
        }
        int type, pay_size, uuid_off;
        if (ParseSei((uint8_t*)data + parse_off, len - parse_off, type, pay_size, uuid_off) < 0) {
            LLOG_ERROR("sei parse err, pts %lld", p->pts);
            return;
        }
        seiCount_++;
        parse_off += uuid_off + pay_size + 1;
    }
    return;
}

 

FFmpeg 6.0实现视频硬解码
程序猿老樊的博客
10-24 1276
以上就是利用FFmpeg 6.0实现视频硬解码输出到Surface设备的详细步骤。通过以上的介绍，我们可以看到，虽然这个过程涉及到多个复杂的技术概念，但是只要我们按照步骤进行操作，并仔细阅读每个步骤，就可以顺利完成视频的硬解码和输出。希望这篇文章能够帮助大家更好地理解FFmpeg和Surface设备的相关技术，并在实际的项目中进行应用和实践。
在Rockchip平台上利用FFmpeg实现硬件解码与缩放并导出Python接口
最新发布
Hi20240217的博客
05-24 1390
本文介绍了在Rockchip平台上利用FFmpeg实现硬件解码与缩放的方案，并导出Python接口。通过RKMPP和RGA硬件加速模块，可显著提升4K/8K视频处理效率，降低80%的CPU负载。关键技术包括：硬件解码器初始化、零内存拷贝的DRM_PRIME机制、RGA硬件缩放滤镜链配置，以及高效的Python接口封装。实测表明，该方案在RK3568/RK3588开发板上能实现1080p视频实时处理，CPU占用率低于10%。文中提供了完整的代码示例，展示了从硬件初始化到数据传递的完整流程，特别优化了多线程环境
ffmpeg decoder
12-13
自己封装的ffmpeg解码，支持视音频同步，支持实时网络流解码；播放器必备
最简单的基于FFmpeg的解码器-纯净版（不包含libavformat）
热门推荐
雷霄骅(leixiaohua1020)的专栏
01-03 6万+
本文记录一个更加“纯净”的基于FFmpeg的视频解码器。此前记录过基于FFmpeg的视频播放器实际上就是一个解码器：《最简单的基于FFMPEG+SDL的视频播放器 ver2 （采用SDL2.0）》这个播放器调用了FFmpeg中的libavformat和libavcodec两个库完成了视频解码工作。但是这不是一个“纯净”的解码器。该解码器中libavformat完成封装格式的解析，而libavcod
【C++】FFmpeg-多媒体框架
weixin_43510208的博客
05-09 1239
一、FFmpeg 核心概念。
FFmpeg Decode（解码）
秦城季的博客
01-17 2021
首发地址，会更错 本文来自官方例子doc/examples/decode_audio.c 和 doc/examples/decode_video.c。 FFmpeg解码流程 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wB37NhkP-1610869697159)(11_decode/decode-process.png)] 其中，AVFormatContext、AVPacket等重要的结构体请看：FFmpeg重要结构体（转自雷神） 。 官方例子【Audio】 /** *
FFmpeg视频解码器
qq_46470984的博客
05-06 2762
目录视频解码知识VC下FFmpeg开发环境的搭建示例程序运行FFmpeg解码的函数FFmpeg解码的数据结构 视频解码知识 • 纯净的视频解码流程 压缩编码数据->像素数据。 例如解码H.264，就是“H.264码流->YUV”。 • 一般的视频解码流程 视频码流一般存储在一定的封装格式（例如MP4、AVI等）中。封装格式中通常还包含音频码流等内容。 对于封装格式中的视频，需要先从封装格式中提取中视频码流，然后再进行解码。 例如解码MKV格式的视频文件，就是“MKV->H.264码流-&g
基于ffmpeg实现硬件解码功能
03-17
在本项目中，“基于ffmpeg实现硬件解码功能”是利用FFmpeg库来实现视频的硬件加速解码，旨在提高视频处理效率，减少CPU负载，尤其对于高清和4K视频，硬件解码可以显著提升播放性能。 硬件解码是指将原本由CPU执行的...
C++基于FFmpeg的音频解码和播放
12-17
FFmpeg是一个开源项目，提供了强大的音视频处理工具和库，包括libavcodec（用于编码和解码）、libavformat（用于多媒体容器格式的解析）和libavutil（通用实用工具库）。本示例是针对Visual Studio 2010编译环境的，...
ffmpeg_硬解码方案.zip
06-26
1. FFmpeg架构：理解FFmpeg的组件，如libavformat、libavcodec、libavutil等，它们分别负责输入/输出、编码/解码、通用工具函数等功能。 2. 硬件加速接口：熟悉不同的硬件加速接口，如DXVA2（Windows）、VAAPI...
ffmpeg_decode_video_demo.c例子
01-29
FFmpeg是领先的多媒体框架，能够解码，编码， 转码，复用，解复用，流，过滤和播放人类和机器创造的任何东西(ffmpeg decode video demo.c)
ffmpeg解码器
02-06
ffmpeg解码的过程：封装格式-->h264->yuv的过程，并将相关信息输入到文件中。
ffmpeg nvdecode
01-08
ffmpeg接受流使用英伟达SDK进行硬解，可以直接运行。已经改为多线程,包含测试例子。
ffmpeg decode_video demo
C++ 开发者的博客
05-13 490
ffmpeg API的使用 视频解码主要代码，将压缩视频解码为非压缩的视频
ffmpeg decoders
weixin_30748995的博客
07-26 112
aac cinepak jpegls aac_latm cljr jv aasc cook kgv1 ac3...
ffmpeg decode raw h264
fanbird2008的专栏
11-23 5497
1. configure configure --prefix=/usr/local/ffmpeg \                        --enable-version3 \                        --enable-gpl --enable-pthreads\                        --disable-postproc --en
ffmpeg自定义一种音频编解码myself类型
cai742925624的专栏
05-11 871
注意：请先记得make distclean一下 1、只需要在libavcodec目录操作即可，编写编码器源代码 #include "avcodec.h" typedef struct myself_ctx { int index; }myself_ctx; static const AVClass myself_class = { .class_name = "myself decoder", .item_name = av_de...
【FFmpeg学习】——FFmpeg解码
weixin_55799469的博客
05-17 830
FFmpeg解码视频过程代码： av_register_all() avformat_open_input() avformat_find_stream_info() avcodec_find_decoder() avcodec_open2() av_read_frame() avcodec_decode_video2() avcodec_close() avformat_close_input()
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值