@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/cjs/lib/peer/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./imports/common.js"), exports);
+__exportStar(require("./imports/dtls.js"), exports);
+__exportStar(require("./imports/ice.js"), exports);
+__exportStar(require("./imports/rtp.js"), exports);
+__exportStar(require("./dataChannel.js"), exports);
+__exportStar(require("./media/index.js"), exports);
+__exportStar(require("./peerConnection.js"), exports);
+__exportStar(require("./sdp.js"), exports);
+__exportStar(require("./transport/dtls.js"), exports);
+__exportStar(require("./transport/ice.js"), exports);
+__exportStar(require("./transport/sctp.js"), exports);
+__exportStar(require("./types/domain.js"), exports);
+__exportStar(require("./utils.js"), exports);
+__exportStar(require("./sdpManager.js"), exports);

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

@@ -0,0 +1,15 @@
+import { RTCRtpCodecParameters } from './parameters.js';
+export declare const useH264: (props?: Partial<RTCRtpCodecParameters>) => RTCRtpCodecParameters;
+export declare const useVP8: (props?: Partial<RTCRtpCodecParameters>) => RTCRtpCodecParameters;
+export declare const useVP9: (props?: Partial<RTCRtpCodecParameters>) => RTCRtpCodecParameters;
+export declare const useAV1X: (props?: Partial<RTCRtpCodecParameters>) => RTCRtpCodecParameters;
+export declare const useOPUS: (props?: Partial<RTCRtpCodecParameters>) => RTCRtpCodecParameters;
+export declare const usePCMU: (props?: Partial<RTCRtpCodecParameters>) => RTCRtpCodecParameters;
+export declare function defaultCodecs(): {
+    audio: RTCRtpCodecParameters[];
+    video: RTCRtpCodecParameters[];
+};
+export declare function cloneCodecParameters(codec: RTCRtpCodecParameters): RTCRtpCodecParameters;
+export declare const supportedCodecs: string[];
+export declare const supportedVideoCodecs: string[];
+export declare const supportedAudioCodecs: string[];

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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.supportedAudioCodecs = exports.supportedVideoCodecs = exports.supportedCodecs = exports.usePCMU = exports.useOPUS = exports.useAV1X = exports.useVP9 = exports.useVP8 = exports.useH264 = void 0;
+exports.defaultCodecs = defaultCodecs;
+exports.cloneCodecParameters = cloneCodecParameters;
+const rtcpFeedback_js_1 = require("./extension/rtcpFeedback.js");
+const parameters_js_1 = require("./parameters.js");
+const useH264 = (props = {}) => new parameters_js_1.RTCRtpCodecParameters({
+    mimeType: 'video/h264',
+    clockRate: 90000,
+    rtcpFeedback: [(0, rtcpFeedback_js_1.useNACK)(), (0, rtcpFeedback_js_1.usePLI)(), (0, rtcpFeedback_js_1.useREMB)()],
+    parameters: 'profile-level-id=42e01f;packetization-mode=1;level-asymmetry-allowed=1',
+    ...props
+});
+exports.useH264 = useH264;
+const useVP8 = (props = {}) => new parameters_js_1.RTCRtpCodecParameters({
+    mimeType: 'video/VP8',
+    clockRate: 90000,
+    rtcpFeedback: [(0, rtcpFeedback_js_1.useNACK)(), (0, rtcpFeedback_js_1.usePLI)(), (0, rtcpFeedback_js_1.useREMB)()],
+    ...props
+});
+exports.useVP8 = useVP8;
+const useVP9 = (props = {}) => new parameters_js_1.RTCRtpCodecParameters({
+    mimeType: 'video/VP9',
+    clockRate: 90000,
+    rtcpFeedback: [(0, rtcpFeedback_js_1.useNACK)(), (0, rtcpFeedback_js_1.usePLI)(), (0, rtcpFeedback_js_1.useREMB)()],
+    ...props
+});
+exports.useVP9 = useVP9;
+const useAV1X = (props = {}) => new parameters_js_1.RTCRtpCodecParameters({
+    mimeType: 'video/AV1X',
+    clockRate: 90000,
+    rtcpFeedback: [(0, rtcpFeedback_js_1.useNACK)(), (0, rtcpFeedback_js_1.usePLI)(), (0, rtcpFeedback_js_1.useREMB)()],
+    ...props
+});
+exports.useAV1X = useAV1X;
+const useOPUS = (props = {}) => new parameters_js_1.RTCRtpCodecParameters({
+    mimeType: 'audio/OPUS',
+    clockRate: 48000,
+    channels: 2,
+    ...props
+});
+exports.useOPUS = useOPUS;
+const usePCMU = (props = {}) => new parameters_js_1.RTCRtpCodecParameters({
+    mimeType: 'audio/PCMU',
+    clockRate: 8000,
+    channels: 1,
+    payloadType: 0,
+    ...props
+});
+exports.usePCMU = usePCMU;
+function defaultCodecs() {
+    return {
+        audio: [(0, exports.useOPUS)(), (0, exports.usePCMU)()],
+        video: [(0, exports.useVP8)()]
+    };
+}
+function cloneCodecParameters(codec) {
+    return new parameters_js_1.RTCRtpCodecParameters({
+        mimeType: codec.mimeType,
+        clockRate: codec.clockRate,
+        ...(codec.channels != undefined ? { channels: codec.channels } : {}),
+        ...(codec.payloadType != undefined
+            ? { payloadType: codec.payloadType }
+            : {}),
+        rtcpFeedback: codec.rtcpFeedback.map((feedback) => ({ ...feedback })),
+        ...(codec.parameters != undefined ? { parameters: codec.parameters } : {}),
+        direction: codec.direction
+    });
+}
+exports.supportedCodecs = [
+    (0, exports.useAV1X)(),
+    (0, exports.useVP9)(),
+    (0, exports.useVP8)(),
+    (0, exports.useH264)(),
+    (0, exports.useOPUS)(),
+    (0, exports.usePCMU)()
+].map((codec) => codec.mimeType);
+exports.supportedVideoCodecs = exports.supportedCodecs.filter((codec) => codec.toLowerCase().startsWith('video/'));
+exports.supportedAudioCodecs = exports.supportedCodecs.filter((codec) => codec.toLowerCase().startsWith('audio/'));

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

@@ -0,0 +1,23 @@
+import type { Kind } from '../types/domain.js';
+import type { RTCRtpCodecParameters } from './parameters.js';
+export declare function isCodecCompatible(source: RTCRtpCodecParameters, configured: RTCRtpCodecParameters): boolean;
+/**
+ * remote track が実際に配信する codec を返す。
+ * audio の RED は RTCRtpReceiver が primary へ展開してから track へ渡すため、
+ * RED が参照する primary codec (不明なら先頭の primary) を track の codec とする。
+ */
+export declare function deliveredTrackCodec(kind: string, codec: RTCRtpCodecParameters | undefined, negotiated: readonly RTCRtpCodecParameters[]): RTCRtpCodecParameters | undefined;
+/**
+ * RTX / RED を除く primary codec に MIME 一致が 1 つでもあるか。
+ * remote m-line を local capability で扱えるかの判定 (Issue #705) に使う。
+ */
+export declare function hasCommonPrimaryMimeType(local: readonly RTCRtpCodecParameters[], remote: readonly RTCRtpCodecParameters[]): boolean;
+export declare function intersectCodecs(configured: RTCRtpCodecParameters[], source: readonly RTCRtpCodecParameters[]): RTCRtpCodecParameters[];
+export declare function applyCodecPreferences(configured: RTCRtpCodecParameters[], preferences: readonly RTCRtpCodecParameters[] | undefined): RTCRtpCodecParameters[];
+export declare function resolveCodecs(configured: RTCRtpCodecParameters[], source: readonly RTCRtpCodecParameters[] | undefined, preferences: readonly RTCRtpCodecParameters[] | undefined): RTCRtpCodecParameters[];
+export declare function assertCodecsSupported(options: {
+    kind: Kind;
+    configured: RTCRtpCodecParameters[];
+    source: readonly RTCRtpCodecParameters[] | undefined;
+    preferences: readonly RTCRtpCodecParameters[] | undefined;
+}): RTCRtpCodecParameters[];

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

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCodecCompatible = isCodecCompatible;
+exports.deliveredTrackCodec = deliveredTrackCodec;
+exports.hasCommonPrimaryMimeType = hasCommonPrimaryMimeType;
+exports.intersectCodecs = intersectCodecs;
+exports.applyCodecPreferences = applyCodecPreferences;
+exports.resolveCodecs = resolveCodecs;
+exports.assertCodecsSupported = assertCodecsSupported;
+const errors_js_1 = require("../errors.js");
+const sdp_js_1 = require("../sdp.js");
+function codecName(codec) {
+    return codec.name.toLowerCase();
+}
+function optionalEqual(left, right) {
+    return left == undefined || right == undefined || left === right;
+}
+function h264Parameters(codec) {
+    const parameters = (0, sdp_js_1.codecParametersFromString)(codec.parameters ?? '');
+    return {
+        packetizationMode: parameters['packetization-mode'],
+        profileLevelId: parameters['profile-level-id']?.toString().toLowerCase()
+    };
+}
+function isCodecCompatible(source, configured) {
+    if (source.mimeType.toLowerCase() !== configured.mimeType.toLowerCase()) {
+        return false;
+    }
+    if (source.clockRate !== configured.clockRate)
+        return false;
+    if (!optionalEqual(source.channels, configured.channels))
+        return false;
+    if (codecName(source) !== 'h264')
+        return true;
+    const sourceParameters = h264Parameters(source);
+    const configuredParameters = h264Parameters(configured);
+    if (!optionalEqual(sourceParameters.packetizationMode, configuredParameters.packetizationMode)) {
+        return false;
+    }
+    return optionalEqual(sourceParameters.profileLevelId, configuredParameters.profileLevelId);
+}
+function isAuxiliary(codec) {
+    return ['rtx', 'red'].includes(codecName(codec));
+}
+/**
+ * remote track が実際に配信する codec を返す。
+ * audio の RED は RTCRtpReceiver が primary へ展開してから track へ渡すため、
+ * RED が参照する primary codec (不明なら先頭の primary) を track の codec とする。
+ */
+function deliveredTrackCodec(kind, codec, negotiated) {
+    if (kind !== 'audio' || codec == undefined || codecName(codec) !== 'red') {
+        return codec;
+    }
+    const [primaryPayloadType] = referencedPayloadTypes(codec);
+    return (negotiated.find((candidate) => !isAuxiliary(candidate) && candidate.payloadType === primaryPayloadType) ??
+        negotiated.find((candidate) => !isAuxiliary(candidate)) ??
+        codec);
+}
+/**
+ * RTX / RED を除く primary codec に MIME 一致が 1 つでもあるか。
+ * remote m-line を local capability で扱えるかの判定 (Issue #705) に使う。
+ */
+function hasCommonPrimaryMimeType(local, remote) {
+    return local.some((localCodec) => !isAuxiliary(localCodec) &&
+        remote.some((remoteCodec) => remoteCodec.mimeType.toLowerCase() ===
+            localCodec.mimeType.toLowerCase()));
+}
+function referencedPayloadTypes(codec) {
+    const parameters = codec.parameters ?? '';
+    if (codecName(codec) === 'rtx') {
+        const apt = Number((0, sdp_js_1.codecParametersFromString)(parameters).apt);
+        return Number.isNaN(apt) ? [] : [apt];
+    }
+    if (codecName(codec) === 'red') {
+        return parameters
+            .split('/')
+            .map(Number)
+            .filter((value) => !Number.isNaN(value));
+    }
+    return [];
+}
+function withAuxiliaryCodecs(configured, primary) {
+    const keptPayloadTypes = new Set(primary.map((codec) => codec.payloadType));
+    const auxiliary = configured.filter((codec) => {
+        if (!isAuxiliary(codec))
+            return false;
+        const referenced = referencedPayloadTypes(codec);
+        return (referenced.length > 0 &&
+            referenced.every((payloadType) => keptPayloadTypes.has(payloadType)));
+    });
+    return configured.filter((codec) => primary.includes(codec) || auxiliary.includes(codec));
+}
+function intersectCodecs(configured, source) {
+    const primary = configured.filter((codec) => !isAuxiliary(codec) &&
+        source.some((sourceCodec) => isCodecCompatible(sourceCodec, codec)));
+    return withAuxiliaryCodecs(configured, primary);
+}
+function matchesPreference(candidate, preference) {
+    return (candidate.mimeType.toLowerCase() === preference.mimeType.toLowerCase() &&
+        optionalEqual(candidate.clockRate, preference.clockRate));
+}
+function applyCodecPreferences(configured, preferences) {
+    if (preferences == undefined)
+        return configured;
+    const preferred = preferences.flatMap((preference) => {
+        const match = configured.find((codec) => matchesPreference(codec, preference));
+        return match ? [match] : [];
+    });
+    const uniquePreferred = [...new Set(preferred)];
+    const referencedByPreferredAuxiliary = new Set(uniquePreferred.filter(isAuxiliary).flatMap(referencedPayloadTypes));
+    const primary = configured.filter((codec) => !isAuxiliary(codec) &&
+        (uniquePreferred.includes(codec) ||
+            referencedByPreferredAuxiliary.has(codec.payloadType)));
+    const allowed = withAuxiliaryCodecs(configured, primary);
+    return [
+        ...uniquePreferred.filter((codec) => allowed.includes(codec)),
+        ...allowed.filter((codec) => !uniquePreferred.includes(codec))
+    ];
+}
+function resolveCodecs(configured, source, preferences) {
+    return applyCodecPreferences(source == undefined ? configured : intersectCodecs(configured, source), preferences);
+}
+function list(codecs) {
+    return codecs?.map((codec) => codec.mimeType).join(', ') || '(none)';
+}
+function assertCodecsSupported(options) {
+    const { kind, configured, source, preferences } = options;
+    const sourceCompatible = source == undefined ? configured : intersectCodecs(configured, source);
+    if (source != undefined && sourceCompatible.length === 0) {
+        throw (0, errors_js_1.createWebRtcDomException)('NotSupportedError', `Track codec ${list(source)} is not supported by this RTCPeerConnection. Configured ${kind} codecs: ${list(configured)}`);
+    }
+    const effective = applyCodecPreferences(sourceCompatible, preferences);
+    if (effective.length === 0) {
+        throw (0, errors_js_1.createWebRtcDomException)('NotSupportedError', `No codec remains after applying codec preferences. Source codecs: ${list(source)} Configured codecs: ${list(configured)} Preferred codecs: ${list(preferences)}`);
+    }
+    return effective;
+}

package/dist/cjs/lib/peer/media/extension/rtcpFeedback.d.ts

@@ -0,0 +1,6 @@
+import type { RTCPFB } from '../parameters.js';
+export declare const useFIR: () => RTCPFB;
+export declare const useNACK: () => RTCPFB;
+export declare const usePLI: () => RTCPFB;
+export declare const useREMB: () => RTCPFB;
+export declare const useTWCC: () => RTCPFB;

package/dist/cjs/lib/peer/media/extension/rtcpFeedback.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTWCC = exports.useREMB = exports.usePLI = exports.useNACK = exports.useFIR = void 0;
+const useFIR = () => ({ type: 'ccm', parameter: 'fir' });
+exports.useFIR = useFIR;
+const useNACK = () => ({ type: 'nack' });
+exports.useNACK = useNACK;
+const usePLI = () => ({ type: 'nack', parameter: 'pli' });
+exports.usePLI = usePLI;
+const useREMB = () => ({ type: 'goog-remb' });
+exports.useREMB = useREMB;
+const useTWCC = () => ({ type: 'transport-cc' });
+exports.useTWCC = useTWCC;

package/dist/cjs/lib/peer/media/extension/rtpExtension.d.ts

@@ -0,0 +1,9 @@
+import { RTCRtpHeaderExtensionParameters } from '../parameters.js';
+export declare function useSdesMid(): RTCRtpHeaderExtensionParameters;
+export declare function useSdesRTPStreamId(): RTCRtpHeaderExtensionParameters;
+export declare function useRepairedRtpStreamId(): RTCRtpHeaderExtensionParameters;
+export declare function useTransportWideCC(): RTCRtpHeaderExtensionParameters;
+export declare function useAbsSendTime(): RTCRtpHeaderExtensionParameters;
+export declare function useDependencyDescriptor(): RTCRtpHeaderExtensionParameters;
+export declare function useAudioLevelIndication(): RTCRtpHeaderExtensionParameters;
+export declare function useVideoOrientation(): RTCRtpHeaderExtensionParameters;

package/dist/cjs/lib/peer/media/extension/rtpExtension.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSdesMid = useSdesMid;
+exports.useSdesRTPStreamId = useSdesRTPStreamId;
+exports.useRepairedRtpStreamId = useRepairedRtpStreamId;
+exports.useTransportWideCC = useTransportWideCC;
+exports.useAbsSendTime = useAbsSendTime;
+exports.useDependencyDescriptor = useDependencyDescriptor;
+exports.useAudioLevelIndication = useAudioLevelIndication;
+exports.useVideoOrientation = useVideoOrientation;
+const rtp_js_1 = require("../../imports/rtp.js");
+const parameters_js_1 = require("../parameters.js");
+function useSdesMid() {
+    return new parameters_js_1.RTCRtpHeaderExtensionParameters({
+        uri: rtp_js_1.RTP_EXTENSION_URI.sdesMid
+    });
+}
+function useSdesRTPStreamId() {
+    return new parameters_js_1.RTCRtpHeaderExtensionParameters({
+        uri: rtp_js_1.RTP_EXTENSION_URI.sdesRTPStreamID
+    });
+}
+function useRepairedRtpStreamId() {
+    return new parameters_js_1.RTCRtpHeaderExtensionParameters({
+        uri: rtp_js_1.RTP_EXTENSION_URI.repairedRtpStreamId
+    });
+}
+function useTransportWideCC() {
+    return new parameters_js_1.RTCRtpHeaderExtensionParameters({
+        uri: rtp_js_1.RTP_EXTENSION_URI.transportWideCC
+    });
+}
+function useAbsSendTime() {
+    return new parameters_js_1.RTCRtpHeaderExtensionParameters({
+        uri: rtp_js_1.RTP_EXTENSION_URI.absSendTime
+    });
+}
+function useDependencyDescriptor() {
+    return new parameters_js_1.RTCRtpHeaderExtensionParameters({
+        uri: rtp_js_1.RTP_EXTENSION_URI.dependencyDescriptor
+    });
+}
+function useAudioLevelIndication() {
+    return new parameters_js_1.RTCRtpHeaderExtensionParameters({
+        uri: rtp_js_1.RTP_EXTENSION_URI.audioLevelIndication
+    });
+}
+function useVideoOrientation() {
+    return new parameters_js_1.RTCRtpHeaderExtensionParameters({
+        uri: rtp_js_1.RTP_EXTENSION_URI.videoOrientation
+    });
+}

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

@@ -0,0 +1,12 @@
+export * from './codec.js';
+export * from './codecCompatibility.js';
+export * from './extension/rtcpFeedback.js';
+export * from './extension/rtpExtension.js';
+export * from './parameters.js';
+export * from './router.js';
+export * from './rtpReceiver.js';
+export * from './rtpSender.js';
+export * from './rtpTransceiver.js';
+export * from './stats.js';
+export * from '../transceiverManager.js';
+export * from './track.js';

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

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./codec.js"), exports);
+__exportStar(require("./codecCompatibility.js"), exports);
+__exportStar(require("./extension/rtcpFeedback.js"), exports);
+__exportStar(require("./extension/rtpExtension.js"), exports);
+__exportStar(require("./parameters.js"), exports);
+__exportStar(require("./router.js"), exports);
+__exportStar(require("./rtpReceiver.js"), exports);
+__exportStar(require("./rtpSender.js"), exports);
+__exportStar(require("./rtpTransceiver.js"), exports);
+__exportStar(require("./stats.js"), exports);
+__exportStar(require("../transceiverManager.js"), exports);
+__exportStar(require("./track.js"), exports);

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

@@ -0,0 +1,65 @@
+import type { MediaDirection } from './rtpTransceiver.js';
+export interface RTCRtpParameters {
+    codecs: RTCRtpCodecParameters[];
+    headerExtensions: RTCRtpHeaderExtensionParameters[];
+    muxId?: string;
+    rtpStreamId?: string;
+    repairedRtpStreamId?: string;
+    rtcp?: RTCRtcpParameters;
+}
+export type RTCPFB = {
+    type: string;
+    parameter?: string;
+};
+export declare class RTCRtpCodecParameters {
+    /**
+   * When specifying a codec with a fixed payloadType such as PCMU,
+   * it is necessary to set the correct PayloadType in RTCRtpCodecParameters in advance.
+   */
+    payloadType: number;
+    mimeType: string;
+    clockRate: number;
+    channels?: number;
+    rtcpFeedback: RTCPFB[];
+    parameters?: string;
+    direction: MediaDirection | 'all';
+    constructor(props: Pick<RTCRtpCodecParameters, 'mimeType' | 'clockRate'> & Partial<RTCRtpCodecParameters>);
+    get name(): string;
+    get contentType(): string;
+    get str(): string;
+}
+export declare class RTCRtpHeaderExtensionParameters {
+    id: number;
+    uri: string;
+    constructor(props: Partial<RTCRtpHeaderExtensionParameters> & Pick<RTCRtpHeaderExtensionParameters, 'uri'>);
+}
+export declare class RTCRtcpParameters {
+    cname?: string;
+    mux: boolean;
+    ssrc?: number;
+    constructor(props?: Partial<RTCRtcpParameters>);
+}
+export declare class RTCRtcpFeedback {
+    type: string;
+    parameter?: string;
+    constructor(props?: Partial<RTCRtcpFeedback>);
+}
+export declare class RTCRtpRtxParameters {
+    ssrc: number;
+    constructor(props?: Partial<RTCRtpRtxParameters>);
+}
+export declare class RTCRtpCodingParameters {
+    ssrc: number;
+    payloadType: number;
+    rtx?: RTCRtpRtxParameters;
+    constructor(props: Partial<RTCRtpCodingParameters> & Pick<RTCRtpCodingParameters, 'ssrc' | 'payloadType'>);
+}
+export interface RTCRtpReceiveParameters extends RTCRtpParameters {
+    encodings: RTCRtpCodingParameters[];
+}
+export type RTCRtpSendParameters = RTCRtpParameters;
+export declare class RTCRtpSimulcastParameters {
+    rid: string;
+    direction: 'send' | 'recv';
+    constructor(props: RTCRtpSimulcastParameters);
+}

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RTCRtpSimulcastParameters = exports.RTCRtpCodingParameters = exports.RTCRtpRtxParameters = exports.RTCRtcpFeedback = exports.RTCRtcpParameters = exports.RTCRtpHeaderExtensionParameters = exports.RTCRtpCodecParameters = void 0;
+class RTCRtpCodecParameters {
+    constructor(props) {
+        this.rtcpFeedback = [];
+        this.direction = 'all';
+        Object.assign(this, props);
+    }
+    get name() {
+        return this.mimeType.split('/')[1];
+    }
+    get contentType() {
+        return this.mimeType.split('/')[0];
+    }
+    get str() {
+        let s = `${this.name}/${this.clockRate}`;
+        if (this.channels === 2)
+            s += '/2';
+        return s;
+    }
+}
+exports.RTCRtpCodecParameters = RTCRtpCodecParameters;
+class RTCRtpHeaderExtensionParameters {
+    constructor(props) {
+        Object.assign(this, props);
+    }
+}
+exports.RTCRtpHeaderExtensionParameters = RTCRtpHeaderExtensionParameters;
+class RTCRtcpParameters {
+    constructor(props = {}) {
+        this.mux = false;
+        Object.assign(this, props);
+    }
+}
+exports.RTCRtcpParameters = RTCRtcpParameters;
+class RTCRtcpFeedback {
+    constructor(props = {}) {
+        Object.assign(this, props);
+    }
+}
+exports.RTCRtcpFeedback = RTCRtcpFeedback;
+class RTCRtpRtxParameters {
+    constructor(props = {}) {
+        Object.assign(this, props);
+    }
+}
+exports.RTCRtpRtxParameters = RTCRtpRtxParameters;
+class RTCRtpCodingParameters {
+    constructor(props) {
+        Object.assign(this, props);
+    }
+}
+exports.RTCRtpCodingParameters = RTCRtpCodingParameters;
+class RTCRtpSimulcastParameters {
+    constructor(props) {
+        Object.assign(this, props);
+    }
+}
+exports.RTCRtpSimulcastParameters = RTCRtpSimulcastParameters;

package/dist/cjs/lib/peer/media/receiver/nack.d.ts

@@ -0,0 +1,23 @@
+import { Event } from '../../imports/common.js';
+import { GenericNack, type RtpPacket } from '../../imports/rtp.js';
+import type { RTCRtpReceiver } from '../rtpReceiver.js';
+export declare class NackHandler {
+    private receiver;
+    private newEstSeqNum;
+    private _lost;
+    private nackLoop;
+    readonly onPacketLost: Event<[GenericNack]>;
+    mediaSourceSsrc?: number;
+    retryCount: number;
+    closed: boolean;
+    constructor(receiver: RTCRtpReceiver);
+    get lostSeqNumbers(): number[];
+    private getLost;
+    private setLost;
+    private removeLost;
+    addPacket(packet: RtpPacket): void;
+    private pruneLost;
+    close(): void;
+    private updateRetryCount;
+    private sendNack;
+}

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

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NackHandler = void 0;
+const common_js_1 = require("../../imports/common.js");
+const rtp_js_1 = require("../../imports/rtp.js");
+const log = (0, rtp_js_1.debug)('webrtc/peer/media/receiver/nack');
+const LOST_SIZE = 30 * 5;
+class NackHandler {
+    constructor(receiver) {
+        this.receiver = receiver;
+        this.newEstSeqNum = 0;
+        this._lost = {};
+        this.onPacketLost = new common_js_1.Event();
+        this.retryCount = 10;
+        this.closed = false;
+        this.sendNack = () => new Promise((r, f) => {
+            if (this.lostSeqNumbers.length > 0 && this.mediaSourceSsrc) {
+                const nack = new rtp_js_1.GenericNack({
+                    senderSsrc: this.receiver.rtcpSsrc,
+                    mediaSourceSsrc: this.mediaSourceSsrc,
+                    lost: this.lostSeqNumbers
+                });
+                const rtcp = new rtp_js_1.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((0, common_js_1.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 === (0, common_js_1.uint16Add)(this.newEstSeqNum, 1)) {
+            this.newEstSeqNum = sequenceNumber;
+        }
+        else if (sequenceNumber > (0, common_js_1.uint16Add)(this.newEstSeqNum, 1)) {
+            // packet lost detected
+            for (let i = (0, common_js_1.uint16Add)(this.newEstSeqNum, 1); i < sequenceNumber; i = (0, common_js_1.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;
+            }
+        });
+    }
+}
+exports.NackHandler = NackHandler;