Из SDK я получаю изображения, упакованные в формате пикселей BGR, то есть BGRBGRBGR. Для другого приложения мне нужно преобразовать этот формат в планарный RGB RRRGGGBBB. Я не хочу использовать дополнительную библиотеку только для этой задачи, поэтому мне приходится использовать свой собственный код для преобразования между форматами.
Я использую 32-битный C # .NET 4.5, и данные находятся в байтовых массивах одинакового размера.
Прямо сейчас я просматриваю источник массива и присваиваю значения BGR их соответствующим местам в целевом массиве, но это занимает слишком много времени (250 мс для 1,3-мегапиксельного изображения). Код работает на процессоре Intel Atom E680 и имеет доступ к MMX, SSE, SSE2, SSE3, SSSE3.
К сожалению, у меня нет знаний о встроенных функциях, и я не могу преобразовать код для подобной проблемы, например Быстрый способ копирования памяти с переводом - ARGB в 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
}
edit: Я уменьшил его до 180 мс, удалив такое деление и умножение, но есть ли способ сделать это еще быстрее? Это все еще очень медленно, что, я думаю, связано с тем, что чтение / запись в память не очень оптимальны.
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 мне удалось сократить время со 180 мс до 90 мс! Вот код:
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);
}
}
}
