主页 / coding / 问题 / 79126960
Accepted
Mike
Asked: 2024-10-26 02:38:42 +0800 CST

正确的 RGB888 到 RGB565 转换

  • 772

我找到了三种 RGB888 到 RGB565 的转换算法，但我不确定哪种最正确。前两种产生相同的结果。第三种产生不同的结果，但与在线计算器一致。第三种是有道理的，因为它可以缩放。但前两种会更快，因为没有整数乘法或除法。

uint8_t r8, g8, b8;
uint16_t r5, g6, b5, val;

r8 = someredvalue;
g8 = somegreenvalue;
b8 = somebluevalue;


// first method:
b5 =  (b8  >> 3)        & 0x001F;
g6 = ((g8  >> 2) <<  5) & 0x07E0;
r5 = ((r8  >> 3) << 11) & 0xF800;
val = (r5 | g6 | b5);
printf("%d, %d, %d, %u\n", r8, g8, b8, val);


// second method:
val = ((r8 & 0b11111000) << 8) | ((g8 & 0b11111100) << 3) | (b8 >> 3);
printf("%d, %d, %d, %u\n", r8, g8, b8, val);


// third method:
r5 = r8 * 31 / 255;
g6 = g8 * 63 / 255;
b5 = b8 * 31 / 255;     
val =  (r5 << 11) | (g6 << 5) | (b5);
printf("%d, %d, %d, %u\n", r8, g8, b8, val);
c

2 个回答

  1. Best Answer

    前两个产生相同的结果。

    因为它们是等效的，至少对于支持0bxxx-style 二进制常量的编译器而言，这是对标准 C 的扩展。两者都将 565 格式的颜色值作为 888 格式中对应颜色值的最高有效位的正确数字。

    第三个产生了不同的结果，但与在线计算器的结果一致。

    第三个是有意义的，因为它可以扩展。

    它们都进行缩放。第三个只是使用与其他函数略有不同的缩放因子。

    考虑红色通道。五位可以表示从 0 到 31 的值。八位可以表示从 0 到 255 的值。从数学上讲，从后者范围线性缩放到前者的因子是 31/255，正如第三种方法所使用的那样。另外两种方法是除以 8（通过移位），这在算术上与除以 32/256 相同。当然，它们不是相同的缩放因子，但它们很接近。

    但在你认为方法 3 更正确之前，你应该考虑整数运算的影响。例如，哪些 8 位红色值映射到 5 位表示中的 31？使用方法 3，只有一个可以：255。值 254 缩放到略小于 31，被截断为 30。因此，转换的这种变化对于每个 RGB565 颜色对应的 RGB888 颜色数量是不一致的。

    另一方面，位移方法在这方面是统一的。当以这种方式转换时，每个 RGB565 颜色对应于相同数量（256）的 RGB888 颜色。

    我不确定哪一个是最正确的。

    总体而言，这两种重新缩放方法产生的结果非常相似，每个通道之间的差异在 1 个单位以内。两者都是线性的，直到截断为整数。从绝对意义上讲，没有哪个比另一个更正确。位移替代方案的特点是将结果均匀分布在 RGB565 空间上。另一种替代方案的特点是仅将最大 RGB888 强度映射到最大 RGB565 强度。性能可能也存在差异，但如果这对您很重要，那么您应该进行测量。对于大多数目的，我倾向于选择其中一种位移方法的一致性，但您可能会有不同的想法。

    • 5

  2. @CraigEstey 我多次进行了测试，结果相同。代码在 RPi Pico 上运行。我原本以为方法 #2 也是最快的；但很惊讶方法 #1 是最快的。– Mike

    嗯...我在一台较旧的 x86 PC 上运行测试（没有 RPi）。不过...

    1. 我认为方法 2 是最快的（使用gcc）
    2. 但是，m1 使用速度更快clang。但这是因为它使用了循环展开的 x86 SIMD 指令。

    为了让我们达成共识（只是为了好玩），我附上了针对您的算法的完整基准测试程序。

    以下是测试程序（all.c）：

    #include <stdio.h>
#include <stdlib.h>
#include <time.h>

#if USE_BYTE_ARG
typedef unsigned char arg_t;
#else
typedef unsigned int arg_t;
#endif

typedef unsigned short u8;
typedef unsigned short u16;
typedef unsigned int u32;

#ifndef MAX_Y
#define MAX_Y   1080
#endif

#ifndef MAX_X
#define MAX_X   1920
#endif

u8 bigbuf_888[MAX_Y * MAX_X * 3];
u16 bigbuf_565[MAX_Y * MAX_X];

#define inline_always static inline __attribute__((always_inline))

inline_always u32
m1(arg_t r8,arg_t g8,arg_t b8)
{
    u32 b5 = (b8 >> 3) & 0x001F;
    u32 g6 = ((g8 >> 2) << 5) & 0x07E0;
    u32 r5 = ((r8 >> 3) << 11) & 0xF800;
    u32 val = (r5 | g6 | b5);
    return val;
}

inline_always u32
m2(arg_t r8,arg_t g8,arg_t b8)
{
    u32 val = ((r8 & 0b11111000) << 8) | ((g8 & 0b11111100) << 3) | (b8 >> 3);
    return val;
}

inline_always u32
m3(arg_t r8,arg_t g8,arg_t b8)
{
    u32 r5 = r8 * 31 / 255;
    u32 g6 = g8 * 63 / 255;
    u32 b5 = b8 * 31 / 255;
    u32 val = (r5 << 11) | (g6 << 5) | (b5);
    return val;
}

inline_always u32
m4(arg_t r8,arg_t g8,arg_t b8)
{
    u32 r5 = (r8 * 31) / 256;
    u32 g6 = (g8 * 63) / 256;
    u32 b5 = (b8 * 31) / 256;
    u32 val = (r5 << 11) | (g6 << 5) | (b5);
    return val;
}

#define CAT(_a,_b) \
    _a##_b
#define DOTEST(_m) \
    CAT(dotest_,_m)

#define M   m1
#include "test.c"

#define M   m2
#include "test.c"

#define M   m3
#include "test.c"

#define M   m4
#include "test.c"

typedef struct tst {
    void (*tst_fnc)(u16 *dst,const u8 *src,u32 count);
    const char *tst_sym;
    double tst_elap;
} tst_t;

#define DEFTST(_sym) \
    { .tst_fnc = dotest_##_sym, .tst_sym = #_sym }

tst_t tstlist[] = {
    DEFTST(m1),
    DEFTST(m2),
    DEFTST(m3),
    DEFTST(m4),
};

#define FORALL \
    tst_t *tst = tstlist;  tst < &tstlist[countof(tstlist)];  ++tst

#define countof(_arr) \
    sizeof(_arr) / sizeof(_arr[0])

double
tscgetf(void)
{
    struct timespec ts;
    double sec;

    clock_gettime(CLOCK_MONOTONIC,&ts);
    sec = ts.tv_nsec;
    sec /= 1e9;
    sec += ts.tv_sec;

    return sec;
}

void
dotest(tst_t *tst)
{

    tst->tst_elap = 1e9;

    for (int iter = 1;  iter <= 10;  ++iter) {
        double tscbeg = tscgetf();
        tst->tst_fnc(bigbuf_565,bigbuf_888,MAX_Y * MAX_X);
        double tscend = tscgetf();

        tscend -= tscbeg;
        if (tscend < tst->tst_elap)
            tst->tst_elap = tscend;
    }

#if 0
    printf("%.9f %s\n",tst->tst_elap,tst->tst_sym);
#endif
}

int
tstcmp(const void *alhs,const void *arhs)
{
    const tst_t *lhs = alhs;
    const tst_t *rhs = arhs;
    int cmp;

    do {
        cmp = -1;
        if (lhs->tst_elap < rhs->tst_elap)
            break;

        cmp = 1;
        if (lhs->tst_elap > rhs->tst_elap)
            break;

        cmp = 0;
    } while (0);

    return cmp;
}

int
main(void)
{

    printf("%ux%u\n",MAX_X,MAX_Y);

    for (FORALL)
        dotest(tst);

    qsort(tstlist,countof(tstlist),sizeof(tst_t),tstcmp);

    tst_t *otst = tstlist;
    for (FORALL) {
        printf("%.9f %s (%.3fx slower than %s)\n",
            tst->tst_elap,tst->tst_sym,
            tst->tst_elap / otst->tst_elap,otst->tst_sym);
#if 0
        otst = tst;
#endif
    }

    return 0;
}

    这是test.c它所需要的（必须是单独的文件）：

    void
DOTEST(M)(u16 *rgb565,const u8 *rgb888,u32 count)
{

    for (u32 idx = 0;  idx < count;  idx += 1, rgb888 += 3)
        rgb565[idx] = M(rgb888[0],rgb888[1],rgb888[2]);
}

#undef M

    使用 8.3.1 编译gcc：

    gcc -Wall -O3 -o all all.c

    输出为：

    1920x1080
0.003618755 m2 (1.000x slower than m2)
0.003766094 m1 (1.041x slower than m2)
0.005401992 m4 (1.493x slower than m2)
0.007230262 m3 (1.998x slower than m2)

    使用 7.0.1 编译clang：

    clang -Wall -O3 -o all all.c

    输出：

    1920x1080
0.002214470 m1 (1.000x slower than m1)
0.002892669 m2 (1.306x slower than m1)
0.005501939 m4 (2.485x slower than m1)
0.007757501 m3 (3.503x slower than m1)
    • 2

相关问题