# Windows Host → Android Client 视频流向详解

本文档详细说明 Windows 设备作为 Host，Android 设备作为 Client 时的完整视频流向。

## 完整数据流图

```
┌─────────────────────────────────────────────────────────────────┐
│ Windows Host 设备（发送端）                                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                   │
│ [1] 屏幕捕获层                                                   │
│     Desktop Duplication API / GDI BitBlt                        │
│     ↓ 输出：D3D11 纹理（GPU 纹理，零拷贝）                       │
│                                                                   │
│ [2] 编码层                                                       │
│     Media Foundation H.264 硬件编码器 / D3D11 Video Encoder     │
│     ↓ 输出：H.264 NAL 单元（压缩后的视频数据）                   │
│                                                                   │
│ [3] 协议封装层                                                   │
│     FlatBuffers 序列化                                           │
│     - 帧头信息（时间戳、分辨率、帧类型 I/P）                     │
│     - 编码数据（NAL 单元）                                       │
│     ↓ 输出：序列化的协议消息（二进制数据）                       │
│                                                                   │
│ [4] 网络传输层                                                   │
│     UDP Socket (USB RNDIS / Wi-Fi / 以太网)                     │
│     - 分包处理（MTU 限制，通常 1500 字节）                       │
│     - 重传机制（关键帧 I-frame）                                 │
│     ↓ 输出：UDP 数据包                                           │
│                                                                   │
└─────────────────────────────────────────────────────────────────┘
                          ↓ 网络传输
                          ↓ 延迟：1-5ms (USB RNDIS) / 5-20ms (Wi-Fi)
┌─────────────────────────────────────────────────────────────────┐
│ Android Client 设备（接收端）                                    │
├─────────────────────────────────────────────────────────────────┤
│                                                                   │
│ [5] 网络接收层                                                   │
│     UDP Socket 接收                                              │
│     - 包重组（处理分包）                                         │
│     - 顺序保证（处理乱序）                                       │
│     ↓ 输出：完整的协议消息                                       │
│                                                                   │
│ [6] 协议解析层                                                   │
│     FlatBuffers 反序列化                                         │
│     - 提取帧头信息                                               │
│     - 提取编码数据（NAL 单元）                                   │
│     ↓ 输出：H.264 NAL 单元                                       │
│                                                                   │
│ [7] 解码层                                                       │
│     AMediaCodec (H.264 硬件解码器)                               │
│     ↓ 输出：GPU 纹理（AHardwareBuffer，零拷贝）                  │
│                                                                   │
│ [8] 渲染层                                                       │
│     OpenGL ES / ANativeWindow                                   │
│     - 纹理复制到渲染目标                                         │
│     - Surface 更新                                               │
│     ↓ 输出：渲染后的画面                                         │
│                                                                   │
│ [9] 显示输出                                                     │
│     Android Surface / SurfaceView                               │
│     - 直接显示在 Android 屏幕上                                  │
│     - 支持全屏或窗口模式                                         │
│     ↓ 最终显示在 Android 设备屏幕上                              │
│                                                                   │
└─────────────────────────────────────────────────────────────────┘
```

## 各阶段详细说明

### Windows Host 端

#### [1] 屏幕捕获层

**技术方案：Desktop Duplication API（推荐）**

```cpp
// platforms/windows/src/capture/screen_capture.cpp
#include <dxgi1_2.h>
#include <d3d11.h>

class ScreenCapture {
public:
    bool Initialize() {
        // 创建 D3D11 设备
        D3D11CreateDevice(
            nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr,
            0, nullptr, 0, D3D11_SDK_VERSION,
            &device_, nullptr, &context_
        );
        
        // 获取 DXGI 输出
        IDXGIOutput* output = nullptr;
        // ... 获取主显示器输出
        
        // 创建 Desktop Duplication
        IDXGIOutput1* output1 = nullptr;
        output->QueryInterface(__uuidof(IDXGIOutput1), (void**)&output1);
        output1->DuplicateOutput(device_, &duplication_);
        
        return true;
    }
    
    bool CaptureFrame(ID3D11Texture2D** texture) {
        DXGI_OUTDUPL_FRAME_INFO frameInfo;
        IDXGIResource* resource = nullptr;
        
        // 获取桌面帧
        HRESULT hr = duplication_->AcquireNextFrame(
            0, &frameInfo, &resource
        );
        
        if (SUCCEEDED(hr)) {
            // 获取纹理
            resource->QueryInterface(__uuidof(ID3D11Texture2D), (void**)texture);
            duplication_->ReleaseFrame();
            return true;
        }
        
        return false;
    }
    
private:
    ID3D11Device* device_ = nullptr;
    ID3D11DeviceContext* context_ = nullptr;
    IDXGIOutputDuplication* duplication_ = nullptr;
};
```

**特点：**
- 使用 Desktop Duplication API（Windows 8+）
- 直接获取 GPU 纹理，零拷贝
- 支持多显示器
- 性能最优

**备选方案：GDI BitBlt**
- 适用于较旧的 Windows 版本
- 需要 CPU 拷贝，性能较低

#### [2] 编码层

**技术方案：Media Foundation H.264 硬件编码器**

```cpp
// platforms/windows/src/codec/windows_h264_encoder.cpp
#include <mfapi.h>
#include <mftransform.h>
#include <mferror.h>

class WindowsH264Encoder {
public:
    bool Initialize(int width, int height, int bitrate, int fps) {
        // 创建 Media Foundation 编码器
        IMFActivate** activates = nullptr;
        UINT32 count = 0;
        
        MFTEnum(
            MFT_CATEGORY_VIDEO_ENCODER,
            MFT_ENUM_FLAG_HARDWARE,
            &inputType, nullptr,
            &activates, &count
        );
        
        // 选择 H.264 编码器
        activates[0]->ActivateObject(IID_PPV_ARGS(&encoder_));
        
        // 配置编码器
        IMFMediaType* inputType = nullptr;
        MFCreateMediaType(&inputType);
        inputType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);
        inputType->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_NV12);
        inputType->SetUINT32(MF_MT_INTERLACE_MODE, MFVideoInterlace_Progressive);
        MFSetAttributeSize(inputType, MF_MT_FRAME_SIZE, width, height);
        MFSetAttributeRatio(inputType, MF_MT_FRAME_RATE, fps, 1);
        
        IMFMediaType* outputType = nullptr;
        MFCreateMediaType(&outputType);
        outputType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);
        outputType->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_H264);
        outputType->SetUINT32(MF_MT_AVG_BITRATE, bitrate);
        outputType->SetUINT32(MF_MT_INTERLACE_MODE, MFVideoInterlace_Progressive);
        
        encoder_->SetInputType(0, inputType, 0);
        encoder_->SetOutputType(0, outputType, 0);
        
        encoder_->ProcessMessage(MFT_MESSAGE_COMMAND_FLUSH, 0);
        encoder_->ProcessMessage(MFT_MESSAGE_NOTIFY_BEGIN_STREAMING, 0);
        encoder_->ProcessMessage(MFT_MESSAGE_NOTIFY_START_OF_STREAM, 0);
        
        return true;
    }
    
    bool EncodeFrame(ID3D11Texture2D* inputTexture, std::vector<uint8_t>& output) {
        // 将 D3D11 纹理转换为 Media Foundation Sample
        IMFSample* sample = nullptr;
        // ... 转换逻辑
        
        // 编码
        encoder_->ProcessInput(0, sample, 0);
        
        // 获取编码输出
        MFT_OUTPUT_DATA_BUFFER outputBuffer = {};
        DWORD status = 0;
        encoder_->ProcessOutput(0, 1, &outputBuffer, &status);
        
        // 提取编码数据
        IMFMediaBuffer* buffer = nullptr;
        outputBuffer.pSample->ConvertToContiguousBuffer(&buffer);
        
        BYTE* data = nullptr;
        DWORD length = 0;
        buffer->Lock(&data, nullptr, &length);
        output.assign(data, data + length);
        buffer->Unlock();
        
        return true;
    }
    
private:
    IMFTransform* encoder_ = nullptr;
};
```

**特点：**
- 使用 Media Foundation 硬件编码器
- 支持 H.264 编码
- 硬件加速，CPU 占用低
- 支持动态码率调整

**备选方案：D3D11 Video Encoder**
- 更底层的 API
- 性能可能更好，但实现更复杂

#### [3] 协议封装层

```cpp
// core/src/protocol/message_serializer.cpp
#include "displayflow/core/protocol/message_serializer.h"

class MessageSerializer {
public:
    ByteArray SerializeVideoFrame(const VideoFrame& frame) {
        // 使用 FlatBuffers 序列化
        flatbuffers::FlatBufferBuilder builder;
        
        auto frameData = builder.CreateVector(frame.data.data(), frame.data.size());
        auto message = CreateVideoFrameMessage(
            builder,
            frame.timestamp,
            frame.width,
            frame.height,
            frame.frameType,  // I-frame or P-frame
            frameData
        );
        
        builder.Finish(message);
        return ByteArray(builder.GetBufferPointer(), 
                        builder.GetBufferPointer() + builder.GetSize());
    }
};
```

#### [4] 网络传输层

```cpp
// core/src/network/network_manager.cpp
class NetworkManager {
public:
    bool SendVideoFrame(const ByteArray& data) {
        // UDP Socket 发送
        // 处理分包（MTU 限制）
        const size_t MTU = 1500;
        size_t offset = 0;
        
        while (offset < data.size()) {
            size_t chunkSize = std::min(MTU, data.size() - offset);
            sendto(socket_, 
                   data.data() + offset, chunkSize,
                   0, (sockaddr*)&clientAddr_, sizeof(clientAddr_));
            offset += chunkSize;
        }
        
        return true;
    }
};
```

### Android Client 端

#### [5] 网络接收层

```cpp
// core/src/network/network_manager.cpp
class NetworkManager {
public:
    bool ReceiveVideoFrame(ByteArray& data) {
        // UDP Socket 接收
        // 包重组和顺序保证
        char buffer[MTU];
        sockaddr_in fromAddr;
        socklen_t addrLen = sizeof(fromAddr);
        
        ssize_t received = recvfrom(socket_, buffer, MTU, 0,
                                   (sockaddr*)&fromAddr, &addrLen);
        
        if (received > 0) {
            // 处理分包重组
            // 保证顺序
            data.insert(data.end(), buffer, buffer + received);
            return true;
        }
        
        return false;
    }
};
```

#### [6] 协议解析层

```cpp
// core/src/protocol/message_serializer.cpp
class MessageSerializer {
public:
    bool DeserializeVideoFrame(const ByteArray& data, VideoFrame& frame) {
        // FlatBuffers 反序列化
        auto message = GetVideoFrameMessage(data.data());
        
        frame.timestamp = message->timestamp();
        frame.width = message->width();
        frame.height = message->height();
        frame.frameType = message->frameType();
        
        auto frameData = message->data();
        frame.data.assign(frameData->begin(), frameData->end());
        
        return true;
    }
};
```

#### [7] 解码层

**技术方案：AMediaCodec 硬件解码器**

```cpp
// platforms/android/src/render/render_engine.cpp
#include <media/NdkMediaCodec.h>
#include <media/NdkMediaFormat.h>

class RenderEngine {
public:
    bool Initialize(int width, int height) {
        // 创建解码器
        const char* mimeType = "video/avc";
        decoder_ = AMediaCodec_createDecoderByType(mimeType);
        
        // 配置解码器
        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);
        
        // 获取输出 Surface（用于渲染）
        ANativeWindow* surface = GetOutputSurface();
        
        AMediaCodec_configure(decoder_, format, surface, nullptr, 0);
        AMediaCodec_start(decoder_);
        
        return true;
    }
    
    bool DecodeFrame(const ByteArray& h264Data) {
        // 输入编码数据
        ssize_t inputBufferId = AMediaCodec_dequeueInputBuffer(decoder_, 10000);
        if (inputBufferId >= 0) {
            size_t inputSize = 0;
            uint8_t* inputBuffer = AMediaCodec_getInputBuffer(
                decoder_, inputBufferId, &inputSize);
            
            memcpy(inputBuffer, h264Data.data(), h264Data.size());
            
            AMediaCodec_queueInputBuffer(
                decoder_, inputBufferId, 0, h264Data.size(),
                0, 0);
        }
        
        // 获取解码输出
        AMediaCodecBufferInfo bufferInfo;
        ssize_t outputBufferId = AMediaCodec_dequeueOutputBuffer(
            decoder_, &bufferInfo, 10000);
        
        if (outputBufferId >= 0) {
            // 解码完成，直接渲染到 Surface（零拷贝）
            AMediaCodec_releaseOutputBuffer(decoder_, outputBufferId, true);
            return true;
        }
        
        return false;
    }
    
private:
    AMediaCodec* decoder_ = nullptr;
};
```

**特点：**
- 使用 AMediaCodec 硬件解码器
- 直接输出到 Surface，零拷贝
- 硬件加速，性能最优

#### [8] 渲染层

**技术方案：ANativeWindow + OpenGL ES**

```cpp
// platforms/android/src/render/render_engine.cpp
#include <android/native_window.h>
#include <EGL/egl.h>

class RenderEngine {
public:
    bool Initialize(ANativeWindow* window) {
        nativeWindow_ = window;
        
        // 创建 EGL 上下文
        display_ = eglGetDisplay(EGL_DEFAULT_DISPLAY);
        eglInitialize(display_, nullptr, nullptr);
        
        EGLConfig config;
        EGLint numConfigs;
        eglChooseConfig(display_, attribs, &config, 1, &numConfigs);
        
        surface_ = eglCreateWindowSurface(display_, config, nativeWindow_, nullptr);
        context_ = eglCreateContext(display_, config, EGL_NO_CONTEXT, contextAttribs);
        
        eglMakeCurrent(display_, surface_, surface_, context_);
        
        return true;
    }
    
    void RenderFrame() {
        // 如果使用 AMediaCodec 直接输出到 Surface，这里可能不需要额外渲染
        // 或者使用 OpenGL ES 进行后处理
        
        eglSwapBuffers(display_, surface_);
    }
    
private:
    ANativeWindow* nativeWindow_ = nullptr;
    EGLDisplay display_ = nullptr;
    EGLSurface surface_ = nullptr;
    EGLContext context_ = nullptr;
};
```

**特点：**
- 使用 ANativeWindow 作为渲染目标
- 支持 OpenGL ES 后处理
- 直接显示在 Android Surface 上

#### [9] 显示输出

**技术方案：Android Surface / SurfaceView**

```cpp
// 在 Java/Kotlin 层创建 SurfaceView
// 或使用 ANativeWindow 直接显示

// 在 C++ 层获取 Surface
ANativeWindow* GetOutputSurface() {
    // 从 Java 层传入 Surface，转换为 ANativeWindow
    // 或直接使用 ANativeWindow
    return nativeWindow_;
}
```

## 延迟分析

| 阶段 | 操作 | 典型延迟 | 优化措施 |
|------|------|----------|----------|
| 1. 屏幕捕获 | Desktop Duplication API | 1-3ms | GPU 纹理，零拷贝 |
| 2. 编码 | H.264 硬件编码 | 2-5ms | Media Foundation 硬件编码器 |
| 3. 协议封装 | FlatBuffers 序列化 | <1ms | 零拷贝序列化 |
| 4. 网络传输 | UDP 传输 | 1-20ms | USB RNDIS 优先 |
| 5. 网络接收 | UDP 接收 | <1ms | 高效 Socket 处理 |
| 6. 协议解析 | FlatBuffers 反序列化 | <1ms | 零拷贝反序列化 |
| 7. 解码 | H.264 硬件解码 | 2-5ms | AMediaCodec 硬件解码器 |
| 8. 渲染 | OpenGL ES / Surface | 1-2ms | GPU 渲染 |
| 9. 显示 | Android Surface 输出 | 0-1ms | 直接 Surface 显示 |
| **总计** | **端到端延迟** | **<30ms** | **（USB RNDIS 模式）** |

## 关键特性

1. **零拷贝**：
   - Windows 端：Desktop Duplication → D3D11 纹理 → 编码器（GPU）
   - Android 端：解码器 → Surface（GPU），无需 CPU 拷贝

2. **硬件加速**：
   - Windows：Media Foundation 硬件编码器
   - Android：AMediaCodec 硬件解码器

3. **自适应码率**：
   - 根据网络状况动态调整编码参数
   - 关键帧（I-frame）重传机制

4. **多显示器支持**：
   - Windows 端支持选择特定显示器捕获
   - 支持多显示器扩展模式

## 实现优先级

1. **第一阶段**：基础功能
   - [ ] Windows 屏幕捕获（Desktop Duplication API）
   - [ ] Windows H.264 编码（Media Foundation）
   - [ ] Android H.264 解码（AMediaCodec）
   - [ ] Android Surface 显示

2. **第二阶段**：优化
   - [ ] 零拷贝优化
   - [ ] 帧率控制
   - [ ] 自适应码率

3. **第三阶段**：高级功能
   - [ ] 多显示器支持
   - [ ] 延迟优化
   - [ ] 错误恢复