4

我必须将从一个专有设备 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 内在函数进行基本算术、逻辑和移位操作，但我想知道是否以及如何使用 MMX、SSE2 或 [S]SSE3 加速这种 16 位平面 rgb 到压缩 rgba 转换？

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

4

2 回答 2

3

这是一个简单的 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]
}
于 2013-10-21T17:59:23.303 回答
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]
}
于 2013-11-06T07:28:35.413 回答