图形渲染与显示体系

在 Android 图形渲染与显示体系中，Choreographer、SurfaceFlinger、HWC、VSYNC 是核心基础组件，围绕它们还有一系列负责图形数据处理、渲染执行、硬件交互的关键模块与概念。以下是系统化的梳理，按功能模块分类：

图形渲染与显示体系

Android 图形渲染是一个多层级、跨进程、软硬协同的复杂系统：

• App 端：ViewRootImpl 启动绘制，Canvas/RenderThread 生成指令，Surface/BufferQueue 传递数据；
• 系统端：WMS 管理窗口，SurfaceFlinger 负责合成，HWC/GPU 执行渲染；
• 硬件端：DisplayController 驱动屏幕，VSyncGenerator 同步时序。

这些组件共同保证了从「代码绘制逻辑」到「屏幕显示画面」的高效、流畅流转。

渲染核心框架与引擎

这部分组件负责将 App 的 UI 描述（如 View、Drawable）转化为 GPU 可执行的渲染指令，是图形绘制的 “生产端”。

1. Skia

   • 核心定位：Android 官方 2D 图形渲染引擎，也是 Chrome、Flutter 的默认渲染引擎。
   • 作用：处理 2D 图形的绘制逻辑，包括矢量图形、位图、文字渲染、滤镜效果等；提供统一的 API 抽象，底层可对接 OpenGL ES、Vulkan 或 CPU 绘制，屏蔽不同硬件的差异。
   • 与核心组件的关联：App 的 View.onDraw() 最终会调用 Skia 的 API 生成绘制命令；SurfaceFlinger 合成时也会依赖 Skia 处理部分图层的预处理（如缩放、裁剪）。

2. OpenGL ES / Vulkan

   • 核心定位：跨平台的 3D/2D 图形渲染 API 标准，是 GPU 渲染的 “接口层”。

   • 区别与应用场景

     • OpenGL ES：Android 早期主流，API 相对简单，采用状态机模式，适合中低复杂度的 3D 场景（如游戏、AR 基础功能）。
     • Vulkan：新一代高性能渲染 API，采用无状态设计，支持多线程并行提交指令，降低 CPU 开销，适合高帧率、高复杂度的 3D 场景（如大型手游、实时渲染）。

   • 与核心组件的关联：Skia、SurfaceFlinger 均可选择 OpenGL ES/Vulkan 作为底层渲染驱动；HWC 若不支持某类图层合成，会 fallback 到 GPU（通过 OpenGL ES/Vulkan）进行合成。

3. RenderThread

   • 核心定位：Android 5.0（Lollipop）引入的独立渲染线程，用于分离 UI 线程与渲染操作。
   • 作用：将原本在 UI 线程执行的 onDraw() 绘制命令、图层构建等工作转移到 RenderThread，避免渲染耗时操作阻塞 UI 线程（解决卡顿问题）。
   • 与核心组件的关联：RenderThread 会接收 Choreographer 分发的 VSYNC 信号，触发渲染任务；渲染完成后生成的帧数据会提交到 Surface，供 SurfaceFlinger 合成。

图层管理与数据载体

这部分组件是 “图形数据的容器”，负责存储 App 或系统的渲染结果，是连接 App 与 SurfaceFlinger 的桥梁。

1. Surface

   • 核心定位：每个可绘制组件（如 Activity、SurfaceView、TextureView）对应的图形数据缓冲区抽象。
   • 作用：App 的 RenderThread 会将渲染好的帧数据写入 Surface 对应的缓冲区（BufferQueue）；SurfaceFlinger 从 BufferQueue 中获取缓冲区数据，进行后续合成。
   • 关键特性：不同组件的 Surface 相互独立，SurfaceFlinger 可对多个 Surface 进行分层合成。

2. BufferQueue

   • 核心定位：Surface 与 SurfaceFlinger 之间的缓冲区队列，是图形数据传输的 “管道”。

   • 工作机制

     ：采用

     生产者 - 消费者

     模型

     • 生产者：App 的 RenderThread 作为生产者，将渲染完成的帧数据写入 BufferQueue 的空闲缓冲区。
     • 消费者：SurfaceFlinger 作为消费者，从 BufferQueue 中取出已填充的缓冲区进行合成；合成完成后，缓冲区会被回收为空闲状态，供生产者复用。

   • 核心价值：通过缓冲区复用，减少内存拷贝，提升渲染效率。

3. Layer

   • 核心定位：SurfaceFlinger 内部对每个 Surface 的抽象表示。
   • 作用：SurfaceFlinger 会为每个 Surface 创建对应的 Layer 对象，Layer 中存储了该图层的属性（如大小、位置、透明度、混合模式）；合成时，SurfaceFlinger 会遍历所有 Layer，按照层级关系和属性进行叠加合成。
   • 常见类型：BufferLayer（对应普通 Surface）、ColorLayer（纯色图层）、BlurLayer（模糊图层）等。

硬件加速与合成增强

这部分组件聚焦 “硬件级优化”，通过专用硬件模块提升合成与显示效率，降低 CPU/GPU 负载。

1. HWComposer（HWC）进阶能力

   • 除了基础的图层合成，现代 HWC 还支持以下高级特性：

     • 色域转换：将 App 渲染的 RGB 数据转换为屏幕支持的色域（如 sRGB、DCI-P3），保证色彩准确。
     • HDR 处理：支持 HDR10、HLG 等 HDR 格式的帧数据合成与显示，提升画面动态范围。
     • 刷新率切换：根据场景需求（如静态画面、高帧率游戏），动态调整屏幕刷新率（如 60Hz → 120Hz），平衡流畅度与功耗。

   • 与 SurfaceFlinger 的分工：SurfaceFlinger 负责图层的逻辑排序，HWC 负责硬件层面的物理合成；若图层数量超过 HWC 支持的最大层数，超出部分由 GPU 合成。

2. Display Composer

   • 核心定位：部分高端芯片（如高通 Adreno、联发科 Mali）内置的专用合成硬件，是 HWC 的硬件载体。
   • 作用：独立于 CPU/GPU 运行，专门处理图层合成、分辨率缩放、旋转等操作，进一步降低主芯片的负载，提升合成效率。

3. GPU 驱动（GPU Driver）

   • 核心定位：连接 OpenGL ES/Vulkan API 与物理 GPU 的驱动程序。
   • 作用：将上层渲染指令翻译为 GPU 可执行的硬件指令；优化渲染流水线（如指令重排、显存管理），直接影响 GPU 的渲染性能。
   • 关键厂商：高通（Adreno）、ARM（Mali）、Imagination（PowerVR）。

同步与时序控制

VSYNC 是核心同步信号，围绕它还有一系列保证 “帧时序稳定” 的机制与组件。

1. VSYNC 信号的分类与传递

   • Display VSYNC：由显示控制器（Display Controller） 生成，频率与屏幕刷新率一致（如 60Hz 对应 16.67ms 间隔），是最基础的同步信号。
   • App VSYNC：由 Choreographer 基于 Display VSYNC 分发，触发 App 的 UI 绘制与渲染任务；Android 引入双 VSYNC 机制后，可避免因渲染延迟导致的帧撕裂。
   • SF VSYNC：专门发送给 SurfaceFlinger 的 VSYNC 信号，触发 SurfaceFlinger 的图层合成任务，保证合成完成的帧能刚好赶上屏幕的下一次刷新。

2. Choreographer 核心机制

   • 除了分发 VSYNC，Choreographer 还负责任务调度：将 App 的输入事件处理（INPUT）、动画计算（ANIMATION）、视图绘制（TRAVERSAL）等任务，按顺序在 VSYNC 周期内执行，确保一帧内完成所有准备工作。

3. Frame Pacing

   • 核心定位：帧节奏控制机制，用于稳定帧率，避免画面卡顿或掉帧。
   • 作用：监控 App 的渲染耗时与 SurfaceFlinger 的合成耗时，动态调整任务执行时机；若某一帧耗时过长，会通过丢帧或延迟提交的方式，保证后续帧的时序稳定。

系统级显示管理组件

这部分组件负责 “全局显示资源的管理”，协调多屏幕、分辨率、刷新率等系统级显示参数。

1. DisplayManagerService（DMS）

   • 核心定位：Android 系统服务，负责管理所有显示设备。
   • 作用：检测外接显示器（如 HDMI、无线投屏）的连接与断开；管理显示设备的属性（如分辨率、刷新率、色域）；为 App 提供显示设备的信息查询接口。
   • 与核心组件的关联：SurfaceFlinger 会从 DMS 获取显示设备的配置信息，调整合成策略。

2. WindowManagerService（WMS）

   • 核心定位：Android 系统服务，负责窗口的管理与布局。
   • 作用：管理所有 App 窗口的层级、大小、位置；处理窗口的创建、销毁、切换；将窗口的布局信息传递给 SurfaceFlinger，指导 SurfaceFlinger 进行图层合成。
   • 与核心组件的关联：WMS 与 SurfaceFlinger 紧密协作，WMS 决定 “窗口应该显示在哪里”，SurfaceFlinger 决定 “窗口如何合成到屏幕上”。

3. SurfaceControl

   • 核心定位：App 与 SurfaceFlinger 交互的控制接口。
   • 作用：提供对 Surface 的底层控制能力，如创建 / 销毁 Surface、设置图层属性（透明度、Z 轴顺序）、控制 Surface 的显示 / 隐藏；通常用于自定义渲染场景（如游戏、视频播放器）。

特殊渲染场景相关组件

针对高帧率、跨平台渲染等特殊需求，Android 提供了专门的组件支持。

1. EGL

   • 核心定位：OpenGL ES/Vulkan 与原生窗口系统之间的中间层。
   • 作用：负责创建渲染上下文（Context）、绑定 Surface 与渲染上下文，实现渲染指令与图形缓冲区的关联；是连接 GPU 渲染与屏幕显示的关键桥梁。

2. Flutter Engine（跨平台渲染）

   • 核心定位：Flutter 的跨平台渲染引擎，可独立于 Android 原生渲染体系工作。
   • 与 Android 组件的关联：Flutter Engine 内置 Skia 渲染引擎，通过 FlutterSurfaceView 创建 Surface；SurfaceFlinger 会将 Flutter 的 Surface 与原生 App 的 Surface 同等对待，进行分层合成。

3. Renderscript

   • 核心定位：Android 提供的高性能计算框架，用于并行处理图形数据或通用计算任务。
   • 应用场景：图像滤镜、视频处理、物理模拟等；可调用 CPU/GPU 进行并行计算，提升数据处理效率。

Android 图形渲染完整流程（含核心组件交互 + 可视化流程）

Android 图形渲染的核心是将 App 绘制的图形数据，通过多层组件协作，最终渲染到物理屏幕上，其中 Choreographer（App 端节拍器）、SurfaceFlinger（系统端合成器）、HWC（硬件合成器）是三大核心组件，整个流程分为「App 端绘制准备」、「跨进程数据传递」、「系统端合成渲染」、「硬件屏幕显示」四个阶段，以下是详细流程和可视化说明。

核心组件先验知识（明确各角色定位）

在理解流程前，先明确核心组件的职责，避免混淆：

完整渲染流程（分阶段 + 组件交互 + 数据流转）

整个渲染流程是一个闭环循环（每帧刷新都遵循该流程），以下是单帧渲染的详细步骤，附带组件交互和数据流转说明：

阶段 1：App 端 - 绘制准备与帧数据生成（由 Choreographer 调度）

这一阶段发生在 App 进程内，核心是响应 VSync 信号，完成 View 绘制，并将结果写入 Surface 的 BufferQueue。

1. VSync 信号接收：触发绘制起点

   • 屏幕显示硬件按照固定刷新率（如 60Hz，每 16.67ms 一次）生成 VSync 信号；
   • 信号通过系统底层（SurfaceFlinger 转发）传递到 App 进程的 Choreographer；
   • Choreographer 内部维护了 3 个回调队列（INPUT 输入队列、ANIMATION 动画队列、TRAVERSAL 绘制队列），VSync 信号触发队列依次执行，最终走到绘制流程。

2. Choreographer 调度 View 绘制流程（测量 → 布局 → 绘制）

   • 步骤 2.1：Choreographer 调用 ViewRootImpl.performTraversals() 方法，启动 View 树的遍历；

   • 步骤 2.2：执行 measure() 方法：从上到下遍历 View 树，计算每个 View 的宽高尺寸；

   • 步骤 2.3：执行 layout() 方法：从上到下遍历 View 树，确定每个 View 在父容器中的位置坐标；

   • 步骤 2.4：执行 draw() 方法：从下到上遍历 View 树（保证子 View 覆盖父 View），完成具体绘制：

     • 简单 View（如 TextView）：直接通过 Canvas 绘制到 Surface 对应的缓冲区；
     • 复杂图形 / 动画（如 TextureView、3D 效果）：通过 OpenGL ES/Vulkan 调用 GPU 进行渲染，渲染结果写入 Surface 的 BufferQueue；

   • 关键说明：Canvas 是绘制抽象层，底层最终会关联到 Surface 的图形缓冲区，绘制操作本质是向缓冲区写入像素数据。

3. 帧数据写入 BufferQueue：完成 App 端数据生产

   • 绘制完成后，生成的帧数据（像素数组）被写入 Surface 绑定的 BufferQueue 中的「空闲缓冲区」（GraphicBuffer）；
   • 此时该缓冲区的状态从「空闲」变为「已生产（Produced）」；
   • Surface 通过跨进程通信（Binder）通知 SurfaceFlinger：有新的帧数据可供消费，完成 App 端的绘制流程。

阶段 2：跨进程数据传递（App → SurfaceFlinger）

这一阶段是「数据交接」，核心是通过 Binder 通信和 BufferQueue 完成帧数据从 App 进程到 SurfaceFlinger 进程的传递，帧数据本身不做拷贝（采用「共享内存」方式），仅传递缓冲区句柄和状态，提升效率。

1. App 进程的 Surface 通过 Binder 向 SurfaceFlinger 发送「帧数据就绪」通知，携带 BufferQueue 中已生产缓冲区的句柄（内存地址标识）；
2. SurfaceFlinger 作为 BufferQueue 的「消费者」，接收缓冲区句柄后，通过「共享内存」直接访问该缓冲区中的帧数据（无需拷贝，避免性能损耗）；
3. SurfaceFlinger 将该缓冲区的状态从「已生产」变为「已消费（Consumed）」，并将其加入到「待合成窗口列表」中。

阶段 3：系统端 - 多窗口合成（SurfaceFlinger 主导 + HWC/GPU 协作）

这一阶段发生在 SurfaceFlinger 进程内，核心是将所有 App / 系统窗口的帧数据，按照层级合成为一帧完整的屏幕数据，是渲染流程的核心枢纽。

1. 窗口层级排序：确定显示优先级

   • SurfaceFlinger 收集所有待显示的 Surface（包括当前 App 窗口、状态栏、导航栏、悬浮窗等）；
   • 按照 Z-Order 层级规则（系统预设 + App 配置）对所有 Surface 进行排序，确定哪个 Surface 在最上层显示（如状态栏始终在最顶层）。

2. 合成方式选择：HWC 硬件合成（优先） vs GPU 软件合成

   • SurfaceFlinger 将排序后的 Surface 列表传递给 HWC，查询 HWC 的合成能力；

   • 情况 2.1：HWC 支持所有 Surface 的硬件合成（无复杂特效、Surface 数量在 HWC 支持范围内）→ 优先采用硬件合成：

     • SurfaceFlinger 将各 Surface 的缓冲区句柄、层级、位置信息分发到 HWC；
     • HWC 直接在硬件层（显示控制器）完成多 Surface 合成，无需调用 GPU，性能最优；

   • 情况 2.2：HWC 不支持部分 Surface 合成（如含复杂滤镜、3D 变换、Surface 数量超出限制）→ 混合合成 / 纯软件合成：

     • SurfaceFlinger 调用 GPU（通过 OpenGL ES），先将 HWC 不支持的 Surface 合成为一个中间帧；
     • 将中间帧与其他支持硬件合成的 Surface 一起，传递给 HWC 完成最终合成；
     • 极端情况下，所有 Surface 均由 GPU 合成，再将结果传递给 HWC 输出到屏幕。

3. 合成完成：生成最终屏幕帧

   • HWC/GPU 完成合成后，生成一帧完整的屏幕像素数据，写入 HWC 绑定的「帧缓冲区」（Frame Buffer）；
   • SurfaceFlinger 通知 BufferQueue：已完成该缓冲区的消费，将其状态重置为「空闲」，可供 App 端下一次绘制复用（闭环循环）。

阶段 4：硬件端 - 屏幕显示（HWC → 显示硬件）

这一阶段是渲染流程的最终步骤，核心是将合成后的帧数据输出到物理屏幕，呈现给用户。

1. HWC 持有合成完成的帧缓冲区，等待下一个 VSync 信号（保证与屏幕刷新同步）；
2. 当 VSync 信号到达时，HWC 控制显示硬件（屏幕控制器、LCD/OLED 面板），从帧缓冲区中读取像素数据；
3. 显示硬件将像素数据转换为屏幕可识别的电信号 / 光信号，逐行（或逐列）绘制到物理屏幕上；
4. 屏幕显示完成后，等待下一个 VSync 信号，触发下一轮的 App 绘制 → SurfaceFlinger 合成 → 屏幕显示循环，实现连续的动态画面。

可视化流程图（直观理解组件交互与数据流转）

1. 整体流程框图（横向展示闭环循环）

+------------------------+    +------------------------+    +------------------------+    +------------------------+
|  阶段 1：App 端绘制     |    |  阶段 2：跨进程数据传递  |    |  阶段 3：系统端合成     |    |  阶段 4：硬件屏幕显示   |
|  （Choreographer 主导） |    |  （BufferQueue + Binder）|    |  （SurfaceFlinger 主导） |    |  （HWC + 显示硬件）     |
+------------------------+    +------------------------+    +------------------------+    +------------------------+
        ^                          ^                          ^                          ^
        |                          |                          |                          |
        |  下一轮 VSync 信号       |                          |                          |
        +--------------------------+--------------------------+--------------------------+
|------------------------------------------------------------------------------------------------------------------------|
|  具体步骤 & 组件交互 & 数据流转                                                                                         |
|------------------------------------------------------------------------------------------------------------------------|
|  1.  VSync 信号 → Choreographer（App 进程）                                                                              |
|  2.  Choreographer → ViewRootImpl → performTraversals（measure → layout → draw）                                         |
|  3.  View 绘制/ GPU 渲染 → 帧数据写入 Surface → BufferQueue（生产者：App）                                               |
|  4.  BufferQueue 状态变更（空闲 → 已生产）→ Binder 通知 SurfaceFlinger                                                  |
|  5.  SurfaceFlinger（系统进程）→ 从 BufferQueue 读取帧数据（消费者：共享内存，无拷贝）                                   |
|  6.  SurfaceFlinger → 收集所有 Surface → 按 Z-Order 排序                                                                 |
|  7.  SurfaceFlinger → 调用 HWC → 查询合成能力                                                                             |
|  8.  合成执行：HWC 硬件合成（优先）/ GPU 软件合成 → 生成最终屏幕帧                                                      |
|  9.  合成结果写入 HWC 帧缓冲区 → 等待下一个 VSync 信号                                                                   |
| 10.  VSync 信号触发 → HWC → 显示硬件 → 逐行绘制到物理屏幕                                                               |
| 11.  屏幕显示完成 → BufferQueue 缓冲区重置（空闲）→ 等待下一轮 VSync 信号，开启新循环                                   |
|------------------------------------------------------------------------------------------------------------------------|

2. 核心组件交互时序图（纵向展示单帧流转）

+-------------+        +-------------+        +-------------+        +-------------+        +-------------+
|  显示硬件   |        |  Choreographer |      |  App/Surface |       |  SurfaceFlinger |    |  HWC        |
+-------------+        +-------------+        +-------------+        +-------------+        +-------------+
      |                      |                      |                      |                      |
      |  1. 生成 VSync 信号  |                      |                      |                      |
      |---------------------->---------------------->---------------------->---------------------->
      |                      |                      |                      |                      |
      |                      |  2. 调度绘制任务     |                      |                      |
      |                      |---------------------->                      |                      |
      |                      |                      |  3. 执行 View 绘制/ GPU 渲染 |                      |
      |                      |                      |---------------------->                      |
      |                      |                      |  4. 帧数据写入 BufferQueue  |                      |
      |                      |                      |                      |                      |
      |                      |                      |  5. 通知 SurfaceFlinger 有新帧 |                      |
      |                      |                      |---------------------->                      |
      |                      |                      |                      |  6. 读取 BufferQueue 帧数据 |
      |                      |                      |                      |---------------------->
      |                      |                      |                      |  7. 排序 Surface 并查询 HWC  |
      |                      |                      |                      |---------------------->
      |                      |                      |                      |                      |  8. 执行硬件合成（或请求 GPU 协助）
      |                      |                      |                      |                      |---------------------->
      |                      |                      |                      |  9. 接收合成完成结果        |
      |                      |                      |                      |<----------------------|
      |                      |                      |                      |  10. 等待下一个 VSync 信号  |
      |                      |                      |                      |                      |
      |  11. 生成下一个 VSync 信号 |                      |                      |                      |
      |---------------------->---------------------->---------------------->---------------------->
      |                      |                      |                      |  12. 触发 HWC 输出帧数据   |
      |                      |                      |                      |---------------------->
      |  13. 接收帧数据并显示  |                      |                      |                      |
      |<-----------------------------------------------|----------------------|
      |                      |                      |  14. 重置 BufferQueue 缓冲区 |                      |
      |                      |                      |<----------------------|                      |
      |                      |                      |                      |                      |
      |  15. 屏幕显示完成，开启新循环 |                      |                      |                      |
      |---------------------->---------------------->---------------------->---------------------->

关键数据流转总结（核心亮点）

1. 无拷贝流转：帧数据从 App 到 SurfaceFlinger 采用「共享内存」传递，仅传递缓冲区句柄，避免大量数据拷贝带来的性能损耗；
2. 双端同步 VSync：VSync 信号同时触发 App 绘制和 SurfaceFlinger 合成，保证帧数据生产与消费的同步，避免画面撕裂；
3. 硬件合成优先：HWC 直接在显示硬件层完成合成，绕开 GPU，大幅提升渲染性能（尤其是多窗口场景）；
4. 缓冲区复用：BufferQueue 维护空闲缓冲区循环复用，避免频繁创建 / 销毁缓冲区带来的内存开销，保证渲染流畅性；
5. 闭环循环：单帧渲染完成后，缓冲区重置为空闲状态，等待下一轮 VSync 信号触发新循环，实现连续动态画面。

补充：常见问题与流程关联

1. 卡顿（掉帧）：App 绘制耗时超过 VSync 周期（如 16.67ms），Choreographer 无法按时提交帧数据，导致 SurfaceFlinger 无新帧可合成，只能显示上一帧；
2. 画面撕裂：缺少 VSync 同步，App 绘制与屏幕刷新不同步，HWC 同时读取 / 写入帧缓冲区，导致屏幕显示部分新帧、部分旧帧；
3. 过度绘制：View 树多层叠加绘制，导致 GPU 重复渲染同一像素区域，增加 App 绘制耗时，最终影响整个渲染流程效率。

除了 Choreographer、SurfaceFlinger、HWC，还有哪些组件参与了 Android 图形渲染？

在 Android 图形渲染流程中，除了 Choreographer（App 端节拍器）、SurfaceFlinger（系统合成核心）、HWC（硬件合成器）这三大核心组件外，还有硬件层、抽象绘制层、跨进程通信层、窗口管理层等多类组件参与协作，覆盖从「App 绘制指令生成」到「屏幕像素显示」的全链路。

以下是按功能阶段分类的关键组件，包含各自的职责、交互对象和核心作用：

硬件层核心组件（渲染的物理基础）

这类组件是图形渲染的「最终执行者」，属于设备硬件或硬件驱动层，直接决定渲染性能上限。

App 进程内绘制相关组件（渲染指令的生成层）

这类组件运行在 App 进程中，负责将开发者的「绘制逻辑」转换为「可执行的渲染指令」，是 App 与系统渲染层的接口。

系统进程内辅助组件（合成前的准备与管理）

这类组件运行在 system_server 进程或 SurfaceFlinger 进程中，负责窗口管理、资源调度、权限控制，为 SurfaceFlinger 提供合成所需的上下文信息。

高级渲染框架组件（复杂场景的扩展支持）

这类组件是 Android 提供的高级渲染接口，针对 3D、视频、游戏等复杂场景，底层基于 OpenGL/Vulkan 封装，简化开发者的使用成本。

组件交互补充：全链路协作示例（视频播放场景）

以视频播放为例，串联所有组件的协作流程：

1. MediaCodec 解码视频流 → 生成 YUV 帧数据；
2. 帧数据写入 SurfaceView 的 Surface → 由 BufferQueue 传递给 SurfaceFlinger；
3. VSyncGenerator 发送 VSync 信号 → 同时触发 Choreographer 和 SurfaceFlinger；
4. SurfaceFlinger 接收视频 Layer 和其他窗口 Layer → 询问 HWC 合成能力；
5. HWC 完成硬件合成 → 将帧数据写入 FrameBuffer；
6. DisplayController 读取 FrameBuffer → 驱动屏幕面板显示；
7. 若视频含复杂特效，GPU 协助 SurfaceFlinger 完成软件合成 → 再由 HWC 输出。