@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/esm/lib/rtp/rtcp/rtpfb/twcc.js

@@ -0,0 +1,344 @@
+import { BitWriter2, bufferReader, bufferWriter, debug, getBit } from '../../imports/common.js';
+import { RtcpHeader } from '../header.js';
+const log = debug('webrtc/rtp/rtcp/rtpfb/twcc');
+/* RTP Extensions for Transport-wide Congestion Control
+ * draft-holmer-rmcat-transport-wide-cc-extensions-01
+
+   0               1               2               3
+   0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  |V=2|P|  FMT=15 |    PT=205     |           length              |
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  |                     SSRC of packet sender                     |
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  |                      SSRC of media source                     |
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  |      base sequence number     |      packet status count      |
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  |                 reference time                | fb pkt. count |
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  |          packet chunk         |         packet chunk          |
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  .                                                               .
+  .                                                               .
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  |         packet chunk          |  recv delta   |  recv delta   |
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  .                                                               .
+  .                                                               .
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  |           recv delta          |  recv delta   | zero padding  |
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ */
+export class TransportWideCC {
+    static { this.count = 15; }
+    constructor(props = {}) {
+        this.count = TransportWideCC.count;
+        this.length = 2;
+        this.packetChunks = [];
+        this.recvDeltas = [];
+        Object.assign(this, props);
+        if (!this.header) {
+            this.header = new RtcpHeader({
+                type: 205,
+                count: this.count,
+                version: 2
+            });
+        }
+    }
+    static deSerialize(data, header) {
+        const [senderSsrc, mediaSsrc, baseSequenceNumber, packetStatusCount, referenceTime, fbPktCount] = bufferReader(data, [4, 4, 2, 2, 3, 1]);
+        const packetChunks = [];
+        const recvDeltas = [];
+        let packetStatusPos = 16;
+        for (let processedPacketNum = 0; processedPacketNum < packetStatusCount;) {
+            const type = getBit(data.slice(packetStatusPos, packetStatusPos + 1)[0], 0, 1);
+            let iPacketStatus;
+            switch (type) {
+                case PacketChunk.TypeTCCRunLengthChunk:
+                    {
+                        const packetStatus = RunLengthChunk.deSerialize(data.slice(packetStatusPos, packetStatusPos + 2));
+                        iPacketStatus = packetStatus;
+                        const packetNumberToProcess = Math.min(packetStatusCount - processedPacketNum, packetStatus.runLength);
+                        if (packetStatus.packetStatus ===
+                            PacketStatus.TypeTCCPacketReceivedSmallDelta ||
+                            packetStatus.packetStatus ===
+                                PacketStatus.TypeTCCPacketReceivedLargeDelta) {
+                            for (let _ = 0; _ < packetNumberToProcess; _++) {
+                                recvDeltas.push(new RecvDelta({ type: packetStatus.packetStatus }));
+                            }
+                        }
+                        processedPacketNum += packetNumberToProcess;
+                    }
+                    break;
+                case PacketChunk.TypeTCCStatusVectorChunk:
+                    {
+                        const packetStatus = StatusVectorChunk.deSerialize(data.slice(packetStatusPos, packetStatusPos + 2));
+                        iPacketStatus = packetStatus;
+                        if (packetStatus.symbolSize === 0) {
+                            packetStatus.symbolList.forEach((v) => {
+                                if (v === PacketStatus.TypeTCCPacketReceivedSmallDelta) {
+                                    recvDeltas.push(new RecvDelta({
+                                        type: PacketStatus.TypeTCCPacketReceivedSmallDelta
+                                    }));
+                                }
+                            });
+                        }
+                        if (packetStatus.symbolSize === 1) {
+                            packetStatus.symbolList.forEach((v) => {
+                                if (v === PacketStatus.TypeTCCPacketReceivedSmallDelta ||
+                                    v === PacketStatus.TypeTCCPacketReceivedLargeDelta) {
+                                    recvDeltas.push(new RecvDelta({
+                                        type: v
+                                    }));
+                                }
+                            });
+                        }
+                        processedPacketNum += packetStatus.symbolList.length;
+                    }
+                    break;
+            }
+            if (!iPacketStatus)
+                throw new Error();
+            packetStatusPos += 2;
+            packetChunks.push(iPacketStatus);
+        }
+        let recvDeltaPos = packetStatusPos;
+        recvDeltas.forEach((delta) => {
+            if (delta.type === PacketStatus.TypeTCCPacketReceivedSmallDelta) {
+                delta.deSerialize(data.slice(recvDeltaPos, recvDeltaPos + 1));
+                recvDeltaPos++;
+            }
+            if (delta.type === PacketStatus.TypeTCCPacketReceivedLargeDelta) {
+                delta.deSerialize(data.slice(recvDeltaPos, recvDeltaPos + 2));
+                recvDeltaPos += 2;
+            }
+        });
+        return new TransportWideCC({
+            senderSsrc,
+            mediaSourceSsrc: mediaSsrc,
+            baseSequenceNumber,
+            packetStatusCount,
+            referenceTime,
+            fbPktCount,
+            recvDeltas,
+            packetChunks,
+            header
+        });
+    }
+    serialize() {
+        const constBuf = bufferWriter([4, 4, 2, 2, 3, 1], [
+            this.senderSsrc,
+            this.mediaSourceSsrc,
+            this.baseSequenceNumber,
+            this.packetStatusCount,
+            this.referenceTime,
+            this.fbPktCount
+        ]);
+        const chunks = Buffer.concat(this.packetChunks.map((chunk) => chunk.serialize()));
+        const deltas = Buffer.concat(this.recvDeltas
+            .map((delta) => {
+            try {
+                return delta.serialize();
+            }
+            catch (error) {
+                log(error?.message);
+                return undefined;
+            }
+        })
+            .filter((v) => v));
+        const buf = Buffer.concat([constBuf, chunks, deltas]);
+        //Padded to 32 bits, the padding flag set only then: the receiver takes the last byte for the length of the padding
+        const rest = buf.length % 4;
+        this.header.padding = rest !== 0;
+        if (rest !== 0) {
+            const padding = Buffer.alloc(4 - rest);
+            padding[padding.length - 1] = padding.length;
+            this.header.length = (buf.length + padding.length) / 4;
+            return Buffer.concat([this.header.serialize(), buf, padding]);
+        }
+        this.header.length = buf.length / 4;
+        return Buffer.concat([this.header.serialize(), buf]);
+    }
+    /**
+     * The packets reported, in the order of their sequence numbers: whether each was received, and when (in
+     * milliseconds, on the clock of the receiver)
+     */
+    get packetResults() {
+        const statuses = [];
+        for (const chunk of this.packetChunks) {
+            if (chunk instanceof RunLengthChunk) {
+                for (let index = 0; index < chunk.runLength; index++)
+                    statuses.push(chunk.packetStatus);
+            }
+            else {
+                statuses.push(...chunk.symbolList);
+            }
+        }
+        //The last status vector may go past the packets reported
+        if (statuses.length > this.packetStatusCount)
+            statuses.length = this.packetStatusCount;
+        const results = [];
+        //In microseconds, from the reference time (in multiples of 64 ms)
+        let receivedAt = this.referenceTime * 64000;
+        let deltaIndex = 0;
+        statuses.forEach((status, index) => {
+            const result = new PacketResult({ sequenceNumber: (this.baseSequenceNumber + index) & 0xffff });
+            if (status === PacketStatus.TypeTCCPacketReceivedSmallDelta ||
+                status === PacketStatus.TypeTCCPacketReceivedLargeDelta) {
+                const recvDelta = this.recvDeltas[deltaIndex++];
+                if (recvDelta) {
+                    receivedAt += recvDelta.delta;
+                    result.received = true;
+                    result.delta = recvDelta.delta;
+                    result.receivedAtMs = receivedAt / 1000;
+                }
+            }
+            results.push(result);
+        });
+        return results;
+    }
+}
+//  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |T| S |       Run Length        |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+export class RunLengthChunk {
+    constructor(props = {}) {
+        Object.assign(this, props);
+        this.type = PacketChunk.TypeTCCRunLengthChunk;
+    }
+    static deSerialize(data) {
+        const packetStatus = getBit(data[0], 1, 2);
+        const runLength = (getBit(data[0], 3, 5) << 8) + data[1];
+        return new RunLengthChunk({ type: 0, packetStatus, runLength });
+    }
+    serialize() {
+        const buf = new BitWriter2(16)
+            .set(0)
+            .set(this.packetStatus, 2)
+            .set(this.runLength, 13).buffer;
+        return buf;
+    }
+}
+//  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |T|S|       symbol list         |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+export class StatusVectorChunk {
+    constructor(props = {}) {
+        this.symbolList = [];
+        Object.assign(this, props);
+    }
+    static deSerialize(data) {
+        const type = PacketChunk.TypeTCCStatusVectorChunk;
+        let symbolSize = getBit(data[0], 1, 1);
+        const symbolList = [];
+        function range(n, cb) {
+            for (let i = 0; i < n; i++) {
+                cb(i);
+            }
+        }
+        switch (symbolSize) {
+            case 0:
+                range(6, (i) => symbolList.push(getBit(data[0], 2 + i, 1)));
+                range(8, (i) => symbolList.push(getBit(data[1], i, 1)));
+                break;
+            case 1:
+                range(3, (i) => symbolList.push(getBit(data[0], 2 + i * 2, 2)));
+                range(4, (i) => symbolList.push(getBit(data[1], i * 2, 2)));
+                break;
+            default:
+                symbolSize = (getBit(data[0], 2, 6) << 8) + data[1];
+        }
+        return new StatusVectorChunk({ type, symbolSize, symbolList });
+    }
+    serialize() {
+        const buf = Buffer.alloc(2);
+        const writer = new BitWriter2(16).set(1).set(this.symbolSize);
+        const bits = this.symbolSize === 0 ? 1 : 2;
+        this.symbolList.forEach((v) => {
+            writer.set(v, bits);
+        });
+        buf.writeUInt16BE(writer.value);
+        return buf;
+    }
+}
+export class RecvDelta {
+    constructor(props = {}) {
+        this.parsed = false; // todo refactor
+        Object.assign(this, props);
+    }
+    static deSerialize(data) {
+        let type;
+        let delta;
+        if (data.length === 1) {
+            type = PacketStatus.TypeTCCPacketReceivedSmallDelta;
+            delta = 250 * data[0];
+        }
+        else if (data.length === 2) {
+            type = PacketStatus.TypeTCCPacketReceivedLargeDelta;
+            delta = 250 * data.readInt16BE();
+        }
+        if (type === undefined || delta === undefined)
+            throw new Error();
+        return new RecvDelta({ type, delta });
+    }
+    deSerialize(data) {
+        const res = RecvDelta.deSerialize(data);
+        this.delta = res.delta;
+    }
+    parseDelta() {
+        this.delta = Math.floor(this.delta / 250);
+        if (this.delta < 0 || this.delta > 255) {
+            if (this.delta > 32767)
+                this.delta = 32767; // maxInt16
+            if (this.delta < -32768)
+                this.delta = -32768; // minInt16
+            if (!this.type)
+                this.type = PacketStatus.TypeTCCPacketReceivedLargeDelta;
+        }
+        else {
+            if (!this.type)
+                this.type = PacketStatus.TypeTCCPacketReceivedSmallDelta;
+        }
+        this.parsed = true;
+    }
+    serialize() {
+        if (!this.parsed)
+            this.parseDelta();
+        if (this.type === PacketStatus.TypeTCCPacketReceivedSmallDelta) {
+            const buf = Buffer.alloc(1);
+            buf.writeUInt8(this.delta);
+            return buf;
+        }
+        else if (this.type === PacketStatus.TypeTCCPacketReceivedLargeDelta) {
+            const buf = Buffer.alloc(2);
+            buf.writeInt16BE(this.delta);
+            return buf;
+        }
+        throw new Error('errDeltaExceedLimit ' + this.delta + ' ' + this.type);
+    }
+}
+export var PacketChunk;
+(function (PacketChunk) {
+    PacketChunk[PacketChunk["TypeTCCRunLengthChunk"] = 0] = "TypeTCCRunLengthChunk";
+    PacketChunk[PacketChunk["TypeTCCStatusVectorChunk"] = 1] = "TypeTCCStatusVectorChunk";
+    PacketChunk[PacketChunk["packetStatusChunkLength"] = 2] = "packetStatusChunkLength";
+})(PacketChunk || (PacketChunk = {}));
+export var PacketStatus;
+(function (PacketStatus) {
+    PacketStatus[PacketStatus["TypeTCCPacketNotReceived"] = 0] = "TypeTCCPacketNotReceived";
+    PacketStatus[PacketStatus["TypeTCCPacketReceivedSmallDelta"] = 1] = "TypeTCCPacketReceivedSmallDelta";
+    PacketStatus[PacketStatus["TypeTCCPacketReceivedLargeDelta"] = 2] = "TypeTCCPacketReceivedLargeDelta";
+    PacketStatus[PacketStatus["TypeTCCPacketReceivedWithoutDelta"] = 3] = "TypeTCCPacketReceivedWithoutDelta";
+})(PacketStatus || (PacketStatus = {}));
+export class PacketResult {
+    constructor(props) {
+        this.sequenceNumber = 0;
+        this.delta = 0;
+        this.received = false;
+        this.receivedAtMs = 0;
+        Object.assign(this, props);
+    }
+}

package/dist/esm/lib/rtp/rtcp/sdes.js

@@ -0,0 +1,91 @@
+import { bufferWriter } from '../../common/index.js';
+import { RtcpHeader } from './header.js';
+export class RtcpSourceDescriptionPacket {
+    static { this.type = 202; }
+    constructor(props) {
+        this.type = RtcpSourceDescriptionPacket.type;
+        this.chunks = [];
+        Object.assign(this, props);
+    }
+    get length() {
+        let length = 0;
+        this.chunks.forEach((chunk) => (length += chunk.length));
+        return length;
+    }
+    serialize() {
+        let payload = Buffer.concat(this.chunks.map((chunk) => chunk.serialize()));
+        while (payload.length % 4)
+            payload = Buffer.concat([payload, Buffer.from([0])]);
+        return RtcpHeader.serialize(this.type, this.chunks.length, payload, payload.length / 4);
+    }
+    static deSerialize(payload, _header) {
+        const chunks = [];
+        for (let i = 0; i < payload.length;) {
+            const chunk = SourceDescriptionChunk.deSerialize(payload.slice(i));
+            chunks.push(chunk);
+            i += chunk.length;
+        }
+        return new RtcpSourceDescriptionPacket({ chunks });
+    }
+}
+export class SourceDescriptionChunk {
+    constructor(props = {}) {
+        this.items = [];
+        Object.assign(this, props);
+    }
+    get length() {
+        let length = 4;
+        this.items.forEach((item) => (length += item.length));
+        length += 1;
+        length += getPadding(length);
+        return length;
+    }
+    serialize() {
+        const data = Buffer.concat([
+            bufferWriter([4], [this.source]),
+            Buffer.concat(this.items.map((item) => item.serialize()))
+        ]);
+        const res = Buffer.concat([data, Buffer.alloc(getPadding(data.length))]);
+        return res;
+    }
+    static deSerialize(data) {
+        const source = data.readUInt32BE();
+        const items = [];
+        for (let i = 4; i < data.length;) {
+            const type = data[i];
+            if (type === 0)
+                break;
+            const item = SourceDescriptionItem.deSerialize(data.slice(i));
+            items.push(item);
+            i += item.length;
+        }
+        return new SourceDescriptionChunk({ source, items });
+    }
+}
+export class SourceDescriptionItem {
+    constructor(props) {
+        Object.assign(this, props);
+    }
+    get length() {
+        return 1 + 1 + Buffer.from(this.text).length;
+    }
+    serialize() {
+        const text = Buffer.from(this.text);
+        return Buffer.concat([
+            bufferWriter([1, 1], [this.type, text.length]),
+            text
+        ]);
+    }
+    static deSerialize(data) {
+        const type = data[0];
+        const octetCount = data[1];
+        const text = data.slice(2, 2 + octetCount).toString();
+        return new SourceDescriptionItem({ type, text });
+    }
+}
+function getPadding(len) {
+    if (len % 4 == 0) {
+        return 0;
+    }
+    return 4 - (len % 4);
+}

package/dist/esm/lib/rtp/rtcp/sr.js

@@ -0,0 +1,104 @@
+import { bufferReader, bufferWriter } from '../../common/index.js';
+import { RtcpHeader } from './header.js';
+import { RtcpReceiverInfo } from './rr.js';
+// https://datatracker.ietf.org/doc/html/rfc3550#section-6.4.1
+//         0                   1                   2                   3
+//         0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+//        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// header |V=2|P|    RC   |   PT=SR=200   |             length            |
+//        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//        |                         SSRC of sender                        |
+//        +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+// sender |              NTP timestamp, most significant word             |
+// info   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//        |             NTP timestamp, least significant word             |
+//        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//        |                         RTP timestamp                         |
+//        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//        |                     sender's packet count                     |
+//        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//        |                      sender's octet count                     |
+//        +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+// report |                 SSRC_1 (SSRC of first source)                 |
+// block  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   1    | fraction lost |       cumulative number of packets lost       |
+//        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//        |           extended highest sequence number received           |
+//        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//        |                      interarrival jitter                      |
+//        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//        |                         last SR (LSR)                         |
+//        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//        |                   delay since last SR (DLSR)                  |
+//        +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+// report |                 SSRC_2 (SSRC of second source)                |
+// block  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   2    :                               ...                             :
+//        +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//        |                  profile-specific extensions                  |
+//        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+export class RtcpSrPacket {
+    static { this.type = 200; }
+    constructor(props) {
+        this.ssrc = 0;
+        this.reports = [];
+        this.type = RtcpSrPacket.type;
+        Object.assign(this, props);
+    }
+    toJSON() {
+        return {
+            ssrc: this.ssrc,
+            senderInfo: this.senderInfo.toJSON(),
+            reports: this.reports.map((r) => r.toJSON())
+        };
+    }
+    serialize() {
+        let payload = Buffer.alloc(4);
+        payload.writeUInt32BE(this.ssrc);
+        payload = Buffer.concat([payload, this.senderInfo.serialize()]);
+        payload = Buffer.concat([
+            payload,
+            ...this.reports.map((report) => report.serialize())
+        ]);
+        return RtcpHeader.serialize(RtcpSrPacket.type, this.reports.length, payload, Math.floor(payload.length / 4));
+    }
+    static deSerialize(payload, count) {
+        const ssrc = payload.readUInt32BE();
+        const senderInfo = RtcpSenderInfo.deSerialize(payload.subarray(4, 24));
+        let pos = 24;
+        const reports = [];
+        for (let _ = 0; _ < count; _++) {
+            reports.push(RtcpReceiverInfo.deSerialize(payload.subarray(pos, pos + 24)));
+            pos += 24;
+        }
+        const packet = new RtcpSrPacket({ ssrc, senderInfo, reports });
+        return packet;
+    }
+}
+export class RtcpSenderInfo {
+    constructor(props = {}) {
+        Object.assign(this, props);
+    }
+    toJSON() {
+        return {
+            ntpTimestamp: ntpTime2Sec(this.ntpTimestamp),
+            rtpTimestamp: this.rtpTimestamp
+        };
+    }
+    serialize() {
+        return bufferWriter([8, 4, 4, 4], [this.ntpTimestamp, this.rtpTimestamp, this.packetCount, this.octetCount]);
+    }
+    static deSerialize(data) {
+        const [ntpTimestamp, rtpTimestamp, packetCount, octetCount] = bufferReader(data, [8, 4, 4, 4]);
+        return new RtcpSenderInfo({
+            ntpTimestamp,
+            rtpTimestamp,
+            packetCount,
+            octetCount
+        });
+    }
+}
+export const ntpTime2Sec = (ntp) => {
+    const [ntpSec, ntpMsec] = bufferReader(bufferWriter([8], [ntp]), [4, 4]);
+    return Number(`${ntpSec}.${ntpMsec}`);
+};

package/dist/esm/lib/rtp/rtp/headerExtension.js

@@ -0,0 +1,102 @@
+import { BitStream, bufferReader } from '../../common/index.js';
+export const RTP_EXTENSION_URI = {
+    sdesMid: 'urn:ietf:params:rtp-hdrext:sdes:mid',
+    sdesRTPStreamID: 'urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id',
+    repairedRtpStreamId: 'urn:ietf:params:rtp-hdrext:sdes:repaired-rtp-stream-id',
+    transportWideCC: 'http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01',
+    absSendTime: 'http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time',
+    dependencyDescriptor: 'https://aomediacodec.github.io/av1-rtp-spec/#dependency-descriptor-rtp-header-extension',
+    audioLevelIndication: 'urn:ietf:params:rtp-hdrext:ssrc-audio-level',
+    videoOrientation: 'urn:3gpp:video-orientation'
+};
+export function rtpHeaderExtensionsParser(extensions, extIdUriMap) {
+    return extensions
+        .map((extension) => {
+        const uri = extIdUriMap[extension.id];
+        if (!uri) {
+            return { uri: 'unknown', value: extension.payload };
+        }
+        switch (uri) {
+            case RTP_EXTENSION_URI.sdesMid:
+            case RTP_EXTENSION_URI.sdesRTPStreamID:
+            case RTP_EXTENSION_URI.repairedRtpStreamId:
+                return { uri, value: deserializeString(extension.payload) };
+            case RTP_EXTENSION_URI.transportWideCC:
+                return { uri, value: deserializeUint16BE(extension.payload) };
+            case RTP_EXTENSION_URI.absSendTime:
+                return {
+                    uri,
+                    value: deserializeAbsSendTime(extension.payload)
+                };
+            case RTP_EXTENSION_URI.audioLevelIndication: {
+                return {
+                    uri,
+                    value: deserializeAudioLevelIndication(extension.payload)
+                };
+            }
+            case RTP_EXTENSION_URI.videoOrientation:
+                return { uri, value: deserializeVideoOrientation(extension.payload) };
+            default:
+                return { uri, value: extension.payload };
+        }
+    })
+        .reduce((acc, cur) => {
+        if (cur)
+            acc[cur.uri] = cur.value;
+        return acc;
+    }, {});
+}
+export function serializeSdesMid(id) {
+    return Buffer.from(id);
+}
+export function serializeSdesRTPStreamID(id) {
+    return Buffer.from(id);
+}
+export function serializeRepairedRtpStreamId(id) {
+    return Buffer.from(id);
+}
+export function serializeTransportWideCC(transportSequenceNumber) {
+    const buf = Buffer.allocUnsafe(2);
+    buf.writeUInt16BE(transportSequenceNumber);
+    return buf;
+}
+export function serializeAbsSendTime(ntpTime) {
+    const buf = Buffer.alloc(3);
+    const time = (ntpTime >> 14n) & 0x00ffffffn;
+    buf.writeUIntBE(Number(time), 0, 3);
+    return buf;
+}
+export function serializeAudioLevelIndication(level) {
+    const stream = new BitStream(Buffer.alloc(1));
+    stream.writeBits(1, 1);
+    stream.writeBits(7, level);
+    return stream.uint8Array;
+}
+export function deserializeString(buf) {
+    return buf.toString();
+}
+export function deserializeUint16BE(buf) {
+    return buf.readUInt16BE();
+}
+export function deserializeAbsSendTime(buf) {
+    return bufferReader(buf, [3])[0];
+}
+export function deserializeAudioLevelIndication(buf) {
+    const stream = new BitStream(buf);
+    const value = {
+        v: stream.readBits(1) === 1,
+        level: stream.readBits(7)
+    };
+    return value;
+}
+export function deserializeVideoOrientation(payload) {
+    const stream = new BitStream(payload);
+    stream.readBits(4);
+    const value = {
+        c: stream.readBits(1),
+        f: stream.readBits(1),
+        r1: stream.readBits(1),
+        r0: stream.readBits(1)
+    };
+    return value;
+}

package/dist/esm/lib/rtp/rtp/red/encoder.js

@@ -0,0 +1,40 @@
+import { uint32Add } from '../../../common/index.js';
+import { Red } from './packet.js';
+export class RedEncoder {
+    constructor(distance = 1) {
+        this.distance = distance;
+        this.cache = [];
+        this.cacheSize = 10;
+    }
+    push(payload) {
+        this.cache.push(payload);
+        if (this.cache.length > this.cacheSize) {
+            this.cache.shift();
+        }
+    }
+    build() {
+        const red = new Red();
+        const redundantPayloads = this.cache.slice(-(this.distance + 1));
+        const presentPayload = redundantPayloads.pop();
+        if (!presentPayload) {
+            return red;
+        }
+        redundantPayloads.forEach((redundant) => {
+            const timestampOffset = uint32Add(presentPayload.timestamp, -redundant.timestamp);
+            if (timestampOffset > Max14Uint) {
+                return;
+            }
+            red.blocks.push({
+                block: redundant.block,
+                blockPT: redundant.blockPT,
+                timestampOffset
+            });
+        });
+        red.blocks.push({
+            block: presentPayload.block,
+            blockPT: presentPayload.blockPT
+        });
+        return red;
+    }
+}
+const Max14Uint = (0x01 << 14) - 1;