Android スマホの画面を Mac/iPhone にミラーリングするアーキテクチャ実装

┌─ Source 端（スマホ）──────────────────────────────────────────────────────┐
│                                                                         │
│  ┌─ プラットフォーム層（Android）─────────────────────────────────────┐    │
│  │  画面キャプチャ (MediaProjection)                                  │    │
│  │      ↓                                                            │    │
│  │  ハードウェアエンコーダ (MediaCodec)                                │    │
│  │  H.264/H.265 │ 1080p@60fps │ 8Mbps │ IDR 応答                     │    │
│  │      ↓                                                            │    │
│  │  エンコードフレームコールバック → NAL フラグメント                   │    │
│  └───────┬───────────────────────────────────────────────────────────┘    │
│          ▼                                                              │
│  ┌─ ミラーリング伝送 SDK (Source モード) ─────────────────────────────┐    │
│  │  AES 暗号化 → RTP パケット化（シーケンス番号 + timestamp）→ UDP/TCP 送信  │
│  │  ← Sink からのフィードバック受信：損失率 / IDR 要求 / ビットレート調整    │
│  └──────────────────────────────────────────────────────────────────┘    │
└──────────────────────────────────┬───────────────────────────────────────┘
                                   │ Wi-Fi ローカルネットワーク
                                   ▼
┌─ Sink 端（Mac / iPhone / Pad）───────────────────────────────────────────┐
│  ┌─ ミラーリング伝送 SDK (Sink モード) ────────────────────────────────┐  │
│  │  UDP/TCP 受信 → RTP 再構成 → AES 復号 → メディア種別ごとにコールバック配信 │
│  │  → Source へフィードバック：損失率統計 / IDR 要求 / 推奨ビットレート      │
│  └────────────────────────────────┬────────────────┬──────────────────┘  │
│                                   │ 映像データ      │ 音声データ           │
│                                   ▼                ▼                     │
│  ┌─ プラットフォーム層（Mac/iPhone 各々実装）───────────────────────────────┐  │
│  │  VideoDecoder（VideoToolbox）→ RenderManager → Metal レンダリング     │  │
│  │  AudioDecoder（PCM/AAC）→ AudioQueue 再生                           │  │
│  │  逆方向制御：イベント収集 → 30Hz スロットル → コマンドエンコード → UDP → スマホ注入  │
│  └─────────────────────────────────────────────────────────────────────┘  │
└──────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│  Android プラットフォーム層                                    │
│                                                             │
│  MediaProjection（画面キャプチャ）                            │
│       ↓ Surface                                             │
│  MediaCodec（ハードウェアエンコーダ）                           │
│       │  H.264/H.265  │  設定：解像度/フレームレート/ビットレート/Profile │
│       ↓ エンコードフレームコールバック                          │
│  NAL フラグメント処理                                         │
│       ↓                                                     │
├─────────────────────────────────────────────────────────────┤
│  ミラーリング伝送 SDK                                         │
│                                                             │
│  ┌──────────┐    ┌──────────┐    ┌───────────────────────┐  │
│  │ AES 暗号化 │ →  │ RTP パケット化│ →  │ UDP/TCP 送信          │  │
│  └──────────┘    └──────────┘    └───────────────────────┘  │
│       ↑                                                     │
│  ビットレート調整 / IDR 要求（Sink 側からのフィードバック）      │
└─────────────────────────────────────────────────────────────┘

struct EncoderConfig {
    CodecType codec = CodecType::H265;  // デフォルト H.265、旧デバイスは H.264 にフォールバック
    int width = 1920;
    int height = 1080;
    int fps = 60;
    int bitrate = 8 * 1000 * 1000;  // 8 Mbps
    int profile;
    int level;
};

エンコーダ出力 NAL ユニット
       ↓
  NAL フラグメントとカプセル化
       ↓
  RTP パケット化（シーケンス番号 + timestamp）
       ↓
    AES 暗号化
       ↓
  ┌────┴────┐
  │ ネットワーク状態│
  └────┬────┘
 正常 ↙     ↘ 深刻なパケット損失
UDP 送信    TCP 送信

class MediaSender {
public:
    void sendEncodedFrame(const uint8_t* data, size_t size, int64_t pts) {
        auto fragments = fragmentNAL(data, size);

        for (auto& frag : fragments) {
            RTPPacket packet;
            packet.sequenceNumber = nextSequenceNum_++;
            packet.timestamp = toRTPTimestamp(pts);
            packet.payload = encrypt(frag.data, frag.size);

            if (useTCP_) {
                sendTCP(packet.data(), packet.size());
            } else {
                sendUDP(packet.data(), packet.size());
            }
        }
    }

    void onNetworkDegraded() {
        useTCP_ = true;
        encoder_.setBitrate(bitrate_ / 2);
    }

private:
    uint16_t nextSequenceNum_{0};
    bool useTCP_{false};
};

┌─ Source 端 ─────────────────────────────┐  ┌─ Sink 端 ───────────────────────────────┐
│                                          │  │                                          │
│  IMiPlayCastMirrorServer (C++ インターフェース) │  │  IMiPlayCastMirrorClient (C++ インターフェース) │
│                                          │  │                                          │
│  • attachSurface(surface)  キャプチャ Surface をバインド│  │  • attachSurface(surface) レンダリング Surface をバインド│
│  • setAttribute(type, val) エンコードパラメータ設定     │  │  • setAttribute(type, val) デコードパラメータ設定     │
│  • registerVideoPlugin(p)  エンコードコールバック登録   │  │  • registerVideoPlugin(p) デコードコールバック登録   │
│  • registerAudioPlugin(p)  音声コールバック登録      │  │  • registerAudioPlugin(p) 音声コールバック登録      │
│  • registerStateCallback() 状態コールバック登録      │  │  • registerStateCallback() 状態コールバック登録     │
│  • write(type, data, len, pts) エンコードフレーム送信 │  │  • start(uri) / stop() セッション制御               │
│  • start(uri) / stop() セッション制御              │  │  • pause(mediaType) / resume() メディア制御       │
│                                          │  │                                          │
└──────────────────────────────────────────┘  └──────────────────────────────────────────┘

class MediaPlugin {
public:
    virtual int32_t onInit(MediaAttribute attr) = 0;  // ネゴシエーション後のメディアパラメータを渡す
    virtual int32_t onStart() = 0;
    virtual int32_t onStop() = 0;
    virtual int32_t onPause() = 0;
    virtual int32_t onResume() = 0;
    virtual int32_t onChangeMediaAttribute(int32_t type, MediaAttribute attr) = 0;
};

struct MediaAttribute {
    int32_t width;        // 映像幅
    int32_t height;       // 映像高
    int32_t fps;          // フレームレート
    int8_t  format[50];   // コーデックフォーマット文字列 (video/avc 等)
    int32_t profile;      // Profile
    int32_t level;        // Level
    int32_t bitrate;      // ビットレート (bps)
    int32_t channels;     // 音声チャンネル数
    int32_t sampleBits;   // 音声サンプルビット数
    int32_t sampleRate;   // 音声サンプルレート
};

class StateCallback {
public:
    virtual void onStarted(int32_t localPort) = 0;           // Server 側起動成功
    virtual void onConnected() = 0;                          // 接続確立
    virtual void onDisconnected() = 0;                       // 接続切断
    virtual void onPlayed(int32_t status) = 0;               // メディア再生開始
    virtual void onError(int32_t what, int32_t extra) = 0;   // エラー
    virtual void onInfo(int32_t what, int64_t extra) = 0;    // 情報通知
    virtual int32_t onReceiveData(int32_t mediaType,         // メディアデータ受信
                                   int8_t* data, int32_t len, int64_t pts) = 0;
};

Server.start(uri)                                        Client.start(uri)
       │                                                       │
       ▼                                                       ▼
  接続確立 ─────────── TCP ハンドシェイク / RTSP シグナリング ─────→ 接続確立
       │                                                       │
       ▼                                                       ▼
onStarted(localPort)                                   onConnected()
       │                                                       │
       ▼                                                       ▼
 暗号化ネゴシエーション ──────── AES key/iv 交換 ──────────────→ 暗号化ネゴシエーション
       │                                                       │
       ▼                                                       ▼
registerMediaPlugin()                                 registerMediaPlugin()
       │                                                       │
       ▼                                                       ▼
  start データストリーム ───── RTP over UDP ────────────────→ onReceiveData()
       │                                                     → plugin.onInit(attr)
       │                                                     → plugin.onStart()
       ▼                                                       ▼
onPlayed(0)                                           onPlayed(0)

アプリケーションデータ層：エンコード後の H.264/H.265 映像フレーム / PCM/AAC 音声フレーム
     ↓
RTP カプセル化層：シーケンス番号 + timestamp + ペイロードタイプ識別子
     ↓
カスタム伝送層 (MPT)：UDP 優先、TCP フォールバックと天琴チャネルをサポート
     ↓
物理リンク：Wi-Fi / P2P / Bluetooth

Source 端 setAttribute()                  Sink 端 setAttribute()
  VideoWidth  = 1920                       VideoWidth  = 1920
  VideoFps    = 60                         VideoFps    = 60
  VideoEncType = H265                      VideoEncType = H264  ← Sink 側は H.264 を優先
  VideoBitrate = 8M
       │                                        │
       └──────── ネゴシエーション結果 ────────────┘
                     VideoEncType = H264  (積集合、Sink が非対応のため H.264 にフォールバック)
                     その他のパラメータは最小値を採用
                     → onInit(attr) で上位層に通知

┌─ SDK プロトコル層 ──────────────────────────────────────────────┐
│  UDP/TCP 受信 → AES 復号 → RTP 再構成 → メディア種別配信        │
└────────────────────────────┬─────────────┬────────────────────┘
                             │ 映像        │ 音声
┌─ コーデックエンジン層 ─────▼─────────────▼────────────────────┐
│                                                               │
│  VideoDecoder (VideoToolbox)   AudioDecoder (PCM/AAC)            │
│       ↓                          ↓                            │
│  RenderManager                AudioPlayer                     │
│  (Jitter Buffer/フレームスケジューリング) (AudioQueue リングバッファ) │
│       ↓                                                       │
├───────┼───────────────────────────────────────────────────────┤
│       ↓              UI レンダリング層                         │
│  MetalRenderView（YUV→RGB / ゼロコピー）                       │
└───────────────────────────────────────────────────────────────┘

class SessionClient {
public:
    void registerStateCallback(StateCallback* cb);
    void registerVideoPlugin(VideoPlugin* plugin);
    void registerAudioPlugin(AudioPlugin* plugin);

    int start(const char* uri, const SessionConfig& config);
    int stop();
    int pause();
    int resume();

    int setAttribute(AttributeType type, int value);

private:
    void receiveLoop();
    void decryptAndDispatch(const uint8_t* data, size_t size);
};

class VideoDecoder {
public:
    int onInit(MediaAttribute attr);
    int onStart();
    int onStop();

    int write(const uint8_t* data, size_t size, int64_t pts);
    void setFrameCallback(FrameDecodedCallback cb);

private:
    void decodeLoop();

    RenderManager renderManager_;
    std::unique_ptr<NativeVTDecoder> nativeVTDecoder_;
};

class NativeVTDecoder {
public:
    int init(int width, int height, CodecType codec) {
        // ビットストリームの SPS/PPS から CMVideoFormatDescription を構築
        CMVideoFormatDescriptionCreateFromH264ParameterSets(
            nullptr, paramCount, paramPointers, paramSizes, 4,
            &formatDescription_);

        // VTDecompressionSession を作成
        VTDecompressionOutputCallbackRecord callback{&onFrameDecoded, this};
        return VTDecompressionSessionCreate(
            nullptr, formatDescription_, decoderSpec,
            destImageBufferAttributes, &callback, &session_);
    }

    int decode(const uint8_t* data, size_t size, int64_t pts) {
        // Annex-B startcode → AVCC 長さプレフィックス形式変換
        auto avccData = convertAnnexBToAVCC(data, size);

        // CMSampleBuffer を構築してデコードを投入
        CMBlockBufferRef blockBuffer;
        CMBlockBufferCreateWithMemoryBlock(nullptr, avccData.data(),
            avccData.size(), kCFAllocatorNull, nullptr, 0,
            avccData.size(), 0, &blockBuffer);

        CMSampleBufferRef sampleBuffer;
        CMSampleBufferCreate(nullptr, blockBuffer, true, nullptr,
            nullptr, formatDescription_, 1, 1, &timingInfo,
            0, nullptr, &sampleBuffer);

        VTDecompressionSessionDecodeFrame(session_, sampleBuffer,
            kVTDecodeFrame_EnableAsynchronousDecompression, nullptr, nullptr);

        CFRelease(sampleBuffer);
        CFRelease(blockBuffer);
        return 0;
    }

private:
    static void onFrameDecoded(void* refCon, void*,
                                OSStatus status, VTDecodeInfoFlags,
                                CVImageBufferRef imageBuffer,
                                CMTime pts, CMTime) {
        auto* self = static_cast<NativeVTDecoder*>(refCon);
        if (status == noErr && self->frameCallback_) {
            self->frameCallback_(imageBuffer, CMTimeGetSeconds(pts));
        }
    }

    VTDecompressionSessionRef session_{nullptr};
    CMVideoFormatDescriptionRef formatDescription_{nullptr};
    FrameCallback frameCallback_;
};

デコードスレッド receiveLoop():
    ├─ put(AVPacket) → デコード待ちキューへ
    ├─ decodeLoop(): キューからパケットを取り出す
    │   └─ NativeVTDecoder.decode() → VTDecompressionSessionDecodeFrame()
    └─ onFrameDecoded() コールバック → RenderManager.addFrame()

class RenderManager {
public:
    void addFrame(int64_t index, int64_t pts);
    int64_t render();  // 次回レンダリングまでの待機時間を返す（μs）
    uint32_t forceRender();
    void updateJitterBuffer(int32_t bufferMs, int64_t currentTime);
    void setRefreshRate(int rate);

    using RenderCallback = std::function<void(int64_t pts, int64_t localTime, bool dropped)>;
    void setRenderCallback(RenderCallback cb);

private:
    struct FrameInfo {
        int64_t index;
        int64_t pts;
        int64_t decodeClock;
        int64_t renderClock;
    };

    std::deque<FrameInfo> pendingFrames_;
    int64_t lastRenderTime_{0};
    int64_t recommendMinus_{0};        // 推奨レンダリング先行時間
    int64_t vsyncInterval_{16000};     // V-Sync 間隔（μs, ~60fps）
    int64_t maxRenderDelayUs_{70000};  // 最大許容レンダリング遅延
    int maxRenderCache_{0};
};

int64_t RenderManager::render() {
    if (pendingFrames_.empty()) return emptyWaitTime_;

    auto& frame = pendingFrames_.front();
    int64_t now = currentTimeMicros();
    int64_t targetTime = frame.pts + recommendMinus_;

    // キュー蓄積：古いフレームを破棄し、最新のみ保持
    if (maxRenderCache_ > 0 && pendingFrames_.size() > maxRenderCache_) {
        while (pendingFrames_.size() > 1) {
            pendingFrames_.pop_front();
            dropCount_++;
        }
    }

    // フレームが古すぎる：破棄
    if (now - targetTime > maxRenderDelayUs_) {
        pendingFrames_.pop_front();
        dropCount_++;
        return 0;  // 直ちに次のフレームをチェック
    }

    // レンダリング時刻に達していない：待機
    if (now < targetTime) return targetTime - now;

    // レンダリング
    pendingFrames_.pop_front();
    renderCallback_(frame.pts, now, false);
    return vsyncInterval_;
}

class MetalRenderView {
    private var device: MTLDevice!
    private var commandQueue: MTLCommandQueue!
    private var pipelineState: MTLRenderPipelineState!
    private var textureCache: CVMetalTextureCache!
    private var metalLayer: CAMetalLayer!

    func setupMetal() {
        device = MTLCreateSystemDefaultDevice()
        commandQueue = device.makeCommandQueue()

        metalLayer = CAMetalLayer()
        metalLayer.device = device
        metalLayer.pixelFormat = .bgra8Unorm

        // CVMetalTextureCache：ゼロコピーの鍵
        CVMetalTextureCacheCreate(kCFAllocatorDefault, nil, device, nil, &textureCache)

        setupRenderPipeline()
    }

    func render(pixelBuffer: CVPixelBuffer) {
        let width = CVPixelBufferGetWidth(pixelBuffer)
        let height = CVPixelBufferGetHeight(pixelBuffer)

        // Y プレーンテクスチャ（ゼロコピー：IOSurface を直接マッピング）
        var texY: CVMetalTexture?
        CVMetalTextureCacheCreateTextureFromImage(
            kCFAllocatorDefault, textureCache,
            pixelBuffer, nil, .r8Unorm, width, height, 0, &texY)

        // UV プレーンテクスチャ
        var texUV: CVMetalTexture?
        CVMetalTextureCacheCreateTextureFromImage(
            kCFAllocatorDefault, textureCache,
            pixelBuffer, nil, .rg8Unorm, width / 2, height / 2, 1, &texUV)

        guard let mtlY = CVMetalTextureGetTexture(texY!),
              let mtlUV = CVMetalTextureGetTexture(texUV!) else { return }

        // GPU 描画コマンドを投入
        guard let drawable = metalLayer.nextDrawable(),
              let commandBuffer = commandQueue.makeCommandBuffer() else { return }

        let descriptor = MTLRenderPassDescriptor()
        descriptor.colorAttachments[0].texture = drawable.texture
        descriptor.colorAttachments[0].loadAction = .clear

        let encoder = commandBuffer.makeRenderCommandEncoder(descriptor: descriptor)!
        encoder.setRenderPipelineState(pipelineState)
        encoder.setFragmentTexture(mtlY, index: 0)
        encoder.setFragmentTexture(mtlUV, index: 1)
        encoder.drawPrimitives(type: .triangleStrip, vertexStart: 0, vertexCount: 4)
        encoder.endEncoding()

        commandBuffer.present(drawable)
        commandBuffer.commit()
    }
}

#include <metal_stdlib>
using namespace metal;

struct VertexOut {
    float4 position [[position]];
    float2 texCoord;
};

fragment float4 fragmentShader(VertexOut in [[stage_in]],
                               texture2d<float> texY [[texture(0)]],
                               texture2d<float> texUV [[texture(1)]]) {
    constexpr sampler s(address::clamp_to_edge, filter::linear);

    float y = texY.sample(s, in.texCoord).r;
    float2 uv = texUV.sample(s, in.texCoord).rg;

    // BT.709 色空間変換
    float y_adj = y - 0.0625;
    float u = uv.x - 0.5;
    float v = uv.y - 0.5;

    float r = y_adj + 1.5748 * v;
    float g = y_adj - 0.1873 * u - 0.4681 * v;
    float b = y_adj + 1.8556 * u;

    return float4(r, g, b, 1.0);
}

class AudioDecoder {
public:
    int write(const uint8_t* data, size_t size, int64_t pts);
    int readPCM(uint8_t* buffer, size_t size, int64_t* pts);

private:
    PCMDecoder pcmDecoder_;   // PCM パススルー（デフォルト）
    AACDecoder aacDecoder_;   // FFmpeg AAC → PCM（フォールバック）
};

class AudioPlayer {
    static constexpr int kBufferCount = 5;

    AudioQueueRef queue_{nullptr};
    AudioQueueBufferRef buffers_[kBufferCount];

    static void onBufferRequest(void* userData, AudioQueueRef queue,
                                 AudioQueueBufferRef buffer) {
        auto* player = static_cast<AudioPlayer*>(userData);
        player->fillBuffer(buffer);
    }

    void fillBuffer(AudioQueueBufferRef buffer) {
        size_t available = ringBuffer_.readableSize();
        size_t toRead = std::min(available, buffer->mAudioDataBytesCapacity);
        ringBuffer_.read(buffer->mAudioData, toRead);
        buffer->mAudioDataByteSize = toRead;
        AudioQueueEnqueueBuffer(queue_, buffer, 0, nullptr);
    }
};

    Sink 端（Mac/iPhone）              ネットワーク                Source 端（スマホ）
┌───────────────────────┐    ┌──────────────┐    ┌─────────────────────┐
│ マウス/タッチイベント収集  │    │              │    │ コマンド解析         │
│       ↓               │    │  独立 UDP    │    │    ↓                │
│ 座標正規化            │ ──►│  チャネル    │──► │ 座標マッピング       │
│       ↓               │    │ (HID コマンド)│    │    ↓                │
│ 30Hz スロットル→シリアル化│    │              │    │ Android 入力システム注入│
└───────────────────────┘    └──────────────┘    └─────────────────────┘

struct ControlCommand {
    enum ActionType: UInt8 {
        case touchDown  = 0
        case touchMove  = 1
        case touchUp    = 2
        case scroll     = 5
        case keyPress   = 6
    }

    let action: ActionType
    let x: Float         // 正規化座標 (0.0 - 1.0)
    let y: Float
    let pressure: Float
    let timestamp: UInt64
}

extension MirrorPlayView {
    override func mouseDown(with event: NSEvent) {
        let location = convert(event.locationInWindow, from: nil)
        let cmd = ControlCommand(
            action: .touchDown,
            x: Float(location.x / bounds.width),
            y: Float(location.y / bounds.height),
            pressure: Float(event.pressure),
            timestamp: currentTimeMicros()
        )
        throttler.submit(cmd)
    }

    override func mouseDragged(with event: NSEvent) {
        let location = convert(event.locationInWindow, from: nil)
        throttler.submit(ControlCommand(
            action: .touchMove,
            x: Float(location.x / bounds.width),
            y: Float(location.y / bounds.height),
            pressure: Float(event.pressure),
            timestamp: currentTimeMicros()
        ))
    }
}

class ControlChannel {
    UDPSocket socket_;

    int send(const ControlCommand& cmd) {
        uint8_t buffer[64];
        size_t offset = 0;
        buffer[offset++] = static_cast<uint8_t>(cmd.action);
        memcpy(buffer + offset, &cmd.x, 4);         offset += 4;
        memcpy(buffer + offset, &cmd.y, 4);         offset += 4;
        memcpy(buffer + offset, &cmd.pressure, 4);  offset += 4;
        memcpy(buffer + offset, &cmd.timestamp, 8); offset += 8;
        return socket_.send(buffer, offset);
    }
};

void onCommandReceived(const uint8_t* data, size_t size) {
    auto cmd = deserialize(data, size);

    // 正規化座標 → スマホの実際のピクセル座標
    int screenX = static_cast<int>(cmd.x * deviceWidth_);
    int screenY = static_cast<int>(cmd.y * deviceHeight_);

    switch (cmd.action) {
    case TOUCH_DOWN: injectTouchEvent(ACTION_DOWN, screenX, screenY); break;
    case TOUCH_MOVE: injectTouchEvent(ACTION_MOVE, screenX, screenY); break;
    case TOUCH_UP:   injectTouchEvent(ACTION_UP, screenX, screenY);   break;
    }
}

class EventThrottler {
    private let interval: TimeInterval = 1.0 / 30.0  // 33ms
    private var lastSendTime: TimeInterval = 0
    private var pendingCommand: ControlCommand?

    func submit(_ command: ControlCommand) {
        let now = CACurrentMediaTime()

        // touchDown / touchUp は即時送信、スロットルしない
        if command.action == .touchDown || command.action == .touchUp {
            send(command)
            lastSendTime = now
            return
        }

        // touchMove はスロットル
        if now - lastSendTime >= interval {
            send(command)
            lastSendTime = now
        } else {
            pendingCommand = command  // 最新の位置を保持し、次回送信
        }
    }
}