[英]Intel intrinsics : multiply interleaved 8bit values
我正在研究RGBA32緩沖區（每個組件8位），我需要將每個組件乘以常量，然后將乘法的每個結果添加到其他組件中：
結果= r * x + g * y + b * z + a * w（兩個向量rgba和xyzw之間的點積）
我正在嘗試使用英特爾SSE內在函數來加速這個過程，但我不知道如何在不改變輸入的情況下做這樣的事情。
有沒有辦法做到這一點？ 就像建立一個包含{x，y，z，w，x，y，z，w，x，y，z，w，x，y，z，w}的寄存器並執行8位乘法飽和度？
最終目標是將RGBA矢量乘以相應的顏色轉換矩陣：
[ 66 129 25 0] [R]
[-38 -74 112 0] * [G]
[112 -94 -18 0] [B]
[0 0 0 0] [A]
謝謝
編輯1：這是最終函數，使用浮點計算獲得更多顏色精度，使用SSE將rgba圖像轉換為YUV444。 功能需要1.9到3.5毫秒才能在intel i5 3570k上轉換全高清圖像，只使用一個線程（這個功能非常容易，它可以產生顯着的性能提升）：
void SSE_rgba2YUV444_FP(char* a, char* y, char* u, char* v)
{
__m128i mask = _mm_setr_epi8(0x00,0x04,0x08,0x0c, 0x01,0x05,0x09,0x0d, 0x02,0x06,0x0a,0x0e, 0x03,0x07,0x0b,0x0f); // Masque de mélange, chaque uint8 donne la position à donner (en offset en octet) du uint8 correspondant
float m[9] = {0.299, 0.587, 0.114, -0.1687, -0.3313, 0.5, 0.5, -0.4187, -0.0813}; // Dans le __m128i que l'on mélange
__m128i row[4];
for(int i=0; i<4; i++) {
row[i] = _mm_loadu_si128((__m128i*)&a[16*i]);
row[i] = _mm_shuffle_epi8(row[i],mask);
}
// row[i] = {rrrrggggbbbbaaaa} tous en uint8t
__m128i t0 = _mm_unpacklo_epi32(row[0], row[1]); //to = {rrrrrrrrgggggggg}
__m128i t1 = _mm_unpacklo_epi32(row[2], row[3]); //t1 = {rrrrrrrrgggggggg}
__m128i t2 = _mm_unpackhi_epi32(row[0], row[1]); //t2 = {bbbbbbbbaaaaaaaa}
__m128i t3 = _mm_unpackhi_epi32(row[2], row[3]); //t3 = {bbbbbbbbaaaaaaaa}
row[0] = _mm_unpacklo_epi64(t0, t1); // row[0] = {rrrrrrrrrrrrrrrr}
row[1] = _mm_unpackhi_epi64(t0, t1); // etc
row[2] = _mm_unpacklo_epi64(t2, t3);
__m128i v_lo[3], v_hi[3];
for(int i=0; i<3; i++) {
v_lo[i] = _mm_unpacklo_epi8(row[i],_mm_setzero_si128()); // On entrelace chaque row avec des 0, ce qui fait passer les valeurs
v_hi[i] = _mm_unpackhi_epi8(row[i],_mm_setzero_si128()); // de 8bits à 16bits pour pouvoir travailler dessus
}
__m128 v32_lo1[3], v32_hi1[3], v32_lo2[3], v32_hi2[3];
for(int i=0; i<3; i++) {
v32_lo1[i] = _mm_cvtepi32_ps(_mm_unpacklo_epi16(v_lo[i],_mm_setzero_si128()));
v32_lo2[i] = _mm_cvtepi32_ps(_mm_unpackhi_epi16(v_lo[i],_mm_setzero_si128()));
v32_hi1[i] = _mm_cvtepi32_ps(_mm_unpacklo_epi16(v_hi[i],_mm_setzero_si128()));
v32_hi2[i] = _mm_cvtepi32_ps(_mm_unpackhi_epi16(v_hi[i],_mm_setzero_si128()));
} // On a nos rgb sur 32 bits
__m128i yuv[3]; // {Y, U, V}
__m128 ylo1 = _mm_add_ps(_mm_mul_ps(v32_lo1[0], _mm_set1_ps(m[0])), _mm_add_ps(_mm_mul_ps(v32_lo1[1], _mm_set1_ps(m[1])), _mm_mul_ps(v32_lo1[2], _mm_set1_ps(m[2]))));
__m128 ylo2 = _mm_add_ps(_mm_mul_ps(v32_lo2[0], _mm_set1_ps(m[0])), _mm_add_ps(_mm_mul_ps(v32_lo2[1], _mm_set1_ps(m[1])), _mm_mul_ps(v32_lo2[2], _mm_set1_ps(m[2]))));
__m128 yhi1 = _mm_add_ps(_mm_mul_ps(v32_hi1[0], _mm_set1_ps(m[0])), _mm_add_ps(_mm_mul_ps(v32_hi1[1], _mm_set1_ps(m[1])), _mm_mul_ps(v32_hi1[2], _mm_set1_ps(m[2]))));
__m128 yhi2 = _mm_add_ps(_mm_mul_ps(v32_hi2[0], _mm_set1_ps(m[0])), _mm_add_ps(_mm_mul_ps(v32_hi2[1], _mm_set1_ps(m[1])), _mm_mul_ps(v32_hi2[2], _mm_set1_ps(m[2]))));
__m128i ylo1i = _mm_cvtps_epi32(ylo1);
__m128i ylo2i = _mm_cvtps_epi32(ylo2);
__m128i yhi1i = _mm_cvtps_epi32(yhi1);
__m128i yhi2i = _mm_cvtps_epi32(yhi2);
__m128i ylo = _mm_packus_epi32(ylo1i, ylo2i);
__m128i yhi = _mm_packus_epi32(yhi1i, yhi2i);
yuv[0] = _mm_packus_epi16(ylo, yhi);
ylo1 = _mm_add_ps(_mm_add_ps(_mm_mul_ps(v32_lo1[0], _mm_set1_ps(m[3])), _mm_add_ps(_mm_mul_ps(v32_lo1[1], _mm_set1_ps(m[4])), _mm_mul_ps(v32_lo1[2], _mm_set1_ps(m[5])))), _mm_set1_ps(128.0f));
ylo2 = _mm_add_ps(_mm_add_ps(_mm_mul_ps(v32_lo2[0], _mm_set1_ps(m[3])), _mm_add_ps(_mm_mul_ps(v32_lo2[1], _mm_set1_ps(m[4])), _mm_mul_ps(v32_lo2[2], _mm_set1_ps(m[5])))), _mm_set1_ps(128.0f));
yhi1 = _mm_add_ps(_mm_add_ps(_mm_mul_ps(v32_hi1[0], _mm_set1_ps(m[3])), _mm_add_ps(_mm_mul_ps(v32_hi1[1], _mm_set1_ps(m[4])), _mm_mul_ps(v32_hi1[2], _mm_set1_ps(m[5])))), _mm_set1_ps(128.0f));
yhi2 = _mm_add_ps(_mm_add_ps(_mm_mul_ps(v32_hi2[0], _mm_set1_ps(m[3])), _mm_add_ps(_mm_mul_ps(v32_hi2[1], _mm_set1_ps(m[4])), _mm_mul_ps(v32_hi2[2], _mm_set1_ps(m[5])))), _mm_set1_ps(128.0f));
ylo1i = _mm_cvtps_epi32(ylo1);
ylo2i = _mm_cvtps_epi32(ylo2);
yhi1i = _mm_cvtps_epi32(yhi1);
yhi2i = _mm_cvtps_epi32(yhi2);
ylo = _mm_packus_epi32(ylo1i, ylo2i);
yhi = _mm_packus_epi32(yhi1i, yhi2i);
yuv[1] = _mm_packus_epi16(ylo, yhi);
ylo1 = _mm_add_ps(_mm_add_ps(_mm_mul_ps(v32_lo1[0], _mm_set1_ps(m[6])), _mm_add_ps(_mm_mul_ps(v32_lo1[1], _mm_set1_ps(m[7])), _mm_mul_ps(v32_lo1[2], _mm_set1_ps(m[8])))), _mm_set1_ps(128.0f));
ylo2 = _mm_add_ps(_mm_add_ps(_mm_mul_ps(v32_lo2[0], _mm_set1_ps(m[6])), _mm_add_ps(_mm_mul_ps(v32_lo2[1], _mm_set1_ps(m[7])), _mm_mul_ps(v32_lo2[2], _mm_set1_ps(m[8])))), _mm_set1_ps(128.0f));
yhi1 = _mm_add_ps(_mm_add_ps(_mm_mul_ps(v32_hi1[0], _mm_set1_ps(m[6])), _mm_add_ps(_mm_mul_ps(v32_hi1[1], _mm_set1_ps(m[7])), _mm_mul_ps(v32_hi1[2], _mm_set1_ps(m[8])))), _mm_set1_ps(128.0f));
yhi2 = _mm_add_ps(_mm_add_ps(_mm_mul_ps(v32_hi2[0], _mm_set1_ps(m[6])), _mm_add_ps(_mm_mul_ps(v32_hi2[1], _mm_set1_ps(m[7])), _mm_mul_ps(v32_hi2[2], _mm_set1_ps(m[8])))), _mm_set1_ps(128.0f));
ylo1i = _mm_cvtps_epi32(ylo1);
ylo2i = _mm_cvtps_epi32(ylo2);
yhi1i = _mm_cvtps_epi32(yhi1);
yhi2i = _mm_cvtps_epi32(yhi2);
ylo = _mm_packus_epi32(ylo1i, ylo2i);
yhi = _mm_packus_epi32(yhi1i, yhi2i);
yuv[2] = _mm_packus_epi16(ylo, yhi);
_mm_storeu_si128((__m128i*)y,yuv[0]);
_mm_storeu_si128((__m128i*)u,yuv[1]);
_mm_storeu_si128((__m128i*)v,yuv[2]);
}
這是一個基於OP和Paul R的評論的解決方案。內在的_mm_maddubs_epi16要求簽名的第二個參數，這是g的129因子的問題。 但是，我們可以通過這樣做來解決這個問題
y = ((66-64)*r + (129-64)*g + (25-64)*b + -64*a) + (64*r + 64*g + 64*b + 64*a)
= (2*r + 65*g + -39*b -64*a) + 64(r + g + a)
使用此我們只需要16位整數，我們可以計算出16個y在這樣的時刻字節：
請注意，我最初使用128，但這導致溢出，因為255*((25-128)-128)<-32768 。
__m128i yk = _mm_set1_epi32(0xc0d94102); -64,-39,64,2
__m128i y4[4];
for(int i=0; i<4; i++) {
__m128i a4 = _mm_loadu_si128((__m128i*)&a[16*i]);
__m128i t1 = _mm_maddubs_epi16(a4, yk);
__m128i t2 = _mm_maddubs_epi16(a4, _mm_set1_epi8(1));
t2 = _mm_slli_epi16(t2, 6); //multiply by 64
y4[i] = _mm_add_epi16(t1,t2);
}
short tmp[8];
_mm_storeu_si128((__m128i*)tmp, y4[0]);
__m128i y8_lo = _mm_hadd_epi16(y4[0], y4[1]);
__m128i y8_hi = _mm_hadd_epi16(y4[2], y4[3]);
y8_lo = _mm_add_epi16(y8_lo, _mm_set1_epi16(128));
y8_lo = _mm_srli_epi16(y8_lo, 8);
y8_lo = _mm_add_epi16(y8_lo, _mm_set1_epi16(16));
y8_hi = _mm_add_epi16(y8_hi, _mm_set1_epi16(128));
y8_hi = _mm_srli_epi16(y8_hi, 8);
y8_hi = _mm_add_epi16(y8_hi, _mm_set1_epi16(16));
__m128i y16 = _mm_packus_epi16(y8_lo,y8_hi);
這是顯示此工作的代碼。 我將結果與如何在C / C ++中執行rgb yuv轉換的公式（有修改）進行了比較，它是：
#define CLIP(X) ( (X) > 255 ? 255 : (X) < 0 ? 0 : X)
#define RGB2Y(R, G, B) CLIP(( ( 66 * (0xff & R) + 129 * (0xff & G) + 25 * (0xff & B) + 128) >> 8) + 16)
代碼：
#include <stdio.h>
#include <x86intrin.h>
#include <stdlib.h>
#define CLIP(X) ( (X) > 255 ? 255 : (X) < 0 ? 0 : X)
#define RGB2Y(R, G, B) CLIP(( ( 66 * (0xff & R) + 129 * (0xff & G) + 25 * (0xff & B) + 128) >> 8) + 16)
void rgba2y_SSE_v1(char *a, char *b) {
__m128i yk = _mm_setr_epi16(66,129,25,0, 66,129,25,0);
__m128i out[4];
for(int i=0; i<4; i++) {
__m128i a4, lo, hi;
a4 = _mm_loadu_si128((__m128i*)&a[16*i]);
lo = _mm_unpacklo_epi8(a4,_mm_setzero_si128());
hi = _mm_unpackhi_epi8(a4,_mm_setzero_si128());
lo = _mm_madd_epi16(lo,yk);
lo = _mm_hadd_epi32(lo,lo);
hi = _mm_madd_epi16(hi,yk);
hi = _mm_hadd_epi32(hi,hi);
out[i] = _mm_unpackhi_epi64(lo,hi);
}
__m128i out_lo = _mm_packus_epi32(out[0], out[1]);
__m128i out_hi = _mm_packus_epi32(out[2], out[3]);
out_lo = _mm_add_epi16(out_lo, _mm_set1_epi16(128));
out_lo = _mm_srli_epi16(out_lo, 8);
out_lo = _mm_add_epi16(out_lo, _mm_set1_epi16(16));
out_hi = _mm_add_epi16(out_hi, _mm_set1_epi16(128));
out_hi = _mm_srli_epi16(out_hi, 8);
out_hi = _mm_add_epi16(out_hi, _mm_set1_epi16(16));
__m128i y16 = _mm_packus_epi16(out_lo,out_hi);
_mm_storeu_si128((__m128i*)b,y16);
}
void rgba2y_SSE_v2(char *a, char *b) {
__m128i yk = _mm_set1_epi32(0xc0d94102);
__m128i y4[4];
for(int i=0; i<4; i++) {
__m128i a4 = _mm_loadu_si128((__m128i*)&a[16*i]);
__m128i t1 = _mm_maddubs_epi16(a4, yk);
__m128i t2 = _mm_maddubs_epi16(a4, _mm_set1_epi8(1));
t2 = _mm_slli_epi16(t2, 6);
y4[i] = _mm_add_epi16(t1,t2);
}
short tmp[8];
_mm_storeu_si128((__m128i*)tmp, y4[0]);
__m128i y8_lo = _mm_hadd_epi16(y4[0], y4[1]);
__m128i y8_hi = _mm_hadd_epi16(y4[2], y4[3]);
y8_lo = _mm_add_epi16(y8_lo, _mm_set1_epi16(128));
y8_lo = _mm_srli_epi16(y8_lo, 8);
y8_lo = _mm_add_epi16(y8_lo, _mm_set1_epi16(16));
y8_hi = _mm_add_epi16(y8_hi, _mm_set1_epi16(128));
y8_hi = _mm_srli_epi16(y8_hi, 8);
y8_hi = _mm_add_epi16(y8_hi, _mm_set1_epi16(16));
__m128i y16 = _mm_packus_epi16(y8_lo,y8_hi);
_mm_storeu_si128((__m128i*)b,y16);
}
void rgba2yuv_SSE(char *a, char *b) {
__m128i mask = _mm_setr_epi8(0x00,0x04,0x08,0x0c, 0x01,0x05,0x09,0x0d, 0x02,0x06,0x0a,0x0e, 0x03,0x07,0x0b,0x0f);
short m[9] = {66, 129, 25, -38, -74, 112, 112, -94, -18};
__m128i row[4];
for(int i=0; i<4; i++) {
row[i] = _mm_loadu_si128((__m128i*)&a[16*i]);
row[i] = _mm_shuffle_epi8(row[i],mask);
}
__m128i t0 = _mm_unpacklo_epi32(row[0], row[1]);
__m128i t1 = _mm_unpacklo_epi32(row[2], row[3]);
__m128i t2 = _mm_unpackhi_epi32(row[0], row[1]);
__m128i t3 = _mm_unpackhi_epi32(row[2], row[3]);
row[0] = _mm_unpacklo_epi64(t0, t1);
row[1] = _mm_unpackhi_epi64(t0, t1);
row[2] = _mm_unpacklo_epi64(t2, t3);
__m128i v_lo[3], v_hi[3];
for(int i=0; i<3; i++) {
v_lo[i] = _mm_unpacklo_epi8(row[i],_mm_setzero_si128());
v_hi[i] = _mm_unpackhi_epi8(row[i],_mm_setzero_si128());
}
__m128i yuv[3];
for(int i=0; i<3; i++) {
__m128i yuv_lo, yuv_hi;
yuv_lo = _mm_add_epi16(_mm_add_epi16(
_mm_mullo_epi16(v_lo[0], _mm_set1_epi16(m[3*i+0])),
_mm_mullo_epi16(v_lo[1], _mm_set1_epi16(m[3*i+1]))),
_mm_mullo_epi16(v_lo[2], _mm_set1_epi16(m[3*i+2])));
yuv_lo = _mm_add_epi16(yuv_lo, _mm_set1_epi16(128));
yuv_lo = _mm_srli_epi16(yuv_lo, 8);
yuv_lo = _mm_add_epi16(yuv_lo, _mm_set1_epi16(16));
yuv_hi = _mm_add_epi16(_mm_add_epi16(
_mm_mullo_epi16(v_hi[0], _mm_set1_epi16(m[3*i+0])),
_mm_mullo_epi16(v_hi[1], _mm_set1_epi16(m[3*i+1]))),
_mm_mullo_epi16(v_hi[2], _mm_set1_epi16(m[3*i+2])));
yuv_hi = _mm_add_epi16(yuv_hi, _mm_set1_epi16(128));
yuv_hi = _mm_srli_epi16(yuv_hi, 8);
yuv_hi = _mm_add_epi16(yuv_hi, _mm_set1_epi16(16));
yuv[i] = _mm_packus_epi16(yuv_lo,yuv_hi);
}
_mm_storeu_si128((__m128i*)b,yuv[0]);
}
int main(void) {
char rgba[64];
char y1[16], y2[16], yuv[48];
for(int i=0; i<64; i++) rgba[i] = rand()%256;
rgba2y_SSE_v1(rgba,y1);
rgba2y_SSE_v2(rgba,y2);
rgba2yuv_SSE(rgba,yuv);
printf("RGB2Y: "); for(int i=0; i<16; i++) printf("%x ", 0xff & RGB2Y(rgba[4*i+0], rgba[4*i+1], rgba[4*i+2])); printf("\n");
printf("SSE_v1 "); for(int i=0; i<16; i++) printf("%x ", 0xff & y1[i]); printf("\n");
printf("SSE_v2 "); for(int i=0; i<16; i++) printf("%x ", 0xff & y2[i]); printf("\n");
printf("SSE_v3 "); for(int i=0; i<16; i++) printf("%x ", 0xff & yuv[i]); printf("\n");
}
輸出：
RGB2Y: 99 ad 94 e3 9a a2 60 81 45 59 49 a5 aa 9b 60 4d
SSE_v1 99 ad 94 e3 9a a2 60 81 45 59 49 a5 aa 9b 60 4d
SSE_v2 99 ad 94 e3 9a a2 60 81 45 59 49 a5 aa 9b 60 4d
SSE_v3 99 ad 94 e3 9a a2 60 81 45 59 49 a5 aa 9b 60 4d
這是一個解決方案，它同時找到Y，U和V，並且只使用垂直運算符
要做到這一點，我首先像這樣轉換四個像素
rgbargbargbargba -> rrrrggggbbbbaaaa
使用帶有掩碼的內在_mm_shuffle_epi8 。 我這樣做為16像素，然后再轉置它們
從
row[0] : rrrrggggbbbbaaaa
row[1] : rrrrggggbbbbaaaa
row[2] : rrrrggggbbbbaaaa
ro2[3] : rrrrggggbbbbaaaa
至
row[0] : rrrrrrrrrrrrrrrr
row[1] : gggggggggggggggg
row[2] : bbbbbbbbbbbbbbbb
這與轉換像這樣的4x4整數矩陣的方式相同：
__m128i t0 = _mm_unpacklo_epi32(row[0], row[1]);
__m128i t1 = _mm_unpacklo_epi32(row[2], row[3]);
__m128i t2 = _mm_unpackhi_epi32(row[0], row[1]);
__m128i t3 = _mm_unpackhi_epi32(row[2], row[3]);
row[0] = _mm_unpacklo_epi64(t0, t1);
row[1] = _mm_unpackhi_epi64(t0, t1);
row[2] = _mm_unpacklo_epi64(t2, t3);
現在我將每一行分為高和低，並像這樣擴展到16位
__m128i v_lo[3], v_hi[3];
for(int i=0; i<3; i++) {
v_lo[i] = _mm_unpacklo_epi8(row[i],_mm_setzero_si128());
v_hi[i] = _mm_unpackhi_epi8(row[i],_mm_setzero_si128());
}
最后，我像這樣計算Y，U和V：
short m[9] = {66, 129, 25, -38, -74, 112, 112, -94, -18};
__m128i yuv[3];
for(int i=0; i<3; i++) {
__m128i yuv_lo, yuv_hi;
yuv_lo = _mm_add_epi16(_mm_add_epi16(
_mm_mullo_epi16(v_lo[0], _mm_set1_epi16(m[3*i+0])),
_mm_mullo_epi16(v_lo[1], _mm_set1_epi16(m[3*i+1]))),
_mm_mullo_epi16(v_lo[2], _mm_set1_epi16(m[3*i+2])));
yuv_lo = _mm_add_epi16(yuv_lo, _mm_set1_epi16(128));
yuv_lo = _mm_srli_epi16(yuv_lo, 8);
yuv_lo = _mm_add_epi16(yuv_lo, _mm_set1_epi16(16));
yuv_hi = _mm_add_epi16(_mm_add_epi16(
_mm_mullo_epi16(v_hi[0], _mm_set1_epi16(m[3*i+0])),
_mm_mullo_epi16(v_hi[1], _mm_set1_epi16(m[3*i+1]))),
_mm_mullo_epi16(v_hi[2], _mm_set1_epi16(m[3*i+2])));
yuv_hi = _mm_add_epi16(yuv_hi, _mm_set1_epi16(128));
yuv_hi = _mm_srli_epi16(yuv_hi, 8);
yuv_hi = _mm_add_epi16(yuv_hi, _mm_set1_epi16(16));
yuv[i] = _mm_packus_epi16(yuv_lo,yuv_hi);
}
有關此代碼的工作示例，請參閱我的第一個答案和函數rgba2yuv_SSE 。
如何使用Intel內部函數從8位整數數組構建32位整數？
[英]How to build 32bit integers from array of 8bit integers using Intel intrinsics?
通過利用我們有一個 32 位微控制器，將一個 8 位數組與一個常量相乘並更快地縮小到 8 位
[英]Multiply a 8bit array with a constant and scale back to 8bit faster by leveraging that we have a 32 bit microcontroller
聲明:本站的技術帖子網頁，遵循CC BY-SA 4.0協議，如果您需要轉載，請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.