Unified Transport Encoding Architecture

Encoding Agents & Channel Responsibilities

Agent 1: TMDS Lane Encoding (HDMI/DP PHY)

Responsibility: Wire encoding over GPU display controller TMDS lanes.

3 lanes (HDMI 2.0) / 4 lanes (DP 1.4/2.0) — byte-striped round-robin
Fragment packet (31 bytes): PacketType(1) | VersionFlags(1) | FragmentIndex(1) | FragmentData(28)
8b/10b encoding per lane (hardware, transparent)
Blanking interval insertion: ~16% of link capacity for RDMA stealth
RDMANetHeader (41 bytes) → 2 fragments (START + END)
Multi-frame reassembly via {FragmentIndex, QPN, seq}
Hot-plug state machine: disconnected → training → trained → suspended | error

Agent 2: VCN Video Encoding (Steam Deck MKV Trick)

Responsibility: Pack RDMA payload into video frames, hardware encode/decode.

1920×1080 YUV420 frame = 3,110,400 bytes per frame
Pixel packing: 6 bytes → 1 macroblock (4 Y + 1 U + 1 V)
Pixel signature in first 24 bytes: RDMAVCN\0 + version + seq + length
H.265 Main, All-IDR, QP 2-4, transform skip on, deblocking+SAO off
CRC32 per frame in SEI NAL (user_data_unregistered type 5)
~9 MB/s raw at 60fps (H.265 at QP4 compresses to ~162 Mbps)
Pipeline latency: ~10ms (DMA + encode + transmit + decode + verify)

Agent 3: Mesh Multi-Transport Routing

Responsibility: Transport selection, fragmentation, multi-hop relay, fallback.

Unified envelope: [tag(1)] + [transport-specific header] + [RDMANetHeader(41)] + [payload]
Fragmentation at MTU boundaries: [fragSeq(2)][totalFrags(1)][flags(1)]
Transport cost = latency_ratio × 1000 + bandwidth_ratio × 100 + priority × 10 + frag_penalty
Multi-hop: receive on transport A → decap → refrag for MTU_B → re-encap → send on transport B
Fallback: ordered chain through top-N transports, max 3 retries per transport
Multi-transmit: stripe payload across top-N transports concurrently

Channel Hierarchy & Wire Formats

Priority  Transport           MTU       Tag  Header Overhead    Best Use
──────────────────────────────────────────────────────────────────────────
0         DP 2.0 UHBR20      65536     0x04  1+31 (fragment)   Bulk RDMA
1         HDMI 2.1 FRL       65536     0x04  1+31              Bulk RDMA
2         DP 1.4 HBR3        65536     0x04  1+31              Bulk RDMA
3         HDMI 2.0 TMDS      65536     0x04  1+31              Bulk RDMA
4         VCN H.265 encode   3.1M/f    0x05  1+1+4             Compressed bulk
5         USB DMA            65536     0x00  4+41              General RDMA
6         VCN H.264 encode   3.1M/f    0x05  1+1+4             Wider compat
7         WiFi UDP           1472      0x01  2+2+41            Remote mesh
8         Bluetooth L2CAP    251       0x02  2+41              Close peer
9         Serial (braid)     8         0x03  1+41              FPGA fabric
10        DP AUX             16        0x06  2+41              Control/keys

Unified Envelope Wire Format

Byte 0:     Transport Tag (0x00-0x06)
Byte 1-4:   Transport-Specific Header (varies per tag)
Byte 5-45:  RDMANetHeader (41 bytes, fixed)
Byte 46+:   Payload (fragmented at MTU-46 boundary)

Fragment Header (within payload region)

Byte 0-1:   fragSeq (UInt16, sequence within transfer)
Byte 2:     totalFrags (UInt8)
Byte 3:     flags (bit 0=START, bit 1=END, bit 2=RETRANS)

Transport-Specific Headers

Tag	Header	Size
0x00 (USB DMA)	`sessionId:UInt32`	4
0x01 (WiFi)	`srcPort:UInt16, dstPort:UInt16`	4
0x02 (BT)	`cid:UInt16`	2
0x03 (Serial)	`mode:UInt8`	1
0x04 (TMDS)	`configId:UInt8` + fragment framing	1+31
0x05 (VCN)	`codec:UInt8, seq:UInt32` + YUV frame	5+3.1M
0x06 (AUX)	`addr:UInt16`	2

Multi-Hop Routing Flow

Source peer
  → computeRDMApath(target) → [relay0 via WiFi, relay1 via BT, target via USB]
  → selectEgressNIC(dst) → pick NIC with wire link to first hop
  → encapsulateRDMARequest(wr, qp, transport) → wire bytes
  → send on transport A

Intermediate relay peer
  → receive on transport A
  → parse TransportEnvelope tag
  → reencapsulateForNextHop: strip A header, wrap in B header
  → refragment for MTU_B if needed
  → send on transport B

Destination peer
  → receive on transport B
  → reassemble fragments via {transferId, fragSeq}
  → validate RDMANetHeader (lkey/rkey checks)
  → perform DMA into registered memory region

Fallback Chain

For each (transport, maxRetries=3) in selectTopNTransports(all_reachable):
  attempt encapsulateRDMARequest(wr, qp, transport)
  if success: return
  if failure after maxRetries: advance to next transport
If all exhausted: return failure

Multi-Transmit Striping

partition(payload, n_transports):
  each plane = payload[n * i : n * (i+1)], capped at MTU × 64
  send all planes concurrently
  wait for all completions
  reassemble in order

5 KiB Raw Blame History Unescape Escape