whepts 1.0.1 → 1.0.2

package/src/utils/flow-check.ts

@@ -0,0 +1,73 @@
+import { ErrorTypes, WebRTCError } from '~/errors'
+
+export interface FlowCheckParams {
+  interval: number
+  onError: (err: WebRTCError) => void
+}
+
+/**
+ * Flow checking logic (断流检测)
+ */
+export class FlowCheck {
+  private checkInterval: number
+  private lastBytesReceived: number = 0
+  private checkTimer?: NodeJS.Timeout
+  private pc?: RTCPeerConnection
+  private onError: (err: WebRTCError) => void
+
+  constructor(params: FlowCheckParams) {
+    this.checkInterval = params.interval
+    this.onError = params.onError
+  }
+
+  setPeerConnection(pc: RTCPeerConnection) {
+    this.pc = pc
+  }
+
+  /**
+   * 启动断流检测
+   */
+  start(): void {
+    this.stop()
+    this.checkTimer = setInterval(() => this.checkFlowState(), this.checkInterval)
+  }
+
+  /**
+   * 停止断流检测
+   */
+  stop(): void {
+    if (this.checkTimer) {
+      clearInterval(this.checkTimer)
+      this.checkTimer = undefined
+    }
+  }
+
+  /**
+   * 检测流状态（通过接收字节数判断是否断流）
+   */
+  private async checkFlowState(): Promise<void> {
+    if (!this.pc) {
+      return
+    }
+
+    const stats = await this.pc.getStats()
+    let currentBytes = 0
+
+    // 遍历统计信息，获取视频接收字节数
+    stats.forEach((stat: RTCStats) => {
+      const inboundRtpStat = stat as RTCInboundRtpStreamStats
+      if (stat.type === 'inbound-rtp' && inboundRtpStat.kind === 'video') {
+        currentBytes = inboundRtpStat.bytesReceived || 0
+      }
+    })
+
+    // 断流判定：连接正常但字节数无变化
+    if (currentBytes === this.lastBytesReceived && this.pc.connectionState === 'connected') {
+      this.onError(new WebRTCError(ErrorTypes.NETWORK_ERROR, 'data stream interruption'))
+      return
+    }
+
+    // 更新上一次字节数
+    this.lastBytesReceived = currentBytes
+  }
+}

package/src/utils/sdp.ts

@@ -0,0 +1,253 @@
+/** Type for parsed offer data */
+export interface ParsedOffer {
+  iceUfrag: string
+  icePwd: string
+  medias: string[]
+}
+
+/**
+ * SDP processing utilities
+ */
+export class SdpUtils {
+  /**
+   * Parse an offer SDP into iceUfrag, icePwd, and medias.
+   */
+  static parseOffer(sdp: string): ParsedOffer {
+    const ret: ParsedOffer = {
+      iceUfrag: '',
+      icePwd: '',
+      medias: [],
+    }
+
+    for (const line of sdp.split('\r\n')) {
+      if (line.startsWith('m=')) {
+        ret.medias.push(line.slice('m='.length))
+      }
+      else if (ret.iceUfrag === '' && line.startsWith('a=ice-ufrag:')) {
+        ret.iceUfrag = line.slice('a=ice-ufrag:'.length)
+      }
+      else if (ret.icePwd === '' && line.startsWith('a=ice-pwd:')) {
+        ret.icePwd = line.slice('a=ice-pwd:'.length)
+      }
+    }
+
+    return ret
+  }
+
+  /**
+   * Reserve a payload type.
+   */
+  static reservePayloadType(payloadTypes: string[]): string {
+    // everything is valid between 30 and 127, except for interval between 64 and 95
+    // https://chromium.googlesource.com/external/webrtc/+/refs/heads/master/call/payload_type.h#29
+    for (let i = 30; i <= 127; i++) {
+      if ((i <= 63 || i >= 96) && !payloadTypes.includes(i.toString())) {
+        const pl = i.toString()
+        payloadTypes.push(pl)
+        return pl
+      }
+    }
+    throw new Error('unable to find a free payload type')
+  }
+
+  /**
+   * Enable stereo PCMA/PCMU codecs.
+   */
+  static enableStereoPcmau(payloadTypes: string[], section: string): string {
+    const lines = section.split('\r\n')
+
+    let payloadType = SdpUtils.reservePayloadType(payloadTypes)
+    lines[0] += ` ${payloadType}`
+    lines.splice(lines.length - 1, 0, `a=rtpmap:${payloadType} PCMU/8000/2`)
+    lines.splice(lines.length - 1, 0, `a=rtcp-fb:${payloadType} transport-cc`)
+
+    payloadType = SdpUtils.reservePayloadType(payloadTypes)
+    lines[0] += ` ${payloadType}`
+    lines.splice(lines.length - 1, 0, `a=rtpmap:${payloadType} PCMA/8000/2`)
+    lines.splice(lines.length - 1, 0, `a=rtcp-fb:${payloadType} transport-cc`)
+
+    return lines.join('\r\n')
+  }
+
+  /**
+   * Enable multichannel Opus codec.
+   */
+  static enableMultichannelOpus(payloadTypes: string[], section: string): string {
+    const lines = section.split('\r\n')
+
+    let payloadType = SdpUtils.reservePayloadType(payloadTypes)
+    lines[0] += ` ${payloadType}`
+    lines.splice(lines.length - 1, 0, `a=rtpmap:${payloadType} multiopus/48000/3`)
+    lines.splice(lines.length - 1, 0, `a=fmtp:${payloadType} channel_mapping=0,2,1;num_streams=2;coupled_streams=1`)
+    lines.splice(lines.length - 1, 0, `a=rtcp-fb:${payloadType} transport-cc`)
+
+    payloadType = SdpUtils.reservePayloadType(payloadTypes)
+    lines[0] += ` ${payloadType}`
+    lines.splice(lines.length - 1, 0, `a=rtpmap:${payloadType} multiopus/48000/4`)
+    lines.splice(lines.length - 1, 0, `a=fmtp:${payloadType} channel_mapping=0,1,2,3;num_streams=2;coupled_streams=2`)
+    lines.splice(lines.length - 1, 0, `a=rtcp-fb:${payloadType} transport-cc`)
+
+    payloadType = SdpUtils.reservePayloadType(payloadTypes)
+    lines[0] += ` ${payloadType}`
+    lines.splice(lines.length - 1, 0, `a=rtpmap:${payloadType} multiopus/48000/5`)
+    lines.splice(
+      lines.length - 1,
+      0,
+      `a=fmtp:${payloadType} channel_mapping=0,4,1,2,3;num_streams=3;coupled_streams=2`,
+    )
+    lines.splice(lines.length - 1, 0, `a=rtcp-fb:${payloadType} transport-cc`)
+
+    payloadType = SdpUtils.reservePayloadType(payloadTypes)
+    lines[0] += ` ${payloadType}`
+    lines.splice(lines.length - 1, 0, `a=rtpmap:${payloadType} multiopus/48000/6`)
+    lines.splice(
+      lines.length - 1,
+      0,
+      `a=fmtp:${payloadType} channel_mapping=0,4,1,2,3,5;num_streams=4;coupled_streams=2`,
+    )
+    lines.splice(lines.length - 1, 0, `a=rtcp-fb:${payloadType} transport-cc`)
+
+    payloadType = SdpUtils.reservePayloadType(payloadTypes)
+    lines[0] += ` ${payloadType}`
+    lines.splice(lines.length - 1, 0, `a=rtpmap:${payloadType} multiopus/48000/7`)
+    lines.splice(
+      lines.length - 1,
+      0,
+      `a=fmtp:${payloadType} channel_mapping=0,4,1,2,3,5,6;num_streams=4;coupled_streams=4`,
+    )
+    lines.splice(lines.length - 1, 0, `a=rtcp-fb:${payloadType} transport-cc`)
+
+    payloadType = SdpUtils.reservePayloadType(payloadTypes)
+    lines[0] += ` ${payloadType}`
+    lines.splice(lines.length - 1, 0, `a=rtpmap:${payloadType} multiopus/48000/8`)
+    lines.splice(
+      lines.length - 1,
+      0,
+      `a=fmtp:${payloadType} channel_mapping=0,6,1,4,5,2,3,7;num_streams=5;coupled_streams=4`,
+    )
+    lines.splice(lines.length - 1, 0, `a=rtcp-fb:${payloadType} transport-cc`)
+
+    return lines.join('\r\n')
+  }
+
+  /**
+   * Enable L16 codec.
+   */
+  static enableL16(payloadTypes: string[], section: string): string {
+    const lines = section.split('\r\n')
+
+    let payloadType = SdpUtils.reservePayloadType(payloadTypes)
+    lines[0] += ` ${payloadType}`
+    lines.splice(lines.length - 1, 0, `a=rtpmap:${payloadType} L16/8000/2`)
+    lines.splice(lines.length - 1, 0, `a=rtcp-fb:${payloadType} transport-cc`)
+
+    payloadType = SdpUtils.reservePayloadType(payloadTypes)
+    lines[0] += ` ${payloadType}`
+    lines.splice(lines.length - 1, 0, `a=rtpmap:${payloadType} L16/16000/2`)
+    lines.splice(lines.length - 1, 0, `a=rtcp-fb:${payloadType} transport-cc`)
+
+    payloadType = SdpUtils.reservePayloadType(payloadTypes)
+    lines[0] += ` ${payloadType}`
+    lines.splice(lines.length - 1, 0, `a=rtpmap:${payloadType} L16/48000/2`)
+    lines.splice(lines.length - 1, 0, `a=rtcp-fb:${payloadType} transport-cc`)
+
+    return lines.join('\r\n')
+  }
+
+  /**
+   * Enable stereo Opus codec.
+   */
+  static enableStereoOpus(section: string): string {
+    let opusPayloadFormat = ''
+    const lines = section.split('\r\n')
+
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].startsWith('a=rtpmap:') && lines[i].toLowerCase().includes('opus/')) {
+        opusPayloadFormat = lines[i].slice('a=rtpmap:'.length).split(' ')[0]
+        break
+      }
+    }
+
+    if (opusPayloadFormat === '') {
+      return section
+    }
+
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].startsWith(`a=fmtp:${opusPayloadFormat} `)) {
+        if (!lines[i].includes('stereo')) {
+          lines[i] += ';stereo=1'
+        }
+        if (!lines[i].includes('sprop-stereo')) {
+          lines[i] += ';sprop-stereo=1'
+        }
+      }
+    }
+
+    return lines.join('\r\n')
+  }
+
+  /**
+   * Edit an offer SDP to enable non-advertised codecs.
+   */
+  static editOffer(sdp: string, nonAdvertisedCodecs: string[]): string {
+    const sections = sdp.split('m=')
+
+    const payloadTypes = sections
+      .slice(1)
+      .map(s => s.split('\r\n')[0].split(' ').slice(3))
+      .reduce((prev, cur) => [...prev, ...cur], [])
+
+    for (let i = 1; i < sections.length; i++) {
+      if (sections[i].startsWith('audio')) {
+        sections[i] = SdpUtils.enableStereoOpus(sections[i])
+
+        if (nonAdvertisedCodecs.includes('pcma/8000/2')) {
+          sections[i] = SdpUtils.enableStereoPcmau(payloadTypes, sections[i])
+        }
+        if (nonAdvertisedCodecs.includes('multiopus/48000/6')) {
+          sections[i] = SdpUtils.enableMultichannelOpus(payloadTypes, sections[i])
+        }
+        if (nonAdvertisedCodecs.includes('L16/48000/2')) {
+          sections[i] = SdpUtils.enableL16(payloadTypes, sections[i])
+        }
+
+        break
+      }
+    }
+
+    return sections.join('m=')
+  }
+
+  /**
+   * Generate an SDP fragment.
+   */
+  static generateSdpFragment(od: ParsedOffer, candidates: RTCIceCandidate[]): string {
+    const candidatesByMedia: Record<number, RTCIceCandidate[]> = {}
+    for (const candidate of candidates) {
+      const mid = candidate.sdpMLineIndex
+      if (mid) {
+        if (candidatesByMedia[mid] === undefined) {
+          candidatesByMedia[mid] = []
+        }
+        candidatesByMedia[mid].push(candidate)
+      }
+    }
+
+    let frag = `a=ice-ufrag:${od.iceUfrag}\r\n` + `a=ice-pwd:${od.icePwd}\r\n`
+
+    let mid = 0
+
+    for (const media of od.medias) {
+      if (candidatesByMedia[mid] !== undefined) {
+        frag += `m=${media}\r\n` + `a=mid:${mid}\r\n`
+
+        for (const candidate of candidatesByMedia[mid]) {
+          frag += `a=${candidate.candidate}\r\n`
+        }
+      }
+      mid++
+    }
+
+    return frag
+  }
+}

package/src/utils/webrtc.ts

@@ -0,0 +1,123 @@
+import { ErrorTypes, WebRTCError } from '~/errors'
+
+/**
+ * WebRTC utilities
+ */
+export class WebRtcUtils {
+  /**
+   * Check if the browser supports a non-advertised codec.
+   */
+  static async supportsNonAdvertisedCodec(codec: string, fmtp?: string): Promise<boolean> {
+    return new Promise((resolve) => {
+      const pc = new RTCPeerConnection({ iceServers: [] })
+      const mediaType = 'audio'
+      let payloadType = ''
+
+      pc.addTransceiver(mediaType, { direction: 'recvonly' })
+      pc.createOffer()
+        .then((offer) => {
+          if (!offer.sdp) {
+            throw new Error('SDP not present')
+          }
+          if (offer.sdp.includes(` ${codec}`)) {
+            // codec is advertised, there's no need to add it manually
+            throw new Error('already present')
+          }
+
+          const sections = offer.sdp.split(`m=${mediaType}`)
+
+          const payloadTypes = sections
+            .slice(1)
+            .map(s => s.split('\r\n')[0].split(' ').slice(3))
+            .reduce((prev, cur) => [...prev, ...cur], [])
+          payloadType = WebRtcUtils.reservePayloadType(payloadTypes)
+
+          const lines = sections[1].split('\r\n')
+          lines[0] += ` ${payloadType}`
+          lines.splice(lines.length - 1, 0, `a=rtpmap:${payloadType} ${codec}`)
+          if (fmtp !== undefined) {
+            lines.splice(lines.length - 1, 0, `a=fmtp:${payloadType} ${fmtp}`)
+          }
+          sections[1] = lines.join('\r\n')
+          offer.sdp = sections.join(`m=${mediaType}`)
+          return pc.setLocalDescription(offer)
+        })
+        .then(() =>
+          pc.setRemoteDescription(
+            new RTCSessionDescription({
+              type: 'answer',
+              sdp:
+                `v=0\r\n`
+                + `o=- 6539324223450680508 0 IN IP4 0.0.0.0\r\n`
+                + `s=-\r\n`
+                + `t=0 0\r\n`
+                + `a=fingerprint:sha-256 0D:9F:78:15:42:B5:4B:E6:E2:94:3E:5B:37:78:E1:4B:54:59:A3:36:3A:E5:05:EB:27:EE:8F:D2:2D:41:29:25\r\n`
+                + `m=${mediaType} 9 UDP/TLS/RTP/SAVPF ${payloadType}\r\n`
+                + `c=IN IP4 0.0.0.0\r\n`
+                + `a=ice-pwd:7c3bf4770007e7432ee4ea4d697db675\r\n`
+                + `a=ice-ufrag:29e036dc\r\n`
+                + `a=sendonly\r\n`
+                + `a=rtcp-mux\r\n`
+                + `a=rtpmap:${payloadType} ${codec}\r\n${fmtp !== undefined ? `a=fmtp:${payloadType} ${fmtp}\r\n` : ''}`,
+            }),
+          ),
+        )
+        .then(() => resolve(true))
+        .catch(() => resolve(false))
+        .finally(() => pc.close())
+    })
+  }
+
+  /**
+   * Unquote a credential string.
+   */
+  static unquoteCredential(v: string): string {
+    return JSON.parse(`"${v}"`)
+  }
+
+  /**
+   * Convert Link header to iceServers array.
+   */
+  static linkToIceServers(links: string | null): RTCIceServer[] {
+    if (links) {
+      return links.split(', ').map((link) => {
+        const m = link.match(
+          /^<(.+?)>; rel="ice-server"(; username="(.*?)"; credential="(.*?)"; credential-type="password")?/i,
+        )
+
+        if (!m) {
+          throw new WebRTCError(ErrorTypes.SIGNAL_ERROR, 'Invalid ICE server link format')
+        }
+
+        const ret: RTCIceServer = {
+          urls: [m[1]],
+        }
+
+        if (m[3]) {
+          ret.username = WebRtcUtils.unquoteCredential(m[3])
+          ret.credential = WebRtcUtils.unquoteCredential(m[4])
+          ret.credentialType = 'password'
+        }
+
+        return ret
+      })
+    }
+    return []
+  }
+
+  /**
+   * Reserve a payload type.
+   */
+  static reservePayloadType(payloadTypes: string[]): string {
+    // everything is valid between 30 and 127, except for interval between 64 and 95
+    // https://chromium.googlesource.com/external/webrtc/+/refs/heads/master/call/payload_type.h#29
+    for (let i = 30; i <= 127; i++) {
+      if ((i <= 63 || i >= 96) && !payloadTypes.includes(i.toString())) {
+        const pl = i.toString()
+        payloadTypes.push(pl)
+        return pl
+      }
+    }
+    throw new Error('unable to find a free payload type')
+  }
+}