Introduction

Basically this kind of conversion needs following steps:

• extract components R, G and B (using bitwise and)
• extend words from 6 or 5 bits to 8 bits (shift left)
• place components at desired places in a 32-bit word (shift, bitwise or)

R = (pixel16 and 0x001f) shl 3
G = (pixel16 and 0x07e0) shr 5
B = (pixel16 and 0xf800) shr 11

pixel32 = R or (G shl 8) or (B shl 16)

Since there aren't many pixels (32 or 64 thousand) lookup tables can be used. First approach is to use one big table indexed by pixels treated as natural numbers: this table has size 65536 * 4 bytes = 262144 bytes. Just one memory access is needed to get 32bpp pixel, however the table size is big, and even if it fits in a L2 cache, then the memory latency kill performance.

pixel32 = LUT[pixel16]

Another approach needs two tables indexed by the lower and the higher byte of a pixel, the final pixel is result of bitwise or. These tables has size 2 * 256 * 4 bytes = 2048 bytes — perfectly fit in a L1 cache.

pixel32 = LUT_hi[pixel16 shr 8] or LUT_lo[pixel16 and 0xff]

Sample program

Sample program is available at github, and includes following procedures:

• naive — is a straightforward implementation of the algorithm described in the beginning;
• lookup16 — uses single, large lookup table;
• lookup8 — use two, small lookup tables; it converts one pixel per iteration;
• lookup8(2) — improved lookup8 — converts two pixels per iteration, requires single fetch of 4 bytes;
• MMX — naive algorithm using MMX instructions;
• SSE2 — naive algorithm using SSE2 instructions; converts 8 pixels per iteration;
• SSE2(2) — unrolled SSE2 version that converts 16 pixels per iteration;

Test results

gcc -O3 pixconv16bpp-32bpp.c -o test

gcc -O3 -DNONTEMPORAL pixconv16bpp-32bpp.c -o testnta