// 统一 SDP 处理工具函数（伪代码）
function normalizeH264Sdp(sdp, policy = 'constrained-baseline') {
  const lines = sdp.split('rn');
  return lines.map(line => {
    if (!line.startsWith('a=fmtp:') || !line.includes('H264')) return line;
    // 1. 强制 packetization-mode=1
    line = line.replace(/packetization-mode=d/, 'packetization-mode=1');
    // 2. 统一 profile-level-id 为 CBP L3.1 (42e01f)
    if (policy === 'constrained-baseline') {
      line = line.replace(/profile-level-id=[0-9a-fA-F]+/, 'profile-level-id=42e01f');
    }
    // 3. 开启 level-asymmetry-allowed
    if (!line.includes('level-asymmetry-allowed')) {
      line += ';level-asymmetry-allowed=1';
    }
    return line;
  }).join('rn');
}

// WebRTC VideoEncoder 接口层伪代码
class H264EncoderAdapter : public VideoEncoder {
  void OnRatesUpdated(const RateControlParameters& params) override {
    // 根据带宽自动降级 Profile
    if (params.bitrate.get_sum_bps() < 800'000) { // 800kbps 以下强制 CBP
      encoder_->SetProfile(H264Profile::kConstrainedBaseline);
      encoder_->SetLevel(H264Level::kLevel3_1);
    } else if (params.bitrate.get_sum_bps() < 2'000'000) {
      encoder_->SetProfile(H264Profile::kMain);
      encoder_->SetLevel(H264Level::kLevel3_1);
    } else {
      encoder_->SetProfile(H264Profile::kHigh);
      encoder_->SetLevel(H264Level::kLevel4_1);
    }
    // 分辨率/帧率钳制，防止超 Level
    ClampResolutionAndFpsToLevel(encoder_->GetLevel());
  }
};

// Web 端 PeerConnection 监听解码错误
pc.getReceivers().forEach(r => {
  r.track.addEventListener('decodeerror', e => {
    if (e.codec === 'H264' && e.profile === 'High') {
      // 触发重新协商，强制声明 CBP
      renegotiateWithProfile('constrained-baseline');
    }
  });
});

// 伪代码：启动期编码器能力探测与排序
struct CodecCapability {
  std::string name;           // "H264", "VP8", "VP9"
  H264Profile profile;        // kConstrainedBaseline, kHigh
  bool hardwareAccelerated;   // true/false
  int maxResolution;          // 1080p, 720p, 4K
  double encodeLatencyMs;     // 实测平均编码延迟
  double powerEfficiency;     // mW/frame (移动端关键)
};

std::vector<CodecCapability> ProbeAndRankCodecs() {
  std::vector<CodecCapability> caps;
  // 1. 枚举所有可用编码器工厂
  for (auto& factory : GetAvailableEncoderFactories()) {
    // 2. 实例化并跑 1 秒基准测试（720p@30fps）
    auto result = RunBenchmark(factory, 1280, 720, 30, 2000kbps);
    caps.push_back({factory.name, result.profile, result.hwAccel,
                    result.maxRes, result.avgLatencyMs, result.powerEff});
  }
  // 3. 多目标排序：硬编优先 > 低延迟 > 低功耗 > 高 Profile
  std::sort(caps.begin(), caps.end(), [](const auto& a, const auto& b) {
    if (a.hardwareAccelerated != b.hardwareAccelerated) return a.hardwareAccelerated;
    if (std::abs(a.encodeLatencyMs - b.encodeLatencyMs) > 2.0) return a.encodeLatencyMs < b.encodeLatencyMs;
    return a.powerEfficiency < b.powerEfficiency;
  });
  return caps;
}

// 编码器内部状态机（伪代码）
enum class ProfileTransitionState { STABLE, PENDING_IDR, SWITCHING };

class DynamicProfileController {
  void OnBandwidthEstimateUpdate(uint64_t bwe_bps) {
    H264Profile target = (bwe_bps < 800'000) ? H264Profile::kConstrainedBaseline
                          : (bwe_bps < 2'000'000) ? H264Profile::kMain
                          : H264Profile::kHigh;
    if (target != current_profile_ && state_ == STABLE) {
      pending_profile_ = target;
      state_ = PENDING_IDR;
      encoder_->ForceKeyFrame(); // 请求下一帧为 IDR
    }
  }

  void OnEncodeComplete(const EncodedImage& frame) {
    if (state_ == PENDING_IDR && frame._frameType == VideoFrameType::kVideoFrameKey) {
      // 关键帧到来，原子切换 Profile 参数
      encoder_->SetProfile(pending_profile_); // 仅修改 SPS/PPS 语法元素，不 flush DPB
      current_profile_ = pending_profile_;
      state_ = STABLE;
      // 关键：在 SPS 中设置 `vui_parameters.timing_info_present_flag=1`
      // 并更新 `num_units_in_tick`/`time_scale` 保持时间戳连续
    }
  }
};

# ci/webrtc_interop_criteria.yaml
pass_criteria:
  connection_establishment_rate: ">= 99.5%"      # ICE/DTLS/SRTP 全建联
  first_frame_render_time_p99: "< 3000ms"        # 首帧渲染
  freeze_rate_per_minute: "< 0.5"                # 卡顿率
  profile_mismatch_error_rate: "== 0%"           # 零 Profile 不匹配错误
  keyframe_request_rate: "< 0.2/s"               # PLI/FIR 频率
  audio_video_sync_drift_ms: "< 80"              # 音视频同步
  cpu_usage_encoder_p95: "< 70%"                 # 编码 CPU
  memory_leak_check: "valgrind/asan clean"       # 内存安全

// WebCodecs 编码器配置示例：显式指定 Profile/Level
const encoder = new VideoEncoder({
  output: handleChunk,
  error: handleError
});
encoder.configure({
  codec: 'avc1.42E01F', // Constrained Baseline L3.1
  width: 1280,
  height: 720,
  bitrate: 1_500_000,
  framerate: 30,
  hardwareAcceleration: 'prefer-hardware', // 或 'prefer-software'
  // 关键新增：显式控制 Profile 工具集
  avc: { 
    format: 'annexb',
    profileIdc: 66,           // Baseline
    constraintSetFlags: 0x04, // Constrained Baseline flag
    levelIdc: 31              // Level 3.1
  }
});

# tools/sdp_h264_doctor.py
# 用法: python sdp_h264_doctor.py offer.sdp answer.sdp
import re, sys, json

PROFILE_MAP = {
    '42e01f': 'Constrained Baseline L3.1',
    '42c01f': 'Constrained Baseline L3.0',
    '4d001f': 'Main L3.1',
    '4d0029': 'High L4.1',
    '640029': 'High L4.2',
}

def parse_fmtp(sdp):
    fmts = {}
    for m in re.finditer(r'a=fmtp:(d+)s+(.+)', sdp):
        pt, params = m.groups()
        fmts[pt] = dict(p.split('=') for p in params.split(';') if '=' in p)
    return fmts

def analyze(pt, fmtp):
    issues = []
    pid = fmtp.get('profile-level-id', '').lower()
    pmode = fmtp.get('packetization-mode', '1')
    asym = fmtp.get('level-asymmetry-allowed', '0')
    
    if pid not in PROFILE_MAP:
        issues.append(f'❌ 未知 profile-level-id: {pid}')
    else:
        print(f'  ✅ Profile: {PROFILE_MAP[pid]}')
    
    if pmode != '1':
        issues.append(f'⚠️ packetization-mode={pmode} (建议 1)')
    
    if asym != '1':
        issues.append(f'⚠️ level-asymmetry-allowed=0 (建议开启 1)')
    
    # 检查 sprop-parameter-sets 合法性
    if 'sprop-parameter-sets' in fmtp:
        sps_pps = fmtp['sprop-parameter-sets'].split(',')
        if len(sps_pps) != 2:
            issues.append('❌ sprop-parameter-sets 格式错误')
        else:
            print(f'  📦 SPS/PPS Base64 长度: {len(sps_pps[0])}/{len(sps_pps[1])}')
    
    return issues

if __name__ == '__main__':
    offer, answer = sys.argv[1], sys.argv[2]
    for label, path in [('OFFER', offer), ('ANSWER', answer)]:
        print(f'n=== {label} ===')
        with open(path) as f:
            sdp = f.read()
        fmts = parse_fmtp(sdp)
        for pt, fmtp in fmts.items():
            if 'H264' in sdp.split(f'a=rtpmap:{pt} ')[1].split('n')[0] if f'a=rtpmap:{pt} ' in sdp else False:
                print(f'Payload Type: {pt}')
                issues = analyze(pt, fmtp)
                for i in issues:
                    print(f'  {i}')
    print('n💡 建议: 统一双端 profile-level-id=42e01f;packetization-mode=1;level-asymmetry-allowed=1')