H264/H265 NALU 起始码搜索性能优化(1)

已于 2024-02-07 15:25:23 修改
阅读量378 收藏 2
点赞数 2
分类专栏： c++开发 视频技术 文章标签： ffmpeg h264 h265 nalu 起始码 性能优化
于 2022-12-10 17:55:40 首次发布
原创作品 版权所有 不得转载
本文链接：https://blog.csdn.net/bluestn/article/details/128267176
版权

在ffmpeg中，在进行h264 rbsp流demux的时候，需要进行starting code的搜索，其采用的方法比较简单，就是不断比较字节流中连续的三个字节，是不是 0x00, 0x00, 0x01，ffmpeg采用如下代码用来找到各个NALU的分界点：

static int find_next_start_code(const uint8_t *buf, const uint8_t *next_avc)
{

    int i = 0;

    if (buf + 3 >= next_avc)

        return next_avc - buf;

    while (buf + i + 3 < next_avc) {

        if (buf[i] == 0 && buf[i + 1] == 0 && buf[i + 2] == 1)
            break;

        i++;

    }
    return i + 3;
}

这种方法比较传统，一般来说如果对于性能没有特别的要求，是能够很好满足要求了。

按照ffmpeg的算法，搜索一个内存块中的所有H264 NALU的起始码，并将起始码的位置写入nalu_borders数组中，写出来的代码如下，整个逻辑简单明了：

vector<int> split_simd_ffmpeg(const uint8_t *data, size_t cb)
{
    const uint8_t *p = data;

    const uint8_t *e = data + cb;

    vector<int> list_index;

    while (p < e -3){
        if (p[0] == 0 && p[1] == 0 && p[2] == 1){
            list_index.emplace_back(p - data);
        }
        p++;
    }

    return list_index;
}

本文提出一种更高效的starting code的搜索算法：

void split_nalu(char *video_data, int size,  std::vector<int> &nalu_borders)
{

    while(index + 8 <= (size_t)size){

        uint64_t code = *(uint64_t*)(video_data+index);

        if ((code & 0xFFFFFFull) == 0x010000ull){
            nalu_borders.emplace_back(index);
            index += 3;
            continue;
        }
                    
        if ((code & 0xFFFFFF00ull) == 0x01000000ull){
            nalu_borders.emplace_back(index+1);
            index += 4;
            continue;
        }

                    
        if ((code & 0xFFFFFF0000ull) == 0x0100000000ull){
            nalu_borders.emplace_back(index+2);
            index += 5;
            continue;
        }
                    
        if (((code & 0xFFFFFF000000ull) == 0x010000000000ull){
            nalu_borders.emplace_back(index+3);
            index += 6;
            continue;
        }

        if ((code & 0xFFFFFF00000000ull) ==  0x01000000000000ull){
            nalu_borders.emplace_back(index+4);
            index += 7;
            continue;
        }

        if ((code & 0xFFFFFF0000000000ull) ==  0x0100000000000000ull){
            nalu_borders.emplace_back(index+5);
            index += 8;
            continue;
        }

        if ((code & 0xFFFF000000000000ull) ==  0x0ull){
            index += 6;
        }else if ((code & 0xFF00000000000000ull) ==  0x0ull){
            index += 7;
        }
        else{
            index += 8;
        }
    }

    while(index + 4 < (size_t)size){

        uint32_t code = *(uint64_t*)(video_data+index);

        if ((code & 0x00FFFFFFu) == 0x00010000u){
            nalu_borders.emplace_back(index);
            index += 3;
            continue;
        }

        index++;
    }
}

看上去代码复杂了很多，但是实际测试结果，对比ffmpeg的搜索算法，在x64的CPU的机器上面，性能至少提升了30%。

本算法利用了64位的寄存器预先读取8个字节，然后在循环提内通过掩码与操作进行比对，一个循环中对8个字节进行264起始码的搜索，相比ffmpeg需要不断从内存中load，然后逐字节比对来说，使得搜索性能得到了显著提升。毕竟寄存器的性能远比内存的读写性能要强多了！而且在一个循环里面可以通过编译器和CPU的优化进行指令的多路并发执行。

然后最近几天拼命想利用SIMD优化指令进行搜索的算法，好不容易熟悉了simd的几个指令，调试了老半天，终于写出来如下代码：

    const uint8_t mask_1[32] = { 0xFF, 0xFF, 0xFF, 0x00,
                                 0xFF, 0xFF, 0xFF, 0x00,  
                                 0xFF, 0xFF, 0xFF, 0x00,  
                                 0xFF, 0xFF, 0xFF, 0x00  };

    const uint8_t dest_1[32] = { 0, 0, 1, 0,   0, 0, 1, 0,
                                 0, 0, 1, 0,   0, 0, 1, 0 };


    const uint8_t mask_2[32] = { 0x00, 0xFF, 0xFF, 0xFF,
                                 0x00, 0xFF, 0xFF, 0xFF,
                                 0x00, 0xFF, 0xFF, 0xFF,
                                 0x00, 0xFF, 0xFF, 0xFF,};

    const uint8_t dest_2[32] = { 0, 0, 0, 1,   0, 0, 0, 1,
                                 0, 0, 0, 1,   0, 0, 0, 1};

vector<int> split_nalu_simd(const uint8_t *video_data, size_t size)
{
    size_t index = 0;
    vector<int> list_index;
    
    op_data od;

    size_t next_block = 31;

    while(index + 16 <= (size_t)size){
        
        __m128i src  = _mm_load_si128((__m128i*)(video_data+index));
        __m128i mask = _mm_load_si128((__m128i*)od.mask_1);
        __m128i dest = _mm_load_si128((__m128i*)od.dest_1);
        __m128i tmp  = _mm_and_si128(src, mask);
        __m128i tmp2 = _mm_cmpeq_epi32(tmp, dest);

        if (_mm_extract_epi32(tmp2, 0) == 0xFFFFFFFFu){
            list_index.emplace_back(index);
        }
        
        if (_mm_extract_epi32(tmp2, 1) == 0xFFFFFFFFu){
            list_index.emplace_back(index + 4);
        }
        
        if (_mm_extract_epi32(tmp2, 2) == 0xFFFFFFFFu){
            list_index.emplace_back(index + 8);
        }
        
        if (_mm_extract_epi32(tmp2, 3) == 0xFFFFFFFFu){
            list_index.emplace_back(index + 12);
        }



        mask = _mm_load_si128((__m128i*)od.mask_2);
        dest = _mm_load_si128((__m128i*)od.dest_2);
        tmp  = _mm_and_si128(src, mask);
        tmp2 = _mm_cmpeq_epi32(tmp, dest);

        if (_mm_extract_epi32(tmp2, 0) == 0xFFFFFFFFu){
            list_index.emplace_back(index + 1);
        }
        
        if (_mm_extract_epi32(tmp2, 1) == 0xFFFFFFFFu){
            list_index.emplace_back(index + 5);
        }
        
        if (_mm_extract_epi32(tmp2, 2) == 0xFFFFFFFFu){
            list_index.emplace_back(index + 9);
        }
        
        if (_mm_extract_epi32(tmp2, 3) == 0xFFFFFFFFu){
            list_index.emplace_back(index + 13);
        }


        src = _mm_srli_si128(src, 2);

        mask = _mm_load_si128((__m128i*)od.mask_1);
        dest = _mm_load_si128((__m128i*)od.dest_1);
        tmp  = _mm_and_si128(src, mask);
        tmp2 = _mm_cmpeq_epi32(tmp, dest);

        if (_mm_extract_epi32(tmp2, 0) == 0xFFFFFFFFu){
            list_index.emplace_back(index + 2);
        }
        
        if (_mm_extract_epi32(tmp2, 1) == 0xFFFFFFFFu){
            list_index.emplace_back(index + 6);
        }
        
        if (_mm_extract_epi32(tmp2, 2) == 0xFFFFFFFFu){
            list_index.emplace_back(index + 10);
        }


        mask = _mm_load_si128((__m128i*)od.mask_2);
        dest = _mm_load_si128((__m128i*)od.dest_2);
        tmp  = _mm_and_si128(src, mask);
        tmp2 = _mm_cmpeq_epi32(tmp, dest);


        if (_mm_extract_epi32(tmp2, 0) == 0xFFFFFFFFu){
            list_index.emplace_back(index + 3);
        }
        
        if (_mm_extract_epi32(tmp2, 1) == 0xFFFFFFFFu){
            list_index.emplace_back(index + 7);
        }
        
        if (_mm_extract_epi32(tmp2, 2) == 0xFFFFFFFFu){
            list_index.emplace_back(index + 11);
        }


        index += 16;
        uint32_t tail = _mm_extract_epi32(src, 3);



        if (tail == 0x0u){
            if (index + 1 <= size && video_data[index] == 0x01){
                list_index.emplace_back(index-2);
                continue;
            }
        }

        if ((tail & 0x0000FF00u) == 0x0u){
            if (index + 2 <= size && video_data[index] == 0x00 && video_data[index+1] == 0x01){
                list_index.emplace_back(index-1);
            }
        }
    }

    while(index + 4 < (size_t)size){

        uint32_t code = *(uint64_t*)(video_data+index);

        if ((code & 0x00FFFFFFu) == 0x00010000u){
            list_index.emplace_back(index);
            index += 3;
            continue;
        }

        index++;
    }    
    
    std::sort(list_index.begin(), list_index.end());

    return list_index;
}

但是测试下来的效果不太理想，大失所望，基本上和上面的split_nalu不相上下，应该是中间用了太多条件判断的分支，抵消了simd的优势，加上插入起始码位置的时候因为并不是按顺序插入的，需要在结尾处进行一次sort操作一定程度上会引起性能的降低，得不偿失。

感觉能够想到的方法还是split_nalu比较靠谱，也不是太复杂。

今天下午，突然来了灵感，修改了上面的simd的代码，减少了if条件判断分支，尽然性能提升1倍，开心！！！！

    const uint8_t mask_1[32] = { 0xFF, 0xFF, 0xFF, 0x00,
                                 0xFF, 0xFF, 0xFF, 0x00,  
                                 0xFF, 0xFF, 0xFF, 0x00,  
                                 0xFF, 0xFF, 0xFF, 0x00  };

    const uint8_t dest_1[32] = { 0, 0, 1, 0,   0, 0, 1, 0,
                                 0, 0, 1, 0,   0, 0, 1, 0 };


    const uint8_t mask_2[32] = { 0x00, 0xFF, 0xFF, 0xFF,
                                 0x00, 0xFF, 0xFF, 0xFF,
                                 0x00, 0xFF, 0xFF, 0xFF,
                                 0x00, 0xFF, 0xFF, 0xFF,};

    const uint8_t dest_2[32] = { 0, 0, 0, 1,   0, 0, 0, 1,
                                 0, 0, 0, 1,   0, 0, 0, 1};

vector<int> split_nalu_simd2(const uint8_t *video_data, size_t size)
{
    size_t index = 0;
    vector<int> list_index;
    
    op_data od;

    size_t next_block = 31;

    while(index + 16 <= (size_t)size){
        
        __m128i src  = _mm_load_si128((__m128i*)(video_data+index));
        __m128i mask = _mm_load_si128((__m128i*)od.mask_1);
        __m128i dest = _mm_load_si128((__m128i*)od.dest_1);
        __m128i tmp  = _mm_and_si128(src, mask);
        __m128i tmp2 = _mm_cmpeq_epi32(tmp, dest);
        
        int m = _mm_movemask_epi8(tmp2);
        if (m != 0){
            if (m & 0x0F){
                list_index.emplace_back(index);
            }
            
            if (m & 0xF0){
                list_index.emplace_back(index + 4);
            }
            
            if (m & 0xF00){
                list_index.emplace_back(index + 8);
            }
            
            if (m & 0xF000){
                list_index.emplace_back(index + 12);
            }
        }

        mask = _mm_load_si128((__m128i*)od.mask_2);
        dest = _mm_load_si128((__m128i*)od.dest_2);
        tmp  = _mm_and_si128(src, mask);
        tmp2 = _mm_cmpeq_epi32(tmp, dest);

        m = _mm_movemask_epi8(tmp2);
        if (m != 0){
            if (m & 0x0F){
                list_index.emplace_back(index + 1);
            }
            
            if (m & 0xF0){
                list_index.emplace_back(index + 5);
            }
            
            if (m & 0xF00){
                list_index.emplace_back(index + 9);
            }
            
            if (m & 0xF000){
                list_index.emplace_back(index + 13);
            }
        }

        src = _mm_srli_si128(src, 2);

        mask = _mm_load_si128((__m128i*)od.mask_1);
        dest = _mm_load_si128((__m128i*)od.dest_1);
        tmp  = _mm_and_si128(src, mask);
        tmp2 = _mm_cmpeq_epi32(tmp, dest);

        m = _mm_movemask_epi8(tmp2);
        if (m != 0){
            if (m & 0x0F){
                list_index.emplace_back(index + 2);
            }
            
            if (m & 0xF0){
                list_index.emplace_back(index + 6);
            }
            
            if (m & 0xF00){
                list_index.emplace_back(index + 10);
            }
        }

        mask = _mm_load_si128((__m128i*)od.mask_2);
        dest = _mm_load_si128((__m128i*)od.dest_2);
        tmp  = _mm_and_si128(src, mask);
        tmp2 = _mm_cmpeq_epi32(tmp, dest);

        m = _mm_movemask_epi8(tmp2);
        if (m != 0){
            if (m & 0x0F){
                list_index.emplace_back(index + 3);
            }
            
            if (m & 0xF0){
                list_index.emplace_back(index + 7);
            }
            
            if (m & 0xF00){
                list_index.emplace_back(index + 11);
            }
        }


        index += 16;
        uint32_t tail = _mm_extract_epi32(src, 3);



        if (tail == 0x0u){
            if (index + 1 <= size && video_data[index] == 0x01){
                list_index.emplace_back(index-2);
                continue;
            }
        }

        if ((tail & 0x0000FF00u) == 0x0u){
            if (index + 2 <= size && video_data[index] == 0x00 && video_data[index+1] == 0x01){
                list_index.emplace_back(index-1);
            }
        }
    }

    while(index + 4 < (size_t)size){

        uint32_t code = *(uint64_t*)(video_data+index);

        if ((code & 0x00FFFFFFu) == 0x00010000u){
            list_index.emplace_back(index);
            index += 3;
            continue;
        }

        index++;
    }    
    
    std::sort(list_index.begin(), list_index.end());

    return list_index;
}

关键是是通过_mm_movemask_epi8将前面比较的结果合并到一个int型的字段m中，然后直接判断m是否都为0，如果为0就可以直接掉过里面的分支逻辑了，大大减少了条件分支，从而提升了性能。

ps：

      需要提一下，如果没有开启-O3编译器优化，split_nalu_simd2比split_nalu版本性能差了一倍，开启以后则反回过了，虽然split_nalu性能也提升了，但是split_nalu_simd2提升非常明显。

     假设待编译的代码为test.cpp，那么用如下编译指令：

      g++ test.cpp -mavx2 -o test -g -O3

     -mavx2是必须要加的，否则编译器不能支持simd相关指令。

码农心语
关注
专栏目录
【论文解读】A Study on Multi-Screen Sharing System Using H.264/AVC Encoder
想都是问题，做才有答案～～
08-07 125
【论文解读】A Study on Multi-Screen Sharing System Using H.264/AVC Encoder
H264/H265 NALU 起始码搜索性能优化(2)
一个致力于开源代码学习、分析和交流的博客
12-21 230
H264 起始码查询smid优化方法。
H265编码
qq_33607245的博客
02-15 1564
参考文档1： 详细分析 HEVC/H265编码框架原理（入门）：https://blog.csdn.net/dong_daxia/article/details/82870838 参考文档2： 读书笔记——新一代高效视频编码H.265HEVC原理、标准与实现：https://blog.csdn.net/u012868357/article/details/79367508 ...
H.264区分NALU startCode和NALU 内部和startCode相同的内容
weixin_37515325的博客
12-06 314
H.264区分NALU startCode和NALU 内部和startCode相同的内容
《Android 音视频开发》笔记 - H.264编码
YK
09-30 712
H.264
H265格式
weixin_42226021的博客
03-31 8979
H265 1、H265一个图像序列的组成：VPS+SPS+PPS+SEI+一个I帧+若干个P帧。VPS、SPS、PPS、SEI、一个I帧、一个P帧都可以称 为一个NALU。 2、H265的NALU结构：开始码+NALU头+NALU数据 （1）、开始码大小为四个字节，是一个固定值00 00 00 01（十六进制），标识一个NALU的开始。 （2）、NALU头大小为两个字节，共16位，第1位值为0，第...
RTP_Protocol.rar_h.264 NALU_nalu_rfc3984_rtp 264
09-23
《RTP协议在H.264 NALU打包中的应用》 实时传输协议（RTP）是网络中广泛使用的协议，特别是在音频和视频流媒体应用中。它遵循Internet工程任务组（IETF）发布的rfc3550文档定义的标准，确保数据能够在不可靠的网络...
Android调用FFmpeg 拉rtsp流 获得h264原始压缩数据(Nalu数据)
04-17
在Android平台上，调用FFmpeg库来拉取RTSP流并获取H264原始压缩数据（NAL单元数据）是一项常见的任务，特别是在实时视频处理和流媒体应用...在实际开发中，还需要考虑错误处理、性能优化以及不同设备之间的兼容性问题。
H264裸流帧解码器
09-01
初始化阶段，解码器会设置必要的参数，比如H264编码流的起始点、解码器配置等。`Init`函数可能需要用户输入这些参数，以确保解码器能正确解析比特流。一旦初始化完成，就可以通过调用`H264toIplimage`函数，将接收到...
H264裸码流分析
05-13
例如，NAL头中的第一个字节，通常称为NALU起始码，其值为0x000001或0x00000001，表示NAL单元的开始。接下来的几个比特通常指示NAL单元类型，如0x67表示SPS，0x68表示PPS，0x65或0x69表示IDR帧，0x61或0x62表示非IDR...
H264 NALU详细分析3 关于slice 关于RBSP 关于是否带Start Code 也许是终章了
qq_16401691的博客
07-14 1614
h264 NALU详细分析
H264/H265的两种格式Annex B、AVCC(H264)/HVCC(H265)
最新发布
不定期更新关于音视频的文章
03-25 4572
H.264 (AVC) 和 H.265 (HEVC) 是两种常见的视频编码标准，它们都有不同的封装格式，即Annex B 和 AVCC(H264)/HVCC(H265) 封装格式。
H264&H265格式
weixin_39331060的博客
03-27 1760
H264&H265格式
h.264 NALU详细分析2
qq_16401691的博客
06-28 692
h264 NALU 详细分析
【从零实现一个H.264码流解析器】(一)：从码流中找到NALU
houxiaoni01的博客
08-22 2193
1、本系列的目的 这个系列是为了配合【H.264/AVC 句法和语义】来写的，通俗点来讲，【句法和语义】和【解析器】这两个系列，前者相当于理论研究，后者相当于工程实践。而且【解析器】这个系列，是一步一步跟着【句法和语义】的脚步来走的。这样我们就可以一边学习理论，一边实际操作，二者结合，既能达到复习巩固的效果，又能增强项目能力。 2、为何名称叫“解析器”而不叫“解码器” 系列名称之所以取【解析器】，...
H265码流分析详解
程序猿老樊的博客
09-30 6065
根据《T-REC-H.265-201504-I!!PDF-E》协议描述。 HEVC的码流格式定义： 字节流格式由字节流NAL 单元语法结构序列构成。每一字节流NAL 单元语法结构包含有一个起始编码前缀，后面跟随一个nal_unit(NumBytesInNALunit)语法结构。它可能（一定情况下，它应该）包含一个额外的zero_byte 语法元素。它也可能包含一个或多个额外的trailing_zero_8bits 语法元素。当为第一个字节流NAL 单元时，也可能包含一个或多个额外的leading_zer
音视频学习（十一）——H265视频码流
www_dong的博客
10-09 1970
h265码流简要分析
nal 开始码分析
linda012518的博客
06-08 820
其中每个NALU之间通过startcode（起始码）进行分隔，起始码分成两种：0x000001（3Byte）或者0x00000001（4Byte）。如果NALU对应的Slice为一帧的开始就用0x00000001，否则就用0x000001。 ...
H264中的一些概念-NALU
书山有路勤为径
05-15 1067
一、H.264分层结构 视频是由视频序列组成的，而视频序列又由一帧帧图像组成，图像又由片组成，片由宏块组成，宏块由子宏块组成。 这种分层结构有助于更高效的节省码流。缺点也很大：1）每层中，头部和数据强依赖，头部丢失数据就无法解码；2）序列层和图像层数据量大，不能一次传输，若头部所在分组丢失，其他数据无法解码；3）图像层各片之间常携带相同数据，造成码流浪费。 因此，H.264取消了图像层和序列层，取而代之的是图像参数集（PPS）和序列参数集（SPS），其余部分放入片层。 序列参数集和图像参数集
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

码农心语

您的鼓励是我写作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值