@lakutata/webrtc 0.0.0-stage → 3.1.4

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

@@ -0,0 +1,47 @@
+import type { RTCDtlsTransport } from '../../transport/dtls.js';
+/**
+ * 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 declare class ReceiverTWCC {
+    private dtlsTransport;
+    /**The arrival times not reported yet, in microseconds, by sequence number (unwrapped)*/
+    readonly arrivals: Map<number, number>;
+    /** uint8 */
+    fbPktCount: number;
+    readonly rtcpSsrc: number;
+    private highestSequenceNumber?;
+    /**The first sequence number not reported yet (unwrapped)*/
+    private nextSequenceNumber?;
+    private mediaSourceSsrc;
+    private timer?;
+    constructor(dtlsTransport: RTCDtlsTransport);
+    /**
+     * A packet arrived
+     * @param transportSequenceNumber
+     * @param mediaSourceSsrc The synchronization source of the packet
+     * @param arrivalTime In microseconds
+     */
+    handleTWCC(transportSequenceNumber: number, mediaSourceSsrc: number, arrivalTime?: number): void;
+    /**
+     * Report no more
+     */
+    stop(): void;
+    /**
+     * Report the packets since the last report, up to the last one received
+     */
+    sendTWCC(): void;
+    /**
+     * The sequence number on more than 16 bits, the closest to the highest one received
+     * @param sequenceNumber
+     */
+    private unwrap;
+    /**
+     * 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
+     */
+    private buildFeedback;
+}

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

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReceiverTWCC = void 0;
+const node_crypto_1 = require("node:crypto");
+const common_js_1 = require("../../imports/common.js");
+const rtp_js_1 = require("../../imports/rtp.js");
+const utils_js_1 = require("../../utils.js");
+const log = (0, rtp_js_1.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 rtp_js_1.RunLengthChunk({ packetStatus: statuses[index], runLength: run }));
+            index += run;
+            continue;
+        }
+        const oneBit = statuses.slice(index, index + 14);
+        const vector = oneBit.includes(rtp_js_1.PacketStatus.TypeTCCPacketReceivedLargeDelta)
+            ? statuses.slice(index, index + 7)
+            : oneBit;
+        const length = vector === oneBit ? 14 : 7;
+        chunks.push(new rtp_js_1.StatusVectorChunk({
+            type: rtp_js_1.PacketChunk.TypeTCCStatusVectorChunk,
+            symbolSize: length === 14 ? 0 : 1,
+            //Filled up with packets not received, past the ones reported
+            symbolList: [...vector, ...Array(length - vector.length).fill(rtp_js_1.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.
+ */
+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 = (0, node_crypto_1.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((0, utils_js_1.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 rtp_js_1.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(rtp_js_1.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
+                ? rtp_js_1.PacketStatus.TypeTCCPacketReceivedSmallDelta
+                : rtp_js_1.PacketStatus.TypeTCCPacketReceivedLargeDelta;
+            statuses.push(type);
+            recvDeltas.push(new rtp_js_1.RecvDelta({ type, delta: delta * 250 }));
+            time += delta * 250;
+        }
+        const feedback = new rtp_js_1.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 = (0, common_js_1.uint8Add)(this.fbPktCount, 1);
+        return { feedback, next: sequenceNumber };
+    }
+}
+exports.ReceiverTWCC = ReceiverTWCC;

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

@@ -0,0 +1,22 @@
+import type { RtpPacket } from '../../imports/rtp.js';
+export declare class StreamStatistics {
+    base_seq?: number;
+    max_seq?: number;
+    cycles: number;
+    packets_received: number;
+    bytesReceived: number;
+    headerBytesReceived: number;
+    lastPacketReceivedTimestamp?: number;
+    readonly clockRate: number;
+    jitter_q4: number;
+    private last_arrival?;
+    private last_timestamp?;
+    expected_prior: number;
+    received_prior: number;
+    constructor(clockRate: number);
+    add(packet: RtpPacket, now?: number): void;
+    get fraction_lost(): number;
+    get jitter(): number;
+    get packets_expected(): number;
+    get packets_lost(): number;
+}

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamStatistics = void 0;
+const common_js_1 = require("../../imports/common.js");
+const stats_js_1 = require("../stats.js");
+// from aiortc
+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 ||
+            (0, common_js_1.uint16Gt)(packet.header.sequenceNumber, this.max_seq);
+        this.packets_received++;
+        this.bytesReceived += packet.payload.length;
+        this.headerBytesReceived += packet.header.serializeSize;
+        this.lastPacketReceivedTimestamp = (0, stats_js_1.getStatsTimestamp)();
+        if (this.base_seq == undefined) {
+            this.base_seq = packet.header.sequenceNumber;
+        }
+        if (inOrder) {
+            const arrival = (0, common_js_1.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;
+    }
+}
+exports.StreamStatistics = StreamStatistics;

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

@@ -0,0 +1,25 @@
+import { type RtcpPacket, type RtpPacket } from '../imports/rtp.js';
+import type { RTCRtpReceiveParameters, RTCRtpSimulcastParameters } from './parameters.js';
+import { RTCRtpReceiver } from './rtpReceiver.js';
+import type { RTCRtpSender } from './rtpSender.js';
+import type { RTCRtpTransceiver } from './rtpTransceiver.js';
+export declare class RtpRouter {
+    ssrcTable: {
+        [ssrc: number]: RTCRtpReceiver | RTCRtpSender;
+    };
+    ridTable: {
+        [rid: string]: RTCRtpReceiver | RTCRtpSender;
+    };
+    extIdUriMap: {
+        [id: number]: string;
+    };
+    constructor();
+    registerRtpSender(sender: RTCRtpSender): void;
+    private registerRtpReceiver;
+    registerRtpReceiverBySsrc(transceiver: RTCRtpTransceiver, params: RTCRtpReceiveParameters): void;
+    registerRtpReceiverByRid(transceiver: RTCRtpTransceiver, param: RTCRtpSimulcastParameters, params: RTCRtpReceiveParameters): void;
+    /**停止した transceiver の SSRC / RID 登録を解除する */
+    unregisterTransceiver(transceiver: RTCRtpTransceiver): void;
+    routeRtp: (packet: RtpPacket) => void;
+    routeRtcp: (packet: RtcpPacket) => void;
+}

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

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RtpRouter = void 0;
+const rtp_js_1 = require("../imports/rtp.js");
+const codecCompatibility_js_1 = require("./codecCompatibility.js");
+const rtpReceiver_js_1 = require("./rtpReceiver.js");
+const track_js_1 = require("./track.js");
+const log = (0, rtp_js_1.debug)('webrtc/peer/media/router');
+class RtpRouter {
+    constructor() {
+        this.ssrcTable = {};
+        this.ridTable = {};
+        this.extIdUriMap = {};
+        this.routeRtp = (packet) => {
+            const extensions = (0, rtp_js_1.rtpHeaderExtensionsParser)(packet.header.extensions, this.extIdUriMap);
+            let rtpReceiver = this.ssrcTable[packet.header.ssrc];
+            const rid = extensions[rtp_js_1.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 rtpReceiver_js_1.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_js_1.RTP_EXTENSION_URI.sdesMid];
+            if (typeof sdesMid === 'string') {
+                rtpReceiver.sdesMid = sdesMid;
+            }
+            const repairedRid = extensions[rtp_js_1.RTP_EXTENSION_URI.repairedRtpStreamId];
+            if (typeof repairedRid === 'string') {
+                rtpReceiver.latestRepairedRid = repairedRid;
+            }
+        };
+        this.routeRtcp = (packet) => {
+            const recipients = [];
+            switch (packet.type) {
+                case rtp_js_1.RtcpSrPacket.type:
+                    {
+                        packet = packet;
+                        recipients.push(this.ssrcTable[packet.ssrc]);
+                    }
+                    break;
+                case rtp_js_1.RtcpRrPacket.type:
+                    {
+                        packet = packet;
+                        packet.reports.forEach((report) => {
+                            recipients.push(this.ssrcTable[report.ssrc]);
+                        });
+                    }
+                    break;
+                case rtp_js_1.RtcpSourceDescriptionPacket.type:
+                    //Source descriptions are not used
+                    break;
+                case rtp_js_1.RtcpTransportLayerFeedback.type:
+                    {
+                        const rtpfb = packet;
+                        if (rtpfb.feedback) {
+                            recipients.push(this.ssrcTable[rtpfb.feedback.mediaSourceSsrc]);
+                        }
+                    }
+                    break;
+                case rtp_js_1.RtcpPayloadSpecificFeedback.type:
+                    {
+                        const psfb = packet;
+                        switch (psfb.feedback.count) {
+                            case rtp_js_1.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 track_js_1.MediaStreamTrack({
+                ssrc: encode.ssrc,
+                kind: transceiver.kind,
+                id: transceiver.sender.trackId,
+                remote: true,
+                codec: (0, codecCompatibility_js_1.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 track_js_1.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];
+            }
+        }
+    }
+}
+exports.RtpRouter = RtpRouter;

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

@@ -0,0 +1,90 @@
+import { Event } from '../imports/common.js';
+import { type Extensions, type RtcpPacket, type RtpPacket } from '../imports/rtp.js';
+import type { PeerConfig } from '../peerConnection.js';
+import type { RTCDtlsTransport } from '../transport/dtls.js';
+import type { Kind } from '../types/domain.js';
+import type { RTCRtpReceiveParameters } from './parameters.js';
+import { type RTCStats, type RTCStatsReport } from './stats.js';
+import { MediaStreamTrack } from './track.js';
+export declare class RTCRtpReceiver {
+    readonly config: PeerConfig;
+    kind: Kind;
+    rtcpSsrc: number;
+    private readonly codecs;
+    private readonly defaultTrack;
+    private sortedCodecs?;
+    private get codecArray();
+    private readonly ssrcByRtx;
+    private readonly nack;
+    private readonly audioRedHandler;
+    readonly type = "receiver";
+    readonly uuid: string;
+    readonly tracks: MediaStreamTrack[];
+    readonly trackBySSRC: {
+        [ssrc: string]: MediaStreamTrack;
+    };
+    readonly trackByRID: {
+        [rid: string]: MediaStreamTrack;
+    };
+    /**last sender Report Timestamp
+   * compactNtp
+   */
+    readonly lastSRtimestamp: {
+        [ssrc: number]: number;
+    };
+    /**seconds */
+    readonly receiveLastSRTimestamp: {
+        [ssrc: number]: number;
+    };
+    readonly onPacketLost: Event<[import("../index.js").GenericNack]>;
+    readonly onRtcp: Event<[RtcpPacket]>;
+    dtlsTransport: RTCDtlsTransport;
+    sdesMid?: string;
+    latestRid?: string;
+    latestRepairedRid?: string;
+    stopped: boolean;
+    remoteStreamId?: string;
+    remoteStreamIds: string[];
+    remoteTrackId?: string;
+    rtcpRunning: boolean;
+    private rtcpCancel;
+    private remoteStreams;
+    private senderReportsReceivedBySsrc;
+    private remoteTimestampsBySsrc;
+    private remotePacketCountBySsrc;
+    private remoteOctetCountBySsrc;
+    private nackCountBySsrc;
+    private pliCountBySsrc;
+    constructor(config: PeerConfig, kind: Kind, rtcpSsrc: number);
+    get transport(): RTCDtlsTransport;
+    setDtlsTransport(dtls: RTCDtlsTransport): void;
+    get track(): MediaStreamTrack;
+    get nackEnabled(): import("./parameters.js").RTCPFB | undefined;
+    get twccEnabled(): import("./parameters.js").RTCPFB | undefined;
+    get pliEnabled(): import("./parameters.js").RTCPFB | undefined;
+    prepareReceive(params: RTCRtpReceiveParameters): void;
+    /**
+   * negotiated codec と receiver の実処理状態を再同期する。
+   * codec map と RTX mapping を置換し、既存 remote track の codec
+   * metadata も新しい先頭 codec に更新する。
+   * transport-cc の有無は twccEnabled が新しい codec から判断する。
+   * setCodecPreferences() 後の createAnswer() 再解決や remote からの
+   * 再交渉では、除外された payload type の RTP を受け付けないようにする。
+   */
+    resyncCodecs(params: RTCRtpReceiveParameters): void;
+    addTrack(track: MediaStreamTrack): boolean;
+    stop(): void;
+    /**transceiver の停止確定時に remote track を ended にする */
+    endTracks(): void;
+    runRtcp(): Promise<void>;
+    private getInboundRtpStatsId;
+    private getRemoteOutboundRtpStatsId;
+    getStatsRootIds(selector?: MediaStreamTrack): string[];
+    collectStats(timestamp: number): RTCStats[];
+    getStats(): Promise<RTCStatsReport>;
+    sendRtcpPLI(mediaSsrc: number): Promise<void>;
+    handleRtcpPacket(packet: RtcpPacket): void;
+    handleRtpBySsrc: (packet: RtpPacket, extensions: Extensions) => void;
+    handleRtpByRid: (packet: RtpPacket, rid: string, extensions: Extensions) => void;
+    private handleRTP;
+}