FFmpeg 解码 H264 格式的视频

已于 2022-02-15 17:14:29 修改
阅读量5.2k 收藏 27
点赞数 1
分类专栏： 音视频
于 2022-01-10 08:27:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tyyj90/article/details/122403096
版权

FFmpeg 解码 H264 主要分三个步骤，其一获取解码器，其二向解码器中送入 H264 NALU，其三从解码器中获取解码后的 YUV 等数据。

一、H264

H.264，同时也是 MPEG-4 第十部分，是由 ITU-T 视频编码专家组（VCEG）和 ISO/IEC 动态图像专家组（MPEG）联合组成的联合视频组（JVT，Joint Video Team）提出的高度压缩数字视频编解码器标准。这个标准通常被称之为 H.264/AVC（或者 AVC/H.264 或者 H.264/MPEG-4 AVC 或 MPEG-4/H.264 AVC）而明确的说明它两方面的开发者。

H264 标准各主要部分有 Access Unit delimiter（访问单元分割符），SEI（附加增强信息），primary coded picture（基本图像编码），Redundant Coded Picture（冗余图像编码）。还有 Instantaneous Decoding Refresh（IDR，即时解码刷新）、Hypothetical Reference Decoder（HRD，假想参考解码）、Hypothetical Stream Scheduler（HSS，假想码流调度器）。

特点

1．低码率（Low Bit Rate）：和 MPEG2 和 MPEG4 ASP 等压缩技术相比，在同等图像质量下，采用 H.264 技术压缩后的数据量只有 MPEG2 的 1/8，MPEG4 的 1/3。

2．高质量的图像：H.264 能提供连续、流畅的高质量图像（DVD质量）。

3．容错能力强：H.264 提供了解决在不稳定网络环境下容易发生的丢包等错误的必要工具。

4．网络适应性强：H.264 提供了网络抽象层（Network Abstraction Layer），使得 H.264 的文件能容易地在不同网络上传输（例如互联网、CDMA、GPRS、WCDMA 和 CDMA2000 等）。

SPS Sequence Paramater Set，序列的参数集（SPS）包括了一个图像序列的所有信息，SPS 中保存了一组编码视频序列（Coded video sequence）的全局参数。

PPS Picture Paramater Set，图像的参数集（PPS）包括了一个图像所有片的信息。

在这里插入图片描述
H264 原始码流是由一个接一个 NALU（NAL Unit）组成，一个 NALU = 一组对应于视频编码的 NALU 头部信息 + 一个原始字节序列负荷（RBSP，Raw Byte Sequence Payload）。

一个原始的 H.264 NALU 单元常由 [StartCode] [NALU Header] [NALU Payload] 三部分组成，其中 Start Code 用于标示这是一个 NALU 单元的开始，必须是 “00 00 00 01”

GOP 是画面组，一个 GOP 是一组连续的画面。GOP 一般有两个数字，如 M = 3，N = 12，M 指定 I 帧与 P 帧之间的距离，N 指定两个 I 帧之间的距离。

IDR 一个序列的第一帧叫做 ID 帧（Instantaneous Decoding Refresh，立即解码刷新）。

在这里插入图片描述
在 H264 中，句法元素共被组织成：序列、图像（帧）、片、宏块和子宏块五个层次。

NALU Header 由三部分组成，forbidden_bit（1bit），nal_ref_idc（2bits）代表优先级，nal_unit_type（5bits）代表该 NALU 的类型。

forbidden_zero_bit

1 bit，H264 规定此位必须为 0

nal_ref_idc

用于表示当前 NALU 的重要性，值越大，越重要

解码器在解码处理不过来的时候，可以丢掉重要性为 0 的 NALU

  1. nal_ref_idc 不等于 0 时，NAL unit 的内容可能是 SPS/PPS/参考帧的片

  2. nal_ref_idc 等于 0 时，NAL unit 的内容可能是非参考图像的片

  3. 当某个图像的片的 nal_ref_id 等于 0 时，该图像的所有片均应等于 0

nal_unit_type

nal_unit_type 是否包含 VCL（Video Coding Layer 视频编码层） 层编码数据分为 VCL NAL units 和 non-VCL NAL units。VCL NAL units 中包含 VCL 层编码输出的数据，而 non-VCL NAL units 则不包含。
在这里插入图片描述

二、H264 解码

想要正确的解码图像，必须要向解码器送入关键解码信息，PPS、SPS 至关重要，还有一些必要的解码器参数也要设置。

  1. 调用 avcodec_find_decoder(…) 来查找 ID 为 AV_CODEC_ID_H264 的解码器；
  2. 调用 avcodec_alloc_context3(…) 分配解码器上下文 AVCodecContext；
  3. 调用 avcodec_parameters_alloc() 给 AVCodecParameters 结构体分配内存，用来设置解码器参数；
  4. 填充必要的解码参数到 AVCodecParameters，尤其 format，此处设置为 AV_PIX_FMT_YUV420P，表示要解码为 YUV420P 这种 YUV 类型；
  5. 调用 avcodec_parameters_to_context(…) 将解码器参数结构体的内容设置到解码器上下文中；
  6. 调用 avcodec_parameters_free(…) 释放解码器参数结构体占用的内存空间；
  7. 现在调用 avcodec_open2(…) 打开解码器；
  8. 调用 av_frame_alloc() 分配 AVFrame 结构体占用的内存空间，为后续解码提供便利。

解码流程

如果 H264 序列中包含 SPS 和 PPS，则先保存到全局变量中，在 I 帧的前面添加 SPS 和 PPS， 这是为了更好的提升兼容性，比如外面如果先设置了 SPS 和 PPS，而码流中没有，也不影响解码流程。

  1. 调用 avcodec_send_packet(…) 将待解码的数据包发送到解码器；
  2. 调用 avcodec_receive_frame(…) 接收解码后的数据包，编码和解码都是一样的，都是 send 1 次，然后 receive 多次，直到 AVERROR(EAGAIN) 或者 AVERROR_EOF；
  3. 对解码后得到的 AVFrame 调用 av_frame_unref(…) 解除引用，为下一次复用 AVFrame 全局变量做好准备。

FFmpeg 解码 H264 代码

将 H264 解码封装到 VideoDecoder 类中。

//
// Created by liuhongwei on 2021/12/7.
//

#ifndef VIDEODECODER_H
#define VIDEODECODER_H

extern "C" {
//编解码
#include "libavcodec/avcodec.h"
}

#include "PacketQueue.h"
#include "cb/FrameDataCallback.h"

class VideoDecoder {

public:
    VideoDecoder(PacketQueue *packetQueue);
    ~VideoDecoder();

    bool open(unsigned int frameRate, unsigned int profile, unsigned int level,
              char *sps, unsigned int spsLen, char *pps, unsigned int ppsLen);

    void close();

    void decode();

    static void *_decode(void *self) {
        static_cast<VideoDecoder *>(self)->decode();
        return nullptr;
    }

    void setFrameDataCallback(FrameDataCallback *frameDataCallback);

private:
    PacketQueue *pPacketQueue;
    AVCodecContext *pVideoAVCodecCtx;
    AVFrame *pFrame;

    bool volatile isDecoding;
    pthread_t decodeThread;
    pthread_mutex_t *pFrameDataCallbackMutex;
    FrameDataCallback *pFrameDataCallback;

    char *pSPS;
    unsigned int volatile gSPSLen;
    char *pPPS;
    unsigned int volatile gPPSLen;

    bool volatile isFirstIDR;

    unsigned int gFrameRate;
};


#endif //VIDEODECODER_H

具体实现在 VideoDecoder.cpp 中。

//
// Created by liuhongwei on 2021/12/7.
//

#include <unistd.h>
#include "VideoDecoder.h"

const char H264_NAL_START[] = {0x00, 0x00, 0x00, 0x01};

VideoDecoder::VideoDecoder(PacketQueue *packetQueue) {
    pPacketQueue = packetQueue;
    pFrameDataCallbackMutex = (pthread_mutex_t *) malloc(sizeof(pthread_mutex_t));

    int ret = pthread_mutex_init(pFrameDataCallbackMutex, nullptr);
    if (ret != 0) {
        LOGE("video FrameDataCallbackMutex init failed.\n");
    }

    gSPSLen = 0;
    pSPS = nullptr;

    gPPSLen = 0;
    pPPS = nullptr;

    isFirstIDR = false;

    gFrameRate = 25;

    pFrameDataCallback = nullptr;
}

VideoDecoder::~VideoDecoder() {
    pthread_mutex_destroy(pFrameDataCallbackMutex);

    if (nullptr != pFrameDataCallbackMutex) {
        free(pFrameDataCallbackMutex);
        pFrameDataCallbackMutex = nullptr;
    }
}

void VideoDecoder::setFrameDataCallback(FrameDataCallback *frameDataCallback) {
    pthread_mutex_lock(pFrameDataCallbackMutex);
    pFrameDataCallback = frameDataCallback;
    pthread_mutex_unlock(pFrameDataCallbackMutex);
}

void VideoDecoder::close() {
    isDecoding = false;
    pthread_join(decodeThread, nullptr);

    if (pSPS != nullptr) {
        free(pSPS);
        pSPS = nullptr;
    }

    if (pPPS != nullptr) {
        free(pPPS);
        pPPS = nullptr;
    }

    if (pFrame != nullptr) {
        av_frame_free(&pFrame);
        LOGI("%s video Frame free", __FUNCTION__);
    }

    if (pVideoAVCodecCtx != nullptr) {
        avcodec_free_context(&pVideoAVCodecCtx);
        LOGI("%s video avcodec_free_context", __FUNCTION__);
    }
}

bool VideoDecoder::open(unsigned int frameRate, unsigned int profile, unsigned int level,
                        char *sps, unsigned int spsLen, char *pps, unsigned int ppsLen) {
    gSPSLen = 0;
    pSPS = nullptr;

    gPPSLen = 0;
    pPPS = nullptr;

    LOGI("%s spsLen=%d ppsLen=%d", __FUNCTION__, spsLen, ppsLen);

    if (spsLen > 0) {
        pSPS = (char *) malloc(spsLen);
        if (nullptr == pSPS) {
            return false;
        }

        memcpy(pSPS, sps, spsLen);
        gSPSLen = spsLen;
    }

    if (ppsLen > 0) {
        pPPS = (char *) malloc(ppsLen);
        if (nullptr == pPPS) {
            free(pSPS);
            return false;
        }

        memcpy(pPPS, pps, ppsLen);
        gPPSLen = ppsLen;
    }

    isFirstIDR = false;

    if (frameRate > 0) {
        gFrameRate = frameRate;
    }

    int ret;
    AVCodec *dec = avcodec_find_decoder(AV_CODEC_ID_H264);
    LOGI("%s video decoder name: %s", __FUNCTION__, dec->name);
    pVideoAVCodecCtx = avcodec_alloc_context3(dec);

    if (pVideoAVCodecCtx == nullptr) {
        LOGE("%s VideoAVCodecCtx alloc failed", __FUNCTION__);
        return false;
    }

    AVCodecParameters *par = avcodec_parameters_alloc();
    if (par == nullptr) {
        LOGE("%s video AVCodecParameters alloc failed", __FUNCTION__);
        free(pSPS);
        free(pPPS);
        avcodec_free_context(&pVideoAVCodecCtx);
        return false;
    }

    par->codec_type = AVMEDIA_TYPE_VIDEO;
    par->codec_id = AV_CODEC_ID_H264;
    par->format = AV_PIX_FMT_YUV420P;//AV_PIX_FMT_NV12
    par->color_range = AVCOL_RANGE_JPEG;

    if (profile != 0) {
        par->profile = (int) profile;
    }

    if (level != 0) {
        par->level = (int) level;
    }

    avcodec_parameters_to_context(pVideoAVCodecCtx, par);
    avcodec_parameters_free(&par);

    LOGI("%s profile=%d level=%d", __FUNCTION__, profile, level);
    ret = avcodec_open2(pVideoAVCodecCtx, dec, nullptr);
    if (ret < 0) {
        LOGE("%s Can not open video encoder", __FUNCTION__);
        free(pSPS);
        free(pPPS);
        avcodec_free_context(&pVideoAVCodecCtx);
        return false;
    }
    LOGI("%s avcodec_open2 video SUCC", __FUNCTION__);
    pFrame = av_frame_alloc();
    if (pFrame == nullptr) {
        LOGE("%s video av_frame_alloc failed", __FUNCTION__);
        free(pSPS);
        free(pPPS);
        avcodec_free_context(&pVideoAVCodecCtx);
        return false;
    }

    isDecoding = true;
    ret = pthread_create(&decodeThread, nullptr, &VideoDecoder::_decode, (void *) this);
    if (ret != 0) {
        LOGE("video decode-thread create failed.\n");
        isDecoding = false;
        free(pSPS);
        free(pPPS);
        avcodec_free_context(&pVideoAVCodecCtx);
        av_frame_free(&pFrame);
        return false;
    }

    return true;
}

void VideoDecoder::decode() {
    int ret;
    unsigned sleepDelta = 1000000 / gFrameRate / 4;// 一帧视频的 1/4
    int NAL_START_LEN = 4;

    while (isDecoding) {

        AVPacket *pkt = av_packet_alloc();

        if (pkt == nullptr) {
            usleep(sleepDelta);
            continue;
        }

        if (pPacketQueue == nullptr) {
            av_packet_free(&pkt);
            usleep(sleepDelta);
            continue;
        }

        PACKET_STRUCT *packetStruct;
        bool isDone = pPacketQueue->Take(packetStruct);
        if (isDone && packetStruct != nullptr && packetStruct->data != nullptr &&
            packetStruct->data_size > 0) {
            //0x67:sps
            if (packetStruct->data[0] == 0x67) {
                if (gSPSLen <= 0) {
                    gSPSLen = packetStruct->data_size;
                    pSPS = (char *) malloc(gSPSLen);
                    if (nullptr == pSPS) {
                        av_packet_free(&pkt);
                        free(packetStruct->data);
                        free(packetStruct);

                        usleep(sleepDelta);
                        continue;
                    }
                    memcpy(pSPS, packetStruct->data, gSPSLen);
                    LOGI("%s get sps spsLen=%d", __FUNCTION__, gSPSLen);
                }

                av_packet_free(&pkt);
                free(packetStruct->data);
                free(packetStruct);

                continue;
            }
            //0x68:pps
            if (packetStruct->data[0] == 0x68) {
                if (gPPSLen <= 0) {
                    gPPSLen = packetStruct->data_size;
                    pPPS = (char *) malloc(gPPSLen);
                    if (nullptr == pPPS) {
                        av_packet_free(&pkt);
                        free(packetStruct->data);
                        free(packetStruct);

                        usleep(sleepDelta);
                        continue;
                    }
                    memcpy(pPPS, packetStruct->data, gPPSLen);
                    LOGI("%s get pps ppsLen=%d", __FUNCTION__, gPPSLen);
                }

                av_packet_free(&pkt);
                free(packetStruct->data);
                free(packetStruct);

                continue;
            }

            if (!isFirstIDR) {
                //0x65:IDR
                if (packetStruct->data[0] == 0x65) {
                    isFirstIDR = true;
                    LOGI("%s get first idr.", __FUNCTION__);
                } else {
                    av_packet_free(&pkt);
                    free(packetStruct->data);
                    free(packetStruct);

                    continue;
                }
            }

            if (packetStruct->data[0] == 0x65 && gSPSLen > 0 && gPPSLen > 0) {
                ret = av_new_packet(pkt, (int) (NAL_START_LEN + gSPSLen +
                                                NAL_START_LEN + gPPSLen +
                                                packetStruct->data_size + NAL_START_LEN));
            } else {
                ret = av_new_packet(pkt, packetStruct->data_size + NAL_START_LEN);
            }

            if (ret < 0) {
                av_packet_free(&pkt);
                free(packetStruct->data);
                free(packetStruct);

                usleep(sleepDelta);
                continue;
            }
        } else {
            av_packet_free(&pkt);
            usleep(sleepDelta);
            continue;
        }

        if (packetStruct->data[0] == 0x65 && gSPSLen > 0 && gPPSLen > 0) {
            int pos = 0;
            //复制 0x 00 00 00 01
            memcpy(pkt->data + pos, H264_NAL_START, NAL_START_LEN);
            pos += NAL_START_LEN;
            memcpy(pkt->data + pos, pSPS, gSPSLen);
            pos += (int) gSPSLen;

            memcpy(pkt->data + pos, H264_NAL_START, NAL_START_LEN);
            pos += NAL_START_LEN;
            memcpy(pkt->data + pos, pPPS, gPPSLen);
            pos += (int) gPPSLen;

            memcpy(pkt->data + pos, H264_NAL_START, NAL_START_LEN);
            pos += NAL_START_LEN;
            memcpy(pkt->data + pos, packetStruct->data, packetStruct->data_size);
        } else {
            memcpy(pkt->data, H264_NAL_START, NAL_START_LEN);
            memcpy(pkt->data + NAL_START_LEN, packetStruct->data, packetStruct->data_size);
        }

        pkt->pts = packetStruct->timestamp;
        pkt->dts = packetStruct->timestamp;

        free(packetStruct->data);
        free(packetStruct);
        /* send the packet for decoding */
        ret = avcodec_send_packet(pVideoAVCodecCtx, pkt);
        //LOGD("%s send the video packet for decoding pkt size=%d", __FUNCTION__, pkt->size);

        av_packet_unref(pkt);
        av_packet_free(&pkt);

        if (ret < 0) {
            LOGE("%s Error sending the video pkt to the decoder ret=%d", __FUNCTION__, ret);
            usleep(sleepDelta);
            continue;
        } else {
            // 编码和解码都是一样的，都是send 1次，然后receive多次, 直到AVERROR(EAGAIN)或者AVERROR_EOF
            while (ret >= 0) {
                ret = avcodec_receive_frame(pVideoAVCodecCtx, pFrame);
                if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
                    usleep(sleepDelta);
                    continue;
                } else if (ret < 0) {
                    LOGE("%s Error receive decoding video frame ret=%d", __FUNCTION__, ret);
                    usleep(sleepDelta);
                    continue;
                }

                pthread_mutex_lock(pFrameDataCallbackMutex);
                if (pFrameDataCallback != nullptr) {
                    // 解码固定为 AV_PIX_FMT_YUV420P
                    int planeNum = 3;
                    int yuvLens[planeNum];
                    yuvLens[0] = pFrame->linesize[0] * pFrame->height;
                    yuvLens[1] = pFrame->linesize[1] * pFrame->height / 2;
                    yuvLens[2] = pFrame->linesize[2] * pFrame->height / 2;
                    //LOGI("%s video onDataArrived", __FUNCTION__);
                    pFrameDataCallback->onDataArrived(StreamType::VIDEO,
                                                      (long long) pFrame->pts,
                                                      (char **) pFrame->data,
                                                      yuvLens,
                                                      planeNum,
                                                      -1,
                                                      -1,
                                                      pFrame->width,
                                                      pFrame->height);
                }

                pthread_mutex_unlock(pFrameDataCallbackMutex);

                av_frame_unref(pFrame);
            }
        }

    }
}
FFMPEG之H.264视频解码
陌上烟雨遥的博客
07-25 3363
一 概括 FFMPEG 的libavcodec完成音视频编码或解码，H.264解码主要由H264.c实现，H.264.c 往下调用X264 实现编解码功能，H.264解码过程包含初始化/解码/关闭三个部分。 解码原理为: 将NAL 数据位流输入到H.264解码器中，熵解码模块解码后输出量化系数X；系数经过反量化和反变化得到残差数据R；解码器使用从码流中解析的头信息生成预测块Pred,然后把Pred与残差R求和得到数据块DF；每个块df通过去除块效应滤波得到解码图像的重建块F。 ...
ffmpeg解码h264视频文件，并且实时显示（mfc）
07-26
用ffmpeg解码h264视频文件，并且将解码出来的每帧图像用opencv封装进行显示，ffmpeg采用的是最新的3-2版本。另外，程序预留了将每帧图像保存成bmp的接口，注释详细。使用时须配置好ffmpeg和opencv，然后将自己的h264文件名称修改为1.h264 并将其置于当前目录即可运行（可作为2次开发的参考）
基于 FFmpeg 的 H264 转 MP4 步骤总结
最新发布
2301_80657297的博客
03-06 896
基于 FFmpeg 实现 H.264 转 MP4 视频转码-CSDN博客。
ffmpeg 解码h264数据
str999_cn的专栏
05-27 1046
本文内容均为原创，转载请注明出处。 使用ffmpeg解码h264数据其实相对使用x264进行视频编码是简单了许多的，因为ffmpeg提供了一个decoding_encoding.c的文件，这个文件里面有简单的使用ffmpeg进行视频、音频编解码的例子，不过可能有的人也会找不到这个示例，我就讲我改造过的这个示例放在这里，同时加一些解释。 其中需要注意的的一点我需要在此说明，就是ffmpeg在
FFmpeg的H.264解码器源代码简单分析：宏块解码（Decode）部分-帧内宏块（Intra）
热门推荐
雷霄骅(leixiaohua1020)的专栏
04-20 3万+
本文分析FFmpeg的H.264解码器的宏块解码（Decode）部分的源代码。FFmpeg的H.264解码器调用decode_slice()函数完成了解码工作。这些解码工作可以大体上分为3个步骤：熵解码，宏块解码以及环路滤波。本文分析这3个步骤中的第2个步骤。由于宏块解码部分的内容比较多，因此将本部分内容拆分成两篇文章：一篇文章记录帧内预测宏块（Intra）的宏块解码，另一篇文章记录帧间预测宏块（
【FFmpeg】调用ffmpeg进行H264软解
weixin_42877471的博客
05-06 2819
参考FFmpeg当中的/doc/examples当中的video_decode.c文件，进行调用过程的理解和实现
ffmpeg 解码h264
鹏程万里--扬帆起航
10-10 8564
VC6+FFmpeg-full-SDK-3.2：   1：编码：     关于编码，x264就可以了（当然有空的话，会继续写一点关于ffmpeg编码的东西）；      2：解码：      解码主要参考了apiexample.c，下面我列出一个函数将解码后的AVFrame转为bmp；   int AVFrame_create_bmp(AVFrame *pAVFrame,in
Qt基于FFmpeg解码本地视频生成 H.264文件并播放
01-14
以上就是利用Qt和FFmpeg解码本地视频生成H.264文件并播放的基本流程。通过这个过程，我们可以实现对不同视频格式的支持，以及自定义解码和编码的细节，从而满足各种复杂的多媒体处理需求。在实际项目中，你可能还...
Java解码H264格式视频流中的图片
08-25
"Java解码H264格式视频流中的图片" ...Java解码H264格式视频流中的图片需要使用到一些专门的库和工具，例如JavaCV和FFmpeg，并且需要注意版本问题。通过使用这些库和工具，我们可以将H264格式的视频流转换为图片。
Android 移植ffmpeg解码h264文件并播放渲染
12-15
1.移植ffmpeg到android...2.通过JNI接口调用ffmpeg实现h264的解码以及渲染 3.h264渲染采用opengles技术 代码保护局ffmpeg源码 JNI部分 以及opengles渲染部分，还有上层demo APP程序，该程序可以直接安装，播放h264文件
LINUX下FFMPEG解码h264格式到YUV
05-08
在Linux环境下，使用FFmpeg解码H264格式的视频并将其转换为YUV格式是一项常见的任务，这在视频处理、分析或播放场景中非常有用。H264是一种高效的视频编码标准，而YUV是视频处理中常见的颜色空间格式，常用于存储...
FFMEPG实现h264解码
02-06
FFMPEG实现的h264解码。对于理解ffmpeg的解码流程很有好处。是作为x264的编码器的解码补充
使用ffmpeg h264解码
10-14
使用ffmpeg h264解码的一个小例子 大家可以看一下 有需要的下载一下
ffmpeg_H264文件解码
11-28
播放H264文件的播放器，使用ffmpeg，平台是Windows Mobile,语言是VC++.
用FFmpeg把H264数据流解码成YUV420P
m0_60259116的博客
05-19 4905
在FFmpeg中，H264在编码前必须要转换成YUV420P，本文就分享一下怎么将h264转成YUV420P。 以下就是yuv420： 八个像素为：[Y0 U0 V0] [Y1 U1 V1] [Y2 U2 V2] [Y3 U3 V3][Y5 U5 V5] [Y6 U6 V6] [Y7U7 V7] [Y8 U8 V8] 码流为：Y0 U0 Y1 Y2 U2 Y3 Y5 V5 Y6 Y7 V7 Y8 映射出的像素点为：[Y0 U0 V5] [Y1 U0 V5] [Y2 U2 V7] [Y3 U2 V7][Y
FFmpeg：H264编解码(附完整源代码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
01-04 1412
FFmpeg：H264编解码(附完整源代码)
使用FFmpeg解码H264
NB_vol_1的专栏
12-03 714
接口定义 使用FFmpeg解码之前，先定义一些接口： 打开解码器：Open 关闭解码器：Close 解码：Decode 根据上面的定义，可以使用C++来抽象出一个虚基类 namespace toy { class VideoDecoder { public: struct Setting { // TODO }; virtual ~VideoDecoder() {}; ...
FFmpeg解码H264视频裸流(直接可用)
yinshipin007的博客
11-30 2160
1、写在前面此文章主要包含解码H264视频流数据，主要有以下几点：1、H264视频帧为Annex B格式，若使用AVCC格式可自行研究；2、H264视频裸流，非解码视频文件(若有需要我后期可添加这部分代码);3、支持输出RGB24或YUV420格式，其他可自行修改；4、FFmpeg官网代码迭代及接口变更较大，代码适应于FFmpeg3.4.2"Cantor"、3.3.7"Hilbert"等版本，较旧接口请看旧版本代码；
基于VC和ffmpeg实现H264格式视频播放器
接着，“程序中附带my.h264格式的文件”，指出该播放器软件可能包含一个或多个H264编码的视频文件（my.h264），这些文件可能是示例文件，用于演示播放器的功能。同时，这也表明使用者在获得源代码后，将拥有一个直接...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

TYYJ-洪伟

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值