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

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);
    }
}

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;
    }
}

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

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);
    }
}