m=video 9 UDP/TLS/RTP/SAVPF 96
a=rtpmap:96 VP9/90000
a=fmtp:96 profile-id=0; max-fr=30; max-fs=12288; scalabilityMode=L3T3
a=rid:q send pt=96; max-width=320; max-height=180; max-fps=30; max-br=150; dependencies=h,f
a=rid:h send pt=96; max-width=640; max-height=360; max-fps=30; max-br=600; dependencies=f
a=rid:f send pt=96; max-width=1280; max-height=720; max-fps=30; max-br=2500
a=simulcast:send q;h;f

a=rid:q recv pt=96
a=rid:h recv pt=96
a=rid:f recv pt=96
a=extmap:3 urn:ietf:params:rtp-hdr-ext:dependency-descriptor

// 伪代码：SFU 转发决策
func (s *SFU) forwardPacket(pkt *rtp.Packet, downstream *Peer) {
    // 1. 解析 Dependency Descriptor 扩展头
    dd, err := pkt.GetExtension(dependencyDescriptorURI)
    if err != nil { return } // 非 SVC 流或解析失败

    spatialId := dd.SpatialId       // 0, 1, 2
    temporalId := dd.TemporalId     // 0, 1, 2
    frameDeps := dd.FrameDependencies // 依赖的帧 ID

    // 2. 订阅过滤
    if spatialId > downstream.targetSpatialLayer {
        return // 超出订阅分辨率，丢弃
    }
    if temporalId > downstream.targetTemporalLayer {
        return // 超出订阅帧率，丢弃
    }

    // 3. 关键帧/参考帧保护逻辑
    // 如果是关键帧，或被后续帧引用，即使超过目标层也可能需要转发（视具体代码实现）
    // 通常策略：仅转发订阅层内的包，依赖关系由发送端编码结构保证。

    s.sendToDownstream(pkt, downstream)
}

// TypeScript 示例：带宽估算回调处理
interface LayerConfig { spatial: number; temporal: number; bitrate: number; }

const LAYER_MAP: LayerConfig[] = [
  { spatial: 0, temporal: 2, bitrate: 150_000 },  // L0T2: 180p@30fps ~150kbps
  { spatial: 1, temporal: 1, bitrate: 400_000 },  // L1T1: 360p@15fps ~400kbps
  { spatial: 1, temporal: 2, bitrate: 800_000 },  // L1T2: 360p@30fps ~800kbps
  { spatial: 2, temporal: 1, bitrate: 1_200_000 }, // L2T1: 720p@15fps ~1.2Mbps
  { spatial: 2, temporal: 2, bitrate: 2_500_000 }, // L2T2: 720p@30fps ~2.5Mbps (Target)
];

let currentLayerIndex = LAYER_MAP.length - 1; // 默认最高

function onBitrateEstimateChanged(availableBitrateBps: number) {
  // 1. 寻找最高可承受层级 (留 20% 余量)
  const targetBitrate = availableBitrateBps * 0.8;
  let newIndex = 0;
  for (let i = LAYER_MAP.length - 1; i >= 0; i--) {
    if (LAYER_MAP[i].bitrate <= targetBitrate) {
      newIndex = i;
      break;
    }
  }

  // 2. 迟滞控制：防止来回震荡
  // 升级需更高阈值，降级更敏感
  if (newIndex > currentLayerIndex) {
    // 升级：要求带宽超过目标层 1.2 倍
    if (targetBitrate < LAYER_MAP[newIndex].bitrate * 1.2) return;
  } else if (newIndex < currentLayerIndex) {
    // 降级：立即生效
  } else return;

  currentLayerIndex = newIndex;
  applyLayerConfig(LAYER_MAP[currentLayerIndex]);
}

async function applyLayerConfig(cfg: LayerConfig) {
  const sender = pc.getSenders().find(s => s.track?.kind === 'video');
  if (!sender) return;

  const params = sender.getParameters();
  if (!params.encodings || params.encodings.length === 0) return;

  // 假设使用 Simulcast 模拟 SVC (rid: q, h, f)
  // 实际 VP9 SVC 单流模式下，通过 active/maxBitrate 控制
  const encoding = params.encodings[0]; // 单流 SVC 通常只有一个 encoding

  // 1. 控制空间层：通过 scaleResolutionDownBy (仅限模拟/特定实现)
  // 标准 SVC 单流模式下，空间层由编码器内部 scalabilityMode 决定，
  // 这里通过 maxBitrate 间接驱动编码器降层，或使用 scalabilityMode 变更 (需重新协商)。
  // 推荐做法：预协商 L3T3，运行时仅调整 maxBitrate 和 maxFramerate，
  // 由编码器内部率控自动决定激活哪些层。

  encoding.maxBitrate = cfg.bitrate;
  encoding.maxFramerate = cfg.temporal === 2 ? 30 : 15; // 简化映射

  // 2. 如果需要强制关闭高空间层 (如从 L2 降到 L1)，
  // 可能需设置 scaleResolutionDownBy = 2.0 (分辨率减半)
  // 注意：此操作可能触发关键帧请求
  if (cfg.spatial === 1) encoding.scaleResolutionDownBy = 2.0; // 720p -> 360p
  else if (cfg.spatial === 0) encoding.scaleResolutionDownBy = 4.0; // 720p -> 180p
  else delete encoding.scaleResolutionDownBy;

  try {
    await sender.setParameters(params);
    console.log(`[Adaptation] Applied: Spatial L${cfg.spatial}, Temporal T${cfg.temporal}, Bitrate ${cfg.bitrate/1000}kbps`);
    
    // 3. 通知 SFU/对端 订阅变更 (通过 DataChannel 或 信令)
    signaling.send('layer-update', { spatial: cfg.spatial, temporal: cfg.temporal });
  } catch (e) {
    console.error('setParameters failed:', e);
  }
}

a=fmtp:97 profile=0; max-fr=30; max-fs=12288; scalabilityMode=L3T3_KEY

 0 1 2 3 4 5 6 7
+-+-+-+-+-+-+-+-+
|I|P|L|F|S|T|  R  |  第 1 字节 (必选)
+-+-+-+-+-+-+-+-+
|   Spatial Id  |  (如果 S=1) 第 2 字节
+-+-+-+-+-+-+-+-+
|  Temporal Id  |  (如果 T=1) 第 3 字节
+-+-+-+-+-+-+-+-+
|  Frame Id (低 8 位) | ... (如果 I=1, 变长整数编码)
+-+-+-+-+-+-+-+-+
|  Frame Dependencies (变长) | ...
+-+-+-+-+-+-+-+-+

AV1 DD 核心差异：
1. 解码器需先解析 Template (通常在序列头或首帧携带)，建立 "Frame Context" 状态机。
2. 后续包仅携带 Template Index + Frame Offset。
3. 支持 Switching Point (SP) 帧：允许从高层直接切换到低层无需等待关键帧。

m=video 9 UDP/TLS/RTP/SAVPF 96 97 98 99 100 101 127
a=rtpmap:96 VP9/90000
a=fmtp:96 profile-id=0; scalabilityMode=L3T3
a=rid:f send pt=96; max-width=1280; max-height=720; max-br=2500

a=rtpmap:97 H264/90000
a=fmtp:97 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f
a=rid:h send pt=97; max-width=1280; max-height=720; max-br=2000
a=rid:m send pt=97; max-width=640; max-height=360; max-br=800
a=rid:l send pt=97; max-width=320; max-height=180; max-br=300
a=simulcast:send h;m;l

a=rtpmap:127 rtx/90000
a=fmtp:127 apt=96
a=fmtp:127 apt=97
...

graph LR
A[VideoFrame<br/>Camera/Canvas] --> B(VideoEncoder<br/>WebCodecs VP9/AV1)
B --> C{EncodedVideoChunk<br/>Metadata: spatialId, temporalId,<br/>keyFrame, decodeTimestamp}
C --> D[Insertable Streams<br/>RTCRtpScriptTransform]
D --> E[RTP Packetizer<br/>自定义 Payload Descriptor + DD Header]
E --> F[Network]

// 1. 初始化 VP9 SVC 编码器 (需浏览器支持 WebCodecs VP9 Scalability)
const encoder = new VideoEncoder({
  output: handleEncodedChunk,
  error: e => console.error(e)
});

await encoder.configure({
  codec: 'vp09.00.10.08', // VP9 Profile 0, Level 3.1
  width: 1280,
  height: 720,
  bitrate: 2_500_000,
  framerate: 30,
  scalabilityMode: 'L3T3', // 关键：请求浏览器底层硬编支持 SVC
  // 进阶：部分实现支持 svcParams 精细控制 (非标准草案)
  // svcParams: { layers: [{spatial:0, temporal:2, bitrate:150k}, ...] }
});

// 2. 编码回调：提取层级元数据，注入 RTP 扩展头
function handleEncodedChunk(chunk, metadata) {
  // metadata: { spatialId, temporalId, decodeTimestamp, frameId, dependencies[] }
  // 这是浏览器暴露的内部 SVC 结构信息，极其宝贵
  
  const rtpPacket = packetizeVP9(chunk, metadata);
  
  // 3. 通过 Insertable Streams 发送
  // sender.sendStreams[0].writable.getWriter().write(rtpPacket);
}

// 4. 自定义 RTP 打包器：构造 VP9 Payload Descriptor (RFC 7741) + DD Header
function packetizeVP9(chunk, meta) {
  const payload = new Uint8Array(chunk.byteLength);
  chunk.copyTo(payload);
  
  // 构造 VP9 Payload Descriptor (首字节)
  // I=1(图像开始), P=meta.spatialId>0?1:0(跨层预测), L=1, F=0, B=1(帧结束), E=0, V=0
  const pd0 = 0x80 | (meta.spatialId > 0 ? 0x40 : 0) | 0x10 | 0x08; 
  
  // 构造 Dependency Descriptor (见第一节)
  const ddHeader = buildVp9DDHeader(meta); 
  
  // 组装 RTP 包: Header(12B) + ExtHeader(1B+len) + PD(1B) + Payload
  return assembleRTP(rtpHeader, ddHeader, pd0, payload);
}

async function probeHardwareSVC() {
  // 1. 检查 WebCodecs 支持
  if (!('VideoEncoder' in window)) return { svc: false, reason: 'No WebCodecs' };
  
  // 2. 检查 VP9 SVC 硬编支持 (isConfigSupported)
  const supported = await VideoEncoder.isConfigSupported({
    codec: 'vp09.00.10.08',
    scalabilityMode: 'L3T3',
    width: 1280, height: 720
  });
  
  if (!supported || !supported.supported) {
    return { svc: false, reason: 'HW VP9 SVC not supported' };
  }
  
  // 3. 实测编码一帧，验证 metadata 产出
  // ... 创建 encoder, encode 1 frame, check metadata.spatialId ...
  
  return { svc: true, codec: 'vp09.00.10.08' };
}

// 业务入口
const caps = await probeHardwareSVC();
if (caps.svc) {
  initWebCodecsPipeline(); // 高性能路径
} else {
  initNativeRTCPipeline(); // 兜底：原生 RTCRtpSender (软编或单层硬编)
}

// SFU 转发决策伪代码
func (s *SFU) forwardFlexFEC(pkt *rtp.Packet, downstream *Peer) {
    // 1. 识别 FlexFEC 流 (通过 SDP mid/rid 或 payload type 关联)
    if pkt.SSRC == downstream.mediaSSRC {
        // 媒体包：按 SVC DD 策略转发
        s.forwardMedia(pkt, downstream)
        return
    }
    
    if pkt.SSRC == downstream.fecSSRC {
        // FEC 包：解析 FlexFEC Header 确认保护哪些媒体包/层
        fecHdr := parseFlexFECHeader(pkt)
        
        // 核心策略：仅当下游订阅了受保护的层时，才转发 FEC
        // 例：下游只订阅 L1，FEC 保护 L0+L1，则转发；若只保护 L2，则丢弃
        if s.isLayerProtected(fecHdr, downstream.targetSpatialLayer) {
            s.sendToDownstream(pkt, downstream)
        }
        return
    }
}

# 伪代码：MP4 Muxer 处理 VP9 SVC 流
class SVCMP4Muxer:
    def __init__(self, target_spatial_layer=2):
        self.target_layer = target_spatial_layer
        self.pending_frames = [] # 缓冲区
        self.base_layer_ref_frame_id = None # 记录基础层可解码帧 ID

    def on_rtp_packet(self, pkt, dd_header):
        spatial_id = dd_header.spatial_id
        temporal_id = dd_header.temporal_id
        frame_id = dd_header.frame_id
        is_key = dd_header.is_key_frame # VP9: Frame header 中的 frame_type == KEY_FRAME
        deps = dd_header.frame_dependencies # 依赖的 Frame IDs

        # 1. 只缓存目标层及其依赖的基础层包
        if spatial_id > self.target_layer: return
        
        # 2. 关键帧对齐逻辑
        if is_key and spatial_id == self.target_layer:
            # 检查依赖的基础层帧是否已收到且可解码
            if self._check_base_layer_ready(deps):
                self._flush_pending_to_mp4() # 写入前清空旧片段
                self._start_new_segment(frame_id) # 新片段从这里开始
            else:
                # 目标层是关键帧，但基础层参考帧缺失 -> 丢弃该帧，等待下一个同步点
                return 

        self.pending_frames.append((pkt, dd_header))

    def _check_base_layer_ready(self, deps):
        # 简化：检查最低空间层 (L0) 对应的 Frame ID 是否已收到完整帧
        # 实际需维护每层的 "Last Decodable Frame ID"
        return self.base_layer_ref_frame_id in deps