RTC 미디어 경로 해부 — RTP에서 Media Push·Cloud Recording까지

❌ mp4 파일이 아닙니다
❌ 하나의 연속된 스트림이 아닙니다
❌ "영상 파일을 보내는 것"이 아닙니다

✅ 실시간 패킷 스트림입니다
✅ 각 패킷은 독립적으로 유실될 수 있습니다
✅ 순서가 뒤바뀔 수 있습니다
✅ 그래도 동작합니다

카메라 (Raw Frame: YUV/NV12)
   ↓ 인코딩
Encoded Video Frame (H.264 NAL Unit / VP8 Frame)
   ↓ 패킷화
RTP Packets (MTU 이하로 분할)
   ↓ 전송
ICE가 선택한 transport 경로

마이크 (Raw Audio: PCM)
   ↓ 인코딩
Encoded Audio Frame (예: Opus Frame)
   ↓ 패킷화
RTP Packet (보통 1개 프레임 = 1개 패킷)
   ↓ 전송
ICE가 선택한 transport 경로

┌─────────────────────────────────────────────────┐
│                   RTP Packet                     │
├─────────────────────────────────────────────────┤
│  Header (12 bytes 고정 + extension)              │
│  ┌─────────────────────────────────────────────┐│
│  │ V=2  │ P │ X │ CC │ M │  PT (Payload Type)  ││
│  │ Sequence Number (16bit)                      ││
│  │ Timestamp (32bit)                            ││
│  │ SSRC - Synchronization Source (32bit)        ││
│  └─────────────────────────────────────────────┘│
├─────────────────────────────────────────────────┤
│  Payload                                         │
│  ┌─────────────────────────────────────────────┐│
│  │ H.264 NAL Unit slice                         ││
│  │ 또는 Opus encoded frame                      ││
│  │ 또는 VP8 partition                           ││
│  └─────────────────────────────────────────────┘│
└─────────────────────────────────────────────────┘

1. 실시간     — 1초 뒤 도착하는 데이터는 쓸모없음
2. packet loss 허용 — 일부 유실돼도 계속 재생
3. reorder 가능     — 패킷 순서가 뒤바뀔 수 있음
4. jitter buffer 있음 — 네트워크 지연 변동을 흡수하는 버퍼

TCP: 패킷 유실 → 재전송 → 기다림 → 지연 누적
     실시간 미디어에서는 "늦게 도착한 패킷"은 쓸모없음

UDP: 애플리케이션이 deadline과 손실 복구 정책을 직접 제어
     WebRTC는 UDP를 우선하되 TCP/TLS relay fallback도 지원

  Host A                    Agora SD-RTN                    Viewer B
  ┌──────┐                 ┌──────────────┐                ┌──────┐
  │      │  RTP packets    │              │  RTP packets   │      │
  │ Send ├────────────────▶│  SFU Server  ├───────────────▶│ Recv │
  │      │  (encrypted)    │              │  (forwarded)   │      │
  └──────┘                 │  미디어를 디코딩 │                └──────┘
                           │  하지 않고     │
                           │  패킷을 그대로  │
                           │  전달 (forward) │
                           └──────────────┘

  MCU (Media Control Unit) — 옛날 방식:
  서버가 디코딩 → 합성 → 재인코딩 → 전달
  CPU 부하 높음, 지연 큼

  SFU (Selective Forwarding Unit) — 현대 방식:
  서버가 패킷을 선택적으로 전달만 함
  CPU 부하 낮음, 지연 낮음

                        ┌──────────────────────────────────┐
                        │         Agora SD-RTN Cloud        │
                        │                                   │
  외부 세계              │        RTC Channel (SFU)          │        외부 세계
                        │                                   │
  ┌──────────┐          │   👤 Real User A (SSRC: 0x1A)     │
  │ RTMP/SRT │──①──────▶│   👤 Real User B (SSRC: 0x2B)     │
  │ 송출 장비 │          │                                   │──④──▶ CDN (RTMP)
  └──────────┘          │   🤖 ① Media Gateway Bot          │
                        │   🤖 ② Cloud Player Bot           │──⑤──▶ Storage (MP4)
  ┌──────────┐          │   🤖 ③ Cloud Transcoder Bot       │
  │ URL 소스  │──②──────▶│   🤖 ④ Converter Bot (Media Push) │
  └──────────┘          │   🤖 ⑤ Recorder Bot               │
                        │                                   │
                        └──────────────────────────────────┘

[외부 RTMP 스트림]                    [RTC Channel]
H.264 + AAC                          RTP Packets
FLV container                        UDP transport
TCP transport                        Agora 프로토콜

  OBS/인코더 ──RTMP──▶ Gateway Server
                         │
                         ├── FLV 컨테이너 해체 (demux)
                         ├── H.264 NAL units 추출
                         ├── AAC frames 추출  
                         ├── (선택) 트랜스코딩 (해상도/코덱 변환)
                         ├── RTP 패킷으로 재패킷화
                         └── RTC 채널에 publish (새 SSRC 할당)

RTMP Input (1080p)
   ↓ Gateway Transcoder
   ├── Layer 0: 1080p, 3800kbps (SSRC: 0xA0)
   ├── Layer 1: 720p,  2400kbps (SSRC: 0xA1)
   ├── Layer 2: 540p,  1500kbps (SSRC: 0xA2)
   └── Layer 3: 360p,  500kbps  (SSRC: 0xA3)
   
   수신 측 SDK가 네트워크 상태에 따라 자동 전환

  Cloud Player Server
     │
     ├── HTTP/RTMP/HLS로 외부 URL에서 미디어 다운로드
     ├── 컨테이너 해체 (MP4 demux, HLS segment 파싱)
     ├── 코덱 프레임 추출
     ├── (선택) 트랜스코딩
     ├── RTP 패킷 생성
     └── 지정된 UID + SSRC로 채널에 publish

  Input Phase (Subscribe)
  ──────────────────────────────
  Host A의 RTP packets (SSRC: 0x1A) ──subscribe──┐
  Host B의 RTP packets (SSRC: 0x2B) ──subscribe──┤
                                                  ▼
  Decode Phase
  ──────────────────────────────
  RTP reassembly (seq number로 재정렬)
     ↓
  Jitter Buffer (네트워크 지연 변동 흡수)
     ↓
  H.264 decode → Raw YUV frames (Host A)
  H.264 decode → Raw YUV frames (Host B)
  Opus decode  → Raw PCM samples (Host A)
  Opus decode  → Raw PCM samples (Host B)

  Processing Phase
  ──────────────────────────────
  Video Compositing:
     Canvas (960x480 빈 프레임 생성)
        ↓
     Host A의 YUV를 (0,0,320,360) 영역에 scale & paste
     Host B의 YUV를 (320,0,320,320) 영역에 scale & paste
     Watermark 이미지를 alpha blend
        ↓
     합성된 단일 YUV frame
  
  Audio Mixing:
     Host A PCM + Host B PCM → 샘플 단위로 합산 (clipping 방지)
        ↓
     믹싱된 단일 PCM stream

  Encode Phase
  ──────────────────────────────
  합성된 YUV → H.264 encode → NAL units
  믹싱된 PCM → Opus/AAC encode → audio frames

  Output Phase (Publish)
  ──────────────────────────────
  NAL units → RTP packets (새 SSRC: 0xC0, UID: 1000)
  Audio frames → RTP packets
     ↓
  출력 채널에 publish

  SFU (기본):
  시청자가 받는 것 = Host A RTP + Host B RTP (2개 스트림)
  서버 CPU: decode/compose 경로보다 낮음
  시청자 CPU: 2x decode + 렌더링
  대역폭: 2x

  Cloud Transcoding:
  시청자가 받는 것 = 합성된 1개 스트림 (1개 SSRC)
  서버 CPU: 2x decode + compositing + 1x encode (높음)
  시청자 CPU: 1x decode만
  대역폭: 1x

RTP stream (H.264/Opus)
   ↓
depacketize (RTP 헤더 제거, NAL unit 재조립)
   ↓
remux (FLV 컨테이너에 담기)
   ↓
RTMP stream (TCP)

RTP stream (여러 호스트)
   ↓
depacketize
   ↓
decode (H.264 → YUV frames, Opus → PCM)
   ↓
composite (캔버스에 합성, 워터마크)
   ↓
encode (YUV → H.264, PCM → AAC) ← 완전히 새로운 영상
   ↓
mux (FLV container)
   ↓
RTMP stream (TCP)

WebRTC RTP:  packet 기반. SRTP/ICE를 사용하고 UDP를 우선하되 fallback 가능.
RTMP:        스트림 기반. 연속된 바이트 흐름. 유실 불가. TCP.

Client (Converter)              CDN Server
       │                            │
       ├── C0 (version) ──────────▶│
       ├── C1 (timestamp+random) ─▶│
       │◀── S0 (version) ──────────┤
       │◀── S1 (timestamp+random) ─┤
       │◀── S2 (echo C1) ──────────┤
       ├── C2 (echo S1) ──────────▶│
       │                            │
       │  handshake 완료, 연결 수립   │

rtmp://youtube.com/live/STREAM_KEY
                         ▲
                         │
                    이게 틀리면 → 즉시 drop

✅ Video: H.264가 가장 널리 호환됨
✅ Audio: AAC가 가장 널리 호환됨

❌ VP8 보내면 → reject 또는 깨짐
❌ VP9 보내면 → reject 또는 깨짐
❌ Opus 보내면 → reject 또는 깨짐

YouTube Live / Twitch / Facebook Live:
  해상도·fps·codec별 bitrate와 keyframe interval 요구가 서로 다르고 변경될 수 있음
  송출 직전에 각 플랫폼의 현재 공식 encoder 설정을 확인

Media Push가 외부 CDN ingest로 전달하는 구성에서는 ingest 이후의 transcoding·packaging·배포를 해당 CDN/플랫폼이 담당합니다. Agora의 다른 제품이 HLS나 recording output을 만들 수 있으므로 이를 전체 Agora 서비스의 불변 경계로 일반화하면 안 됩니다.

  Agora 영역                          CDN 영역
  ──────────                          ──────────
  RTC Channel                         
     ↓                                
  Converter (RTMP 생성)                
     ↓                                
  RTMP push ──────────────────▶ CDN ingest 서버
                                     ↓
                               ┌─────────────────┐
                               │  CDN이 하는 일    │
                               │                  │
                               │  1. Transmux     │
                               │  2. Segment      │
                               │  3. Manifest     │
                               │  4. Edge 배포     │
                               └─────────────────┘
                                     ↓
                               시청자 (브라우저/앱)

RTMP (FLV container)
   ↓ transmux
HLS (TS 또는 fMP4 container)

H.264 + AAC 코덱은 그대로 유지
container만 FLV → TS/fMP4로 변경

연속된 비디오 스트림
   ↓
segment1.ts 또는 fMP4 fragment
segment2.ts 또는 fMP4 fragment
segment3.ts 또는 fMP4 fragment
...

#EXTM3U
#EXT-X-TARGETDURATION:6
#EXT-X-MEDIA-SEQUENCE:0
#EXTINF:6.0,
segment0.ts
#EXTINF:6.0,
segment1.ts
#EXTINF:6.0,
segment2.ts

Origin Server (RTMP 수신 + transmux)
   ↓ 
Edge Server (서울)     ← 한국 시청자
Edge Server (도쿄)     ← 일본 시청자  
Edge Server (LA)       ← 미국 시청자

  카메라 → encode → RTP → Agora SFU → Converter → RTMP → CDN → HLS → 시청자
  
  ├── Agora 책임 ──────────────────────────────┤├── CDN 책임 ─────────┤
  │  RTP packets (UDP)                         ││  Transmux           │
  │  Converter: RTP → RTMP                     ││  Segment            │
  │  H.264 + AAC, FLV container               ││  Manifest (.m3u8)   │
  │                                            ││  Edge 캐싱/배포       │
  └────────────────────────────────────────────┘└─────────────────────┘

RTC (RTP):   "실시간 패킷"   — UDP, 유실 허용, 초저지연
RTMP:        "실시간 스트림"  — TCP, 유실 불가, 중간 지연
HLS/DASH:    "파일 조각"     — HTTP, 완전한 파일, 높은 지연

  Recording Mode에 따라 파이프라인이 다릅니다:
  
  Individual Recording (decode 불필요):
     RTP depacketize → 인코딩된 프레임 그대로 → 파일에 mux
     참가자별 output을 저장할 수 있음. 정확한 파일명·container는 recording 설정에 따름
  
  Composite Recording (decode 필요):
     RTP → decode → 합성 → encode → 단일 MP4 파일
  
     ↓
  지원되는 recording output으로 mux/segment
     ↓
  S3/OSS/GCS 등 클라우드 스토리지에 업로드

  ┌────────────────────────────────────────────────────────────┐
  │                    미디어 변환 스택                          │
  │                                                            │
  │   Transport:    UDP ←→ TCP                                 │
  │   Protocol:     RTP ←→ RTMP / SRT / HTTP                  │
  │   Container:    RTP payload ←→ RTMP message / MP4 / TS     │
  │   Codec:        H.264 ←→ VP8 / VP9  (선택적 트랜스코딩)     │
  │   Processing:   합성 / 믹싱 / 워터마크 (선택적)              │
  │                                                            │
  └────────────────────────────────────────────────────────────┘

  제품별 변환 경로:

  Media Gateway:   RTMP(TCP/FLV)  → [demux → repacketize]     → RTP(UDP)
  Media Pull:      HTTP/HLS/RTMP  → [fetch → demux → repack]  → RTP(UDP)
  Cloud Transcoding: RTP(UDP)     → [decode → 합성 → encode]  → RTP(UDP)
  Media Push(Raw): RTP(UDP)       → [depacketize → remux]      → RTMP(TCP/FLV)
  Media Push(TC):  RTP(UDP)       → [decode → 합성 → encode]  → RTMP(TCP/FLV)
  Cloud Recording: RTP(UDP)       → [decode → mux]            → MP4/M3U8(File)

  정상 네트워크:
  SSRC 0x1A (Video) ──▶ 전송 중 ✅
  SSRC 0x1B (Audio) ──▶ 전송 중 ✅

  대역폭 부족 감지:
  SSRC 0x1A (Video) ──▶ 저화질로 전환 (Dual Stream: Low layer)
  SSRC 0x1B (Audio) ──▶ 전송 유지 ✅

  대역폭 심각하게 부족한 경우의 가능한 정책:
  SSRC 0x1A (Video) ──▶ 전송 중단 ❌
  SSRC 0x1B (Audio) ──▶ audio-only로 전환 시도

  simulcast/dual-stream 기능을 활성화하면:

  인코더가 2개 스트림을 동시 생성:
  
  High Stream: 1080p, 2Mbps  → SSRC 0xA1B2C3D4 → RTP packets
  Low Stream:  360p, 200kbps → SSRC 0xE5F6A7B8 → RTP packets
  (해상도·bitrate·SSRC는 예시이며 실제 값은 SDK 설정·구현에 따름)
  
  수신 측 SDK가 네트워크 상태에 따라:
  - 양호: High Stream subscribe
  - 불안정: Low Stream으로 자동 전환
  - 최악: 둘 다 끄고 Audio만 유지

카메라 → YUV (raw)
      → H.264 NAL units (encoded)
      → RTP packets (packetized, SRTP/ICE)
      → RTMP messages (remuxed or transcoded, TCP/TLS)
      → HLS segments (segmented, HTTP)
      → 화면 (decoded, rendered)