NEON做色域变化_ 用单核性能无限逼近八核并行OpenCV

【前言】本文版权属于GiantPandaCV公众号，未经许可请勿转载～

最近开始接触neon汇编，觉得这个东西在一些应用场景上好用，遂做些记录，分享下自己做的一些工作。

一、背景

色域变化是个老生常谈的问题，涉及到工程应用的方方面面，例如计算机视觉中常见的BGR转RGB，SLAM特征提取中的BGR转灰度图，安防监控中的YUV转BGR，车载显示中的NV12或NV21转RGB等。本篇博文主要讲两个操作，一个是BGR转RGB，一个是BGR转GRAY。

二、相关知识

Neon汇编是一种针对ARM架构处理器的一种汇编语言，是一种SIMD（单指令多数据）架构的扩展，它允许处理器同时对多个数据执行相同的操作，从而显著提高处理速度，特别是对于处理多媒体和图形数据。

Neon指令集提供了许多操作，如加法、减法、乘法、比较和浮点运算，这些操作可以在128位的寄存器上同时作用于16位、32位、64位的数据元素。Neon寄存器是128位的，可以被视为1个128位、2个64位、4个32位、8个16位或者16个8位的数据元素。Neon汇编通常也被用于优化性能，如视频编解码、图像处理和音频处理等。由于Neon指令集提供了非常多的操作和灵活性，因此需要开发者有深入的理解和经验才能有效地使用。

三、相关工作

由于网上许多neon汇编优化工作都是和C语言相比，虽然具有一定参考意义，但本身C语言做的功能实现限制较多也比较简单，这篇博客更偏向于直接和OpenCV进行比较，毕竟在性能优化方面，OpenCV已经做的非常不错，内部引入了OpenMP，OpenCL，NEON等技术，也考虑到了很多细节场景。可能读者们会感到诧异，明明OpenCV都引入了NEON，做啥还要专门再写一套NEON。

其实不然，这是由于受用群体不同，才有了这篇博客，如何理解？正是因为OpenCV是广受大众喜爱的一款图像处理开源软件，所以它内部考虑了非常多的细节问题，这也就导致如果我们自己使用，适配自己场景的功能并不需要这么完善，假设我们需要落地一套分割算法，源头接入数据流，此时我们发现，由于落地时很多摄像头拉取的画面比例支持4:3或者16:9，刚好可以投机取巧，调用128位的寄存器进行处理（一次16个像素）。

四、实现

我们先看下一张BGR图像内部是如何排列的：

当我们需要对图像像素值进行操作时，理论上我们只需要知道首指针，利用首指针进行移位和赋值，就可以对像素值进行操作。

那么接下来，我们先熟悉下几个会经常用到的neon函数以及数据类型：

4.1 BGR转RGB

我们先丢出BGR转RGB操作的neon intrinsic代码，如下：

void bgr_to_rgb(uint8_t *bgr, uint8_t *rgb, int width, int height)
{
    // Ensure BGR and BGR buffers are 16-byte aligned for NEON
    uint8_t *bgr_aligned = (uint8_t *)(((uintptr_t)bgr + 15) & ~15);
    uint8_t *rgb_aligned = (uint8_t *)(((uintptr_t)rgb + 15) & ~15);

    for (int q = 0; q < height * width / 16; q++)
    {
        // Calculate the index for the current pixel
        int index = q * 16 * 3;

        // Load 16 BGR pixels into three vectors.
        uint8x16x3_t bgr_vector = vld3q_u8(bgr_aligned + index);

        // Shuffle the bytes to convert from BGR to BGR.
        uint8x16_t b = bgr_vector.val[2]; // Blue
        uint8x16_t g = bgr_vector.val[1]; // Green
        uint8x16_t r = bgr_vector.val[0]; // Red

        // Combine the shuffled bytes into a single vector.
        uint8x16x3_t rgb_vector = {b, g, r};

        // Store the result.
        vst3q_u8(rgb_aligned + index, rgb_vector);
    }
}

4.2 BGR转GRAY的neon操作

接着，我们给出BGR转GRAY的neon intrinsic操作代码，如下：

void bgr_to_gray(uint8_t *bgr, uint8_t *gray, int width, int height)
{
    // 读取8字节的预设值到64位寄存器
    //  将一个标量扩展城向量 8 bit * 8
    uint8x8_t rfac = vdup_n_u8(77);  // 转换权值 R
    uint8x8_t gfac = vdup_n_u8(151); // 转换权值 G
    uint8x8_t bfac = vdup_n_u8(28);  // 转换权值 B
    size_t n = width * height / 16; // 每次处理16个像素

    for (size_t i = 0; i < n; i++)
    {
        uint16x8_t temp;
        // uint8x8 表示将64bit寄存器 分成 8 个 8bit
        uint8x8x4_t bgr_vector = vld4_u8(bgr); // 一次读取4个unit8x8到4个64位寄存器

        temp = vmull_u8(bgr_vector.val[0], rfac);       // temp=bgr.val[0]*rfac
        temp = vmlal_u8(temp, bgr_vector.val[1], gfac); // temp=temp+bgr.val[1]*gfac
        temp = vmlal_u8(temp, bgr_vector.val[2], bfac); // temp=temp+bgr.val[2]*bfac

        uint8x8_t result = vshrn_n_u16(temp, 8); // vshrn_n_u16 会在temp做右移8 位的同时将2字节无符号型转成1字节无符号型
        vst1_u8(gray, result);         // 转存运算结果到dest

        // 处理第二个8像素
        temp = vmull_u8(bgr_vector.val[3], rfac);       // temp=bgr.val[3]*rfac
        temp = vmlal_u8(temp, bgr_vector.val[4], gfac); // temp=temp+bgr.val[4]*gfac
        temp = vmlal_u8(temp, bgr_vector.val[5], bfac); // temp=temp+bgr.val[5]*bfac

        result = vshrn_n_u16(temp, 8); // vshrn_n_u16 会在temp做右移8 位的同时将2字节无符号型转成1字节无符号型
        vst1_u8(gray + 8, result);     // 转存运算结果到dest

        bgr += 16 * 3;
        gray += 16;
    }
}

五、测试

上述代码相对来说比较简单，我们直接在板端上测试效果，测试机器位4核A76+4核A55的ARM板，测试对应的OpenCV版本为4.5.5.

5.1 先看下BGR2RGB的测试对比耗时：

从上述图表不难看出，在图像尺度较大的时候，利用neon的128位寄存器进行数据搬运，是非常有优势的，然而当图像尺寸到了1280以下，优势已被OpenCV反超，这时候我们可以看下CPU内核的资源占用。

OpenCV基本已将8颗CPU核全部占满，反观NEON操作全程只使用到一颗CPU核。

5.2 再看下BGR2GRAY的测试对比耗时：

我们看到了与第一小节几乎相反的情况，从1280以下的尺寸开始，neon几乎吊打了OpenCV，我们看下转灰度图和转RGB的区别。由于转灰度图是，通常使用以下公式来计算每个像素的灰度值：

gray = 0.299 * R + 0.587 * G + 0.114 * B

这里的R、G、B分别代表红色、绿色和蓝色通道的像素值，范围通常是0到255。0.299、0.587和0.114是色彩转换系数，它们分别代表了人眼对红、绿、蓝颜色的敏感度。这些系数加起来等于1，以确保转换后的灰度图像的亮度与原始彩色图像相似。

因此，在转换时，资源消耗已不是在数据搬运上面，而且用于一系列的乘加操作，在尺寸越大时，进行乘加操作的次数增加，单核的资源越容易到达瓶颈。

同样看下内核占用的情况：

OpenCV依旧把所有的CPU核利用得满满当当。

六、像素拆分再加速

NEON只能打到这里了吗？那不一定，我们做一些拆分措施，继续压榨下单核的资源。

如上，我们将一张图拆分成两个Block同时进行处理，此时for循环内只需处理一半的数据流，代码如下：

void bgr_to_rgb_half(uint8_t *bgr, uint8_t *rgb, int width, int height)
{
    // Ensure BGR and BGR buffers are 16-byte aligned for NEON
    uint8_t *bgr_aligned = (uint8_t *)(((uintptr_t)bgr + 15) & ~15);
    uint8_t *rgb_aligned = (uint8_t *)(((uintptr_t)rgb + 15) & ~15);

    int gap = height * width * 3 / 2;

    for (int q = 0; q < height * width / 16 / 2; q++)
    {
        // Calculate the index for the current pixel
        int index = q * 16 * 3;

        // Load 16 BGR pixels into three vectors.
        uint8x16x3_t bgr_vector_upper = vld3q_u8(bgr_aligned + index);

        // Shuffle the bytes to convert from BGR to BGR.
        uint8x16_t b_upper = bgr_vector_upper.val[2]; // Blue
        uint8x16_t g_upper = bgr_vector_upper.val[1]; // Green
        uint8x16_t r_upper = bgr_vector_upper.val[0]; // Red

        // Combine the shuffled bytes into a single vector.
        uint8x16x3_t rgb_vector_upper = {b_upper, g_upper, r_upper};

        // Store the result.
        vst3q_u8(rgb_aligned + index, rgb_vector_upper);
        /* upper block end*/
        
        // Load 16 BGR pixels into three vectors.
        uint8x16x3_t bgr_vector_lower = vld3q_u8(bgr_aligned + gap + index);

        // Shuffle the bytes to convert from BGR to BGR.
        uint8x16_t b_lower = bgr_vector_lower.val[2]; // Blue
        uint8x16_t g_lower = bgr_vector_lower.val[1]; // Green
        uint8x16_t r_lower = bgr_vector_lower.val[0]; // Red

        // Combine the shuffled bytes into a single vector.
        uint8x16x3_t rgb_vector_lower = {b_lower, g_lower, r_lower};

        // Store the result.
        vst3q_u8(rgb_aligned + gap + index, rgb_vector_lower);
    }
}

这个时候，我们可以简单对比下优化后的耗时对比：