从SDK中可以获得打包为BGR像素格​​式的图像,即BGRBGRBGR。对于另一个应用程序,我需要将此格式转换为RGB plane RRRGGGBBB。我不想仅为此任务使用额外的库,因此我必须使用自己的代码在格式之间进行转换。

我正在使用C#.NET 4.5 32位,并且数据位于具有相同大小的字节数组中。

现在,我正在遍历数组源并将BGR值分配给它们在目标数组中的适当位置,但这花费的时间太长(对于1.3兆像素的图像需要250毫秒)。代码运行的处理器是Intel Atom E680,可以访问MMX,SSE,SSE2,SSE3,SSSE3。

不幸的是,我不了解内在函数,也无法为类似Fast method to copy memory with translation - ARGB to BGR这样的类似问题转换代码以满足我的需求。

我当前用于在像素格式之间进行转换的代码是:

// the array with the BGRBGRBGR pixel data
byte[] source;
// the array with the RRRGGGBBB pixel data
byte[] result;
// the amount of pixels in one channel, width*height
int imageSize;

for (int i = 0; i < source.Length; i += 3)
{
    result[i/3] = source[i + 2]; // R
    result[i/3 + imageSize] = source[i + 1]; // G
    result[i/3 + imageSize * 2] = source[i]; // B
}


我试图将对源数组的访问分为三个循环,每个通道一个循环,但这并没有真正的帮助。因此,我愿意提出建议。

for (int i = 0; i < source.Length; i += 3)
{
    result[i/3] = source[i + 2]; // R
}

for (int i = 0; i < source.Length; i += 3)
{
    result[i/3 + imageSize] = source[i + 1]; // G
}

for (int i = 0; i < source.Length; i += 3)
{
    result[i/3 + imageSize * 2] = source[i]; // B
}


编辑:我通过除去这样的除法和乘法将其降低到180ms,但是有没有办法使其更快?我仍然认为它仍然很慢,因为内存的读/写不是很理想。

int targetPosition = 0;
int imageSize2 = imageSize * 2;
for (int i = 0; i < source.Length; i += 3)
{
    result[targetPosition] = source[i + 2]; // R
    targetPosition++;
}

targetPosition = 0;

for (int i = 0; i < source.Length; i += 3)
{
    result[targetPosition + imageSize] = source[i + 1]; // G
    targetPosition++;
}

targetPosition = 0;

for (int i = 0; i < source.Length; i += 3)
{
    result[targetPosition + imageSize2] = source[i]; // B
    targetPosition++;
}


多亏了MBo的回答,我才能够将时间从180ms减少到90ms!这是代码:

Converter.cpp:

#include "stdafx.h"

BOOL __stdcall DllMain(HINSTANCE hInst, DWORD dwReason, LPVOID lpReserved) {
return  TRUE;
}

const unsigned char Mask[] = { 0, 3, 6, 9,
                           1, 4, 7, 10,
                           2, 5, 8, 11,
                           12, 13, 14, 15};

extern "C" __declspec(dllexport) char* __stdcall ConvertPixelFormat(unsigned char* source, unsigned char *target, int imgSize) {

_asm {
    //interleave r1g1b1 r2g2b2 r3g3b3 r4b4g4 r5b5g5 r6... to planar
    //           r1r2r3r4r5..... g1g2g3g4g5... b1b2b3b4b5...
        push edi
        push esi
        mov eax, source      //A address
        mov edx, target      //B address
        mov ecx, imgSize
        movdqu xmm5, Mask    //load shuffling mask
        mov edi, imgSize     //load interleave step
        mov esi, eax
        add esi, edi
        add esi, edi
        add esi, edi
        shr ecx, 2           //divide count by 4
        dec ecx              //exclude last array chunk
        jle Rest

    Cycle:
        movdqu xmm0, [eax]        //load 16 bytes
        pshufb xmm0, xmm5         //shuffle bytes, we are interested in 12 ones
        movd [edx], xmm0          //store 4 bytes of R
        psrldq xmm0, 4            //shift right register, now G is on the end
        movd [edx + edi], xmm0    //store 4 bytes of G to proper place
        psrldq xmm0, 4            //do the same for B
        movd [edx + 2 * edi], xmm0
        add eax, 12               //shift source index to the next portion
        add edx, 4                //shift destination index
        loop Cycle

    Rest:                       //treat the rest of array
        cmp eax, esi
        jae Finish
        mov ecx, [eax]
        mov [edx], cl           //R
        mov [edx + edi], ch     //G
        shr ecx, 16
        mov [edx + 2 * edi], cl //B
        add eax, 3
        add edx, 1
        jmp Rest

    Finish:
        pop esi
        pop edi
    }
}


C#文件:

// Code to define the method
[DllImport("Converter.dll")]
unsafe static extern void ConvertPixelFormat(byte* source, byte* target, int imgSize);

// Code to execute the conversion
unsafe
{
    fixed (byte* sourcePointer = &source[0])
    {
        fixed (byte* resultPointer = &result[0])
        {
            ConvertPixelFormat(sourcePointer, resultPointer, imageSize);
        }
    }
}

最佳答案

我已经在Delphi中实现了这个交错问题,并检查了内置的asm。我没有内部函数,因此使用普通汇编器。
 pshufb等于_mm_shuffle_epi8SSSE3 intrinsic

在每个循环步骤中,我将16个字节的(r1g1b1 r2g2b2 r3g3b3 r4b4g4 r5b5g5 r6)加载到128位XMM寄存器中,将它们按(r1r2r3r4 g1g2g3g4 b1b2b3b4 xxxx)顺序洗牌,然后将r,g,b块保存到目标内存中(忽略最后4个字节)。下一步加载(r5b5g5 r6g6b6 r7g7b7 ...),依此类推。

请注意,为了简化代码,我没有在第一个代码版本中正确处理数组的尾部。由于您可以使用此代码,因此我已进行了必要的更正。

第一版发行示例:
imgSize = 32
数组大小= 96字节
32/4 = 8个周期
最后一个周期从第84个字节开始,读取16个字节,直到第99个字节-因此我们超出了数组范围!
我只是在此处添加了保护字节:GetMem(A, Size * 3 + 15);,但是对于实际任务来说,它可能不适用,因此值得对最后一个数组块进行特殊处理。

对于i5-4670机器,此代码在pascal变体上花费967 ms,在asm变体上花费140 ms,以在i5-4670机器上转换200个1.3MP cadr(对于单线程,处理器本身比Atom 680快6-8倍)。速度约为0.75 GB /秒(pas)和5.4 GB /秒(asm)

const
  Mask: array[0..15] of Byte = ( 0, 3, 6, 9,
                                 1, 4, 7, 10,
                                 2, 5, 8, 11,
                                 12, 13, 14, 15);
var
  A, B: PByteArray;
  i, N, Size: Integer;
  t1, t2: DWord;
begin
  Size := 1280 * 960 * 200;
  GetMem(A, Size * 3);
  GetMem(B, Size * 3);

  for i := 0 to Size - 1 do begin
    A[3 * i] := 1;
    A[3 * i + 1] := 2;
    A[3 * i + 2] := 3;
  end;

  t1 := GetTickCount;
  for i := 0 to Size - 1 do begin
    B[i] := A[3 * i];
    B[i + Size] := A[3 * i + 1];
    B[i + 2 * Size] := A[3 * i + 2];
  end;
  t2:= GetTickCount;

    //interleave r1g1b1 r2g2b2 r3g3b3 r4b4g4 r5b5g5 r6... to planar
    //r1r2r3r4r5..... g1g2g3g4g5... b1b2b3b4b5...
  asm
    push edi
    push esi
    mov eax, A      //A address
    mov edx, B      //B address
    mov ecx, Size
    movdqu xmm5, Mask   //load shuffling mask
    mov edi, Size       //load interleave step
    mov esi, eax
    add esi, edi
    add esi, edi
    add esi, edi
    shr ecx, 2      //divide count by 4
    dec ecx         //exclude last array chunk
    jle @@Rest

  @@Cycle:
    movdqu xmm0, [eax]   //load 16 bytes
    pshufb xmm0, xmm5    //shuffle bytes, we are interested in 12 ones
    movd [edx], xmm0     //store 4 bytes of R
    psrldq xmm0, 4        //shift right register, now G is on the end
    movd [edx + edi], xmm0   //store 4 bytes of G to proper place
    psrldq xmm0, 4            //do the same for B
    movd [edx + 2 * edi], xmm0
    add eax, 12               //shift source index to the next portion
    add edx, 4                //shift destination index
    loop @@Cycle

   @@Rest:       //treat the rest of array
    cmp eax, esi
    jae @@Finish
    mov ecx, [eax]
    mov [edx], cl   //R
    mov [edx + edi], ch  //G
    shr ecx, 16
    mov [edx + 2 * edi], cl //B
    add eax, 3
    add edx, 1
    jmp @@Rest
  @@Finish:

    pop esi
    pop edi
  end;

  Memo1.Lines.Add(Format('pas %d asm %d', [t2-t1, GetTickCount - t2]));
  FreeMem(A);
  FreeMem(B);

07-24 09:45
查看更多