@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/cjs/lib/peer/media/rtpTransceiver.d.ts

@@ -0,0 +1,117 @@
+import { Event } from '../imports/common.js';
+import type { RTCDtlsTransport } from '../index.js';
+import type { Kind } from '../types/domain.js';
+import type { RTCRtpCodecParameters, RTCRtpHeaderExtensionParameters } from './parameters.js';
+import type { RTCRtpReceiver } from './rtpReceiver.js';
+import type { RTCRtpSender } from './rtpSender.js';
+import { type RTCStats } from './stats.js';
+import type { MediaStream, MediaStreamTrack } from './track.js';
+export declare class RTCRtpTransceiver {
+    readonly kind: Kind;
+    receiver: RTCRtpReceiver;
+    sender: RTCRtpSender;
+    /**RFC 8829 4.2.4.  direction the transceiver was initialized with */
+    private _direction;
+    readonly id: string;
+    readonly onTrack: Event<[MediaStreamTrack, RTCRtpTransceiver]>;
+    mid: string | null;
+    mLineIndex?: number;
+    /**should not be reused because it has been used for sending before. */
+    usedForSender: boolean;
+    private _currentDirection?;
+    offerDirection: MediaDirection;
+    _codecs: RTCRtpCodecParameters[];
+    set codecs(codecs: RTCRtpCodecParameters[]);
+    get codecs(): RTCRtpCodecParameters[];
+    headerExtensions: RTCRtpHeaderExtensionParameters[];
+    private _codecPreferences?;
+    readonly onCodecPreferencesChanged: Event<[]>;
+    pendingLocalOfferCodecs?: RTCRtpCodecParameters[];
+    codecPreferencesNeedResolution: boolean;
+    get codecPreferences(): readonly RTCRtpCodecParameters[] | undefined;
+    setCodecPreferences(codecs: RTCRtpCodecParameters[]): void;
+    options: Partial<TransceiverOptions>;
+    /**stop() 済み、または停止が確定した transceiver */
+    stopping: boolean;
+    /**port 0 の交渉が確定し、m-line が停止した transceiver */
+    stopped: boolean;
+    /**
+   * 共通 codec がない / remote port 0 のため answer で拒否することが確定した。
+   * `inactive` や app の `stop()` とは区別し、確定後は `stopped` も true になる。
+   */
+    rejected: boolean;
+    /**
+   * remote offer の m-line を拒否予定 (answer 未確定)。
+   * 確定するまで既存の RTP pipeline / track は維持し、rollback で false に戻す。
+   */
+    pendingRejection: boolean;
+    /**@private remote から受信中として track event を通知済みか */
+    firedReceiving: boolean;
+    /**@private Created by addTrack: a media of a remote offer not associated yet may take it (RFC 8829 5.10)*/
+    addedByAddTrack: boolean;
+    /**@private app の stop() 要求を manager に伝える */
+    readonly onStopRequested: Event<[]>;
+    /**@private 停止の確定または stop() でメディア資源を解放する際に通知する */
+    readonly onRelease: Event<[]>;
+    /**@private The direction set by the application changed: it is negotiated (W3C: the negotiation-needed flag)*/
+    readonly onDirectionChanged: Event<[]>;
+    constructor(kind: Kind, dtlsTransport: RTCDtlsTransport | undefined, receiver: RTCRtpReceiver, sender: RTCRtpSender, 
+    /**RFC 8829 4.2.4.  direction the transceiver was initialized with */
+    _direction: MediaDirection);
+    get dtlsTransport(): RTCDtlsTransport;
+    /**RFC 8829 4.2.4. setDirectionに渡された最後の値を示します */
+    get direction(): MediaDirection;
+    set direction(direction: MediaDirection);
+    setDirection(direction: MediaDirection): void;
+    /**RFC 8829 4.2.5. last negotiated direction */
+    get currentDirection(): CurrentDirection | null;
+    setCurrentDirection(direction: CurrentDirection | undefined): void;
+    setDtlsTransport(dtls: RTCDtlsTransport): void;
+    get msid(): string;
+    get msids(): string[];
+    addTrack(track: MediaStreamTrack): void;
+    /**m-line (MID / index) と関連付け済みか */
+    get associated(): boolean;
+    /**
+   * https://www.w3.org/TR/webrtc/#dom-rtcrtptransceiver-stop
+   * 送受信をただちに止めて資源を解放し、次の自分の offer で port 0 を交渉する。
+   * 冪等で、2 回目以降は何もしない。
+   */
+    stop(): void;
+    /**
+   * @private
+   * port 0 の交渉確定 (自分の stop の answer / remote による拒否) を反映する。
+   */
+    commitStopped({ rejected }: {
+        rejected: boolean;
+    }): void;
+    private markStopped;
+    private releaseMedia;
+    forceStop(): void;
+    getPayloadType(mimeType: string): number | undefined;
+    getCodecStats(): RTCStats[];
+    collectCodecStats(timestamp: number): RTCStats[];
+}
+export declare const Inactive = "inactive";
+export declare const Sendonly = "sendonly";
+export declare const Recvonly = "recvonly";
+export declare const Sendrecv = "sendrecv";
+export declare const Directions: readonly ["inactive", "sendonly", "recvonly", "sendrecv"];
+export type MediaDirection = (typeof Directions)[number];
+export type CurrentDirection = MediaDirection | 'stopped';
+type SimulcastDirection = 'send' | 'recv';
+export interface RTCRtpEncodingParameters {
+    active?: boolean;
+    rid?: string;
+    maxBitrate?: number;
+}
+export interface TransceiverOptions {
+    direction: MediaDirection;
+    sendEncodings: RTCRtpEncodingParameters[];
+    simulcast: {
+        direction: SimulcastDirection;
+        rid: string;
+    }[];
+    streams: MediaStream[];
+}
+export {};

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

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Directions = exports.Sendrecv = exports.Recvonly = exports.Sendonly = exports.Inactive = exports.RTCRtpTransceiver = void 0;
+const node_crypto_1 = require("node:crypto");
+const common_js_1 = require("../imports/common.js");
+const const_js_1 = require("../const.js");
+const errors_js_1 = require("../errors.js");
+const codec_js_1 = require("./codec.js");
+const stats_js_1 = require("./stats.js");
+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 (0, errors_js_1.createWebRtcTypeError)('codecs must be an array');
+        }
+        const next = codecs.length === 0 ? undefined : codecs.map(codec_js_1.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 = (0, node_crypto_1.randomUUID)().toString();
+        this.onTrack = new common_js_1.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 common_js_1.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 common_js_1.Event();
+        /**@private 停止の確定または stop() でメディア資源を解放する際に通知する */
+        this.onRelease = new common_js_1.Event();
+        /**@private The direction set by the application changed: it is negotiated (W3C: the negotiation-needed flag)*/
+        this.onDirectionChanged = new common_js_1.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' &&
+            const_js_1.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' &&
+            const_js_1.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 = (0, stats_js_1.getStatsTimestamp)();
+        return this.collectCodecStats(timestamp);
+    }
+    collectCodecStats(timestamp) {
+        const stats = [];
+        if (!this.dtlsTransport) {
+            return stats;
+        }
+        const transportId = (0, stats_js_1.generateStatsId)('transport', this.dtlsTransport.id);
+        // Add codec stats for each codec
+        for (const codec of this.codecs) {
+            const codecStats = {
+                type: 'codec',
+                id: (0, stats_js_1.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;
+    }
+}
+exports.RTCRtpTransceiver = RTCRtpTransceiver;
+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';
+}
+exports.Inactive = 'inactive';
+exports.Sendonly = 'sendonly';
+exports.Recvonly = 'recvonly';
+exports.Sendrecv = 'sendrecv';
+exports.Directions = [exports.Inactive, exports.Sendonly, exports.Recvonly, exports.Sendrecv];

package/dist/cjs/lib/peer/media/sender/cumulativeResult.d.ts

@@ -0,0 +1,19 @@
+export declare class CumulativeResult {
+    numPackets: number;
+    /**byte */
+    totalSize: number;
+    firstPacketSentAtMs: number;
+    lastPacketSentAtMs: number;
+    firstPacketReceivedAtMs: number;
+    lastPacketReceivedAtMs: number;
+    /**
+   *
+   * @param size byte
+   * @param sentAtMs
+   * @param receivedAtMs
+   */
+    addPacket(size: number, sentAtMs: number, receivedAtMs: number): void;
+    reset(): void;
+    get receiveBitrate(): number;
+    get sendBitrate(): number;
+}

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CumulativeResult = void 0;
+const rtp_js_1 = require("../../imports/rtp.js");
+// refer by mediasoup
+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 (0, rtp_js_1.Int)(bitrate);
+    }
+    get sendBitrate() {
+        const sendIntervalMs = this.lastPacketSentAtMs - this.firstPacketSentAtMs;
+        const bitrate = (this.totalSize / sendIntervalMs) * 8 * 1000;
+        return (0, rtp_js_1.Int)(bitrate);
+    }
+}
+exports.CumulativeResult = CumulativeResult;

package/dist/cjs/lib/peer/media/sender/senderBWE.d.ts

@@ -0,0 +1,32 @@
+import { Event } from '../../imports/common.js';
+import { type TransportWideCC } from '../../imports/rtp.js';
+export declare class SenderBandwidthEstimator {
+    congestion: boolean;
+    readonly onAvailableBitrate: Event<[number]>;
+    /**congestion occur or not */
+    readonly onCongestion: Event<[boolean]>;
+    readonly onCongestionScore: Event<[number]>;
+    private congestionCounter;
+    private cumulativeResult;
+    private sentInfos;
+    private _congestionScore;
+    /**1~10 big is worth*/
+    get congestionScore(): number;
+    set congestionScore(v: number);
+    private _availableBitrate;
+    get availableBitrate(): number;
+    set availableBitrate(v: number);
+    constructor();
+    receiveTWCC(feedback: TransportWideCC): void;
+    rtpPacketSent(sentInfo: SentInfo): void;
+}
+export interface SentInfo {
+    wideSeq: number;
+    /**
+   * byte
+   */
+    size: number;
+    isProbation?: boolean;
+    sendingAtMs: number;
+    sentAtMs: number;
+}

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

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderBandwidthEstimator = void 0;
+const common_js_1 = require("../../imports/common.js");
+const rtp_js_1 = require("../../imports/rtp.js");
+const utils_js_1 = require("../../utils.js");
+const cumulativeResult_js_1 = require("./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;
+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 common_js_1.Event();
+        /**congestion occur or not */
+        this.onCongestion = new common_js_1.Event();
+        this.onCongestionScore = new common_js_1.Event();
+        this.congestionCounter = 0;
+        this.cumulativeResult = new cumulativeResult_js_1.CumulativeResult();
+        this.sentInfos = new Map();
+        this._congestionScore = 1;
+        this._availableBitrate = 0;
+    }
+    receiveTWCC(feedback) {
+        const nowMs = (0, utils_js_1.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 = (0, rtp_js_1.Int)(COUNTER_MAX / 2) + 1;
+                const minBonus = (0, rtp_js_1.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);
+    }
+}
+exports.SenderBandwidthEstimator = SenderBandwidthEstimator;