@lakutata/webrtc 0.0.0-stage → 3.1.1

package/dist/esm/lib/peer/media/receiver/nack.js

@@ -0,0 +1,100 @@
+import { Event, detached, uint16Add } from '../../imports/common.js';
+import { GenericNack, RtcpTransportLayerFeedback, debug } from '../../imports/rtp.js';
+const log = debug('webrtc/peer/media/receiver/nack');
+const LOST_SIZE = 30 * 5;
+export class NackHandler {
+    constructor(receiver) {
+        this.receiver = receiver;
+        this.newEstSeqNum = 0;
+        this._lost = {};
+        this.onPacketLost = new Event();
+        this.retryCount = 10;
+        this.closed = false;
+        this.sendNack = () => new Promise((r, f) => {
+            if (this.lostSeqNumbers.length > 0 && this.mediaSourceSsrc) {
+                const nack = new GenericNack({
+                    senderSsrc: this.receiver.rtcpSsrc,
+                    mediaSourceSsrc: this.mediaSourceSsrc,
+                    lost: this.lostSeqNumbers
+                });
+                const rtcp = new RtcpTransportLayerFeedback({
+                    feedback: nack
+                });
+                this.receiver.dtlsTransport.sendRtcp([rtcp]).then(r).catch(f);
+                this.updateRetryCount();
+                this.onPacketLost.execute(nack);
+            }
+        });
+    }
+    get lostSeqNumbers() {
+        return Object.keys(this._lost).map(Number).sort();
+    }
+    getLost(seq) {
+        return this._lost[seq];
+    }
+    setLost(seq, count) {
+        this._lost[seq] = count;
+        if (this.nackLoop || this.closed) {
+            return;
+        }
+        this.nackLoop = setInterval(detached(async () => {
+            await this.sendNack();
+            if (!Object.keys(this._lost).length) {
+                clearInterval(this.nackLoop);
+                this.nackLoop = undefined;
+            }
+        }, (error) => log('failed to send nack', error)), 5);
+    }
+    removeLost(sequenceNumber) {
+        delete this._lost[sequenceNumber];
+    }
+    addPacket(packet) {
+        const { sequenceNumber, ssrc } = packet.header;
+        this.mediaSourceSsrc = ssrc;
+        if (this.newEstSeqNum === 0) {
+            this.newEstSeqNum = sequenceNumber;
+            return;
+        }
+        if (this.getLost(sequenceNumber)) {
+            // log("packetLoss resolved", { sequenceNumber });
+            this.removeLost(sequenceNumber);
+            return;
+        }
+        if (sequenceNumber === uint16Add(this.newEstSeqNum, 1)) {
+            this.newEstSeqNum = sequenceNumber;
+        }
+        else if (sequenceNumber > uint16Add(this.newEstSeqNum, 1)) {
+            // packet lost detected
+            for (let i = uint16Add(this.newEstSeqNum, 1); i < sequenceNumber; i = uint16Add(i, 1)) {
+                this.setLost(i, 1);
+            }
+            // this.receiver.sendRtcpPLI(this.mediaSourceSsrc);
+            this.newEstSeqNum = sequenceNumber;
+            this.pruneLost();
+        }
+    }
+    pruneLost() {
+        if (this.lostSeqNumbers.length > LOST_SIZE) {
+            this._lost = Object.entries(this._lost)
+                .slice(-LOST_SIZE)
+                .reduce((acc, [key, v]) => {
+                acc[key] = v;
+                return acc;
+            }, {});
+        }
+    }
+    close() {
+        this.closed = true;
+        clearInterval(this.nackLoop);
+        this._lost = {};
+    }
+    updateRetryCount() {
+        this.lostSeqNumbers.forEach((seq) => {
+            const count = this._lost[seq]++;
+            if (count > this.retryCount) {
+                this.removeLost(seq);
+                return seq;
+            }
+        });
+    }
+}

package/dist/esm/lib/peer/media/receiver/receiverTwcc.js

@@ -0,0 +1,175 @@
+import { randomBytes } from 'node:crypto';
+import { uint8Add } from '../../imports/common.js';
+import { PacketChunk, PacketStatus, RecvDelta, RtcpTransportLayerFeedback, RunLengthChunk, StatusVectorChunk, TransportWideCC, debug } from '../../imports/rtp.js';
+import { microTime } from '../../utils.js';
+const log = debug('webrtc/peer/media/receiver/receiverTwcc');
+//How often the feedback is sent, in milliseconds (as libwebrtc does by default)
+const FEEDBACK_INTERVAL = 100;
+//The most packets one feedback reports, for it to fit a datagram
+const MAX_PACKETS_PER_FEEDBACK = 500;
+//The most arrivals kept until reported
+const MAX_ARRIVALS = 1 << 15;
+/**
+ * The statuses of the packets of a feedback in chunks: a run of the same status in a run length chunk, the others in
+ * status vectors (of one bit while no delta is large)
+ * @param statuses
+ */
+function packetChunksOf(statuses) {
+    const chunks = [];
+    let index = 0;
+    while (index < statuses.length) {
+        let run = 1;
+        while (index + run < statuses.length && statuses[index + run] === statuses[index] && run < 8191)
+            run++;
+        if (run >= 7) {
+            chunks.push(new RunLengthChunk({ packetStatus: statuses[index], runLength: run }));
+            index += run;
+            continue;
+        }
+        const oneBit = statuses.slice(index, index + 14);
+        const vector = oneBit.includes(PacketStatus.TypeTCCPacketReceivedLargeDelta)
+            ? statuses.slice(index, index + 7)
+            : oneBit;
+        const length = vector === oneBit ? 14 : 7;
+        chunks.push(new StatusVectorChunk({
+            type: PacketChunk.TypeTCCStatusVectorChunk,
+            symbolSize: length === 14 ? 0 : 1,
+            //Filled up with packets not received, past the ones reported
+            symbolList: [...vector, ...Array(length - vector.length).fill(PacketStatus.TypeTCCPacketNotReceived)]
+        }));
+        index += length;
+    }
+    return chunks;
+}
+/**
+ * The transport-wide congestion control feedback of a transport: the arrival times of the packets it receives with a
+ * transport-wide sequence number (the ones of all its streams), reported to the sender every FEEDBACK_INTERVAL. The
+ * packets missing are reported lost; the ones arriving after their report are left out.
+ */
+export class ReceiverTWCC {
+    constructor(dtlsTransport) {
+        this.dtlsTransport = dtlsTransport;
+        /**The arrival times not reported yet, in microseconds, by sequence number (unwrapped)*/
+        this.arrivals = new Map();
+        /** uint8 */
+        this.fbPktCount = 0;
+        this.rtcpSsrc = randomBytes(4).readUInt32BE();
+        this.mediaSourceSsrc = 0;
+    }
+    /**
+     * A packet arrived
+     * @param transportSequenceNumber
+     * @param mediaSourceSsrc The synchronization source of the packet
+     * @param arrivalTime In microseconds
+     */
+    handleTWCC(transportSequenceNumber, mediaSourceSsrc, arrivalTime = Number(microTime())) {
+        const sequenceNumber = this.unwrap(transportSequenceNumber);
+        if (this.nextSequenceNumber !== undefined && sequenceNumber < this.nextSequenceNumber)
+            return;
+        if (!this.arrivals.has(sequenceNumber))
+            this.arrivals.set(sequenceNumber, arrivalTime);
+        if (this.arrivals.size > MAX_ARRIVALS) {
+            let oldest = sequenceNumber;
+            for (const each of this.arrivals.keys())
+                oldest = Math.min(oldest, each);
+            this.arrivals.delete(oldest);
+            this.nextSequenceNumber = oldest + 1;
+        }
+        this.mediaSourceSsrc = mediaSourceSsrc;
+        if (!this.timer) {
+            this.timer = setInterval(() => this.sendTWCC(), FEEDBACK_INTERVAL);
+            this.timer.unref();
+        }
+    }
+    /**
+     * Report no more
+     */
+    stop() {
+        clearInterval(this.timer);
+        this.timer = undefined;
+        this.arrivals.clear();
+    }
+    /**
+     * Report the packets since the last report, up to the last one received
+     */
+    sendTWCC() {
+        if (this.arrivals.size === 0)
+            return;
+        let begin = this.nextSequenceNumber ?? Infinity;
+        if (begin === Infinity) {
+            for (const sequenceNumber of this.arrivals.keys())
+                begin = Math.min(begin, sequenceNumber);
+        }
+        const end = this.highestSequenceNumber;
+        while (begin <= end) {
+            const { feedback, next } = this.buildFeedback(begin, end);
+            this.dtlsTransport.sendRtcp([new RtcpTransportLayerFeedback({ feedback })]).catch((error) => log(error));
+            begin = next;
+        }
+        this.arrivals.clear();
+        this.nextSequenceNumber = end + 1;
+    }
+    /**
+     * The sequence number on more than 16 bits, the closest to the highest one received
+     * @param sequenceNumber
+     */
+    unwrap(sequenceNumber) {
+        if (this.highestSequenceNumber === undefined) {
+            this.highestSequenceNumber = sequenceNumber;
+            return sequenceNumber;
+        }
+        let delta = (sequenceNumber - this.highestSequenceNumber) & 0xffff;
+        if (delta >= 0x8000)
+            delta -= 0x10000;
+        const unwrapped = this.highestSequenceNumber + delta;
+        if (unwrapped > this.highestSequenceNumber)
+            this.highestSequenceNumber = unwrapped;
+        return unwrapped;
+    }
+    /**
+     * The feedback of the packets from begin, up to end: it stops before a packet received too long after the one
+     * before (its delta not fitting 16 bits), or after MAX_PACKETS_PER_FEEDBACK
+     * @param begin
+     * @param end
+     */
+    buildFeedback(begin, end) {
+        //The reference time is the one of the first packet received, in multiples of 64 ms
+        let first = begin;
+        while (!this.arrivals.has(first))
+            first++;
+        const referenceTime = Math.floor(this.arrivals.get(first) / 64000);
+        let time = referenceTime * 64000;
+        const statuses = [];
+        const recvDeltas = [];
+        let sequenceNumber = begin;
+        for (; sequenceNumber <= end && statuses.length < MAX_PACKETS_PER_FEEDBACK; sequenceNumber++) {
+            const arrival = this.arrivals.get(sequenceNumber);
+            if (arrival === undefined) {
+                statuses.push(PacketStatus.TypeTCCPacketNotReceived);
+                continue;
+            }
+            //In 250 µs
+            const delta = Math.round((arrival - time) / 250);
+            if (delta < -32768 || delta > 32767)
+                break;
+            const type = delta >= 0 && delta <= 255
+                ? PacketStatus.TypeTCCPacketReceivedSmallDelta
+                : PacketStatus.TypeTCCPacketReceivedLargeDelta;
+            statuses.push(type);
+            recvDeltas.push(new RecvDelta({ type, delta: delta * 250 }));
+            time += delta * 250;
+        }
+        const feedback = new TransportWideCC({
+            senderSsrc: this.rtcpSsrc,
+            mediaSourceSsrc: this.mediaSourceSsrc,
+            baseSequenceNumber: begin & 0xffff,
+            packetStatusCount: statuses.length,
+            referenceTime: referenceTime & 0xffffff,
+            fbPktCount: this.fbPktCount,
+            packetChunks: packetChunksOf(statuses),
+            recvDeltas
+        });
+        this.fbPktCount = uint8Add(this.fbPktCount, 1);
+        return { feedback, next: sequenceNumber };
+    }
+}

package/dist/esm/lib/peer/media/receiver/statistics.js

@@ -0,0 +1,67 @@
+import { int, uint16Gt } from '../../imports/common.js';
+import { getStatsTimestamp } from '../stats.js';
+// from aiortc
+export class StreamStatistics {
+    constructor(clockRate) {
+        this.cycles = 0;
+        this.packets_received = 0;
+        this.bytesReceived = 0;
+        this.headerBytesReceived = 0;
+        this.jitter_q4 = 0;
+        // # fraction lost
+        this.expected_prior = 0;
+        this.received_prior = 0;
+        this.clockRate = clockRate;
+    }
+    add(packet, now = Date.now() / 1000) {
+        const inOrder = this.max_seq == undefined ||
+            uint16Gt(packet.header.sequenceNumber, this.max_seq);
+        this.packets_received++;
+        this.bytesReceived += packet.payload.length;
+        this.headerBytesReceived += packet.header.serializeSize;
+        this.lastPacketReceivedTimestamp = getStatsTimestamp();
+        if (this.base_seq == undefined) {
+            this.base_seq = packet.header.sequenceNumber;
+        }
+        if (inOrder) {
+            const arrival = int(now * this.clockRate);
+            if (this.max_seq != undefined &&
+                packet.header.sequenceNumber < this.max_seq) {
+                this.cycles += 1 << 16;
+            }
+            this.max_seq = packet.header.sequenceNumber;
+            if (packet.header.timestamp !== this.last_timestamp &&
+                this.packets_received > 1) {
+                const diff = Math.abs(arrival -
+                    (this.last_arrival ?? 0) -
+                    (packet.header.timestamp - (this.last_timestamp ?? 0)));
+                this.jitter_q4 += diff - ((this.jitter_q4 + 8) >> 4);
+            }
+            this.last_arrival = arrival;
+            this.last_timestamp = packet.header.timestamp;
+        }
+    }
+    get fraction_lost() {
+        const expected_interval = this.packets_expected - this.expected_prior;
+        this.expected_prior = this.packets_expected;
+        const received_interval = this.packets_received - this.received_prior;
+        this.received_prior = this.packets_received;
+        const lost_interval = expected_interval - received_interval;
+        if (expected_interval == 0 || lost_interval <= 0) {
+            return 0;
+        }
+        else {
+            return Math.floor((lost_interval << 8) / expected_interval);
+        }
+    }
+    get jitter() {
+        return this.jitter_q4 >> 4;
+    }
+    get packets_expected() {
+        return this.cycles + (this.max_seq ?? 0) - (this.base_seq ?? 0) + 1;
+    }
+    get packets_lost() {
+        const lost = this.packets_expected - this.packets_received;
+        return lost < 0 ? 0 : lost;
+    }
+}

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

@@ -0,0 +1,162 @@
+import { RTP_EXTENSION_URI, ReceiverEstimatedMaxBitrate, RtcpPayloadSpecificFeedback, RtcpRrPacket, RtcpSourceDescriptionPacket, RtcpSrPacket, RtcpTransportLayerFeedback, debug, rtpHeaderExtensionsParser } from '../imports/rtp.js';
+import { deliveredTrackCodec } from './codecCompatibility.js';
+import { RTCRtpReceiver } from './rtpReceiver.js';
+import { MediaStreamTrack } from './track.js';
+const log = debug('webrtc/peer/media/router');
+export class RtpRouter {
+    constructor() {
+        this.ssrcTable = {};
+        this.ridTable = {};
+        this.extIdUriMap = {};
+        this.routeRtp = (packet) => {
+            const extensions = rtpHeaderExtensionsParser(packet.header.extensions, this.extIdUriMap);
+            let rtpReceiver = this.ssrcTable[packet.header.ssrc];
+            const rid = extensions[RTP_EXTENSION_URI.sdesRTPStreamID];
+            if (typeof rid === 'string') {
+                rtpReceiver = this.ridTable[rid];
+                if (rtpReceiver) {
+                    rtpReceiver.latestRid = rid;
+                    rtpReceiver.handleRtpByRid(packet, rid, extensions);
+                }
+            }
+            else if (rtpReceiver) {
+                rtpReceiver.handleRtpBySsrc(packet, extensions);
+            }
+            else {
+                // simulcast after send receiver report
+                rtpReceiver = Object.values(this.ridTable)
+                    .filter((r) => r instanceof RTCRtpReceiver)
+                    .find((r) => r.trackBySSRC[packet.header.ssrc]);
+                if (rtpReceiver) {
+                    log('simulcast register receiver by ssrc', packet.header.ssrc);
+                    this.registerRtpReceiver(rtpReceiver, packet.header.ssrc);
+                    rtpReceiver.handleRtpBySsrc(packet, extensions);
+                }
+                else {
+                    // bug
+                }
+            }
+            if (!rtpReceiver) {
+                log('ssrcReceiver not found');
+                return;
+            }
+            const sdesMid = extensions[RTP_EXTENSION_URI.sdesMid];
+            if (typeof sdesMid === 'string') {
+                rtpReceiver.sdesMid = sdesMid;
+            }
+            const repairedRid = extensions[RTP_EXTENSION_URI.repairedRtpStreamId];
+            if (typeof repairedRid === 'string') {
+                rtpReceiver.latestRepairedRid = repairedRid;
+            }
+        };
+        this.routeRtcp = (packet) => {
+            const recipients = [];
+            switch (packet.type) {
+                case RtcpSrPacket.type:
+                    {
+                        packet = packet;
+                        recipients.push(this.ssrcTable[packet.ssrc]);
+                    }
+                    break;
+                case RtcpRrPacket.type:
+                    {
+                        packet = packet;
+                        packet.reports.forEach((report) => {
+                            recipients.push(this.ssrcTable[report.ssrc]);
+                        });
+                    }
+                    break;
+                case RtcpSourceDescriptionPacket.type:
+                    //Source descriptions are not used
+                    break;
+                case RtcpTransportLayerFeedback.type:
+                    {
+                        const rtpfb = packet;
+                        if (rtpfb.feedback) {
+                            recipients.push(this.ssrcTable[rtpfb.feedback.mediaSourceSsrc]);
+                        }
+                    }
+                    break;
+                case RtcpPayloadSpecificFeedback.type:
+                    {
+                        const psfb = packet;
+                        switch (psfb.feedback.count) {
+                            case ReceiverEstimatedMaxBitrate.count:
+                                {
+                                    const remb = psfb.feedback;
+                                    recipients.push(this.ssrcTable[remb.ssrcFeedbacks[0]]);
+                                }
+                                break;
+                            default:
+                                //A feedback on a media source (a picture loss indication) goes to the sender of that
+                                //source: the source sending the feedback may be one this side receives (sendrecv)
+                                recipients.push(this.ssrcTable[psfb.feedback.mediaSsrc] ||
+                                    this.ssrcTable[psfb.feedback.senderSsrc]);
+                        }
+                    }
+                    break;
+            }
+            recipients
+                .filter((v) => v) // todo simulcast
+                .forEach((recipient) => recipient.handleRtcpPacket(packet));
+        };
+    }
+    registerRtpSender(sender) {
+        this.ssrcTable[sender.ssrc] = sender;
+    }
+    registerRtpReceiver(receiver, ssrc) {
+        log('registerRtpReceiver', ssrc);
+        this.ssrcTable[ssrc] = receiver;
+    }
+    registerRtpReceiverBySsrc(transceiver, params) {
+        log('registerRtpReceiverBySsrc', params);
+        params.encodings
+            .filter((e) => e.ssrc != undefined) // todo fix
+            .forEach((encode, i) => {
+            this.registerRtpReceiver(transceiver.receiver, encode.ssrc);
+            transceiver.addTrack(new MediaStreamTrack({
+                ssrc: encode.ssrc,
+                kind: transceiver.kind,
+                id: transceiver.sender.trackId,
+                remote: true,
+                codec: deliveredTrackCodec(transceiver.kind, params.codecs[i], params.codecs)
+            }));
+            if (encode.rtx) {
+                this.registerRtpReceiver(transceiver.receiver, encode.rtx.ssrc);
+            }
+        });
+        params.headerExtensions.forEach((extension) => {
+            this.extIdUriMap[extension.id] = extension.uri;
+        });
+    }
+    registerRtpReceiverByRid(transceiver, param, params) {
+        // サイマルキャスト利用時のRTXをサポートしていないのでcodecs/encodingsは常に一つ
+        const [codec] = params.codecs;
+        log('registerRtpReceiverByRid', param);
+        transceiver.addTrack(new MediaStreamTrack({
+            rid: param.rid,
+            kind: transceiver.kind,
+            id: transceiver.sender.trackId,
+            remote: true,
+            codec
+        }));
+        this.ridTable[param.rid] = transceiver.receiver;
+    }
+    /**停止した transceiver の SSRC / RID 登録を解除する */
+    unregisterTransceiver(transceiver) {
+        const owners = [
+            transceiver.sender,
+            transceiver.receiver
+        ];
+        for (const [ssrc, owner] of Object.entries(this.ssrcTable)) {
+            if (owners.includes(owner)) {
+                delete this.ssrcTable[Number(ssrc)];
+            }
+        }
+        for (const [rid, owner] of Object.entries(this.ridTable)) {
+            if (owners.includes(owner)) {
+                delete this.ridTable[rid];
+            }
+        }
+    }
+}