@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/esm/lib/peer/media/rtpTransceiver.js

@@ -0,0 +1,241 @@
+import { randomUUID } from 'node:crypto';
+import { Event } from '../imports/common.js';
+import { SenderDirections } from '../const.js';
+import { createWebRtcTypeError } from '../errors.js';
+import { cloneCodecParameters } from './codec.js';
+import { generateCodecStatsId, generateStatsId, getStatsTimestamp } from './stats.js';
+export class RTCRtpTransceiver {
+    set codecs(codecs) {
+        this._codecs = codecs;
+    }
+    get codecs() {
+        return this._codecs;
+    }
+    get codecPreferences() {
+        return this._codecPreferences;
+    }
+    setCodecPreferences(codecs) {
+        if (!Array.isArray(codecs)) {
+            throw createWebRtcTypeError('codecs must be an array');
+        }
+        const next = codecs.length === 0 ? undefined : codecs.map(cloneCodecParameters);
+        if (sameCodecPreferences(this._codecPreferences, next))
+            return;
+        this._codecPreferences = next;
+        // 現在の交渉結果とは別に、次回 offer/answer 用の再解決要求を保持する。
+        // pending offer への answer が現在の codec を書き戻しても、この要求は
+        // 次回の createOffer() まで失われない。
+        this.codecPreferencesNeedResolution = true;
+        this._codecs = [];
+        this.onCodecPreferencesChanged.execute();
+    }
+    constructor(kind, dtlsTransport, receiver, sender, 
+    /**RFC 8829 4.2.4.  direction the transceiver was initialized with */
+    _direction) {
+        this.kind = kind;
+        this.receiver = receiver;
+        this.sender = sender;
+        this._direction = _direction;
+        this.id = randomUUID().toString();
+        this.onTrack = new Event();
+        this.mid = null;
+        /**should not be reused because it has been used for sending before. */
+        this.usedForSender = false;
+        this._codecs = [];
+        this.headerExtensions = [];
+        this.onCodecPreferencesChanged = new Event();
+        this.codecPreferencesNeedResolution = false;
+        this.options = {};
+        /**stop() 済み、または停止が確定した transceiver */
+        this.stopping = false;
+        /**port 0 の交渉が確定し、m-line が停止した transceiver */
+        this.stopped = false;
+        /**
+       * 共通 codec がない / remote port 0 のため answer で拒否することが確定した。
+       * `inactive` や app の `stop()` とは区別し、確定後は `stopped` も true になる。
+       */
+        this.rejected = false;
+        /**
+       * remote offer の m-line を拒否予定 (answer 未確定)。
+       * 確定するまで既存の RTP pipeline / track は維持し、rollback で false に戻す。
+       */
+        this.pendingRejection = false;
+        /**@private remote から受信中として track event を通知済みか */
+        this.firedReceiving = false;
+        /**@private Created by addTrack: a media of a remote offer not associated yet may take it (RFC 8829 5.10)*/
+        this.addedByAddTrack = false;
+        /**@private app の stop() 要求を manager に伝える */
+        this.onStopRequested = new Event();
+        /**@private 停止の確定または stop() でメディア資源を解放する際に通知する */
+        this.onRelease = new Event();
+        /**@private The direction set by the application changed: it is negotiated (W3C: the negotiation-needed flag)*/
+        this.onDirectionChanged = new Event();
+        if (dtlsTransport) {
+            this.setDtlsTransport(dtlsTransport);
+        }
+    }
+    get dtlsTransport() {
+        return this.receiver.dtlsTransport;
+    }
+    /**RFC 8829 4.2.4. setDirectionに渡された最後の値を示します */
+    get direction() {
+        return this._direction;
+    }
+    set direction(direction) {
+        const changed = direction !== this._direction;
+        this.setDirection(direction);
+        if (changed)
+            this.onDirectionChanged.execute();
+    }
+    setDirection(direction) {
+        this._direction = direction;
+        if (this._currentDirection &&
+            this._currentDirection !== 'stopped' &&
+            SenderDirections.includes(this._currentDirection)) {
+            this.usedForSender = true;
+        }
+    }
+    /**RFC 8829 4.2.5. last negotiated direction */
+    get currentDirection() {
+        return this._currentDirection ?? null;
+    }
+    setCurrentDirection(direction) {
+        this._currentDirection = direction;
+        if (direction &&
+            direction !== 'stopped' &&
+            SenderDirections.includes(direction) &&
+            this.sender.track) {
+            // 実際に送信へ使われた sender は addTrack の自動再使用対象から外す
+            this.usedForSender = true;
+        }
+    }
+    setDtlsTransport(dtls) {
+        this.receiver.setDtlsTransport(dtls);
+        this.sender.setDtlsTransport(dtls);
+    }
+    get msid() {
+        return this.msids[0];
+    }
+    get msids() {
+        return this.sender.streamIds.map((streamId) => `${streamId} ${this.sender.trackId}`);
+    }
+    addTrack(track) {
+        const res = this.receiver.addTrack(track);
+        if (res) {
+            this.onTrack.execute(track, this);
+        }
+    }
+    /**m-line (MID / index) と関連付け済みか */
+    get associated() {
+        return this.mid != null && this.mLineIndex != undefined;
+    }
+    /**
+   * https://www.w3.org/TR/webrtc/#dom-rtcrtptransceiver-stop
+   * 送受信をただちに止めて資源を解放し、次の自分の offer で port 0 を交渉する。
+   * 冪等で、2 回目以降は何もしない。
+   */
+    stop() {
+        if (this.stopping) {
+            return;
+        }
+        this.stopping = true;
+        this.releaseMedia();
+        if (!this.associated) {
+            // m-line と未関連付けなら交渉対象の m-line を作らずに停止を確定する
+            this.markStopped();
+        }
+        this.onStopRequested.execute();
+    }
+    /**
+   * @private
+   * port 0 の交渉確定 (自分の stop の answer / remote による拒否) を反映する。
+   */
+    commitStopped({ rejected }) {
+        if (rejected && !this.stopping) {
+            this.rejected = true;
+        }
+        this.pendingRejection = false;
+        this.stopping = true;
+        this.releaseMedia();
+        this.markStopped();
+    }
+    markStopped() {
+        this.stopped = true;
+        this.setCurrentDirection('stopped');
+    }
+    releaseMedia() {
+        // W3C の stop() は sender.track を null にしないため参照は維持する
+        this.sender.stop({ keepTrack: true });
+        this.receiver.stop();
+        this.receiver.endTracks();
+        this.onRelease.execute();
+    }
+    forceStop() {
+        if (this.stopped && this.sender.stopped && this.receiver.stopped) {
+            return;
+        }
+        this.stopping = true;
+        this.stopped = true;
+        this.setCurrentDirection('stopped');
+        this.receiver.stop();
+        this.sender.stop();
+        this.onRelease.execute();
+    }
+    getPayloadType(mimeType) {
+        return this.codecs.find((codec) => codec.mimeType.toLowerCase().includes(mimeType.toLowerCase()))?.payloadType;
+    }
+    getCodecStats() {
+        const timestamp = getStatsTimestamp();
+        return this.collectCodecStats(timestamp);
+    }
+    collectCodecStats(timestamp) {
+        const stats = [];
+        if (!this.dtlsTransport) {
+            return stats;
+        }
+        const transportId = generateStatsId('transport', this.dtlsTransport.id);
+        // Add codec stats for each codec
+        for (const codec of this.codecs) {
+            const codecStats = {
+                type: 'codec',
+                id: generateCodecStatsId(transportId, codec.payloadType, this.id),
+                timestamp,
+                payloadType: codec.payloadType,
+                transportId,
+                mimeType: codec.mimeType,
+                clockRate: codec.clockRate,
+                channels: codec.channels,
+                sdpFmtpLine: codec.parameters
+            };
+            stats.push(codecStats);
+        }
+        return stats;
+    }
+}
+function sameCodecPreferences(left, right) {
+    if (left === right)
+        return true;
+    if (left == undefined || right == undefined || left.length !== right.length) {
+        return false;
+    }
+    return stableCodecValue(left) === stableCodecValue(right);
+}
+function stableCodecValue(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map(stableCodecValue).join(',')}]`;
+    }
+    if (value != undefined && typeof value === 'object') {
+        const entries = Object.entries(value)
+            .filter(([, item]) => item !== undefined)
+            .sort(([left], [right]) => left.localeCompare(right));
+        return `{${entries
+            .map(([key, item]) => `${JSON.stringify(key)}:${stableCodecValue(item)}`)
+            .join(',')}}`;
+    }
+    return JSON.stringify(value) ?? 'undefined';
+}
+export const Inactive = 'inactive';
+export const Sendonly = 'sendonly';
+export const Recvonly = 'recvonly';
+export const Sendrecv = 'sendrecv';
+export const Directions = [Inactive, Sendonly, Recvonly, Sendrecv];

package/dist/esm/lib/peer/media/sender/cumulativeResult.js

@@ -0,0 +1,57 @@
+import { Int } from '../../imports/rtp.js';
+// refer by mediasoup
+export class CumulativeResult {
+    constructor() {
+        this.numPackets = 0;
+        /**byte */
+        this.totalSize = 0;
+        this.firstPacketSentAtMs = 0;
+        this.lastPacketSentAtMs = 0;
+        this.firstPacketReceivedAtMs = 0;
+        this.lastPacketReceivedAtMs = 0;
+    }
+    /**
+   *
+   * @param size byte
+   * @param sentAtMs
+   * @param receivedAtMs
+   */
+    addPacket(size, sentAtMs, receivedAtMs) {
+        if (this.numPackets === 0) {
+            this.firstPacketSentAtMs = sentAtMs;
+            this.firstPacketReceivedAtMs = receivedAtMs;
+            this.lastPacketSentAtMs = sentAtMs;
+            this.lastPacketReceivedAtMs = receivedAtMs;
+        }
+        else {
+            if (sentAtMs < this.firstPacketSentAtMs)
+                this.firstPacketSentAtMs = sentAtMs;
+            if (receivedAtMs < this.firstPacketReceivedAtMs)
+                this.firstPacketReceivedAtMs = receivedAtMs;
+            if (sentAtMs > this.lastPacketSentAtMs)
+                this.lastPacketSentAtMs = sentAtMs;
+            if (receivedAtMs > this.lastPacketReceivedAtMs)
+                this.lastPacketReceivedAtMs = receivedAtMs;
+        }
+        this.numPackets++;
+        this.totalSize += size;
+    }
+    reset() {
+        this.numPackets = 0;
+        this.totalSize = 0;
+        this.firstPacketSentAtMs = 0;
+        this.lastPacketSentAtMs = 0;
+        this.firstPacketReceivedAtMs = 0;
+        this.lastPacketReceivedAtMs = 0;
+    }
+    get receiveBitrate() {
+        const recvIntervalMs = this.lastPacketReceivedAtMs - this.firstPacketReceivedAtMs;
+        const bitrate = (this.totalSize / recvIntervalMs) * 8 * 1000;
+        return Int(bitrate);
+    }
+    get sendBitrate() {
+        const sendIntervalMs = this.lastPacketSentAtMs - this.firstPacketSentAtMs;
+        const bitrate = (this.totalSize / sendIntervalMs) * 8 * 1000;
+        return Int(bitrate);
+    }
+}

package/dist/esm/lib/peer/media/sender/senderBWE.js

@@ -0,0 +1,95 @@
+import { Event } from '../../imports/common.js';
+import { Int } from '../../imports/rtp.js';
+import { milliTime } from '../../utils.js';
+import { CumulativeResult } from './cumulativeResult.js';
+const COUNTER_MAX = 20;
+const SCORE_MAX = 10;
+//The packets sent kept for their feedback, by transport-wide sequence number: the feedback comes within a few hundred
+//milliseconds
+const SENT_HISTORY = 8192;
+export class SenderBandwidthEstimator {
+    /**1~10 big is worth*/
+    get congestionScore() {
+        return this._congestionScore;
+    }
+    set congestionScore(v) {
+        this._congestionScore = v;
+        this.onCongestionScore.execute(v);
+    }
+    get availableBitrate() {
+        return this._availableBitrate;
+    }
+    set availableBitrate(v) {
+        this._availableBitrate = v;
+        this.onAvailableBitrate.execute(v);
+    }
+    constructor() {
+        this.congestion = false;
+        this.onAvailableBitrate = new Event();
+        /**congestion occur or not */
+        this.onCongestion = new Event();
+        this.onCongestionScore = new Event();
+        this.congestionCounter = 0;
+        this.cumulativeResult = new CumulativeResult();
+        this.sentInfos = new Map();
+        this._congestionScore = 1;
+        this._availableBitrate = 0;
+    }
+    receiveTWCC(feedback) {
+        const nowMs = milliTime();
+        //Since the first packet acknowledged of the window (none yet: just started)
+        const elapsedMs = this.cumulativeResult.numPackets
+            ? nowMs - this.cumulativeResult.firstPacketSentAtMs
+            : 0;
+        if (elapsedMs > 1000) {
+            this.cumulativeResult.reset();
+            // Congestion may be occurring.
+            if (this.congestionCounter < COUNTER_MAX) {
+                this.congestionCounter++;
+            }
+            else if (this.congestionScore < SCORE_MAX) {
+                this.congestionScore++;
+            }
+            if (this.congestionCounter >= COUNTER_MAX && !this.congestion) {
+                this.congestion = true;
+                this.onCongestion.execute(this.congestion);
+            }
+        }
+        for (const result of feedback.packetResults) {
+            if (!result.received)
+                continue;
+            const wideSeq = result.sequenceNumber;
+            const info = this.sentInfos.get(wideSeq);
+            if (!info)
+                continue;
+            if (!result.receivedAtMs)
+                continue;
+            this.cumulativeResult.addPacket(info.size, info.sendingAtMs, result.receivedAtMs);
+        }
+        if (elapsedMs >= 100 && this.cumulativeResult.numPackets >= 20) {
+            this.availableBitrate = Math.min(this.cumulativeResult.sendBitrate, this.cumulativeResult.receiveBitrate);
+            this.cumulativeResult.reset();
+            if (this.congestionCounter > -COUNTER_MAX) {
+                const maxBonus = Int(COUNTER_MAX / 2) + 1;
+                const minBonus = Int(COUNTER_MAX / 4) + 1;
+                const bonus = maxBonus - ((maxBonus - minBonus) / 10) * this.congestionScore;
+                this.congestionCounter = this.congestionCounter - bonus;
+            }
+            if (this.congestionCounter <= -COUNTER_MAX) {
+                if (this.congestionScore > 1) {
+                    this.congestionScore--;
+                    this.onCongestion.execute(false);
+                }
+                this.congestionCounter = 0;
+            }
+            if (this.congestionCounter <= 0 && this.congestion) {
+                this.congestion = false;
+                this.onCongestion.execute(this.congestion);
+            }
+        }
+    }
+    rtpPacketSent(sentInfo) {
+        this.sentInfos.delete((sentInfo.wideSeq - SENT_HISTORY) & 0xffff);
+        this.sentInfos.set(sentInfo.wideSeq, sentInfo);
+    }
+}

package/dist/esm/lib/peer/media/stats.js

@@ -0,0 +1,81 @@
+/**
+ * WebRTC Statistics API implementation
+ * Based on: https://www.w3.org/TR/webrtc-stats/
+ */
+/**
+ * RTCStatsReport is a Map-like object that holds WebRTC statistics
+ */
+export class RTCStatsReport extends Map {
+    constructor(stats) {
+        super();
+        if (stats) {
+            for (const stat of stats) {
+                this.set(stat.id, stat);
+            }
+        }
+    }
+}
+/**
+ * Generate a unique ID for a statistics object
+ */
+export function generateStatsId(type, ...parts) {
+    const validParts = parts.filter((p) => p !== undefined);
+    return `${type}_${validParts.join('_')}`;
+}
+export function generateCodecStatsId(transportId, payloadType, scopeId) {
+    return generateStatsId('codec', transportId, payloadType, scopeId);
+}
+/**
+ * Get current timestamp in milliseconds (DOMHighResTimeStamp)
+ */
+export function getStatsTimestamp() {
+    return performance.timeOrigin + performance.now();
+}
+export function getReferencedStatsIds(stat) {
+    const references = [];
+    for (const [key, value] of Object.entries(stat)) {
+        if (key === 'id') {
+            continue;
+        }
+        if (key.endsWith('Id')) {
+            if (typeof value === 'string') {
+                references.push(value);
+            }
+            continue;
+        }
+        if (key.endsWith('Ids') && Array.isArray(value)) {
+            for (const entry of value) {
+                if (typeof entry === 'string') {
+                    references.push(entry);
+                }
+            }
+        }
+    }
+    return references;
+}
+export function buildStatsReport(stats, rootIds) {
+    const index = new Map();
+    for (const stat of stats) {
+        index.set(stat.id, stat);
+    }
+    if (!rootIds) {
+        return new RTCStatsReport([...index.values()]);
+    }
+    const includedIds = new Set();
+    const queue = [...new Set(Array.from(rootIds))];
+    while (queue.length > 0) {
+        const id = queue.shift();
+        if (!id || includedIds.has(id)) {
+            continue;
+        }
+        const stat = index.get(id);
+        if (!stat) {
+            continue;
+        }
+        includedIds.add(id);
+        queue.push(...getReferencedStatsIds(stat));
+    }
+    return new RTCStatsReport([...includedIds]
+        .map((id) => index.get(id))
+        .filter((stat) => !!stat));
+}

package/dist/esm/lib/peer/media/track.js

@@ -0,0 +1,208 @@
+import { randomUUID } from 'node:crypto';
+import { Event } from '../imports/common.js';
+import { EventTarget } from '../helper.js';
+import { RtpPacket } from '../imports/rtp.js';
+const sourceCodecsByTrack = new WeakMap();
+const sourceCodecsCapturedByTrack = new WeakSet();
+export function setTrackSourceCodecs(track, codecs) {
+    sourceCodecsCapturedByTrack.add(track);
+    if (codecs == undefined)
+        sourceCodecsByTrack.delete(track);
+    else
+        sourceCodecsByTrack.set(track, codecs);
+}
+export function getTrackSourceCodecs(track) {
+    return track == undefined ? undefined : sourceCodecsByTrack.get(track);
+}
+export function captureTrackSourceCodecs(track) {
+    if (sourceCodecsCapturedByTrack.has(track))
+        return;
+    sourceCodecsCapturedByTrack.add(track);
+    if (track.codec != undefined) {
+        sourceCodecsByTrack.set(track, [track.codec]);
+    }
+}
+class TrackBroadcastSource {
+    constructor() {
+        this.tracks = new Set();
+        this.upstreamStops = new Set();
+    }
+    attach(track) {
+        this.tracks.add(track);
+    }
+    detach(track) {
+        this.tracks.delete(track);
+        if (this.tracks.size > 0) {
+            return;
+        }
+        for (const stop of [...this.upstreamStops]) {
+            stop();
+        }
+        this.upstreamStops.clear();
+    }
+    addUpstreamStop(stop) {
+        const once = () => {
+            this.upstreamStops.delete(once);
+            stop();
+        };
+        this.upstreamStops.add(once);
+    }
+    deliverRtp(packet, extensions) {
+        const live = [...this.tracks].filter((track) => !track.stopped);
+        for (const track of live) {
+            track.applyIncomingRtp(packet.clone(), extensions);
+        }
+    }
+    deliverRtcp(packet) {
+        for (const track of this.tracks) {
+            if (!track.stopped) {
+                track.onReceiveRtcp.execute(packet);
+            }
+        }
+    }
+    deliverSourceChanged(header) {
+        for (const track of this.tracks) {
+            if (!track.stopped) {
+                track.onSourceChanged.execute(header);
+            }
+        }
+    }
+    stopAllTracks() {
+        for (const track of [...this.tracks]) {
+            track.stop();
+        }
+    }
+}
+export class MediaStreamTrack extends EventTarget {
+    constructor(props) {
+        super();
+        this.uuid = randomUUID().toString();
+        this.remote = false;
+        /**todo impl */
+        this.enabled = true;
+        this.onReceiveRtp = new Event();
+        this.onReceiveRtcp = new Event();
+        this.onSourceChanged = new Event();
+        this.stopped = false;
+        this.muted = true;
+        this.stop = () => {
+            if (this.stopped) {
+                return;
+            }
+            this.stopped = true;
+            this.muted = true;
+            this.onReceiveRtp.complete();
+            this.emit('ended');
+            this.broadcastSource.detach(this);
+        };
+        this.writeRtp = (rtp) => {
+            if (this.remote) {
+                throw new Error('this is remoteTrack');
+            }
+            const packet = Buffer.isBuffer(rtp)
+                ? RtpPacket.deSerialize(rtp)
+                : rtp.clone();
+            packet.header.payloadType =
+                this.codec?.payloadType ?? packet.header.payloadType;
+            this.broadcastSource.deliverRtp(packet);
+        };
+        this.writeRtcp = (rtcp) => {
+            this.broadcastSource.deliverRtcp(rtcp);
+        };
+        const sharedSource = props.broadcastSource;
+        Object.assign(this, props);
+        this.id ??= this.uuid;
+        this.broadcastSource = sharedSource ?? new TrackBroadcastSource();
+        if (!this.stopped) {
+            this.broadcastSource.attach(this);
+        }
+        this.onReceiveRtp.subscribe((rtp) => {
+            this.muted = false;
+            this.header = rtp.header;
+        });
+        this.label = `${this.remote ? 'remote' : 'local'} ${this.kind}`;
+    }
+    get readyState() {
+        return this.stopped ? 'ended' : 'live';
+    }
+    notifySourceChanged(header) {
+        this.broadcastSource.deliverSourceChanged(header);
+    }
+    applyIncomingRtp(packet, extensions) {
+        if (this.stopped) {
+            return;
+        }
+        this.onReceiveRtp.execute(packet, extensions);
+    }
+    bindUpstreamStop(stop) {
+        this.broadcastSource.addUpstreamStop(stop);
+    }
+    stopMediaSource() {
+        this.broadcastSource.stopAllTracks();
+    }
+    clone() {
+        const cloned = new MediaStreamTrack({
+            kind: this.kind,
+            remote: this.remote,
+            enabled: this.enabled,
+            muted: this.muted,
+            stopped: this.stopped,
+            codec: this.codec,
+            ssrc: this.ssrc,
+            rid: this.rid,
+            header: this.header,
+            broadcastSource: this.broadcastSource
+        });
+        if (sourceCodecsCapturedByTrack.has(this)) {
+            setTrackSourceCodecs(cloned, getTrackSourceCodecs(this));
+        }
+        else {
+            captureTrackSourceCodecs(cloned);
+        }
+        return cloned;
+    }
+}
+export class MediaStream {
+    constructor(props = {}) {
+        this.tracks = [];
+        if (Array.isArray(props)) {
+            this.tracks = props;
+        }
+        else {
+            Object.assign(this, props);
+        }
+        this.id ??= randomUUID().toString();
+    }
+    addTrack(track) {
+        track.streamId = this.id;
+        this.tracks.push(track);
+    }
+    removeTrack(track) {
+        this.tracks = this.tracks.filter((currentTrack) => currentTrack !== track);
+        if (track.streamId === this.id) {
+            track.streamId = undefined;
+        }
+    }
+    getTracks() {
+        return this.tracks;
+    }
+    getAudioTracks() {
+        return this.tracks.filter((track) => track.kind === 'audio');
+    }
+    getVideoTracks() {
+        return this.tracks.filter((track) => track.kind === 'video');
+    }
+    getTrackById(id) {
+        return this.tracks.find((track) => track.id === id);
+    }
+    get active() {
+        return this.tracks.some((track) => !track.stopped);
+    }
+    clone() {
+        const cloned = new MediaStream();
+        for (const track of this.tracks) {
+            cloned.addTrack(track.clone());
+        }
+        return cloned;
+    }
+}