分离h265/h264裸流的帧

最新推荐文章于 2024-07-24 10:55:08 发布
最新推荐文章于 2024-07-24 10:55:08 发布
阅读量3.1k 收藏 5
点赞数 2
分类专栏： 嵌入式开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/codeheng/article/details/65630729
版权

1、此模块分离h265/h264裸流的帧

#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>
#include <assert.h>
#include <pthread.h>
#include <unistd.h>

typedef int (*video_frame_cb)(int stream, char *frame, unsigned long len, int key, double pts);

typedef struct split_frame_s
{
    unsigned char buffer[1*1024*1024];
    unsigned char dst[1*1024*1024];
    unsigned char idr[1*1024*1024];
    int idr_len;
    unsigned char vps[128]; //only h265
    int vps_len;
    unsigned char sps[128];
    int sps_len;
    unsigned char pps[128];
    int pps_len;
    unsigned char sei[128];
    int sei_len;
    FILE* fp;
    int file_type; // 0->264, 1->265
    video_frame_cb frame_cb;
    double pts;

    int running;
    pthread_t pid;
}split_frame_s;

static split_frame_s g_arg;

int split_frame_264(unsigned char* src, int s_len, int* r_len, unsigned char* dst, int* len)
{
    *r_len = 0;
    *len = 0;
    int i = 0;
    int j = 0;
    int valid = 0;
    for (i = 0; i < s_len; i++)
    {
        if (i+3 < s_len && src[i] == 0 && src[i+1] == 0 && src[i+2] == 0 && src[i+3] == 1)
        {
            //printf("%d %02x %02x %02x %02x %02x %02x\n", __LINE__, src[i], src[i+1], src[i+2], src[i+3], src[i+4], src[i+5]);
            for (j = i+3; j < s_len; j++)
            {
                if (j+3 < s_len && src[j] == 0 && src[j+1] == 0 && src[j+2] == 0 && src[j+3] == 1)
                {
                    //printf("%d %02x %02x %02x %02x %02x %02x\n", __LINE__, src[j], src[j+1], src[j+2], src[j+3], src[j+4], src[j+5]);
                    valid = 1;
                    break;
                }
            }
            break;
        }
    }

    if (valid)
    {
        memcpy(dst, src+i, j-i);
        *len = j -i;
        *r_len = j;
    }

    return 0;
}

/*
src: input sources
s_len: input sources length
r_len: output handled length
dst: destination
len: destination length
*/
int split_frame_265(unsigned char* src, int s_len, int* r_len, unsigned char* dst, int* len)
{
    *r_len = 0;
    *len = 0;
    int i = 0;
    int j = 0;
    int valid = 0;
    for (i = 0; i < s_len; i++)
    {
        if (i+5 < s_len && src[i] == 0 && src[i+1] == 0 && src[i+2] == 0 && src[i+3] == 1 && src[i+5] == 1)
        {
            //printf("%d %02x %02x %02x %02x %02x %02x\n", __LINE__, src[i], src[i+1], src[i+2], src[i+3], src[i+4], src[i+5]);
            for (j = i+3; j < s_len; j++)
            {
                if (j+5 < s_len && src[j] == 0 && src[j+1] == 0 && src[j+2] == 0 && src[j+3] == 1 && src[j+5] == 1)
                {
                    //printf("%d %02x %02x %02x %02x %02x %02x\n", __LINE__, src[j], src[j+1], src[j+2], src[j+3], src[j+4], src[j+5]);
                    valid = 1;
                    break;
                }
            }
            break;
        }
    }

    if (valid)
    {
        memcpy(dst, &src[i], j-i);
        *len = j -i;
        *r_len = j;
    }

    return 0;
}

void* split_frame_proc(void* arg)
{
    int r_len = 0;
    int d_len = 0;
    int writable = 0;

    while (g_arg.running)
    {
        int n = fread(g_arg.buffer+writable, 1, sizeof(g_arg.buffer)-writable, g_arg.fp);
        if (n > 0)
        {
            writable += n;
        }

        if (writable > 0)
        {
            if (g_arg.file_type)
            {
                split_frame_265(g_arg.buffer, writable, &r_len, g_arg.dst, &d_len);
                if (r_len > 0 && d_len > 0)
                {
                    memmove(g_arg.buffer, g_arg.buffer+r_len, sizeof(g_arg.buffer)-r_len);
                    writable = sizeof(g_arg.buffer)-r_len;
                    printf("%d %02x %02x %02x %02x %02x %02x, len: %d\n", __LINE__, g_arg.dst[0], g_arg.dst[1], g_arg.dst[2], g_arg.dst[3], g_arg.dst[4], g_arg.dst[5], d_len);

                    if (g_arg.dst[4] == 0x40)
                    {
                        memset(g_arg.vps, 0, sizeof(g_arg.vps));
                        memcpy(g_arg.vps, g_arg.dst, d_len);
                        g_arg.vps_len = d_len;
                    }
                    if (g_arg.dst[4] == 0x42)
                    {
                        memset(g_arg.sps, 0, sizeof(g_arg.sps));
                        memcpy(g_arg.sps, g_arg.dst, d_len);
                        g_arg.sps_len = d_len;
                    }
                    if (g_arg.dst[4] == 0x44)
                    {
                        memset(g_arg.pps, 0, sizeof(g_arg.pps));
                        memcpy(g_arg.pps, g_arg.dst, d_len);
                        g_arg.pps_len = d_len;
                    }
                    if (g_arg.dst[4] == 0x4e)
                    {
                        memset(g_arg.sei, 0, sizeof(g_arg.sei));
                        memcpy(g_arg.sei, g_arg.dst, d_len);
                        g_arg.sei_len = d_len;
                    }
                    if (g_arg.dst[4] == 0x26)
                    {
                        memset(g_arg.idr, 0, sizeof(g_arg.idr));
                        memcpy(g_arg.idr, g_arg.dst, d_len);
                        g_arg.idr_len = d_len;
                    }
                    if (g_arg.frame_cb && g_arg.dst[4] == 0x26)
                    {
                        memset(g_arg.dst, 0, sizeof(g_arg.dst));
                        int idx = 0;

                        memcpy(g_arg.dst+idx, g_arg.vps, g_arg.vps_len);
                        idx += g_arg.vps_len;
                        printf("%d len: %d\n", __LINE__, idx);
                        memcpy(g_arg.dst+idx, g_arg.sps, g_arg.sps_len);
                        idx += g_arg.sps_len;
                        printf("%d len: %d\n", __LINE__, idx);
                        memcpy(g_arg.dst+idx, g_arg.pps, g_arg.pps_len);
                        idx += g_arg.pps_len;
                        printf("%d len: %d\n", __LINE__, idx);
/*
                        memcpy(g_arg.dst+idx, g_arg.sei, g_arg.sei_len);
                        idx += g_arg.sei_len;
                        printf("%d len: %d\n", __LINE__, idx);
*/
                        memcpy(g_arg.dst+idx, g_arg.idr, g_arg.idr_len);
                        idx += g_arg.idr_len;
                        printf("%d len: %d\n", __LINE__, idx);

                        g_arg.frame_cb(0, (char*)g_arg.dst, idx, 1, g_arg.pts);
                        //g_arg.frame_cb(1, (char*)g_arg.dst, idx, 1, g_arg.pts);
                        g_arg.pts += 40;
                    }
                    else if (g_arg.frame_cb && g_arg.dst[4] == 0x02)
                    {
                        g_arg.frame_cb(0, (char*)g_arg.dst, d_len, 0, g_arg.pts);
                        //g_arg.frame_cb(1, (char*)g_arg.dst, d_len, 0, g_arg.pts);
                        g_arg.pts += 40;
                    }
                }
            }
            else
            {
                split_frame_264(g_arg.buffer, writable, &r_len, g_arg.dst, &d_len);
                if (r_len > 0 && d_len > 0)
                {
                    memmove(g_arg.buffer, g_arg.buffer+r_len, sizeof(g_arg.buffer)-r_len);
                    writable = sizeof(g_arg.buffer)-r_len;
                    printf("%d %02x %02x %02x %02x %02x, len: %d\n", __LINE__, g_arg.dst[0], g_arg.dst[1], g_arg.dst[2], g_arg.dst[3], g_arg.dst[4], d_len);

                    if (g_arg.dst[4] == 0x67)
                    {
                        memset(g_arg.sps, 0, sizeof(g_arg.sps));
                        memcpy(g_arg.sps, g_arg.dst, d_len);
                        g_arg.sps_len = d_len;
                    }
                    if (g_arg.dst[4] == 0x68)
                    {
                        memset(g_arg.pps, 0, sizeof(g_arg.pps));
                        memcpy(g_arg.pps, g_arg.dst, d_len);
                        g_arg.pps_len = d_len;
                    }
                    if (g_arg.dst[4] == 0x06)
                    {
                        memset(g_arg.sei, 0, sizeof(g_arg.sei));
                        memcpy(g_arg.sei, g_arg.dst, d_len);
                        g_arg.sei_len = d_len;
                    }
                    if (g_arg.dst[4] == 0x65)
                    {
                        memset(g_arg.idr, 0, sizeof(g_arg.idr));
                        memcpy(g_arg.idr, g_arg.dst, d_len);
                        g_arg.idr_len = d_len;
                    }
                    if (g_arg.frame_cb && g_arg.dst[4] == 0x65)
                    {
                        memset(g_arg.dst, 0, sizeof(g_arg.dst));
                        int idx = 0;

                        memcpy(g_arg.dst+idx, g_arg.sps, g_arg.sps_len);
                        idx += g_arg.sps_len;
                        printf("%d len: %d\n", __LINE__, idx);
                        memcpy(g_arg.dst+idx, g_arg.pps, g_arg.pps_len);
                        idx += g_arg.pps_len;
                        printf("%d len: %d\n", __LINE__, idx);
                        memcpy(g_arg.dst+idx, g_arg.sei, g_arg.sei_len);
                        idx += g_arg.sei_len;
                        printf("%d len: %d\n", __LINE__, idx);
                        memcpy(g_arg.dst+idx, g_arg.idr, g_arg.idr_len);
                        idx += g_arg.idr_len;
                        printf("%d len: %d\n", __LINE__, idx);

                        g_arg.frame_cb(0, (char*)g_arg.dst, idx, 1, g_arg.pts);
                        //g_arg.frame_cb(1, (char*)g_arg.dst, idx, 1, g_arg.pts);
                        g_arg.pts += 40;
                    }
                    else if (g_arg.frame_cb && g_arg.dst[4] == 0x61)
                    {
                        g_arg.frame_cb(0, (char*)g_arg.dst, d_len, 0, g_arg.pts);
                        //g_arg.frame_cb(1, (char*)g_arg.dst, d_len, 0, g_arg.pts);
                        g_arg.pts += 40;
                    }
                }
            }
        }

        if (feof(g_arg.fp))
        {
            fseek(g_arg.fp , 0L, SEEK_SET);
        }

        usleep(40*1000);
    }

    fclose(g_arg.fp);

    return 0;
}

int split_frame_init(const char* path, video_frame_cb frame_cb)
{
    g_arg.fp = fopen(path, "r");
    assert(g_arg.fp != NULL);

    g_arg.file_type = strstr(path, "265") ? 1 : 0;
    g_arg.frame_cb = frame_cb;

    g_arg.running = 1;
    pthread_create(&g_arg.pid, NULL, split_frame_proc, NULL);

    return 0;
}

int split_frame_exit()
{
    if (g_arg.running)
    {
        g_arg.running = 0;
        pthread_join(g_arg.pid, NULL);
    }

    if (g_arg.fp)
    {
        fclose(g_arg.fp);
    }

    return 0;
}

// test
/*
int main(int argc, char** argv)
{
    if (argc != 2)
    {
        printf("Usage: %s [file]\n", argv[0]);
        printf("sample: %s hik.265\n", argv[0]);
        printf("sample: %s hik.264\n", argv[0]);
        return 0;
    }

    split_frame_init(argv[1]);
    getchar();

    return 0;
}
*/
CodeHeng
关注
专栏目录
H264和H265的学习笔记
qq_50635297的博客
03-10 2564
(2)在每个IDR关键帧前都会有SPS,PPS,等NALU，因此将SPS,PPS,IDR的NALU封装成一个PS包，其包 结构如下：PS包 = PS header + PS system header + PS system map + PES header + h264 raw data。(5)、h264 raw data：h264原始数据以SPS(序列参数集)00 00 00 01 67开始，其中包括SPS(67)、PPS(68)、SEI(06)、 IDE(65)、P帧(61)等。
h264裸流h265裸流各一份
01-25
用ffmpeg将h264转为h265流的Demo，一个关键帧的流。 ffmpeg -i video/I.264 video/I265.hevc 播放分析 选 H264BSAnalyzer
深入学习H264和H265
最新发布
weixin_73901182的博客
07-24 1054
在开始学习H264/H265之前，我们要先了解一些和视频相关的专业名词Level（级别）指定视频编码的最大能力，如最大分辨率、最大帧率等。NAL Unit（网络抽象层单元）视频编码流中的最小可访问单元，用于传输和解码。Slice（片）视频帧的一部分，可以独立解码，用于错误恢复和并行处理。Macroblock（宏块）编码的基本单元，通常为16x16像素的块，用于运动估计和预测。Intra Frame（I帧）不依赖其他帧进行解码的帧，通常用于随机访问点。
分解264/265裸流的帧
CodeHeng的专栏
01-04 1259
也可直接分解avi文件格式的#include <sys/types.h> #include <sys/stat.h> #include <errno.h> #include <fcntl.h> #include <stdio.h> #include <stdlib.h> #include <limits.h> #include <string.h> #include <assert.h> int s
《音视频：从h264裸流数据中提取各NALU单元》
qq_40709487的博客
12-03 472
本文旨在将h264裸流数据分解成一个个NALU单元，以便后续对每一个NALU单元进行RTP封包将其发送出去。h264裸流数据中一般以“00 00 00 01”或者“00 00 01”来分隔NALU单元，所有要做的就是识别到这两种头，将两个头之间的所需要的NALU数据提取出来。直接上代码。
将视频文件的每一帧都拆分成一个独立的文件（提取文件中的所有关键帧）
NewPtone的博客
04-09 1186
将某一个视频文件的每一帧都拆分出来保存成一个独立的文件，如果需要修改I帧，则可以通过FFmpeg修改文件的GOP大小，命令行如下： ffmpeg -i video.mp4 -g 10 gop10.mp4 再提取之前需要先做一件事，那就是需要将视频文件改为ES流： ffmpeg -i gop10.mp4 -vcodec copy -an -f rawvideo -vbsf h264_mp4...
H264播放分析工具及RGB/YUV裸流播放软件
03-26
本主题将围绕"H264播放分析工具及RGB/YUV裸流播放软件"进行深入探讨。 首先，H264播放涉及到视频解码过程。H264编码的视频数据需要通过特定的解码器转换回原始的像素数据，以便显示在屏幕上。这个过程包括熵解码、...
H.265与H.264的区别详解
yinshipin007的博客
12-14 5241
H.265仍然采用混合编解码，编解码结构域H.264基本一致，主要的不同在于：Ø 编码块划分结构：采用CU (CodingUnit)、PU(PredictionUnit)和TU(TransformUnit)的递归结构。Ø 基本细节：各功能块的内部细节有很多差异Ø 并行工具：增加了Tile以及WPP等并行工具集以提高编码速度Ø 滤波器：在去块滤波之后增加了SAO（sample adaptive offset）滤波模块Fig.H.265的框架图。
Android H264数据解帧和播放.zip
06-02
在Android中，处理H264数据的第一步是“解帧”或“分离”。这涉及到从连续的字节流中识别并提取NAL单元。每个NAL单元的开始通常由一个起始码标识，如0x000001或0x00000001。通过查找这些起始码，我们可以将字节流...
h265和yuv分析工具
09-15
在数字视频编码领域，H265（High Efficiency Video Coding，高效视频编码）是当前广泛使用的标准，它显著提升了视频压缩效率，相比之前的H264标准，能在同样的画质下降低大约50%的数据量。H265（也称为HEVC）通过更...
H.265裸码流测试文件
08-31
H.265裸码流文件，用于编解码测试、对比。 x265 [info]: frame I: 2, Avg QP:8.00 kb/s: 299.92 x265 [info]: frame P: 26, Avg QP:11.00 kb/s: 99.16 x265 [info]: frame B: 71, Avg QP:12.66 kb/s: 13.47 x265 [info]: Weighted P-Frames: Y:0.0% UV:0.0% x265 [info]: consecutive B-frames: 10.7% 3.6% 7.1% 78.6% 0.0% encoded 99 frames in 2.58s (38.39 fps), 41.76 kb/s, Avg QP:12.13
h265码流文件
10-20
通过ipc来获取的h265编码文件，可以通过牛奶播放器播放。供开发过程使用。
h265 裸流文件h265 裸流文件h265 裸流文件
10-09
h265裸流文件，h265视频，h265编解码 h265裸流文件，h265视频，h265编解码
H264\H265裸码流提取工具
02-11
1、可以从多种封装格式的视频文件中提取相应的视频裸码流，需要注意的是：目前只支持提取视频裸数据，不支持提取音频裸数据。 2、有bug请留言反馈； 3、可以完善的功能也请留言反馈
H.265裸流文件
04-02
该文件为标准H.265编码的裸流文件，可用于刚接触H.265编解码的同学做测试用。暴风影音可以解码播放。
基于TCP传输的H264流解码和播放
06-15
本主题聚焦于“基于TCP传输的H264流解码和播放”，这涉及到多个核心知识点，包括H264编码标准、TCP传输协议以及视频流的解码与播放流程。 首先，H264，全称ITU-T H.264或MPEG-4 Part 10，是一种高效的视频压缩标准...
纯C读取文件实现解析H264裸流每一帧数据
huntenganwei的博客
11-30 1579
imx的例程是设置一个大的缓冲区，一次性读入不超过10M字节数据，然后全部送到解码器进行解码，对于小于10M字节的视频数据确实很方便的解码了，但是文件大了这种方式就不行了。首先分析下H264裸流文件，发现每一帧数据的起始码是00 00 00 01，那么就可以利用这个起始码来拆分每一帧数据。代码很简单，就是持续读取文件，碰到00 00 00 01则表示一帧读完，然后把这一帧数据送到解码器处理即可。还有一种处理方式是使用FFMpeg来读取每一帧数据，然后送入解码器，是可行的。
【开源工程】之裸码流提取工具--H264/H265
walkingMa的专栏
10-06 3413
序 工程中常常需要分析一些码流，码流文件过大，不利于分析具体的帧数据，由此编写了码流提取软件。 1 下载地址 https://download.csdn.net/download/listener51/10703683 2 软件截图 1.码流拖曳到软件中显示如下： 2. 在某帧上右击保存裸码流如图： 支持ctrl 或 shift 鼠标多选的形式 目前试用版只支持保存前50帧码流。 2. ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值