色彩空间与像素格式 on Dorkytiger 的小屋

RGB 色彩空间

Mon, 01 Jan 0001 00:00:00 +0000

一、RGB 的物理含义

RGB 是加色模型：三种颜色的光叠加在一起，越叠越亮。

       红 (R)
      /   \
    /      \
黄         洋红
|            |
绿 ──── 白 ──── 蓝
|            |
  青         蓝 (B)
      \      /
        \  /
       绿 (G)

显示器的工作原理：每个像素由三个子像素（红/绿/蓝 LED）组成，通过控制亮度百分比混合出各种颜色。

在内存中的排列（C++ 处理时直接面对）：

// RGB24：每个像素 3 字节，R/G/B 各 8 bit
struct RGBPixel {
    uint8_t r, g, b;  // 内存顺序取决于平台
};

// OpenCV 是 BGR 顺序
struct BGRPixel {
    uint8_t b, g, r;  // 注意：蓝在前，红在后
};

// RGBA：每个像素 4 字节，多一个 Alpha（透明度）
struct RGBAPixel {
    uint8_t r, g, b, a;
};

// 一行 1920×1080 RGB 图片的内存布局
// [R][G][B][R][G][B][R][G][B]......[R][G][B]
//  \___________ 1920 × 3 = 5760 字节 ___________/
// 然后下一行

二、RGB 为什么不适合视频编码？

你提到的这个问题确实是很多初学者容易困惑的地方。简单说：RGB 把宝贵的带宽浪费在了人眼不敏感的信息上，而且三个通道之间有大量重复信息。

YUV 色彩空间

Mon, 01 Jan 0001 00:00:00 +0000

一、YUV 的核心思想

把亮度和颜色分开：

Y（Luma）：灰度信息，就是黑白画面
U（Cb / Chroma Blue）：蓝色色度偏移
V（Cr / Chroma Red）：红色色度偏移

YUV 的直观理解：
  把一张彩色照片转成 YUV：
  Y = 黑白照片（完全保留了图像的细节/边缘/纹理）
  U/V = 只有模糊的颜色涂抹（人眼无法分辨色度的细节）

解码器用 Y + UV 合成彩色 → 效果和 RGB 一样，但 UV 可以省带宽。

二、RGB ↔ YUV 转换公式（手写实现）

BT.601 标准（标清视频）的转换：

#include <cstdint>
#include <algorithm>

// ============ RGB → YUV（BT.601） ============

struct YUV {
    uint8_t y, u, v;
};

YUV rgb_to_yuv(uint8_t r, uint8_t g, uint8_t b) {
    YUV out;
    // Y  =  0.299R + 0.587G + 0.114B
    // U  = -0.169R - 0.331G + 0.500B + 128
    // V  =  0.500R - 0.419G - 0.081B + 128
    //
    // 用整数运算避免浮点：
    int y = (66 * r + 129 * g + 25 * b + 128) >> 8 + 16;
    int u = (-38 * r - 74 * g + 112 * b + 128) >> 8 + 128;
    int v = (112 * r - 94 * g - 18 * b + 128) >> 8 + 128;

    out.y = std::clamp(y, 16, 235);   // 广播级范围
    out.u = std::clamp(u, 16, 240);
    out.v = std::clamp(v, 16, 240);
    return out;
}

// ============ YUV → RGB（BT.601） ============

struct RGB {
    uint8_t r, g, b;
};

RGB yuv_to_rgb(uint8_t y, uint8_t u, uint8_t v) {
    int yy = y - 16;
    int uu = u - 128;
    int vv = v - 128;

    int r = (298 * yy + 409 * vv + 128) >> 8;
    int g = (298 * yy - 100 * uu - 208 * vv + 128) >> 8;
    int b = (298 * yy + 516 * uu + 128) >> 8;

    return RGB{
        (uint8_t)std::clamp(r, 0, 255),
        (uint8_t)std::clamp(g, 0, 255),
        (uint8_t)std::clamp(b, 0, 255)
    };
}

对比测试：原始 RGB 值 → 转 YUV → 转回 RGB，验证一致性。

色度采样（Chroma Subsampling）

Mon, 01 Jan 0001 00:00:00 +0000

一、为什么 UV 可以压缩？

一张 1920×1080 的图片，Y 分量保留了所有边缘和纹理细节。把 UV 分辨率降低到 960×540，人眼几乎看不出区别——因为人眼对颜色的空间分辨率远低于亮度。

原始 RGB：1920×1080 × 3 bytes = 6.2 MB
YUV 4:4:4：1920×1080 + 1920×1080 + 1920×1080 = 也 6.2 MB（没省空间）
YUV 4:2:0：1920×1080(Y) + 960×540(U) + 960×540(V) = 3.1 MB → 省了 50%

二、4:4:4 / 4:2:2 / 4:2:0 图解

符号含义："J:a:b"
  J = 水平参考宽度（通常 4 个像素）
  a = 第一行每个 J 像素中有几个色度样本
  b = 第二行中多出的色度样本数

4:4:4（无压缩）
  像素位置: 0    1    2    3    4    5    6    7
  Y:        Y0   Y1   Y2   Y3   Y4   Y5   Y6   Y7
  U:        U0   U1   U2   U3   U4   U5   U6   U7
  V:        V0   V1   V2   V3   V4   V5   V6   V7
  每个像素都有自己的 Y/U/V → 数据量 = 1920×1080×3

4:2:2（水平减半）
  像素位置: 0    1    2    3    4    5    6    7
  Y:        Y0   Y1   Y2   Y3   Y4   Y5   Y6   Y7
  U:        U0        U2        U4        U6
  V:        V0        V2        V4        V6
  每 2 个像素共享一组 UV → 数据量 = 1920×1080 × 2
  常见于专业视频采集、广播设备

4:2:0（水平和垂直都减半）
  像素位置: 0    1    2    3
  第 0 行 Y: Y00  Y10  Y20  Y30
            U:  U00       U20
            V:  V00       V20
  第 1 行 Y: Y01  Y11  Y21  Y31
            U:  (使用第 0 行的 U/V，不重复存储)
            V:
  每 4 个像素共享一组 UV → 数据量 = 1920×1080 × 1.5
  所有视频编码标准（H.264/HEVC/VP9/AV1）的默认格式

三、4:4:4 → 4:2:0 下采样的手写实现

#include <vector>
#include <cstdint>

// 把 YUV 4:4:4 的 UV 平面下采样为 4:2:0
// 输入：UV 平面和 Y 一样大（w × h）
// 输出：UV 平面各缩小为 (w/2) × (h/2)
void subsample_420(const uint8_t* src_u, const uint8_t* src_v,
                   uint8_t* dst_u, uint8_t* dst_v,
                   int width, int height) {
    int uv_w = width / 2;
    int uv_h = height / 2;

    for (int y = 0; y < uv_h; y++) {
        for (int x = 0; x < uv_w; x++) {
            // 4:2:0 的 U/V 取 2×2 块的均值
            int sum_u = 0, sum_v = 0;
            for (int dy = 0; dy < 2; dy++) {
                for (int dx = 0; dx < 2; dx++) {
                    int src_idx = (y * 2 + dy) * width + (x * 2 + dx);
                    sum_u += src_u[src_idx];
                    sum_v += src_v[src_idx];
                }
            }
            int dst_idx = y * uv_w + x;
            dst_u[dst_idx] = sum_u / 4;
            dst_v[dst_idx] = sum_v / 4;
        }
    }
}

四、三种采样格式的数据量对比

void print_sizes(int width, int height) {
    int y_size = width * height;
    int uv_444 = width * height;
    int uv_422 = (width / 2) * height;
    int uv_420 = (width / 2) * (height / 2);

    auto fmt = [](int bytes) {
        if (bytes > 1024 * 1024)
            return std::to_string(bytes / 1024 / 1024) + "MB";
        return std::to_string(bytes / 1024) + "KB";
    };

    std::cout << width << "x" << height << " 一帧:\n"
              << "  RGB24:     " << fmt(y_size * 3) << "\n"
              << "  YUV 4:4:4: " << fmt(y_size + uv_444 * 2) << "\n"
              << "  YUV 4:2:2: " << fmt(y_size + uv_422 * 2) << "\n"
              << "  YUV 4:2:0: " << fmt(y_size + uv_420 * 2) << "\n";
}

// print_sizes(1920, 1080);
// 输出：
//   RGB24:     6.2 MB
//   YUV 4:4:4: 6.2 MB
//   YUV 4:2:2: 4.1 MB
//   YUV 4:2:0: 3.1 MB

YUV 在内存中的布局

Mon, 01 Jan 0001 00:00:00 +0000

一、两种主流布局：Planar vs Semi-Planar

这是 C++ 处理视频时最常搞错的地方。FFmpeg、OpenCV、硬件编码器返回的 YUV 数据格式不同。

YUV420P（Planar）— FFmpeg 的默认格式 av_pix_fmt_yuv420p
  内存：YYYYYYYYYYYYYYYY...UUUUUUUU...VVVVVVVV
        [全部 Y 行]  [全部 U 行]  [全部 V 行]

  索引：
  Y 平面：data[0], linesize[0] = width
  U 平面：data[1], linesize[1] = width/2
  V 平面：data[2], linesize[2] = width/2

  获取像素 (x,y) 的 Y/U/V：
  y = data[0][y * linesize[0] + x]
  u = data[1][y/2 * linesize[1] + x/2]
  v = data[2][y/2 * linesize[2] + x/2]

NV12（Semi-Planar）— 硬件编码器的默认格式（Intel QSV、VideoToolbox、MPP）
  内存：YYYYYYYYYYYYYYYY...UVUVUVUVUV
        [全部 Y 行]  [UV 交错排列]

  Y 平面：data[0], linesize[0] = width
  UV 平面：data[1], linesize[1] = width（UV 交替，每个 U/V 各 1 byte）
  注意：linesize[1] 是 width 而不是 width，因为 UV 交织在一起

  获取像素 (x,y) 的 Y/U/V：
  y = data[0][y * linesize[0] + x]
  uv_index = (y/2) * linesize[1] + (x/2) * 2
  u = data[1][uv_index]
  v = data[1][uv_index + 1]

二、手写 YUV420P ↔ NV12 转换

这两个格式之间互相转换是音视频开发者的基本功：

第一阶段总结

Mon, 01 Jan 0001 00:00:00 +0000

RGB → YUV：
    把亮度（Y）和颜色（UV）分离
    转换是可逆的（伤害误差 < 1/255）

YUV 省带宽的原理：
    人眼对颜色不敏感 → UV 分辨率可以降低
    4:2:0 比 RGB 省 50% 带宽，视觉效果几乎不变

内存布局（C++ 开发者最常犯错的地方）：
    YUV420P：YYYY...UU...VV...（三个平面）
    NV12：   YYYY...UVUV...（Y 平面 + 交错 UV 平面）
    linesize 可能 ≠ width，永远用 linesize 跳过 padding