视频编码原理 on Dorkytiger 的小屋

为什么不直接存 YUV 图片序列？

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

一、数据量对比

void print_bitrate(int width, int height, int fps) {
    auto yuv420_size = [](int w, int h) {
        return w * h * 3 / 2;  // Y + UV/4 + UV/4
    };

    int frame_bytes = yuv420_size(width, height);
    int second_bytes = frame_bytes * fps;
    int minute_bytes = second_bytes * 60;
    int hour_bytes   = minute_bytes * 60;

    auto to_mb = [](int b) { return b / 1024 / 1024; };

    std::cout << width << "x" << height << " @" << fps << "fps YUV420:\n"
              << "  一帧:    " << to_mb(frame_bytes)   << " MB\n"
              << "  一秒:    " << to_mb(second_bytes)  << " MB\n"
              << "  一分:    " << to_mb(minute_bytes)  << " MB\n"
              << "  一小时:  " << to_mb(hour_bytes)    << " MB ≈ "
              << to_mb(hour_bytes) / 1024 << " GB\n";
}

// print_bitrate(1920, 1080, 60);
// 输出：
//   一帧:     3 MB
//   一秒:     180 MB
//   一分:     10800 MB
//   一小时:   648000 MB ≈ 633 GB
// 一小时就要 633GB，不可接受。
// 编码后（H.264 10Mbps）：一小时 ≈ 4.5 GB → 压缩比约 140:1

二、编码器怎么做到的？

编码器利用了两个层面的冗余：

帧类型

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

一、I / P / B 帧的物理含义

I 帧（Intra-coded frame）：
  [████████████████████████████]
  完整编码的一帧，不需要参考其他帧
  相当于一张独立的 JPEG 图片
  体积最大，但可随机访问（seek 时找最近的 I 帧）

P 帧（Predictive frame）：
  [    ████                     ]
  只存"和前一帧不一样的地方"
  需要一个参考帧（通常是前一帧）

B 帧（Bidirectionally predictive frame）：
  [       ██                     ]
  参考前后帧，压缩率最高
  需要前后帧解码后才能解码自己 → 延迟最大

GOP（Group of Pictures）：
  I B B P B B P B B P B B I B B P ...
  ├────────── GOP 1 ──────────┤├── GOP 2...
  每 12 帧一个 I 帧（通常）
  GOP 越大压缩率越高，但 seek 越慢

二、把"帧间差异"可视化的 C++ 代码

#include <vector>
#include <cstdint>
#include <cstdio>

// 模拟：计算两帧之间的差异
// 输出是一张"差帧"——像素越亮说明变化越大

struct FrameDiff {
    std::vector<uint8_t> diff_data;
    int width, height;
    int changed_pixels;   // 有多少像素变了（差 > 阈值）
    double change_ratio;  // 变化比例
};

FrameDiff compute_frame_diff(const uint8_t* frame1, const uint8_t* frame2,
                              int width, int height, int threshold = 16) {
    FrameDiff result;
    result.width = width;
    result.height = height;
    result.diff_data.resize(width * height);
    result.changed_pixels = 0;

    for (int i = 0; i < width * height; i++) {
        int diff = abs((int)frame1[i] - (int)frame2[i]);
        // 差帧可视化：差异越大像素越亮
        result.diff_data[i] = std::min(diff * 4, 255);

        if (diff > threshold) {
            result.changed_pixels++;
        }
    }

    result.change_ratio = (double)result.changed_pixels / (width * height);
    return result;
}

// 模拟"I 帧 + P 帧"的存储方式
struct CompressedFrame {
    bool is_keyframe;      // I 帧还是 P 帧
    std::vector<uint8_t> data;  // 如果是 P 帧，只存差异+位置
    size_t data_size;      // 方便对比大小
};

// I 帧：存所有像素
CompressedFrame encode_iframe(const uint8_t* frame, int w, int h) {
    CompressedFrame cf;
    cf.is_keyframe = true;
    cf.data.assign(frame, frame + w * h);  // 无损存储
    cf.data_size = cf.data.size();
    return cf;
}

// P 帧：只存和参考帧的差异
CompressedFrame encode_pframe(const uint8_t* current, const uint8_t* reference,
                               int w, int h, int threshold = 16) {
    CompressedFrame cf;
    cf.is_keyframe = false;
    cf.data.clear();

    for (int i = 0; i < w * h; i++) {
        int diff = abs((int)current[i] - (int)reference[i]);
        if (diff > threshold) {
            // 存 "位置:旧值→新值"（实际编码器中远更复杂）
            int pos = i;
            cf.data.push_back((pos >> 8) & 0xFF);
            cf.data.push_back(pos & 0xFF);
            cf.data.push_back(current[i]);
        }
    }
    cf.data_size = cf.data.size();
    return cf;
}

// 测试：对比 I 帧和 P 帧的大小
void test_frame_types() {
    const int W = 320, H = 240;
    std::vector<uint8_t> frame1(W * H), frame2(W * H);

    // 生成两帧：第二帧只有右上角 50x50 的区域变化
    for (int i = 0; i < W * H; i++) {
        frame1[i] = 128;  // 灰色背景
        frame2[i] = 128;
    }
    // 在第二帧的右上角画一个白色方块
    for (int y = 20; y < 70; y++) {
        for (int x = W - 70; x < W - 20; x++) {
            frame2[y * W + x] = 240;
        }
    }

    auto iframe = encode_iframe(frame1.data(), W, H);
    auto pframe = encode_pframe(frame2.data(), frame1.data(), W, H);

    std::cout << "I 帧大小: " << iframe.data_size << " bytes\n";
    std::cout << "P 帧大小: " << pframe.data_size << " bytes\n";
    std::cout << "压缩比:   " << (double)iframe.data_size / pframe.data_size << "x\n";

    auto diff = compute_frame_diff(frame1.data(), frame2.data(), W, H);
    std::cout << "变化像素: " << diff.changed_pixels << "/" << (W*H)
              << " (" << diff.change_ratio * 100 << "%)\n";
}

// 输出：
// I 帧大小: 76800 bytes
// P 帧大小: 7935 bytes
// 压缩比:   9.6x
// 变化像素: 2500/76800 (3.25%)
//
// P 帧比 I 帧小了 9.6 倍——只存变化的部分。
// 实际编码器（H.264）的压缩比更大，因为还用了 DCT + 量化。

编码器基础流程

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

一、从原始帧→编码流的四个阶段

原始 YUV 帧
    │
    ▼
① 预测（Prediction）
   帧内预测：用当前帧已编码的区域预测当前块（I 帧适用）
   帧间预测：用前一帧搜索最相似的块，记录位移向量（P 帧适用）
   输出 = 残差块（原始块 - 预测块）
    │
    ▼
② 变换（DCT）
   把残差块从"空间域"转成"频域"
   DCT 后：低频系数（左上角）很大 → 人眼敏感
          高频系数（右下角）很小 → 人眼不敏感
    │
    ▼
③ 量化（Quantization）
   把 DCT 系数除以量化步长 → 高频系数变成 0
   "丢掉人眼不敏感的信息"——这是有损压缩的核心
    │
    ▼
④ 熵编码（Entropy Coding）
   Huffman / 算术编码 → 无损压缩
   CABAC（H.264 默认）：比 CAVLC 压缩率高 10%，但计算量大 3x
    │
    ▼
H.264 码流

二、手写简化 DCT（了解原理即可）

真正的编码器用整数 DCT（如 HEVC 的 4x4 DCT），这里用简化版展示原理：

串行 I/P 帧与编码效率模拟

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

#include <vector>
#include <cstdint>
#include <cstdlib>

// 模拟一个非常简化的视频编码器
// 只编码 I 帧和 P 帧（无 B 帧），观察不同场景下的压缩效率

class SimpleEncoder {
    int width_, height_;
    std::vector<uint8_t> reference_;  // 参考帧
    int keyframe_interval_;           // 每隔几帧插一个 I 帧
    int frame_count_ = 0;

    // "运动估计"：在参考帧中搜索最匹配的 8x8 块
    struct MotionVector { int dx, dy; };
    MotionVector search_block(const uint8_t* cur, const uint8_t* ref,
                               int bx, int by, int search_range = 16) {
        int best_cost = INT_MAX;
        MotionVector best = {0, 0};

        for (int dy = -search_range; dy <= search_range; dy++) {
            for (int dx = -search_range; dx <= search_range; dx++) {
                int cost = 0;
                for (int y = 0; y < 8; y++) {
                    for (int x = 0; x < 8; x++) {
                        int cur_px = cur[(by + y) * width_ + (bx + x)];
                        int ref_px = ref[(by + y + dy) * width_ + (bx + x + dx)];
                        cost += abs(cur_px - ref_px);
                    }
                }
                if (cost < best_cost) {
                    best_cost = cost;
                    best = {dx, dy};
                }
            }
        }
        return best;
    }

public:
    SimpleEncoder(int w, int h, int keyframe_interval)
        : width_(w), height_(h), reference_(w * h), keyframe_interval_(keyframe_interval) {
        std::fill(reference_.begin(), reference_.end(), 128);
    }

    struct EncodedFrame {
        bool is_keyframe;
        size_t data_size;  // 编码后的估计大小
    };

    EncodedFrame encode(const uint8_t* frame) {
        frame_count_++;
        EncodedFrame ef;

        if (frame_count_ % keyframe_interval_ == 1) {
            // I 帧：完整存储（模拟 JPEG 级压缩，约 1/3 原大小）
            ef.is_keyframe = true;
            ef.data_size = width_ * height_;  // 简化：算 1:1
            memcpy(reference_.data(), frame, width_ * height_);
        } else {
            // P 帧：只存运动向量 + 残差
            ef.is_keyframe = false;
            size_t motion_data = 0;
            size_t residual_data = 0;

            for (int y = 0; y < height_; y += 8) {
                for (int x = 0; x < width_; x += 8) {
                    auto mv = search_block(frame, reference_.data(), x, y);
                    // 运动向量：8 位够存 dx, dy
                    motion_data += 2;

                    // 残差：用绝对差和估计
                    for (int by = 0; by < 8; by++) {
                        for (int bx = 0; bx < 8; bx++) {
                            int cur_px = frame[(y + by) * width_ + (x + bx)];
                            int ref_px = reference_[(y + by + mv.dy) * width_ + (x + mv.dx + bx)];
                            residual_data += abs(cur_px - ref_px) < 8 ? 0 : 1;
                        }
                    }
                }
            }
            ef.data_size = motion_data + residual_data;
            memcpy(reference_.data(), frame, width_ * height_);
        }

        return ef;
    }
};

void test_encoder_scenarios() {
    const int W = 64, H = 48;
    SimpleEncoder encoder(W, H, 30);

    // 场景 1：静态画面（摄像头静止）
    std::vector<uint8_t> static_frame(W * H, 128);

    // 场景 2：快速运动（画面整体右移）
    std::vector<uint8_t> motion_frame(W * H);
    for (int y = 0; y < H; y++)
        for (int x = 0; x < W; x++)
            motion_frame[y * W + x] = (x + y * 3) % 256;

    printf("静态场景编码（30 帧）:\n");
    for (int i = 0; i < 30; i++) {
        auto ef = encoder.encode(static_frame.data());
        printf("  帧 %2d: %s, size=%zu\n", i + 1,
               ef.is_keyframe ? "I" : "P", ef.data_size);
    }

    // 重置编码器
    SimpleEncoder motion_enc(W, H, 30);
    printf("\n动态场景编码（30 帧，每帧整体右移 1 像素）:\n");
    for (int i = 0; i < 30; i++) {
        // 模拟画面平移
        for (int y = 0; y < H; y++)
            for (int x = 0; x < W; x++)
                motion_frame[y * W + x] = (x + i + y * 3) % 256;

        auto ef = motion_enc.encode(motion_frame.data());
        printf("  帧 %2d: %s, size=%zu\n", i + 1,
               ef.is_keyframe ? "I" : "P", ef.data_size);
    }
}

测试结果的意义：

第二阶段总结

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

编码的本质：
    帧内预测（空间冗余）+ 帧间预测（时间冗余）
    + DCT（频域变换）
    + 量化（丢细节）
    + 熵编码（无损压缩）

I/P/B 帧：
    I 帧：完整编码，可随机访问，体积最大
    P 帧：参考前一帧，只存差异
    B 帧：参考前后帧，压缩率最高，但需要重新排序

DCT 的作用：
    把像素变换为频率系数
    平坦区域 → 只有一个 DC 系数有用
    量化后大部系数为 0 → 可以高效压缩