Qt纯c++解析h264文件

最新推荐文章于 2024-05-15 04:07:43 发布
最新推荐文章于 2024-05-15 04:07:43 发布
阅读量1.4k 收藏 14
点赞数
分类专栏： QT ffmpeg c++ 文章标签： qt c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cqltbe131421/article/details/126711191
版权
QT 同时被 3 个专栏收录
221 篇文章 29 订阅
订阅专栏
c++
98 篇文章 5 订阅
订阅专栏
ffmpeg
6 篇文章 0 订阅
订阅专栏

最近接到一个研究，就是研究解析原始的h264数据流，还是通过udp传输过来的，测试文件是正常保存的一个h264文件，可以通过ffmpeg进行解析播放，但是通过udp过来的h264数据流是间断的，这就需要自己解析sps，pps这种原始的h264协议。

#ifndef H264VIDEODECODERTOQIMAGE_H
#define H264VIDEODECODERTOQIMAGE_H
#include <QString>
#include <QObject>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <string>
#include "H264PicturesGOP.h"
#include "H264Picture.h"
//H264解码器，解码完一帧后的回调函数
typedef int (*qt_output_frame_callback)(CH264Picture *outPicture, void *userData, int errorCode);

class H264VideoDecoderToQImage : public QObject
{
    Q_OBJECT
public:
    explicit H264VideoDecoderToQImage(QObject *parent = nullptr);
    ~H264VideoDecoderToQImage();
public slots:
    void setFileUrl(QString );
public:
    std::string              m_filename;
    qt_output_frame_callback    m_qt_output_frame_callback; //解码完毕的帧的回调函数，需要用户主动设置
    void *                   m_userData;

    int init();
    int unInit();

    int set_qt_output_frame_callback_functuin(qt_output_frame_callback qt_output_frame_callback, void *userData);

    int open(const char *url);
    int do_callback(CH264Picture *picture_current, CH264PicturesGOP *pictures_gop, int32_t is_need_flush);

    QString m_urlstr;
};

#endif // H264VIDEODECODERTOQIMAGE_H

解析完成后需要通过QImage发送到界面进行显示

#include "h264videodecodertoqimage.h"
#include "FileReader.h"
#include "Bitstream.h"
#include "CommonFunction.h"
#include "H264Golomb.h"
#include <QDebug>

H264VideoDecoderToQImage::H264VideoDecoderToQImage(QObject *parent) : QObject(parent)
{
    m_filename = "";
    m_qt_output_frame_callback = NULL;
    m_userData = NULL;
}

H264VideoDecoderToQImage::~H264VideoDecoderToQImage()
{

}

void H264VideoDecoderToQImage::setFileUrl(QString str)
{
    m_urlstr = str;
}

int H264VideoDecoderToQImage::init()
{
    return 0;
}
int H264VideoDecoderToQImage::unInit()
{
    return 0;
}

int H264VideoDecoderToQImage::set_qt_output_frame_callback_functuin(qt_output_frame_callback qt_output_frame_callback, void *userData)
{
    m_qt_output_frame_callback = qt_output_frame_callback;
    m_userData = userData;
    return 0;
}

int H264VideoDecoderToQImage::open(const char *url)
{
    int ret = 0;
    unsigned char * data = NULL;
    int size = 0;
    int nal_cnt = 0;

    CFileReader fr;
    ret = fr.init(url);
    RETURN_IF_FAILED(ret != 0, ret);

    //---------------------
    int32_t sps_flag = 0;
    int32_t pps_flag = 0;
    CH264SliceHeader slice_header_last;
    CH264Picture * picture_current = NULL;
    CH264Picture * outPicture = NULL;
    int32_t is_need_flush = 0;
    int32_t isStopLoop = 0;

    CH264PicturesGOP * pictures_gop = new CH264PicturesGOP;
    RETURN_IF_FAILED(pictures_gop == NULL, -1);
    picture_current = pictures_gop->m_DecodedPictureBuffer[0]; //初始化第一个picture_current

    //循环解析---------------------
    while(1)
    {
        if (isStopLoop == 1)
        {
            break;
        }
        qDebug()<<"dddddddddddddddddddddddd";
        ret = fr.getNextH264NalUnitByStartCode(data, size);
        BREAK_IF_FAILED(ret != 0);
        CH264NalUnit nu;
        ret = nu.getH264RbspFromNalUnit(data, size);
        BREAK_IF_FAILED(ret != 0);
        CBitstream bs(nu.rbsp_byte, nu.NumBytesInRBSP);
        //--------------------------
        switch(nu.nal_unit_type)
        {
        case H264_NAL_SLICE: //1
        {
            //7.3.2.8 Slice layer without partitioning RBSP syntax
            CH264SliceHeader slice_header;
            ret = slice_header.slice_header(bs, nu, pictures_gop->m_spss, pictures_gop->m_ppss); // 2
            RETURN_IF_FAILED(ret != 0, ret);

            bool is_new_pic = slice_header.is_first_VCL_NAL_unit_of_a_picture(slice_header_last);
            if (is_new_pic == true && picture_current != NULL && picture_current->m_current_picture_ptr != NULL)
            {
                CH264Picture * newEmptyPicture = NULL;
                picture_current->m_current_picture_ptr->end_decode_the_picture_and_get_a_new_empty_picture(newEmptyPicture);
                RETURN_IF_FAILED(ret != 0, ret);

                is_need_flush = picture_current->m_picture_frame.m_h264_slice_header.m_nal_unit.IdrPicFlag; //当前已解码完毕的帧是否是IDR帧
                ret = do_callback(picture_current, pictures_gop, is_need_flush); //回调操作
                if (ret != 0)
                {
                    LOG_ERROR("do_callback() failed! ret=%d;\n", ret);
                    isStopLoop = 1;
                    break;
                }
                picture_current = newEmptyPicture;
            }
            RETURN_IF_FAILED(picture_current == NULL, -1);
            slice_header_last = slice_header;
            slice_header.syntax_element_categories = (0x01 | 0x02) | 0x04; //2 | 3 | 4;
            slice_header.slice_id = 0;
            ret = picture_current->decode_one_slice(slice_header, bs, pictures_gop->m_DecodedPictureBuffer); // /* all categories of slice_data() syntax */ 2 | 3 | 4
            CONTINUE_IF_FAILED(ret != 0);
            ret = rbsp_slice_trailing_bits(bs, slice_header.m_pps.entropy_coding_mode_flag); //2
            RETURN_IF_FAILED(ret != 0, ret);
            break;
        }
        case H264_NAL_DPA: //2
        {
            //7.3.2.9.1 Slice data partition A RBSP syntax
            CH264Golomb gb;
            CH264SliceHeader slice_header;
            ret = slice_header.slice_header(bs, nu, pictures_gop->m_spss, pictures_gop->m_ppss); // 2
            RETURN_IF_FAILED(ret != 0, ret);
            bool is_new_pic = slice_header.is_first_VCL_NAL_unit_of_a_picture(slice_header_last);
            if (is_new_pic == true && picture_current != NULL && picture_current->m_current_picture_ptr != NULL)
            {
                CH264Picture * newEmptyPicture = NULL;
                picture_current->m_current_picture_ptr->end_decode_the_picture_and_get_a_new_empty_picture(newEmptyPicture);
                RETURN_IF_FAILED(ret != 0, ret);

                is_need_flush = picture_current->m_picture_frame.m_h264_slice_header.m_nal_unit.IdrPicFlag; //当前已解码完毕的帧是否是IDR帧
                ret = do_callback(picture_current, pictures_gop, is_need_flush); //回调操作
                if (ret != 0)
                {
                    LOG_ERROR("do_callback() failed! ret=%d;\n", ret);
                    isStopLoop = 1;
                    break;
                }
                picture_current = newEmptyPicture;
            }
            RETURN_IF_FAILED(picture_current == NULL, -1);
            slice_header.syntax_element_categories = 0x01; //2;
            slice_header.slice_id = gb.get_ue_golomb(bs); //All ue(v)
            ret = picture_current->decode_one_slice(slice_header, bs, pictures_gop->m_DecodedPictureBuffer); // /* only category 2 parts of slice_data() syntax */ 2
            CONTINUE_IF_FAILED(ret != 0);
            ret = rbsp_slice_trailing_bits(bs, slice_header.m_pps.entropy_coding_mode_flag); //2
            RETURN_IF_FAILED(ret != 0, ret);
            break;
        }
        case H264_NAL_DPB: //3
        {
            //7.3.2.9.2 Slice data partition B RBSP syntax
            RETURN_IF_FAILED(picture_current->m_current_picture_ptr == NULL, -1);
            CH264SliceHeader & slice_header = picture_current->m_current_picture_ptr->m_h264_slice_header;
            CH264Golomb gb;
            slice_header.slice_id = gb.get_ue_golomb(bs); //All ue(v)
            if (slice_header.m_sps.separate_colour_plane_flag == 1)
            {
                slice_header.colour_plane_id = bs.readBits(2); //All u(2)
            }
            if (slice_header.m_pps.redundant_pic_cnt_present_flag)
            {
                slice_header.redundant_pic_cnt = gb.get_ue_golomb(bs); //All ue(v)
            }
            slice_header.syntax_element_categories = 0x02; //3;
            ret = picture_current->decode_one_slice(slice_header, bs, pictures_gop->m_DecodedPictureBuffer); // /* only category 3 parts of slice_data() syntax */ 3
            CONTINUE_IF_FAILED(ret != 0);
            ret = rbsp_slice_trailing_bits(bs, slice_header.m_pps.entropy_coding_mode_flag); //3
            RETURN_IF_FAILED(ret != 0, ret);
            break;
        }
        case H264_NAL_DPC: //4
        {
            //7.3.2.9.3 Slice data partition C RBSP syntax
            RETURN_IF_FAILED(picture_current->m_current_picture_ptr == NULL, -1);
            CH264SliceHeader & slice_header = picture_current->m_current_picture_ptr->m_h264_slice_header;
            CH264Golomb gb;
            slice_header.slice_id = gb.get_ue_golomb(bs); //All ue(v)
            if (slice_header.m_sps.separate_colour_plane_flag == 1)
            {
                slice_header.colour_plane_id = bs.readBits(2); //All u(2)
            }
            if (slice_header.m_pps.redundant_pic_cnt_present_flag)
            {
                slice_header.redundant_pic_cnt = gb.get_ue_golomb(bs); //All ue(v)
            }
            slice_header.syntax_element_categories = 0x04; //4;
            ret = picture_current->decode_one_slice(slice_header, bs, pictures_gop->m_DecodedPictureBuffer); // /* only category 4 parts of slice_data() syntax */ 4
            CONTINUE_IF_FAILED(ret != 0);
            ret = rbsp_slice_trailing_bits(bs, slice_header.m_pps.entropy_coding_mode_flag); //4
            RETURN_IF_FAILED(ret != 0, ret);
            break;
        }
        case H264_NAL_IDR_SLICE: //5 立即刷新帧（每个GOP的第一帧必须是I帧）
        {
            if (sps_flag == 0 || pps_flag == 0)
            {
                LOG_ERROR("For IDR slice, sps and pps should be present first. m_sps_index=%d; m_pps_index=%d;\n", sps_flag, pps_flag);
                break;
            }
            //7.3.2.8 Slice layer without partitioning RBSP syntax
            CH264SliceHeader slice_header;
            ret = slice_header.slice_header(bs, nu, pictures_gop->m_spss, pictures_gop->m_ppss); // 2
            RETURN_IF_FAILED(ret != 0, ret);
            bool is_new_pic = slice_header.is_first_VCL_NAL_unit_of_a_picture(slice_header_last);
            if (is_new_pic == true && picture_current != NULL && picture_current->m_current_picture_ptr != NULL)
            {
                CH264Picture * newEmptyPicture = NULL;
                picture_current->m_current_picture_ptr->end_decode_the_picture_and_get_a_new_empty_picture(newEmptyPicture);
                RETURN_IF_FAILED(ret != 0, ret);

                is_need_flush = picture_current->m_picture_frame.m_h264_slice_header.m_nal_unit.IdrPicFlag; //当前已解码完毕的帧是否是IDR帧
                ret = do_callback(picture_current, pictures_gop, is_need_flush); //回调操作
                if (ret != 0)
                {
                    LOG_ERROR("do_callback() failed! ret=%d;\n", ret);
                    isStopLoop = 1;
                    break;
                }
                picture_current = newEmptyPicture;
            }
            RETURN_IF_FAILED(picture_current == NULL, -1);
            slice_header_last = slice_header;
            slice_header.syntax_element_categories = 0x01 | 0x02; //2 | 3;
            slice_header.slice_id = 0;
            ret = picture_current->decode_one_slice(slice_header, bs, pictures_gop->m_DecodedPictureBuffer); // /* all categories of slice_data() syntax */ 2 | 3 | 4
            CONTINUE_IF_FAILED(ret != 0);
            ret = rbsp_slice_trailing_bits(bs, slice_header.m_pps.entropy_coding_mode_flag); //2
            RETURN_IF_FAILED(ret != 0, ret);
            break;
        }
        case H264_NAL_SEI: //6
        {
            ret = pictures_gop->m_sei.sei_rbsp(bs);
            if (ret != 0)
            {
                LOG_ERROR("pictures_gop->m_sei.sei_rbsp(bs) failed! ret=%d;\n", ret);
            }
            break;
        }
        case H264_NAL_SPS: //7
        {
            CH264SPS sps;
            ret = sps.seq_parameter_set_data(bs);
            if (ret != 0)
            {
                LOG_ERROR("this->m_sps[m_sps_index].seq_parameter_set_data(bs) failed! ret=%d;\n", ret);
            }

            if (sps.seq_parameter_set_id < 0 || sps.seq_parameter_set_id >= H264_MAX_SPS_COUNT)
            {
                LOG_ERROR("seq_parameter_set_id shall be in the range of 0 to 31, inclusive. sps.seq_parameter_set_id=%d;\n", sps.seq_parameter_set_id);
            }

            pictures_gop->m_spss[sps.seq_parameter_set_id] = sps;
            pictures_gop->max_num_reorder_frames = sps.m_vui.max_num_reorder_frames; //用于按显示顺序输出B帧
            sps_flag = 1;
            break;
        }
        case H264_NAL_PPS: //8
        {
            CH264PPS pps;
            ret = pps.pic_parameter_set_rbsp(bs, pictures_gop->m_spss);
            if (ret != 0)
            {
                LOG_ERROR("this->m_pps[m_pps_index].pic_parameter_set_rbsp(bs) failed! ret=%d;\n", ret);
            }
            if (pps.pic_parameter_set_id < 0 || pps.pic_parameter_set_id >= H264_MAX_PPS_COUNT)
            {
                LOG_ERROR("pic_parameter_set_id shall be in the range of 0 to 255, inclusive. pps.pic_parameter_set_id=%d;\n", pps.pic_parameter_set_id);
            }
            pictures_gop->m_ppss[pps.pic_parameter_set_id] = pps;
            pps_flag = 1;
            break;
        }
        case H264_NAL_SPS_EXT: //13
        {
            ret = pictures_gop->m_sps_ext.seq_parameter_set_extension_rbsp(bs);
            if (ret != 0)
            {
                LOG_ERROR("pictures_gop->m_sps_ext.seq_parameter_set_extension_rbsp(bs) failed! ret=%d;\n", ret);
            }
            break;
        }
        default:
        {
            LOG_ERROR("Unsupported nu.m_nal_unit_type=%d; nal_cnt=%d;\n", nu.nal_unit_type, nal_cnt);
            break;
        }
        }
        nal_cnt++;
    }

    //--------flush操作--------------
    if (isStopLoop == 0)
    {
        if (picture_current)
        {
            is_need_flush = picture_current->m_picture_frame.m_h264_slice_header.m_nal_unit.IdrPicFlag; //当前已解码完毕的帧是否是IDR帧
            ret = do_callback(picture_current, pictures_gop, is_need_flush); //回调操作
            //RETURN_IF_FAILED(ret != 0, ret);
        }

        if (ret == 0)
        {
            is_need_flush = 1;
            ret = do_callback(NULL, pictures_gop, is_need_flush); //最后再回调一次
            //RETURN_IF_FAILED(ret != 0, ret);
        }
    }

    //----------再回调一次空帧，表示解码结束---------------
    int errorCode = H264_DECODE_ERROR_CODE_FILE_END;
    ret = m_qt_output_frame_callback(NULL, m_userData, errorCode);
    //--------------------
    SAFE_DELETE(pictures_gop);
    return ret;
}

int H264VideoDecoderToQImage::do_callback(CH264Picture *picture_current, CH264PicturesGOP *pictures_gop, int32_t is_need_flush)
{
    int ret = 0;
    CH264Picture * outPicture = NULL;
    int errorCode = 0;

    if (is_need_flush) //说明当前已解码完毕的帧是IDR帧
    {
        while(1)
        {
            ret = pictures_gop->getOneOutPicture(NULL, outPicture); //flush操作
            RETURN_IF_FAILED(ret != 0, ret);
            if (outPicture != NULL)
            {
                if (m_qt_output_frame_callback != NULL)
                {
                    ret = m_qt_output_frame_callback(outPicture, m_userData, errorCode); //当找到可输出的帧时，主动通知外部用户
                    if (ret != 0)
                    {
                        return -1; //直接退出
                    }
                }
                outPicture->m_is_in_use = 0; //标记为闲置状态，以便后续回收重复利用
            }
            else //if (outPicture == NULL) //说明已经flush完毕，DPB缓存中已经没有可输出的帧了
            {
                break;
            }
        }
    }

    //-----------------------------------------------------------------------
    ret = pictures_gop->getOneOutPicture(picture_current, outPicture);
    RETURN_IF_FAILED(ret != 0, ret);

    if (outPicture != NULL)
    {
        if (m_qt_output_frame_callback != NULL)
        {
            ret = m_qt_output_frame_callback(outPicture, m_userData, errorCode); //当找到可输出的帧时，主动通知外部用户
            if (ret != 0)
            {
                return -1; //直接退出
            }
        }
        outPicture->m_is_in_use = 0; //标记为闲置状态，以便后续回收重复利用
    }
    return 0;
}
qt5_qt6
关注
  • 0
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
QT组播发送H264文件并接收FFMPEG解析播放
01-02
基于QT与VS2010创建工程，调用QT中的UDP创建组播发送端，读取H.264文件，以每秒25帧发送。在组播接收端接收到数据后，调用FFMPEG库解析H.264数据流，并在QT界面实时显示。
C++ 解析H264文件
12-21
C++ 解析H264文件.vs2012
在qt里面使用ffmpeg播放h264
yfkyfk521的专栏
05-11 1097
使用其他人的demo，在我的系统里移植成功了，改了诸多编译问题！ 待补充！
基于QT和FFmpeg开发流媒体播放器对H.264码流进行解码播放
qq_37933895的博客
08-23 2804
1.上位机界面展示 双击最大化 三通道同步 截图 2.QFFmpeg类 解码相关 #ifndef QFFMPEG_H #define QFFMPEG_H //必须加以下内容,否则编译不能通过,为了兼容C和C99标准 #ifndef INT64_C #define INT64_C #define UINT64_C #endif //引入ffmpeg头文件 //由于我们建立的是C++...
C C++最新H264 编解码协议详解_h264编解码流程框图，2024年最新看这篇文章准没错
最新发布
2401_84976110的博客
05-15 747
H264 原始码流是由一个接一个 NALU（NAL Unit） 组成，它的功能分为两层，VCL（Video Coding Layer）视频编码层和 NAL（Network Abstraction Layer）网络提取层。NAL是 H.264 为适应网络传输应用而制定的一层数据打包操作。传统的视频编码算法编完的视频码流在任何应用领域下（无论用于存储、传输等）都是统一的码流模式，视频码流仅有视频编码层 VCL（Video Coding Layer）。
基于qt和ffmpeg视频播放器开发实战
11-09
ffmpeg是世界上应用广的开源视频处理框架，在各个平台（windows，linux，嵌入式、Android、IOS）被广泛应用，可以说是做视频相关项目技能qt是目前跨平台项目界面开发的第一选择，本课程基于这两种框架在加上VC++，给大家讲解延时如何开发出一个视频播放器，各个模块如何结合，如何考虑性能问题，如何设计封装类，如何处理各种异常情况。
适用于低配机器，从USB摄像头拉H264流的Qt播放器
回头太难
07-25 2385
解决方案：dshow拉H264流+h264_qsv硬解码+d3d渲染 一拉H264流 最近发现FFmpeg不支持从USB摄像头拉H264，只能拉到MJPEG流。而MJPEG流又不能用来推流，目测只能用H264推流。所以下面直接用DirectShow拉H264流。 dshow的用法可以参考msdn和amcap源码。 这里我创建了个CaptureWorker类，继承ISampleGrabberCB。这样就能在回调函数BufferCB中拿到H264数据包。 class CaptureVideo :..
H264视频解码器C++工程说明
jfu22的专栏
02-15 7210
为了弄清楚H264整个解码流程，
QT C++ ffmpeg 调用usb 摄像头显示 并录制 H264录制视频
03-21
通过以上步骤，你就能在QT C++环境中利用FFmpeg调用USB摄像头，显示视频流，并以H264编码保存为MP4格式的视频文件。这个过程涉及了多媒体处理、多线程编程、文件I/O和编码解码等多个方面的知识，对于深入理解QT和...
QT与VS2010开发QT组播发送H264文件并接收FFMPEG解析播放
10-31
在这个项目中，我们将探讨如何使用QT和VS2010协同工作，实现H264视频文件的组播发送，并通过FFmpeg进行接收和解析播放。H264是一种高效的视频编码标准，广泛应用于高清视频传输。FFmpeg是一个开源的多媒体处理工具，...
QT FFMPEG播放H264
01-09
在自定义的QIODevice中，我们需要重载read()和seek()等方法，以便FFmpeg能正确解析H264数据。这里的关键是使用FFmpeg的AVFormatContext、AVPacket和AVFrame等结构体来处理视频流。首先，初始化AVFormatContext并调用...
网络接收H264视频数据并通过FFmpeg实时播放视频
12-10
client和server通过WiFi连接。传输视频数据必须为H264视频数据。 Client文件夹下包含无线网络发送H264视频帧信息。 Server包含无线网络接收H264视频帧信息。 FFmpegAndroid-master包含无线网接收H264视频数据，将数据以队列的时候接收下来，每个队列节点是10K，接收并实时通过FFmpeg解析，再画图播放，同时包含日志调试部分，将日志以文件的形式保存在设备内，USB部分需要网上查资料调试，目前USB也通了。
Qt基于FFmpeg解码本地视频生成 H.264文件并播放
01-14
视频解码的代码写在fdecode中 详见我的博客：https://blog.csdn.net/hml111666/article/details/122485955
基于Qt的摄像头采集数据和264编码，并写入本地文件，可播放
01-11
基于Qt，使用x264对摄像头采集数据进行264编码并将其写入本地文件，可播放。调试麻烦先修改.pro文件中ffmpeg和x264库的动态链接库和文件包含路径
Qt基于FFmpeg播放本地 H.264（H264）文件
07-19
详见我的博客：http://blog.csdn.net/caoshangpa/article/details/51953208
c++下H264编码以及解码的例子
06-06
VC6.0下的h264编码以及解码
Qt基于FFmpeg读取摄像头并进行H264编码
01-20
在本文中，我们将深入探讨如何使用Qt5结合FFmpeg库来读取摄像头视频流，并进行H264编码。这是一个涉及多媒体处理、图形界面编程以及音视频编解码的复杂任务，对于理解和开发相关应用非常有帮助。 首先，我们要了解...
Qt结合FFmpeg解码本地视频生成.h264文件和.yuv文件
似末的博客
01-14 3368
Qt结合FFmpeg解码本地视频生成.h264文件和.yuv文件。一个视频包含有音频流、视频流、字幕流等信息，本文为视频流的解码过程以及代码实现。
Qt结合FFmpeg转码码流数据（h264）生成不同视频格式（mp4、mov、flv、avi等）
似末的博客
02-08 4616
Qt结合FFmpeg转码码流数据（h264）生成不同视频格式（mp4、mov、flv、avi等），也可以将不同封装格式的视频转换成其他封装格式，例如将mp4格式的视频转成mov格式的视频。
qt 怎么将一帧H264数据保存成图片并显示出来
05-27
要将一帧 H264 数据保存成图片并显示出来，需要先将 H264 数据解码成图像，然后再将图像保存成图片并显示出来。以下是一些简要的步骤： 1. 使用 FFmpeg 或其他的 H264 解码库将 H264 数据解码成 YUV 或 RGB 格式的图像。 2. 将 YUV 或 RGB 格式的图像转换成 Qt 支持的 QImage 对象。 3. 使用 QImage 对象的 save() 方法将图像保存成图片。 4. 使用 QLabel 或其他的控件显示保存的图片。 下面是一个简单的代码示例，假设 H264 数据已经存储在 QByteArray 对象中： ``` #include <QImage> #include <QLabel> // 解码 H264 数据并将图像保存成图片 void saveH264Frame(const QByteArray &h264Data, const QString &filename) { // 使用 FFmpeg 或其他的 H264 解码库将 H264 数据解码成 YUV 或 RGB 格式的图像 // ... // 将 YUV 或 RGB 格式的图像转换成 Qt 支持的 QImage 对象 QImage image(width, height, QImage::Format_RGB888); image.fill(Qt::black); for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { int i = y * width + x; int r = yuvData[i] + 1.402 * (yuvData[width*height + (y/2)*(width/2) + (x/2)] - 128); int g = yuvData[i] - 0.34414 * (yuvData[width*height + (y/2)*(width/2) + (x/2)] - 128) - 0.71414 * (yuvData[width*height + (y/2)*(width/2) + (x/2) + width/2] - 128); int b = yuvData[i] + 1.772 * (yuvData[width*height + (y/2)*(width/2) + (x/2) + width/2] - 128); image.setPixelColor(x, y, QColor(r, g, b)); } } // 使用 QImage 对象的 save() 方法将图像保存成图片 image.save(filename); // 使用 QLabel 或其他的控件显示保存的图片 QLabel *label = new QLabel(); label->setPixmap(QPixmap::fromImage(image)); label->show(); } ``` 请注意，这只是一个简单的示例，实际情况可能会更加复杂，例如需要处理 H264 数据的帧率、分辨率等信息，以及处理 YUV 或 RGB 数据的颜色空间转换等问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

qt5_qt6

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

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

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

打赏作者

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

抵扣说明：

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

余额充值