使用 SSE 或 MMX 加速 RGB 平面到 RGBA 交错转换

Question

我必须将从一个专有设备 SDK 检索到的医学图像数据传递到另一个供应商（也是专有）设备 SDK 中的图像处理函数。

第一个函数为我提供了平面 rgb 格式的图像：

int mrcpgk_retrieve_frame(uint16_t *r, uint16_t *g, uint16_t *b, int w, int h);

uint16_t的原因是可以切换器件以输出编码为 16 位浮点值的每个颜色值。但是，我在"字节模式"下操作，因此每个颜色值的高 8 位始终为零。

来自另一个设备 SDK 的第二个函数定义如下：

BOOL process_cpgk_image(const PBYTE rgba, DWORD width, DWORD height);

因此，我们使用以下位填充三个缓冲区：（16位平面rgb）

R: 0000000 rrrrrrrr  00000000 rrrrrrrr ...
G: 0000000 gggggggg  00000000 gggggggg ...
B: 0000000 bbbbbbbb  00000000 bbbbbbbb ...

以位表示的所需输出为：

RGBA: rrrrrrrrggggggggbbbbbbbb00000000 rrrrrrrrggggggggbbbbbbbb00000000 ....

我们无法访问这些函数的源代码，也无法更改环境。目前，我们已经实现了以下基本的"桥接"来连接两个设备：

void process_frames(int width, int height)
{
    uint16_t *r = (uint16_t*)malloc(width*height*sizeof(uint16_t));
    uint16_t *g = (uint16_t*)malloc(width*height*sizeof(uint16_t));
    uint16_t *b = (uint16_t*)malloc(width*height*sizeof(uint16_t));
    uint8_t *rgba = (uint8_t*)malloc(width*height*4);
    int i;
    memset(rgba, 0, width*height*4);
    while ( mrcpgk_retrieve_frame(r, g, b, width, height) != 0 )
    {
        for (i=0; i<width*height; i++)
        {
            rgba[4*i+0] = (uint8_t)r[i];
            rgba[4*i+1] = (uint8_t)g[i];
            rgba[4*i+2] = (uint8_t)b[i];
        }
        process_cpgk_image(rgba, width, height);
    }
    free(r);
    free(g);
    free(b);
    free(rgba);
}

此代码工作正常，但处理数千张高分辨率图像需要很长时间。处理和检索这两个功能非常快，我们的桥目前是瓶颈。

我知道如何使用 SSE2 内部函数进行基本的算术、逻辑和移位运算，但我想知道这种 16 位平面 rgb 到打包的 rgba 转换是否可以以及如何使用 MMX、SSE2 或 [S]SSE3 加速？

（SSE2 更可取，因为仍有一些 2005 年以前的设备在使用中）。

Answer 1

下面是一个简单的 SSE2 实现：

#include <emmintrin.h>            // SSE2 intrinsics
assert((width*height)%8 == 0);    // NB: total pixels must be multiple of 8
for (i=0; i<width*height; i+=8)
{
    __m128i vr = _mm_load_si128((__m128i *)&r[i]);    // load 8 pixels from r[i]
    __m128i vg = _mm_load_si128((__m128i *)&g[i]);    // load 8 pixels from g[i]
    __m128i vb = _mm_load_si128((__m128i *)&b[i]);    // load 8 pixels from b[i]
    __m128i vrg = _mm_or_si128(vr, _mm_slli_epi16(vg, 8));
                                                      // merge r/g
    __m128i vrgba = _mm_unpacklo_epi16(vrg, vb);      // permute first 4 pixels
    _mm_store_si128((__m128i *)&rgba[4*i], vrgba);    // store first 4 pixels to rgba[4*i]
    vrgba = _mm_unpackhi_epi16(vrg, vb);              // permute second 4 pixels
    _mm_store_si128((__m128i *)&rgba[4*i+16], vrgba); // store second 4 pixels to rgba[4*i+16]
}

Answer 2

使用 AVX2 指令的参考实现：

#include <immintrin.h>            // AVX2 intrinsics
assert((width*height)%16 == 0);    // total pixels count must be multiple of 16
assert(r%32 == 0 && g%32 == 0 && b%32 == 0 && rgba% == 0); // all pointers must to have 32-byte alignment
for (i=0; i<width*height; i+=16)
{
    __m256i vr = _mm256_permute4x64_epi64(_mm265_load_si256((__m256i *)(r + i)), 0xD8);    // load 16 pixels from r[i]
    __m256i vg = _mm256_permute4x64_epi64(_mm265_load_si256((__m256i *)(g + i)), 0xD8);    // load 16 pixels from g[i]
    __m256i vb = _mm256_permute4x64_epi64(_mm265_load_si256((__m256i *)(b + i)), 0xD8);    // load 16 pixels from b[i]
    __m256i vrg = _mm256_or_si256(vr, _mm256_slli_si256(vg, 1));// merge r/g
    __m256i vrgba = _mm256_unpacklo_epi16(vrg, vb);      // permute first 8 pixels
    _mm256_store_si256((__m256i *)(rgba + 4*i), vrgba);    // store first 8 pixels to rgba[4*i]
    vrgba = _mm256_unpackhi_epi16(vrg, vb);              // permute second 8 pixels
    _mm256_store_si256((__m256i *)(rgba + 4*i+32), vrgba); // store second 8 pixels to rgba[4*i + 32]
}