598 lines
19 KiB
C++
598 lines
19 KiB
C++
// RGB565Test.cpp - Phase 4: RGB565压缩单元测试
|
||
// 测试 BGRA <-> RGB565 颜色空间转换
|
||
|
||
#include <gtest/gtest.h>
|
||
#include <vector>
|
||
#include <cstdint>
|
||
#include <cstring>
|
||
#include <random>
|
||
#include <cmath>
|
||
|
||
// ============================================
|
||
// RGB565 颜色空间转换实现
|
||
// 来源: client/ScreenCapture.h, server/ScreenSpyDlg.cpp
|
||
// ============================================
|
||
|
||
// RGB565 格式说明:
|
||
// 16位: RRRRRGGG GGGBBBBB
|
||
// R: 5位 (0-31)
|
||
// G: 6位 (0-63)
|
||
// B: 5位 (0-31)
|
||
|
||
class RGB565Converter {
|
||
public:
|
||
// ============================================
|
||
// BGRA -> RGB565 转换 (标量版本)
|
||
// ============================================
|
||
static void ConvertBGRAtoRGB565_Scalar(
|
||
const uint8_t* src,
|
||
uint16_t* dst,
|
||
size_t pixelCount
|
||
) {
|
||
for (size_t i = 0; i < pixelCount; i++) {
|
||
// BGRA 格式: B=0, G=1, R=2, A=3
|
||
uint8_t b = src[i * 4 + 0];
|
||
uint8_t g = src[i * 4 + 1];
|
||
uint8_t r = src[i * 4 + 2];
|
||
// A 通道被忽略
|
||
|
||
// RGB565: RRRRRGGG GGGBBBBB
|
||
dst[i] = static_cast<uint16_t>(
|
||
((r >> 3) << 11) | // R: 高5位 -> 位11-15
|
||
((g >> 2) << 5) | // G: 高6位 -> 位5-10
|
||
(b >> 3) // B: 高5位 -> 位0-4
|
||
);
|
||
}
|
||
}
|
||
|
||
// ============================================
|
||
// RGB565 -> BGRA 转换
|
||
// 位复制填充低位以提高精度
|
||
// ============================================
|
||
static void ConvertRGB565ToBGRA(
|
||
const uint16_t* src,
|
||
uint8_t* dst,
|
||
size_t pixelCount
|
||
) {
|
||
for (size_t i = 0; i < pixelCount; i++) {
|
||
uint16_t c = src[i];
|
||
|
||
// 提取各通道
|
||
uint8_t r5 = (c >> 11) & 0x1F; // 5位红色
|
||
uint8_t g6 = (c >> 5) & 0x3F; // 6位绿色
|
||
uint8_t b5 = c & 0x1F; // 5位蓝色
|
||
|
||
// 扩展到8位（使用位复制填充低位）
|
||
// 例如: 5位 11111 -> 8位 11111111 (通过 (x << 3) | (x >> 2))
|
||
dst[i * 4 + 0] = (b5 << 3) | (b5 >> 2); // B: 5->8位
|
||
dst[i * 4 + 1] = (g6 << 2) | (g6 >> 4); // G: 6->8位
|
||
dst[i * 4 + 2] = (r5 << 3) | (r5 >> 2); // R: 5->8位
|
||
dst[i * 4 + 3] = 0xFF; // A: 不透明
|
||
}
|
||
}
|
||
|
||
// ============================================
|
||
// 单像素转换辅助函数
|
||
// ============================================
|
||
static uint16_t BGRAToRGB565(uint8_t b, uint8_t g, uint8_t r) {
|
||
return static_cast<uint16_t>(
|
||
((r >> 3) << 11) |
|
||
((g >> 2) << 5) |
|
||
(b >> 3)
|
||
);
|
||
}
|
||
|
||
static void RGB565ToBGRA(uint16_t c, uint8_t& b, uint8_t& g, uint8_t& r, uint8_t& a) {
|
||
uint8_t r5 = (c >> 11) & 0x1F;
|
||
uint8_t g6 = (c >> 5) & 0x3F;
|
||
uint8_t b5 = c & 0x1F;
|
||
|
||
b = (b5 << 3) | (b5 >> 2);
|
||
g = (g6 << 2) | (g6 >> 4);
|
||
r = (r5 << 3) | (r5 >> 2);
|
||
a = 0xFF;
|
||
}
|
||
|
||
// ============================================
|
||
// 计算量化误差
|
||
// ============================================
|
||
static int CalculateError(uint8_t original, uint8_t converted) {
|
||
return std::abs(static_cast<int>(original) - static_cast<int>(converted));
|
||
}
|
||
|
||
// 计算最大理论误差
|
||
// 5位通道: 量化+位填充可能产生最大误差 7
|
||
// 6位通道: 量化+位填充可能产生最大误差 3
|
||
static int MaxError5Bit() { return 7; }
|
||
static int MaxError6Bit() { return 3; }
|
||
};
|
||
|
||
// ============================================
|
||
// 测试夹具
|
||
// ============================================
|
||
class RGB565Test : public ::testing::Test {
|
||
protected:
|
||
// 创建BGRA像素数组
|
||
static std::vector<uint8_t> CreateBGRAPixels(size_t count, uint8_t b, uint8_t g, uint8_t r, uint8_t a = 0xFF) {
|
||
std::vector<uint8_t> pixels(count * 4);
|
||
for (size_t i = 0; i < count; i++) {
|
||
pixels[i * 4 + 0] = b;
|
||
pixels[i * 4 + 1] = g;
|
||
pixels[i * 4 + 2] = r;
|
||
pixels[i * 4 + 3] = a;
|
||
}
|
||
return pixels;
|
||
}
|
||
};
|
||
|
||
// ============================================
|
||
// 基础转换测试
|
||
// ============================================
|
||
|
||
TEST_F(RGB565Test, SinglePixel_Black) {
|
||
uint16_t result = RGB565Converter::BGRAToRGB565(0, 0, 0);
|
||
EXPECT_EQ(result, 0x0000);
|
||
}
|
||
|
||
TEST_F(RGB565Test, SinglePixel_White) {
|
||
uint16_t result = RGB565Converter::BGRAToRGB565(255, 255, 255);
|
||
// R=31<<11=0xF800, G=63<<5=0x07E0, B=31=0x001F
|
||
// 合计: 0xFFFF
|
||
EXPECT_EQ(result, 0xFFFF);
|
||
}
|
||
|
||
TEST_F(RGB565Test, SinglePixel_Red) {
|
||
uint16_t result = RGB565Converter::BGRAToRGB565(0, 0, 255);
|
||
// R=31<<11=0xF800, G=0, B=0
|
||
EXPECT_EQ(result, 0xF800);
|
||
}
|
||
|
||
TEST_F(RGB565Test, SinglePixel_Green) {
|
||
uint16_t result = RGB565Converter::BGRAToRGB565(0, 255, 0);
|
||
// R=0, G=63<<5=0x07E0, B=0
|
||
EXPECT_EQ(result, 0x07E0);
|
||
}
|
||
|
||
TEST_F(RGB565Test, SinglePixel_Blue) {
|
||
uint16_t result = RGB565Converter::BGRAToRGB565(255, 0, 0);
|
||
// R=0, G=0, B=31=0x001F
|
||
EXPECT_EQ(result, 0x001F);
|
||
}
|
||
|
||
// ============================================
|
||
// 反向转换测试
|
||
// ============================================
|
||
|
||
TEST_F(RGB565Test, Reverse_Black) {
|
||
uint8_t b, g, r, a;
|
||
RGB565Converter::RGB565ToBGRA(0x0000, b, g, r, a);
|
||
EXPECT_EQ(b, 0);
|
||
EXPECT_EQ(g, 0);
|
||
EXPECT_EQ(r, 0);
|
||
EXPECT_EQ(a, 255);
|
||
}
|
||
|
||
TEST_F(RGB565Test, Reverse_White) {
|
||
uint8_t b, g, r, a;
|
||
RGB565Converter::RGB565ToBGRA(0xFFFF, b, g, r, a);
|
||
EXPECT_EQ(b, 255);
|
||
EXPECT_EQ(g, 255);
|
||
EXPECT_EQ(r, 255);
|
||
EXPECT_EQ(a, 255);
|
||
}
|
||
|
||
TEST_F(RGB565Test, Reverse_Red) {
|
||
uint8_t b, g, r, a;
|
||
RGB565Converter::RGB565ToBGRA(0xF800, b, g, r, a);
|
||
EXPECT_EQ(b, 0);
|
||
EXPECT_EQ(g, 0);
|
||
EXPECT_EQ(r, 255);
|
||
EXPECT_EQ(a, 255);
|
||
}
|
||
|
||
TEST_F(RGB565Test, Reverse_Green) {
|
||
uint8_t b, g, r, a;
|
||
RGB565Converter::RGB565ToBGRA(0x07E0, b, g, r, a);
|
||
EXPECT_EQ(b, 0);
|
||
EXPECT_EQ(g, 255);
|
||
EXPECT_EQ(r, 0);
|
||
EXPECT_EQ(a, 255);
|
||
}
|
||
|
||
TEST_F(RGB565Test, Reverse_Blue) {
|
||
uint8_t b, g, r, a;
|
||
RGB565Converter::RGB565ToBGRA(0x001F, b, g, r, a);
|
||
EXPECT_EQ(b, 255);
|
||
EXPECT_EQ(g, 0);
|
||
EXPECT_EQ(r, 0);
|
||
EXPECT_EQ(a, 255);
|
||
}
|
||
|
||
// ============================================
|
||
// 往返转换测试
|
||
// ============================================
|
||
|
||
TEST_F(RGB565Test, RoundTrip_ExactColors) {
|
||
// 测试能精确表示的颜色 (只有 0 和 255 能完美往返)
|
||
// 位填充公式: (x << 3) | (x >> 2) 只有 x=0 -> 0, x=31 -> 255 是精确的
|
||
struct TestCase {
|
||
uint8_t b, g, r;
|
||
} testCases[] = {
|
||
{0, 0, 0}, // 黑色 - 精确
|
||
{255, 255, 255}, // 白色 - 精确
|
||
{0, 0, 255}, // 红色 - 精确
|
||
{0, 255, 0}, // 绿色 - 精确
|
||
{255, 0, 0}, // 蓝色 - 精确
|
||
{255, 255, 0}, // 青色 - 精确
|
||
{0, 255, 255}, // 黄色 - 精确
|
||
{255, 0, 255}, // 品红 - 精确
|
||
};
|
||
|
||
for (const auto& tc : testCases) {
|
||
uint16_t rgb565 = RGB565Converter::BGRAToRGB565(tc.b, tc.g, tc.r);
|
||
uint8_t b, g, r, a;
|
||
RGB565Converter::RGB565ToBGRA(rgb565, b, g, r, a);
|
||
|
||
// 能精确表示的颜色应该完美还原
|
||
EXPECT_EQ(b, tc.b) << "B channel mismatch for (" << (int)tc.r << "," << (int)tc.g << "," << (int)tc.b << ")";
|
||
EXPECT_EQ(g, tc.g) << "G channel mismatch for (" << (int)tc.r << "," << (int)tc.g << "," << (int)tc.b << ")";
|
||
EXPECT_EQ(r, tc.r) << "R channel mismatch for (" << (int)tc.r << "," << (int)tc.g << "," << (int)tc.b << ")";
|
||
}
|
||
}
|
||
|
||
TEST_F(RGB565Test, RoundTrip_QuantizationError) {
|
||
// 测试所有颜色的量化误差在允许范围内
|
||
std::mt19937 rng(12345);
|
||
std::uniform_int_distribution<int> dist(0, 255);
|
||
|
||
for (int i = 0; i < 1000; i++) {
|
||
uint8_t origB = dist(rng);
|
||
uint8_t origG = dist(rng);
|
||
uint8_t origR = dist(rng);
|
||
|
||
uint16_t rgb565 = RGB565Converter::BGRAToRGB565(origB, origG, origR);
|
||
uint8_t b, g, r, a;
|
||
RGB565Converter::RGB565ToBGRA(rgb565, b, g, r, a);
|
||
|
||
// 验证误差在允许范围内
|
||
EXPECT_LE(RGB565Converter::CalculateError(origB, b), RGB565Converter::MaxError5Bit());
|
||
EXPECT_LE(RGB565Converter::CalculateError(origG, g), RGB565Converter::MaxError6Bit());
|
||
EXPECT_LE(RGB565Converter::CalculateError(origR, r), RGB565Converter::MaxError5Bit());
|
||
}
|
||
}
|
||
|
||
// ============================================
|
||
// 批量转换测试
|
||
// ============================================
|
||
|
||
TEST_F(RGB565Test, BatchConvert_SinglePixel) {
|
||
auto bgra = CreateBGRAPixels(1, 128, 64, 192);
|
||
std::vector<uint16_t> rgb565(1);
|
||
|
||
RGB565Converter::ConvertBGRAtoRGB565_Scalar(bgra.data(), rgb565.data(), 1);
|
||
|
||
// 验证转换结果
|
||
uint16_t expected = RGB565Converter::BGRAToRGB565(128, 64, 192);
|
||
EXPECT_EQ(rgb565[0], expected);
|
||
}
|
||
|
||
TEST_F(RGB565Test, BatchConvert_MultiplePixels) {
|
||
const size_t COUNT = 100;
|
||
auto bgra = CreateBGRAPixels(COUNT, 100, 150, 200);
|
||
std::vector<uint16_t> rgb565(COUNT);
|
||
|
||
RGB565Converter::ConvertBGRAtoRGB565_Scalar(bgra.data(), rgb565.data(), COUNT);
|
||
|
||
uint16_t expected = RGB565Converter::BGRAToRGB565(100, 150, 200);
|
||
for (size_t i = 0; i < COUNT; i++) {
|
||
EXPECT_EQ(rgb565[i], expected);
|
||
}
|
||
}
|
||
|
||
TEST_F(RGB565Test, BatchReverse_MultiplePixels) {
|
||
const size_t COUNT = 100;
|
||
std::vector<uint16_t> rgb565(COUNT, 0xF800); // 红色
|
||
std::vector<uint8_t> bgra(COUNT * 4);
|
||
|
||
RGB565Converter::ConvertRGB565ToBGRA(rgb565.data(), bgra.data(), COUNT);
|
||
|
||
for (size_t i = 0; i < COUNT; i++) {
|
||
EXPECT_EQ(bgra[i * 4 + 0], 0); // B
|
||
EXPECT_EQ(bgra[i * 4 + 1], 0); // G
|
||
EXPECT_EQ(bgra[i * 4 + 2], 255); // R
|
||
EXPECT_EQ(bgra[i * 4 + 3], 255); // A
|
||
}
|
||
}
|
||
|
||
TEST_F(RGB565Test, BatchRoundTrip) {
|
||
const size_t COUNT = 1000;
|
||
std::mt19937 rng(42);
|
||
std::uniform_int_distribution<int> dist(0, 255);
|
||
|
||
// 创建随机BGRA数据
|
||
std::vector<uint8_t> original(COUNT * 4);
|
||
for (size_t i = 0; i < COUNT * 4; i++) {
|
||
original[i] = (i % 4 == 3) ? 255 : dist(rng);
|
||
}
|
||
|
||
// 转换到 RGB565
|
||
std::vector<uint16_t> rgb565(COUNT);
|
||
RGB565Converter::ConvertBGRAtoRGB565_Scalar(original.data(), rgb565.data(), COUNT);
|
||
|
||
// 转换回 BGRA
|
||
std::vector<uint8_t> reconstructed(COUNT * 4);
|
||
RGB565Converter::ConvertRGB565ToBGRA(rgb565.data(), reconstructed.data(), COUNT);
|
||
|
||
// 验证所有像素误差在允许范围内
|
||
for (size_t i = 0; i < COUNT; i++) {
|
||
EXPECT_LE(RGB565Converter::CalculateError(original[i * 4 + 0], reconstructed[i * 4 + 0]),
|
||
RGB565Converter::MaxError5Bit()) << "Pixel " << i << " B";
|
||
EXPECT_LE(RGB565Converter::CalculateError(original[i * 4 + 1], reconstructed[i * 4 + 1]),
|
||
RGB565Converter::MaxError6Bit()) << "Pixel " << i << " G";
|
||
EXPECT_LE(RGB565Converter::CalculateError(original[i * 4 + 2], reconstructed[i * 4 + 2]),
|
||
RGB565Converter::MaxError5Bit()) << "Pixel " << i << " R";
|
||
EXPECT_EQ(reconstructed[i * 4 + 3], 255) << "Pixel " << i << " A";
|
||
}
|
||
}
|
||
|
||
// ============================================
|
||
// 边界值测试
|
||
// ============================================
|
||
|
||
TEST_F(RGB565Test, Boundary_AllZeros) {
|
||
uint16_t result = RGB565Converter::BGRAToRGB565(0, 0, 0);
|
||
EXPECT_EQ(result, 0);
|
||
}
|
||
|
||
TEST_F(RGB565Test, Boundary_AllOnes) {
|
||
uint16_t result = RGB565Converter::BGRAToRGB565(255, 255, 255);
|
||
EXPECT_EQ(result, 0xFFFF);
|
||
}
|
||
|
||
TEST_F(RGB565Test, Boundary_ChannelMax) {
|
||
// 单通道最大值
|
||
EXPECT_EQ(RGB565Converter::BGRAToRGB565(255, 0, 0), 0x001F); // B
|
||
EXPECT_EQ(RGB565Converter::BGRAToRGB565(0, 255, 0), 0x07E0); // G
|
||
EXPECT_EQ(RGB565Converter::BGRAToRGB565(0, 0, 255), 0xF800); // R
|
||
}
|
||
|
||
TEST_F(RGB565Test, Boundary_ChannelMin) {
|
||
// 单通道最小值（其他为最大）
|
||
EXPECT_EQ(RGB565Converter::BGRAToRGB565(0, 255, 255), 0xFFE0); // 无B
|
||
EXPECT_EQ(RGB565Converter::BGRAToRGB565(255, 0, 255), 0xF81F); // 无G
|
||
EXPECT_EQ(RGB565Converter::BGRAToRGB565(255, 255, 0), 0x07FF); // 无R
|
||
}
|
||
|
||
// ============================================
|
||
// 位填充测试
|
||
// ============================================
|
||
|
||
TEST_F(RGB565Test, BitFilling_5BitExpansion) {
|
||
// 测试5位扩展到8位的位填充策略
|
||
// 5位值 11111 (31) -> 8位值 11111111 (255)
|
||
// 公式: (x << 3) | (x >> 2)
|
||
|
||
// 最大值: 31 -> 255
|
||
uint8_t expanded = (31 << 3) | (31 >> 2);
|
||
EXPECT_EQ(expanded, 255);
|
||
|
||
// 最小值: 0 -> 0
|
||
expanded = (0 << 3) | (0 >> 2);
|
||
EXPECT_EQ(expanded, 0);
|
||
|
||
// 中间值: 16 -> 132 (10000 -> 10000100)
|
||
expanded = (16 << 3) | (16 >> 2);
|
||
EXPECT_EQ(expanded, 132);
|
||
}
|
||
|
||
TEST_F(RGB565Test, BitFilling_6BitExpansion) {
|
||
// 测试6位扩展到8位的位填充策略
|
||
// 6位值 111111 (63) -> 8位值 11111111 (255)
|
||
// 公式: (x << 2) | (x >> 4)
|
||
|
||
// 最大值: 63 -> 255
|
||
uint8_t expanded = (63 << 2) | (63 >> 4);
|
||
EXPECT_EQ(expanded, 255);
|
||
|
||
// 最小值: 0 -> 0
|
||
expanded = (0 << 2) | (0 >> 4);
|
||
EXPECT_EQ(expanded, 0);
|
||
|
||
// 中间值: 32 -> 130 (100000 -> 10000010)
|
||
expanded = (32 << 2) | (32 >> 4);
|
||
EXPECT_EQ(expanded, 130);
|
||
}
|
||
|
||
// ============================================
|
||
// Alpha通道测试
|
||
// ============================================
|
||
|
||
TEST_F(RGB565Test, Alpha_Ignored) {
|
||
// 不同alpha值应该产生相同的RGB565
|
||
auto bgra1 = CreateBGRAPixels(1, 100, 100, 100, 255);
|
||
auto bgra2 = CreateBGRAPixels(1, 100, 100, 100, 128);
|
||
auto bgra3 = CreateBGRAPixels(1, 100, 100, 100, 0);
|
||
|
||
std::vector<uint16_t> rgb565_1(1), rgb565_2(1), rgb565_3(1);
|
||
|
||
RGB565Converter::ConvertBGRAtoRGB565_Scalar(bgra1.data(), rgb565_1.data(), 1);
|
||
RGB565Converter::ConvertBGRAtoRGB565_Scalar(bgra2.data(), rgb565_2.data(), 1);
|
||
RGB565Converter::ConvertBGRAtoRGB565_Scalar(bgra3.data(), rgb565_3.data(), 1);
|
||
|
||
EXPECT_EQ(rgb565_1[0], rgb565_2[0]);
|
||
EXPECT_EQ(rgb565_2[0], rgb565_3[0]);
|
||
}
|
||
|
||
TEST_F(RGB565Test, Alpha_RestoredToOpaque) {
|
||
// 反向转换时Alpha应该恢复为255
|
||
std::vector<uint16_t> rgb565 = {0x1234, 0x5678, 0x9ABC};
|
||
std::vector<uint8_t> bgra(3 * 4);
|
||
|
||
RGB565Converter::ConvertRGB565ToBGRA(rgb565.data(), bgra.data(), 3);
|
||
|
||
for (size_t i = 0; i < 3; i++) {
|
||
EXPECT_EQ(bgra[i * 4 + 3], 255);
|
||
}
|
||
}
|
||
|
||
// ============================================
|
||
// 压缩率测试
|
||
// ============================================
|
||
|
||
TEST_F(RGB565Test, CompressionRatio) {
|
||
// BGRA: 4字节/像素
|
||
// RGB565: 2字节/像素
|
||
// 压缩率: 50%
|
||
|
||
const size_t PIXEL_COUNT = 1920 * 1080;
|
||
size_t bgraSize = PIXEL_COUNT * 4;
|
||
size_t rgb565Size = PIXEL_COUNT * 2;
|
||
|
||
EXPECT_EQ(rgb565Size, bgraSize / 2);
|
||
EXPECT_DOUBLE_EQ(static_cast<double>(rgb565Size) / bgraSize, 0.5);
|
||
}
|
||
|
||
// ============================================
|
||
// 特殊颜色测试
|
||
// ============================================
|
||
|
||
TEST_F(RGB565Test, CommonColors) {
|
||
struct ColorTest {
|
||
const char* name;
|
||
uint8_t r, g, b;
|
||
uint16_t expectedRGB565;
|
||
} colors[] = {
|
||
{"Black", 0, 0, 0, 0x0000},
|
||
{"White", 255, 255, 255, 0xFFFF},
|
||
{"Red", 255, 0, 0, 0xF800},
|
||
{"Green", 0, 255, 0, 0x07E0},
|
||
{"Blue", 0, 0, 255, 0x001F},
|
||
{"Yellow", 255, 255, 0, 0xFFE0},
|
||
{"Cyan", 0, 255, 255, 0x07FF},
|
||
{"Magenta", 255, 0, 255, 0xF81F},
|
||
};
|
||
|
||
for (const auto& c : colors) {
|
||
uint16_t result = RGB565Converter::BGRAToRGB565(c.b, c.g, c.r);
|
||
EXPECT_EQ(result, c.expectedRGB565) << "Color: " << c.name;
|
||
}
|
||
}
|
||
|
||
TEST_F(RGB565Test, GrayScales) {
|
||
// 测试灰度值转换
|
||
for (int gray = 0; gray <= 255; gray += 17) {
|
||
uint8_t g = static_cast<uint8_t>(gray);
|
||
uint16_t rgb565 = RGB565Converter::BGRAToRGB565(g, g, g);
|
||
|
||
uint8_t b, gr, r, a;
|
||
RGB565Converter::RGB565ToBGRA(rgb565, b, gr, r, a);
|
||
|
||
// 灰度值在量化误差范围内应该保持一致
|
||
EXPECT_NEAR(b, g, 8);
|
||
EXPECT_NEAR(gr, g, 4);
|
||
EXPECT_NEAR(r, g, 8);
|
||
}
|
||
}
|
||
|
||
// ============================================
|
||
// 参数化测试
|
||
// ============================================
|
||
|
||
class RGB565ChannelTest : public ::testing::TestWithParam<int> {};
|
||
|
||
TEST_P(RGB565ChannelTest, ChannelValueRange) {
|
||
int value = GetParam();
|
||
uint8_t v = static_cast<uint8_t>(value);
|
||
|
||
// 测试R通道
|
||
{
|
||
uint16_t rgb565 = RGB565Converter::BGRAToRGB565(0, 0, v);
|
||
uint8_t b, g, r, a;
|
||
RGB565Converter::RGB565ToBGRA(rgb565, b, g, r, a);
|
||
EXPECT_LE(RGB565Converter::CalculateError(v, r), RGB565Converter::MaxError5Bit());
|
||
}
|
||
|
||
// 测试G通道
|
||
{
|
||
uint16_t rgb565 = RGB565Converter::BGRAToRGB565(0, v, 0);
|
||
uint8_t b, g, r, a;
|
||
RGB565Converter::RGB565ToBGRA(rgb565, b, g, r, a);
|
||
EXPECT_LE(RGB565Converter::CalculateError(v, g), RGB565Converter::MaxError6Bit());
|
||
}
|
||
|
||
// 测试B通道
|
||
{
|
||
uint16_t rgb565 = RGB565Converter::BGRAToRGB565(v, 0, 0);
|
||
uint8_t b, g, r, a;
|
||
RGB565Converter::RGB565ToBGRA(rgb565, b, g, r, a);
|
||
EXPECT_LE(RGB565Converter::CalculateError(v, b), RGB565Converter::MaxError5Bit());
|
||
}
|
||
}
|
||
|
||
INSTANTIATE_TEST_SUITE_P(
|
||
AllValues,
|
||
RGB565ChannelTest,
|
||
::testing::Range(0, 256, 1) // 测试0-255所有值
|
||
);
|
||
|
||
// ============================================
|
||
// 大数据量测试
|
||
// ============================================
|
||
|
||
TEST_F(RGB565Test, LargeFrame_1080p) {
|
||
const size_t WIDTH = 1920, HEIGHT = 1080;
|
||
const size_t COUNT = WIDTH * HEIGHT;
|
||
|
||
// 创建渐变图像
|
||
std::vector<uint8_t> bgra(COUNT * 4);
|
||
for (size_t y = 0; y < HEIGHT; y++) {
|
||
for (size_t x = 0; x < WIDTH; x++) {
|
||
size_t idx = (y * WIDTH + x) * 4;
|
||
bgra[idx + 0] = static_cast<uint8_t>(x * 255 / WIDTH);
|
||
bgra[idx + 1] = static_cast<uint8_t>(y * 255 / HEIGHT);
|
||
bgra[idx + 2] = static_cast<uint8_t>((x + y) * 127 / (WIDTH + HEIGHT));
|
||
bgra[idx + 3] = 255;
|
||
}
|
||
}
|
||
|
||
// 转换
|
||
std::vector<uint16_t> rgb565(COUNT);
|
||
RGB565Converter::ConvertBGRAtoRGB565_Scalar(bgra.data(), rgb565.data(), COUNT);
|
||
|
||
// 验证大小
|
||
EXPECT_EQ(rgb565.size() * sizeof(uint16_t), COUNT * 2);
|
||
|
||
// 抽样验证
|
||
for (size_t i = 0; i < COUNT; i += COUNT / 100) {
|
||
uint16_t expected = RGB565Converter::BGRAToRGB565(bgra[i * 4 + 0], bgra[i * 4 + 1], bgra[i * 4 + 2]);
|
||
EXPECT_EQ(rgb565[i], expected) << "Mismatch at pixel " << i;
|
||
}
|
||
}
|
||
|
||
// ============================================
|
||
// 端序测试
|
||
// ============================================
|
||
|
||
TEST_F(RGB565Test, Endianness_LittleEndian) {
|
||
// RGB565 应该以小端存储
|
||
uint16_t rgb565 = 0x1234;
|
||
uint8_t* bytes = reinterpret_cast<uint8_t*>(&rgb565);
|
||
|
||
// 在小端系统上: bytes[0] = 0x34, bytes[1] = 0x12
|
||
EXPECT_EQ(bytes[0], 0x34);
|
||
EXPECT_EQ(bytes[1], 0x12);
|
||
}
|
||
|
||
// ============================================
|
||
// 错误处理测试
|
||
// ============================================
|
||
|
||
TEST_F(RGB565Test, ZeroPixelCount) {
|
||
std::vector<uint8_t> bgra(4);
|
||
std::vector<uint16_t> rgb565(1);
|
||
|
||
// 零像素不应崩溃
|
||
RGB565Converter::ConvertBGRAtoRGB565_Scalar(bgra.data(), rgb565.data(), 0);
|
||
RGB565Converter::ConvertRGB565ToBGRA(rgb565.data(), bgra.data(), 0);
|
||
}
|