DisplayFlow/docs/IMPLEMENTATION.md

# DisplayFlow 实现原理与视频流向

本文档详细说明 Windows 和 Android 平台的实现原理，以及视频数据在系统中的流向。

## 0. 技术栈说明

**核心原则：纯 C++ 实现**

DisplayFlow 的核心业务逻辑完全由 C++ 实现，包括：
- 网络抽象层
- 协议处理（FlatBuffers）
- 会话管理
- 编解码器抽象
- 角色管理

**平台适配层：**

- **Windows**：完全使用 C++ 和 Windows API（DirectX、IddCx、Win32 API）
- **Android**：**完全使用 C++ 和 Android NDK Native API**
  - 使用 `AMediaCodec`（NDK MediaCodec API）进行硬件编码
  - 使用 `AImageReader`（NDK ImageReader API）获取屏幕帧
  - 使用 `ANativeWindow` 和 `AHardwareBuffer` 进行 GPU 缓冲区操作
  - **无需 JNI 调用 Java API**，完全在 native 层实现
  - 仅权限请求需要最小 Java 层（可选，可通过系统服务实现）

**架构优势：**
- 核心代码 100% 跨平台，可复用
- 平台特定代码隔离在适配层
- **Android 平台完全 native 实现，无 JNI 开销**
- 性能最优，直接调用系统底层 API

## 1. 整体架构概览

DisplayFlow 采用分层架构，数据流从平台层捕获开始，经过核心层处理，最终在目标平台渲染显示。

```
[平台层捕获] -> [编码] -> [协议封装] -> [网络传输] -> [协议解析] -> [解码] -> [平台层渲染]
```

**Android 平台架构：**
```
C++ 核心层 (纯 C++)
    ↑↓ 直接调用
C++ 平台适配层 (AMediaCodec, AImageReader, ANativeWindow)
    ↑↓
Android NDK Native API
    ↑↓
Android 系统底层 (硬件编解码器, GPU)
```

**注意：** 
- MediaProjection 权限请求可能需要一个最小的 Java Activity（一次性操作）
- 但实际的屏幕捕获、编码、网络传输等所有核心功能**完全在 C++ native 层实现**
- 使用 Android NDK Native API（AMediaCodec、AImageReader、ANativeWindow 等）
- **无需 JNI 调用 Java API**，性能最优，代码完全跨平台兼容

**Windows 平台架构：**
```
C++ 核心层 (纯 C++)
    ↑↓ 直接调用
C++ 平台适配层 (DirectX, IddCx, Win32)
    ↑↓
Windows 系统 API
```

## 2. Android 平台实现原理

### 2.1 屏幕捕获（Host 角色）

#### 使用 Android NDK Native API（纯 C++ 实现）

Android 平台使用 **Android NDK Native API** 进行屏幕捕获，完全在 C++ 层实现，无需 JNI 调用 Java API。

**使用的 NDK API：**
- `AImageReader` - 获取屏幕帧（Android API 24+）
- `ANativeWindow` - 窗口和 Surface 操作
- `AHardwareBuffer` - 硬件缓冲区访问（Android API 26+）
- `AMediaCodec` - 硬件视频编码（见 2.2 节）

**实现流程：**

1. **创建 AImageReader（纯 C++）**
   ```cpp
   // platforms/android/src/capture/screen_capture.cpp
   #include <media/NdkImageReader.h>
   #include <android/native_window.h>
   
   class ScreenCapture {
   public:
       bool Initialize(int width, int height) {
           // 创建 AImageReader
           AImageReader* imageReader = nullptr;
           media_status_t status = AImageReader_new(
               width, height,
               AIMAGE_FORMAT_PRIVATE,  // 硬件支持的格式，零拷贝
               2,  // maxImages
               &imageReader
           );
           
           if (status != AMEDIA_OK) {
               return false;
           }
           
           imageReader_ = imageReader;
           
           // 设置图像可用回调
           AImageReader_ImageListener listener = {
               .context = this,
               .onImageAvailable = OnImageAvailable
           };
           AImageReader_setImageListener(imageReader_, &listener);
           
           // 获取 ANativeWindow（用于 VirtualDisplay）
           ANativeWindow* window = nullptr;
           status = AImageReader_getWindow(imageReader_, &window);
           if (status != AMEDIA_OK) {
               return false;
           }
           
           nativeWindow_ = window;
           return true;
       }
       
       // 图像可用回调（由系统调用）
       static void OnImageAvailable(void* context, AImageReader* reader) {
           auto* capture = static_cast<ScreenCapture*>(context);
           capture->ProcessFrame(reader);
       }
       
   private:
       void ProcessFrame(AImageReader* reader) {
           AImage* image = nullptr;
           media_status_t status = AImageReader_acquireLatestImage(reader, &image);
           
           if (status == AMEDIA_OK && image != nullptr) {
               // 获取 AHardwareBuffer（零拷贝访问）
               AHardwareBuffer* buffer = nullptr;
               status = AImage_getHardwareBuffer(image, &buffer);
               
               if (status == AMEDIA_OK && buffer != nullptr) {
                   // 直接传递给编码器，无需 CPU 拷贝
                   OnFrameAvailable(buffer);
               }
               
               // 释放图像
               AImage_delete(image);
           }
       }
       
       AImageReader* imageReader_ = nullptr;
       ANativeWindow* nativeWindow_ = nullptr;
   };
   ```

2. **创建 VirtualDisplay（需要 MediaProjection token）**
   
   注意：VirtualDisplay 的创建需要 MediaProjection 权限。有两种方案：
   
   **方案 A：最小 Java 层（仅权限请求）**
   ```cpp
   // 通过 JNI 获取 MediaProjection token（一次性操作）
   // 然后使用 native API 创建 VirtualDisplay
   
   // 获取 MediaProjection token 后，转换为 native handle
   jobject mediaProjectionToken = GetMediaProjectionToken(); // JNI 调用（仅一次）
   
   // 使用 native API 创建 VirtualDisplay
   // 注意：Android NDK 没有直接提供 VirtualDisplay API
   // 需要通过系统服务或使用 AImageReader + Surface
   ```
   
   **方案 B：使用系统服务（完全 native）**
   ```cpp
   // 通过 Android 系统服务直接创建 VirtualDisplay
   // 使用 AIDL 接口或直接调用系统服务
   // 这需要系统权限或 root 权限
   ```

3. **零拷贝帧获取**
   ```cpp
   // 使用 AHardwareBuffer 直接访问 GPU 缓冲区
   void ProcessHardwareBuffer(AHardwareBuffer* buffer) {
       // 获取缓冲区描述
       AHardwareBuffer_Desc desc;
       AHardwareBuffer_describe(buffer, &desc);
       
       // 直接传递给编码器的 Surface
       // 编码器可以直接从 GPU 缓冲区读取，无需 CPU 拷贝
       ANativeWindow* encoderSurface = GetEncoderInputSurface();
       
       // 将硬件缓冲区内容复制到编码器 Surface
       // 这仍然在 GPU 上完成，零拷贝
       CopyHardwareBufferToSurface(buffer, encoderSurface);
   }
   ```

**技术要点：**
- **完全 native 实现**，无 JNI 开销
- 使用 `AIMAGE_FORMAT_PRIVATE` 格式，直接传递给硬件编码器，零拷贝
- 通过 `AHardwareBuffer` 直接访问 GPU 缓冲区
- 异步回调机制，不阻塞主线程
- 支持动态分辨率调整

**权限处理：**
- MediaProjection 权限请求需要用户交互（一次性）
- 可以通过最小 Java Activity 或系统服务实现
- 权限获取后，所有后续操作完全在 native 层

### 2.2 视频编码

#### AMediaCodec 硬件编码（纯 C++ Native API）

Android 使用 **AMediaCodec**（Android NDK Native API）进行硬件加速编码，完全在 C++ 层实现，支持 H.264 编码。

**编码流程：**

1. **创建编码器（纯 C++）**
   ```cpp
   // platforms/android/src/codec/android_h264_encoder.cpp
   #include <media/NdkMediaCodec.h>
   #include <media/NdkMediaFormat.h>
   #include <android/native_window.h>
   
   class AndroidH264Encoder {
   public:
       bool Initialize(int width, int height, int bitrate, int fps) {
           // 创建编码器（使用 native API）
           const char* mimeType = "video/avc";
           encoder_ = AMediaCodec_createEncoderByType(mimeType);
           
           if (!encoder_) {
               return false;
           }
           
           // 创建 MediaFormat
           AMediaFormat* format = AMediaFormat_new();
           AMediaFormat_setString(format, AMEDIAFORMAT_KEY_MIME, mimeType);
           AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_WIDTH, width);
           AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_HEIGHT, height);
           
           // COLOR_FormatSurface - 使用 Surface 作为输入
           AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_COLOR_FORMAT, 0x7f000789);
           AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_BIT_RATE, bitrate);
           AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_FRAME_RATE, fps);
           AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_I_FRAME_INTERVAL, 1);
           
           // 配置编码器
           media_status_t status = AMediaCodec_configure(
               encoder_,
               format,
               nullptr,  // surface (输入 Surface)
               nullptr,  // crypto
               AMEDIACODEC_CONFIGURE_FLAG_ENCODE
           );
           
           AMediaFormat_delete(format);
           
           if (status != AMEDIA_OK) {
               return false;
           }
           
           // 获取输入 Surface（用于接收屏幕帧）
           status = AMediaCodec_createInputSurface(encoder_, &inputSurface_);
           if (status != AMEDIA_OK) {
               return false;
           }
           
           // 启动编码器
           status = AMediaCodec_start(encoder_);
           return status == AMEDIA_OK;
       }
       
       ANativeWindow* GetInputSurface() const {
           return inputSurface_;
       }
       
   private:
       AMediaCodec* encoder_ = nullptr;
       ANativeWindow* inputSurface_ = nullptr;
   };
   ```

2. **输入 Surface 连接（零拷贝）**
   ```cpp
   // 将 AImageReader 的 Surface 直接连接到编码器
   // 实现零拷贝：GPU -> 编码器
   void ConnectSurfaces(ANativeWindow* imageReaderSurface, ANativeWindow* encoderSurface) {
       // 在创建 VirtualDisplay 时，直接使用编码器的 Surface
       // 这样屏幕内容直接输出到编码器，无需中间拷贝
       
       // 或者使用 EGL 将 AImageReader 的输出复制到编码器 Surface
       // 这仍然在 GPU 上完成，零拷贝
   }
   ```

3. **获取编码数据（纯 C++）**
   ```cpp
   bool GetEncodedFrame(std::vector<uint8_t>& outputData, int& flags) {
       // 出队输出缓冲区
       ssize_t outputBufferId = AMediaCodec_dequeueOutputBuffer(
           encoder_,
           &bufferInfo_,
           10000  // timeoutUs: 10ms
       );
       
       if (outputBufferId >= 0) {
           // 获取输出缓冲区
           size_t outputSize = 0;
           uint8_t* outputBuffer = AMediaCodec_getOutputBuffer(
               encoder_,
               outputBufferId,
               &outputSize
           );
           
           if (outputBuffer && bufferInfo_.size > 0) {
               // 复制编码数据
               outputData.assign(
                   outputBuffer + bufferInfo_.offset,
                   outputBuffer + bufferInfo_.offset + bufferInfo_.size
               );
               
               flags = bufferInfo_.flags;
               
               // 释放缓冲区
               AMediaCodec_releaseOutputBuffer(encoder_, outputBufferId, false);
               
               return true;
           }
       } else if (outputBufferId == AMEDIACODEC_INFO_OUTPUT_FORMAT_CHANGED) {
           // 输出格式改变，获取新格式
           AMediaFormat* format = AMediaCodec_getOutputFormat(encoder_);
           // 处理格式变化
           AMediaFormat_delete(format);
       }
       
       return false;
   }
   
   private:
       AMediaCodecBufferInfo bufferInfo_ = {};
   };
   ```

**性能优化：**
- **完全 native 实现**，无 JNI 开销
- 零拷贝：直接从 GPU 到编码器，无需 CPU 参与
- 使用硬件编码器，CPU 占用极低
- 支持关键帧（I-frame）控制，减少带宽
- 直接内存访问，性能最优

### 2.3 输入处理（Client 角色）

当 Android 设备作为 Client 时，需要将接收到的输入事件注入到系统中。

**方案 A：使用 Linux Input 子系统（完全 native，需要 root）**

```cpp
// platforms/android/src/input/touch_handler.cpp
// 直接操作 Linux /dev/input/eventX 设备

class TouchHandler {
public:
    bool Initialize() {
        // 查找触摸屏输入设备
        const char* inputDevice = FindTouchInputDevice();
        if (!inputDevice) {
            return false;
        }
        
        // 打开输入设备
        fd_ = open(inputDevice, O_RDWR);
        return fd_ >= 0;
    }
    
    bool InjectTouchEvent(int action, float x, float y) {
        struct input_event ev[6];
        memset(ev, 0, sizeof(ev));
        
        // 同步事件
        ev[0].type = EV_SYN;
        ev[0].code = SYN_REPORT;
        ev[0].value = 0;
        
        // ABS_MT_TRACKING_ID
        ev[1].type = EV_ABS;
        ev[1].code = ABS_MT_TRACKING_ID;
        ev[1].value = (action == ACTION_DOWN) ? 0 : -1;
        
        // ABS_MT_POSITION_X
        ev[2].type = EV_ABS;
        ev[2].code = ABS_MT_POSITION_X;
        ev[2].value = (int)(x * 1000);  // 转换为设备坐标
        
        // ABS_MT_POSITION_Y
        ev[3].type = EV_ABS;
        ev[3].code = ABS_MT_POSITION_Y;
        ev[3].value = (int)(y * 1000);
        
        // ABS_MT_PRESSURE
        ev[4].type = EV_ABS;
        ev[4].code = ABS_MT_PRESSURE;
        ev[4].value = (action == ACTION_UP) ? 0 : 100;
        
        // BTN_TOUCH
        ev[5].type = EV_KEY;
        ev[5].code = BTN_TOUCH;
        ev[5].value = (action == ACTION_UP) ? 0 : 1;
        
        // 发送事件
        for (int i = 0; i < 6; i++) {
            write(fd_, &ev[i], sizeof(struct input_event));
        }
        
        return true;
    }
    
private:
    int fd_ = -1;
    
    const char* FindTouchInputDevice() {
        // 遍历 /dev/input/eventX 查找触摸屏设备
        // 通过读取 /proc/bus/input/devices 或直接测试设备
        return "/dev/input/event2";  // 示例
    }
};
```

**方案 B：使用 Android Input 服务（需要系统权限）**

```cpp
// 通过 Android InputManagerService 注入事件
// 需要系统权限或使用系统服务接口
// 可以通过 AIDL 接口调用系统服务
```

**方案 C：最小 JNI 层（仅输入注入）**

如果必须使用 Java API，可以创建一个最小的 JNI 包装器：

```cpp
// 通过 JNI 调用 InputManager 或 Instrumentation
// 但这是最后的选择，优先使用 native 方案
```

**推荐方案：**
- **优先使用方案 A**（Linux Input 子系统）：完全 native，性能最优
- 需要 root 权限或系统权限
- 对于普通应用，可能需要用户授权或使用辅助功能服务

**限制：**
- Linux Input 子系统需要 root 或系统权限
- 普通应用可能需要通过辅助功能服务（AccessibilityService）实现
- 某些设备可能需要特定的权限配置

### 2.4 网络通信

#### USB RNDIS
Android 设备通过 USB 连接时，可以启用 RNDIS（Remote Network Driver Interface Specification）功能。

**实现方式：**
1. 通过 USB Host API 检测 USB 连接
2. 启用 USB 网络共享功能
3. 获取 RNDIS 网络接口的 IP 地址
4. 使用 UDP Socket 进行数据传输

#### Wi-Fi 网络
使用标准的 Wi-Fi 网络进行通信。

**实现方式：**
1. 获取 Wi-Fi 网络信息
2. 使用 UDP 多播或单播进行数据传输
3. 支持一对多广播

## 3. Windows 平台实现原理

### 3.1 虚拟显示器创建（Client 角色）

#### IddCx 驱动框架
Windows 10 1809+ 提供了 IddCx（Indirect Display Driver Class eXtension）框架，用于创建虚拟显示器。

**实现流程：**

1. **驱动安装**
   - 开发 IddCx 驱动（.inf 文件）
   - 使用 `devcon` 或 `pnputil` 安装驱动
   - 驱动注册虚拟显示器设备

2. **创建虚拟显示器**
   ```cpp
   // 通过 IOCTL 与驱动通信
   HANDLE hDevice = CreateFile(
       L"\\\\.\\DisplayFlow",
       GENERIC_READ | GENERIC_WRITE,
       0, NULL, OPEN_EXISTING, 0, NULL
   );
   
   // 发送创建显示器命令
   DISPLAYFLOW_CREATE_DISPLAY createCmd = {};
   createCmd.width = 1920;
   createCmd.height = 1080;
   DWORD bytesReturned;
   DeviceIoControl(
       hDevice,
       IOCTL_DISPLAYFLOW_CREATE_DISPLAY,
       &createCmd, sizeof(createCmd),
       NULL, 0,
       &bytesReturned, NULL
   );
   ```

3. **驱动端处理**
   ```cpp
   // 在驱动中实现 IddCxMonitorCreate
   NTSTATUS IddCxMonitorCreate(
       IDDCX_MONITOR Monitor,
       const IDARG_IN_MONITORCREATE* pInArgs,
       IDARG_OUT_MONITORCREATE* pOutArgs
   ) {
       // 创建虚拟显示器对象
       // 注册显示模式
       // 返回成功
   }
   ```

**技术要点：**
- IddCx 驱动运行在内核模式，性能高
- 创建的虚拟显示器会被系统识别为真实显示器
- 支持动态分辨率调整
- 支持多显示器扩展

### 3.2 DirectX 渲染

#### D3D11 渲染管道
Windows 平台使用 DirectX 11 进行高效渲染。

**渲染流程：**

1. **初始化 D3D11**
   ```cpp
   // 创建 D3D11 设备
   D3D11CreateDevice(
       nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr,
       D3D11_CREATE_DEVICE_VIDEO_SUPPORT,
       featureLevels, ARRAYSIZE(featureLevels),
       D3D11_SDK_VERSION, &device, &featureLevel, &context
   );
   
   // 创建交换链（连接到虚拟显示器）
   DXGI_SWAP_CHAIN_DESC swapChainDesc = {};
   swapChainDesc.BufferDesc.Width = width;
   swapChainDesc.BufferDesc.Height = height;
   swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
   swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
   swapChainDesc.BufferCount = 2;
   swapChainDesc.SampleDesc.Count = 1;
   swapChainDesc.Windowed = TRUE;
   swapChainDesc.OutputWindow = hwnd;  // 虚拟显示器的窗口句柄
   
   IDXGIFactory* factory;
   CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
   factory->CreateSwapChain(device, &swapChainDesc, &swapChain);
   ```

2. **视频解码**
   ```cpp
   // 使用 Media Foundation 或 D3D11 Video Decoder
   // 创建视频解码器
   IMFTransform* decoder = nullptr;
   MFCreateVideoDecoderActivate(...);
   
   // 解码 H.264 数据
   decoder->ProcessInput(0, sample, 0);
   decoder->ProcessOutput(0, &outputSample, &status);
   ```

3. **渲染到纹理**
   ```cpp
   // 创建渲染目标纹理
   ID3D11Texture2D* renderTarget;
   device->CreateTexture2D(&textureDesc, nullptr, &renderTarget);
   
   // 创建渲染目标视图
   ID3D11RenderTargetView* rtv;
   device->CreateRenderTargetView(renderTarget, nullptr, &rtv);
   
   // 将解码后的帧复制到纹理
   context->CopyResource(renderTarget, decodedTexture);
   
   // 渲染到交换链
   context->OMSetRenderTargets(1, &rtv, nullptr);
   swapChain->Present(0, 0);
   ```

**性能优化：**
- 使用硬件视频解码（D3D11 Video Decoder）
- GPU 零拷贝：解码直接输出到 GPU 纹理
- 双缓冲交换链，减少撕裂
- 支持垂直同步（VSync）

### 3.3 输入处理（Client 角色）

Windows 作为 Client 时，需要将输入事件转发到 Host 设备。

**键盘事件捕获：**
```cpp
// 使用低级键盘钩子
HHOOK hHook = SetWindowsHookEx(
    WH_KEYBOARD_LL,
    LowLevelKeyboardProc,
    GetModuleHandle(NULL), 0
);

LRESULT CALLBACK LowLevelKeyboardProc(
    int nCode, WPARAM wParam, LPARAM lParam
) {
    KBDLLHOOKSTRUCT* kbd = (KBDLLHOOKSTRUCT*)lParam;
    // 发送键盘事件到 Host
    sendKeyboardEvent(kbd->vkCode, wParam == WM_KEYDOWN);
    return CallNextHookEx(hHook, nCode, wParam, lParam);
}
```

**鼠标事件捕获：**
```cpp
// 使用低级鼠标钩子
HHOOK hHook = SetWindowsHookEx(
    WH_MOUSE_LL,
    LowLevelMouseProc,
    GetModuleHandle(NULL), 0
);

LRESULT CALLBACK LowLevelMouseProc(
    int nCode, WPARAM wParam, LPARAM lParam
) {
    MSLLHOOKSTRUCT* mouse = (MSLLHOOKSTRUCT*)lParam;
    // 发送鼠标事件到 Host
    sendMouseEvent(mouse->pt.x, mouse->pt.y, wParam);
    return CallNextHookEx(hHook, nCode, wParam, lParam);
}
```

### 3.4 网络通信

#### USB RNDIS 检测
Windows 检测 USB RNDIS 网络适配器。

**实现方式：**
```cpp
// 使用 WMI 查询网络适配器
IWbemLocator* locator;
CoCreateInstance(CLSID_WbemLocator, NULL, CLSCTX_INPROC_SERVER,
                 IID_IWbemLocator, (LPVOID*)&locator);

// 查询 RNDIS 适配器
IEnumWbemClassObject* enumerator;
locator->ExecQuery(
    L"WQL",
    L"SELECT * FROM Win32_NetworkAdapter WHERE Description LIKE '%RNDIS%'",
    WBEM_FLAG_FORWARD_ONLY, NULL, &enumerator
);

// 获取 IP 地址
// 使用 GetAdaptersAddresses API
```

#### Wi-Fi 和以太网
使用标准的 Windows Socket API 进行网络通信。

## 4. 视频流向详解

### 4.1 Host -> Client 完整数据流

```
┌─────────────────────────────────────────────────────────────────┐
│ Android Host 设备                                                │
├─────────────────────────────────────────────────────────────────┤
│                                                                   │
│  [1] 屏幕捕获层                                                   │
│      MediaProjection -> VirtualDisplay -> ImageReader            │
│      ↓ (GPU 纹理，零拷贝)                                         │
│                                                                   │
│  [2] 编码层                                                       │
│      MediaCodec (H.264 硬件编码)                                  │
│      ↓ (编码后的 H.264 NAL 单元)                                  │
│                                                                   │
│  [3] 协议封装层                                                   │
│      FlatBuffers 序列化                                           │
│      - 帧头信息（时间戳、分辨率、帧类型）                          │
│      - 编码数据（NAL 单元）                                        │
│      ↓ (序列化的协议消息)                                         │
│                                                                   │
│  [4] 网络传输层                                                   │
│      UDP Socket (USB RNDIS / Wi-Fi)                              │
│      - 分包处理（MTU 限制）                                        │
│      - 重传机制（关键帧）                                          │
│      ↓ (UDP 数据包)                                              │
│                                                                   │
└─────────────────────────────────────────────────────────────────┘
                              ↓ 网络传输
                              ↓ (延迟: ~1-5ms USB RNDIS, ~5-20ms Wi-Fi)
┌─────────────────────────────────────────────────────────────────┐
│ Windows Client 设备                                              │
├─────────────────────────────────────────────────────────────────┤
│                                                                   │
│  [5] 网络接收层                                                   │
│      UDP Socket 接收                                              │
│      - 包重组                                                     │
│      - 顺序保证                                                   │
│      ↓ (完整的协议消息)                                           │
│                                                                   │
│  [6] 协议解析层                                                   │
│      FlatBuffers 反序列化                                         │
│      - 提取帧头信息                                               │
│      - 提取编码数据                                               │
│      ↓ (H.264 NAL 单元)                                          │
│                                                                   │
│  [7] 解码层                                                       │
│      D3D11 Video Decoder (硬件解码)                               │
│      ↓ (GPU 纹理，零拷贝)                                         │
│                                                                   │
│  [8] 渲染层                                                       │
│      DirectX 11 渲染                                              │
│      - 纹理复制到渲染目标                                         │
│      - 交换链 Present                                             │
│      ↓ (显示到虚拟显示器)                                         │
│                                                                   │
│  [9] 显示输出                                                     │
│      IddCx 虚拟显示器                                             │
│      - 系统识别为真实显示器                                       │
│      - 支持扩展显示模式                                           │
│                                                                   │
└─────────────────────────────────────────────────────────────────┘
```

### 4.2 各阶段延迟分析

| 阶段 | 操作 | 典型延迟 | 优化措施 |
|------|------|----------|----------|
| 1. 屏幕捕获 | MediaProjection 获取帧 | 0-2ms | 使用硬件 Surface，零拷贝 |
| 2. 编码 | H.264 硬件编码 | 2-5ms | 硬件编码器，降低码率 |
| 3. 协议封装 | FlatBuffers 序列化 | <1ms | 零拷贝序列化 |
| 4. 网络传输 | UDP 传输 | 1-20ms | USB RNDIS 优先，优化网络 |
| 5. 网络接收 | UDP 接收 | <1ms | 高效 Socket 处理 |
| 6. 协议解析 | FlatBuffers 反序列化 | <1ms | 零拷贝反序列化 |
| 7. 解码 | H.264 硬件解码 | 2-5ms | D3D11 Video Decoder |
| 8. 渲染 | DirectX 渲染 | 1-2ms | GPU 渲染，双缓冲 |
| 9. 显示 | 虚拟显示器输出 | 0-1ms | IddCx 驱动优化 |
| **总计** | **端到端延迟** | **<30ms** | **（USB RNDIS 模式）** |

### 4.3 关键帧（I-frame）处理

为了减少带宽和延迟，系统采用以下策略：

1. **关键帧间隔**
   - 默认每 30 帧发送一个 I-frame
   - 可根据网络状况动态调整

2. **场景变化检测**
   - 检测画面变化幅度
   - 变化大时立即发送 I-frame

3. **网络重传**
   - I-frame 丢失时请求重传
   - P-frame 丢失时等待下一个 I-frame

### 4.4 自适应码率控制

系统根据网络状况动态调整编码参数：

1. **带宽检测**
   - 监控网络延迟和丢包率
   - 估算可用带宽

2. **码率调整**
   - 高带宽：提高码率，提升画质
   - 低带宽：降低码率，保证流畅

3. **分辨率调整**
   - 极端情况下降低分辨率
   - 保持帧率稳定

## 5. 输入事件流向（Client -> Host）

```
┌─────────────────────────────────────────────────────────────────┐
│ Windows Client 设备                                              │
├─────────────────────────────────────────────────────────────────┤
│                                                                   │
│  [1] 输入捕获                                                     │
│      - 键盘钩子 (WH_KEYBOARD_LL)                                  │
│      - 鼠标钩子 (WH_MOUSE_LL)                                     │
│      ↓ (输入事件数据)                                             │
│                                                                   │
│  [2] 事件封装                                                     │
│      FlatBuffers 序列化                                           │
│      - 事件类型（按键、鼠标移动、点击）                            │
│      - 坐标、按键码等                                             │
│      ↓ (序列化的输入事件)                                         │
│                                                                   │
│  [3] 网络发送                                                     │
│      UDP Socket 发送                                              │
│      ↓ (UDP 数据包)                                              │
│                                                                   │
└─────────────────────────────────────────────────────────────────┘
                              ↓ 网络传输
┌─────────────────────────────────────────────────────────────────┐
│ Android Host 设备                                                │
├─────────────────────────────────────────────────────────────────┤
│                                                                   │
│  [4] 网络接收                                                     │
│      UDP Socket 接收                                              │
│      ↓ (输入事件数据)                                             │
│                                                                   │
│  [5] 事件解析                                                     │
│      FlatBuffers 反序列化                                         │
│      ↓ (输入事件对象)                                             │
│                                                                   │
│  [6] 事件注入                                                     │
│      - 通过 JNI 调用 Instrumentation.sendPointerSync() (触摸)      │
│      - 或通过辅助功能服务（AccessibilityService）                  │
│      ↓ (系统输入事件)                                             │
│                                                                   │
│  [7] 系统处理                                                     │
│      Android 系统处理输入事件                                     │
│      - 触发应用响应                                               │
│      - 更新屏幕内容                                               │
│      ↓ (屏幕变化)                                                 │
│                                                                   │
│  [8] 屏幕捕获                                                     │
│      回到视频流向的步骤 1                                          │
│                                                                   │
└─────────────────────────────────────────────────────────────────┘
```

**输入延迟：**
- 捕获延迟：<1ms
- 网络传输：1-20ms（取决于连接方式）
- 事件注入：<1ms
- **总延迟：<25ms**（USB RNDIS 模式）

## 6. 性能优化策略

### 6.1 零拷贝优化

1. **Android 端**
   - GPU 纹理直接传递给编码器
   - 编码输出直接写入网络缓冲区

2. **Windows 端**
   - 解码直接输出到 GPU 纹理
   - 纹理直接用于渲染，无需 CPU 拷贝

### 6.2 多线程处理

1. **捕获线程**：专门处理屏幕捕获
2. **编码线程**：处理视频编码
3. **网络线程**：处理网络 I/O
4. **渲染线程**：处理视频解码和渲染

### 6.3 缓冲策略

1. **发送端缓冲**
   - 最小化缓冲，降低延迟
   - 关键帧缓冲，支持重传

2. **接收端缓冲**
   - 小缓冲，快速响应
   - 丢帧策略：网络差时丢弃旧帧

## 7. 错误处理与恢复

### 7.1 网络错误

- **连接断开**：自动重连机制
- **数据包丢失**：关键帧重传
- **网络切换**：自动检测并切换网络接口

### 7.2 编解码错误

- **编码失败**：降级到软件编码
- **解码失败**：请求关键帧重传

### 7.3 系统错误

- **权限丢失**：提示用户重新授权
- **资源不足**：降低码率或分辨率

## 8. 总结

DisplayFlow 通过以下技术实现低延迟、高质量的跨平台显示协作：

1. **硬件加速**：充分利用 GPU 和硬件编解码器
2. **零拷贝**：最小化数据拷贝，降低延迟
3. **高效协议**：FlatBuffers 零拷贝序列化
4. **智能网络**：自动选择最佳网络路径
5. **自适应优化**：根据网络状况动态调整参数

通过这些优化，系统在 USB RNDIS 模式下可实现 **<30ms 的端到端延迟**，满足实时显示协作的需求。