"buffer" （泛称，指图形缓冲区）
    │
    └── GraphicBuffer （具体的 C++ 类，定义在 GraphicBuffer.h）
            │
            ├── 描述信息:  width, height, stride, format, usage
            │
            └── handle (buffer_handle_t)
                  │
                  └── 指向 gralloc 分配的物理内存（通过 ION/dmabuf）
                        │
                        └── 这块内存就是实际存放像素的地方

GraphicBuffer 构造
  → GraphicBufferAllocator::allocate()
    → gralloc HAL（硬件抽象层）
      → ION / dmabuf 分配物理内存
        → 返回 buffer_handle_t（包含 fd 和元数据）

FREE → DEQUEUED → QUEUED → ACQUIRED → FREE（循环复用）
(空闲)  (生产者持有)  (已提交)  (消费者持有)  (释放回来)

                         cancelBuffer()
FREE ← ← ← ← ← ← ← ← DEQUEUED

BufferQueue（通常 2~3 个 slot，最大 64 个）：
┌──────────┬──────────┬──────────┐
│  slot 0  │  slot 1  │  slot 2  │
│ GraphicBuf│ GraphicBuf│ GraphicBuf│  ← 首次 dequeue 时分配，之后复用
│ ACQUIRED │ FREE     │ DEQUEUED │
└──────────┴──────────┴──────────┘
  ↑ SF 在读    ↑ 空闲待用   ↑ App 在写

生产者（App）端：
  1. dequeueBuffer(slot) → 获取空闲 slot + releaseFence
  2. requestBuffer(slot) → 获取 GraphicBuffer 指针（首次）
  3. GraphicBufferMapper::lock() → 映射到 CPU 虚拟地址
  4. [渲染：写入像素数据]
  5. GraphicBufferMapper::unlock() → 解除映射
  6. queueBuffer(slot, QueueBufferInput{fence, timestamp, crop, ...})
     → 提交 buffer + 附带元信息

消费者（SurfaceFlinger）端：
  7. acquireBuffer(slot) → 获取已提交的 buffer + acquireFence
  8. [合成：读取像素，合成到帧]
  9. releaseBuffer(slot, releaseFence) → 释放 buffer
  10. Buffer → FREE（可被生产者再次 dequeue）

一个 Layer 在 SurfaceFlinger 中：

┌─────────────────────────────────────┐
│          元数据（Metadata）           │ ← SurfaceControl.Transaction 控制
│                                     │
│  position=(100,200)                 │    "这个图层放在 (100,200)，
│  matrix=[0.8,0,0,0.8]              │     缩放到 0.8 倍，
│  alpha=0.5                          │     透明度 50%，
│  crop=(0,0,540,1200)               │     裁剪成这个矩形"
│  z=5, cornerRadius=20              │
│                                     │    → 告诉 SurfaceFlinger 怎么摆
├─────────────────────────────────────┤
│        buffer 内容（像素）            │ ← Surface.queueBuffer() 提交
│                                     │
│  GraphicBuffer → 物理内存 → 像素     │    "这张图上画了一个按钮、
│                                     │     一段文字、一张图片..."
│                                     │
│                                     │    → 告诉 SurfaceFlinger 画了什么
└─────────────────────────────────────┘

App 进程：

  Surface ──→ BufferQueue ──→ SurfaceFlinger
  (写像素)    (共享内存，零拷贝)  (拿 buffer 合成)
              数据量: 数 MB 像素    传输方式: 共享内存

  SurfaceControl.Transaction ──→ SurfaceFlinger
  (改属性)         (Binder，传几个数值)
                   数据量: 几十字节     传输方式: Binder IPC

假设 Window 动画走 buffer（重绘方案）：
  每帧: App 重绘整个窗口 → CPU measure/layout → GPU 渲染
        → 跨进程传 buffer → SurfaceFlinger 合成
  开销: CPU + GPU + 内存带宽，数 MB 数据

假设 Window 动画走 SurfaceControl（实际方案）：
  每帧: Transaction.setMatrix(float x4) → Binder 传几个 float
        → SurfaceFlinger 直接对已有 buffer 做矩阵变换 → 合成
  开销: 仅几十字节的 Binder 调用

分离后可以自由组合：

场景 1: View 动画
  → 只更新 buffer（每帧新像素），元数据不变

场景 2: Window 动画
  → 只更新元数据（位置/缩放/透明度），buffer 不变

场景 3: 视频播放 + 画中画拖动
  → buffer 和元数据同时独立更新，互不干扰

场景 4: 静态壁纸
  → buffer 和元数据都不变，SurfaceFlinger 直接复用上一帧

┌─────────────────────────────────────────────────────────┐
│                        App 进程                          │
│                                                         │
│   Surface                    SurfaceControl              │
│   ├─ lockCanvas()            ├─ Transaction {            │
│   ├─ queueBuffer()          │    setPosition()          │
│   └─ 操作: GraphicBuffer     │    setMatrix()            │
│       (写像素)               │    setAlpha()             │
│                              │    setCrop()              │
│                              │    apply() ──────────┐    │
│                              └───────────────────── │ ── │
└──────────┬──────────────────────────────────────── │ ───┘
           │                                         │
           │ IGraphicBufferProducer                  │ ISurfaceComposer
           │ (共享内存，零拷贝)                        │ setTransactionState()
           │ 数据量: 数 MB                            │ (Binder，几十字节)
           ▼                                         ▼
┌─────────────────────────────────────────────────────────┐
│                   SurfaceFlinger 进程                     │
│                                                         │
│   Layer                                                 │
│   ├── buffer 内容: GraphicBuffer → 像素数据              │
│   │   (来自 Surface.queueBuffer)                        │
│   │                                                     │
│   └── 元数据: position, matrix, alpha, crop, z, ...     │
│       (来自 SurfaceControl.Transaction)                  │
│                                                         │
│   合成: 用元数据决定怎么摆放 buffer → 输出到屏幕           │
└─────────────────────────────────────────────────────────┘