@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/esm/lib/peer/transceiverManager.js

@@ -0,0 +1,763 @@
+import { ReceiverDirection, SenderDirections } from './const.js';
+import { createWebRtcDomException } from './errors.js';
+import { Event, debug } from './imports/common.js';
+import { MediaStream, RTCRtpCodingParameters, RTCRtpReceiver, RTCRtpRtxParameters, RTCRtpSender, RTCRtpTransceiver, Recvonly, Sendonly, Sendrecv } from './media/index.js';
+import { assertCodecsSupported, hasCommonPrimaryMimeType, isCodecCompatible, resolveCodecs } from './media/codecCompatibility.js';
+import { captureTrackSourceCodecs, getTrackSourceCodecs } from './media/track.js';
+import { codecParametersFromString } from './sdp.js';
+import { reverseDirection } from './utils.js';
+const log = debug('webrtc/peer/transceiverManager');
+function simulcastFromSendEncodings(encodings) {
+    if (!encodings || encodings.length < 2) {
+        return undefined;
+    }
+    const rids = encodings
+        .map((encoding) => encoding.rid)
+        .filter((rid) => typeof rid === 'string' && rid.length > 0);
+    if (rids.length < 2) {
+        return undefined;
+    }
+    return rids.map((rid) => ({ rid, direction: 'send' }));
+}
+export class TransceiverManager {
+    constructor(cname, config, router) {
+        this.cname = cname;
+        this.config = config;
+        this.router = router;
+        this.transceivers = [];
+        this.watched = new WeakSet();
+        //The media ids and the m-line indexes of the transceivers when the signaling state was stable last
+        this.stableState = new Map();
+        this.onTransceiverAdded = new Event();
+        this.onRemoteTransceiverAdded = new Event();
+        this.onTrack = new Event();
+        this.onNegotiationNeeded = new Event();
+    }
+    getTransceivers() {
+        return this.transceivers;
+    }
+    getSenders() {
+        return this.getTransceivers().map((t) => t.sender);
+    }
+    getReceivers() {
+        return this.getTransceivers().map((t) => t.receiver);
+    }
+    getTransceiverByMLineIndex(index) {
+        return this.transceivers.find((transceiver) => transceiver.mLineIndex === index);
+    }
+    pushTransceiver(t) {
+        this.watchTransceiver(t);
+        this.transceivers.push(t);
+    }
+    replaceTransceiver(t, index) {
+        this.watchTransceiver(t);
+        this.transceivers[index] = t;
+    }
+    /**m-line から外れた transceiver の購読を解除する */
+    unwatchTransceiver(t) {
+        this.watched.delete(t);
+        t.onRelease.allUnsubscribe();
+        t.onStopRequested.allUnsubscribe();
+        t.onDirectionChanged.allUnsubscribe();
+        t.sender.onStreamsChanged.allUnsubscribe();
+    }
+    watchTransceiver(t) {
+        if (this.watched.has(t)) {
+            return;
+        }
+        this.watched.add(t);
+        t.onRelease.subscribe(() => {
+            this.router.unregisterTransceiver(t);
+        });
+        t.onStopRequested.subscribe(() => {
+            // 未関連付けの stop は m-line を作らないので交渉不要
+            if (!t.stopped) {
+                this.onNegotiationNeeded.execute();
+            }
+        });
+        //A new direction or new streams of the application are negotiated
+        t.onDirectionChanged.subscribe(() => {
+            if (!t.stopping && !t.stopped)
+                this.onNegotiationNeeded.execute();
+        });
+        t.sender.onStreamsChanged.subscribe(() => {
+            if (!t.stopping && !t.stopped)
+                this.onNegotiationNeeded.execute();
+        });
+    }
+    /**
+   * 拒否 / 停止の交渉が確定した port 0 の位置のうち、同じ kind で
+   * まだ他の transceiver が予約していないものを返す。
+   * stopping (未交渉) の位置は先取りしない。
+   */
+    findReusableTransceiver(kind) {
+        return this.transceivers.find((t) => t.stopped &&
+            t.kind === kind &&
+            t.mLineIndex != undefined &&
+            !this.transceivers.some((other) => other !== t && other.mLineIndex === t.mLineIndex));
+    }
+    /**旧 transceiver を m-line から外し、同じ位置に新しい transceiver を置く */
+    takeOverMLine(oldTransceiver, newTransceiver) {
+        const index = this.transceivers.indexOf(oldTransceiver);
+        newTransceiver.mLineIndex = oldTransceiver.mLineIndex;
+        oldTransceiver.mid = null;
+        oldTransceiver.mLineIndex = undefined;
+        this.unwatchTransceiver(oldTransceiver);
+        this.replaceTransceiver(newTransceiver, index);
+    }
+    /**
+   * 既存の未関連付け transceiver を remote m-line の位置に関連付ける。
+   * 同じ位置に停止済みの旧 transceiver があれば m-line から外し、配列上でも置き換える。
+   * (旧 transceiver が位置を持ったままだと MID の割り当て先が重複する)
+   */
+    associateMLine(transceiver, mLineIndex) {
+        const previous = this.transceivers.find((t) => t !== transceiver && t.stopped && t.mLineIndex === mLineIndex);
+        if (!previous) {
+            return;
+        }
+        this.transceivers.splice(this.transceivers.indexOf(transceiver), 1);
+        this.takeOverMLine(previous, transceiver);
+    }
+    /**
+   * remote offer が定義した位置のうち、関連付けられなかった未交渉 transceiver の予約を解除する。
+   * (remote が予約位置を別 kind や別 transceiver で再利用した場合、次の offer で末尾に追加させる)
+   */
+    releaseUnassociatedReservations(associated, mLineCount) {
+        for (const t of this.transceivers) {
+            if (!associated.has(t) &&
+                t.mid == null &&
+                t.mLineIndex != undefined &&
+                t.mLineIndex < mLineCount) {
+                t.mLineIndex = undefined;
+            }
+        }
+    }
+    addTransceiver(trackOrKind, dtlsTransport, options = {}, { remoteMLineIndex } = {}) {
+        const kind = typeof trackOrKind === 'string' ? trackOrKind : trackOrKind.kind;
+        const direction = options.direction || 'sendrecv';
+        if (typeof trackOrKind !== 'string') {
+            captureTrackSourceCodecs(trackOrKind);
+            assertCodecsSupported({
+                kind,
+                configured: this.filterCodecsByDirection(kind, direction),
+                source: getTrackSourceCodecs(trackOrKind),
+                preferences: undefined
+            });
+        }
+        const sender = new RTCRtpSender(trackOrKind, {
+            pendingRtp: this.config.pendingRtp
+        });
+        const receiver = new RTCRtpReceiver(this.config, kind, sender.ssrc);
+        const newTransceiver = new RTCRtpTransceiver(kind, dtlsTransport, receiver, sender, direction);
+        newTransceiver.onCodecPreferencesChanged.subscribe(() => {
+            this.onNegotiationNeeded.execute();
+        });
+        newTransceiver.options = {
+            ...options,
+            simulcast: options.simulcast ?? simulcastFromSendEncodings(options.sendEncodings)
+        };
+        newTransceiver.sender.setStreams(options.streams ?? []);
+        newTransceiver.sender.setSendEncodings((options.sendEncodings ?? []).map((encoding) => ({ ...encoding })));
+        this.router.registerRtpSender(newTransceiver.sender);
+        // 旧 transceiver は復活させず、MID は次の offer で新しく割り当てる
+        const reusable = remoteMLineIndex == undefined
+            ? this.findReusableTransceiver(kind)
+            : this.transceivers.find((t) => t.stopped && t.mLineIndex === remoteMLineIndex);
+        if (reusable) {
+            this.takeOverMLine(reusable, newTransceiver);
+        }
+        else {
+            this.pushTransceiver(newTransceiver);
+        }
+        if (remoteMLineIndex != undefined) {
+            this.remoteOfferSnapshot?.remoteCreated.add(newTransceiver);
+        }
+        this.onTransceiverAdded.execute(newTransceiver);
+        return newTransceiver;
+    }
+    /**
+     * Whether addTrack may give a track of a kind to a transceiver, rather than adding one
+     * @param transceiver
+     * @param kind
+     */
+    reusableForTrack(transceiver, kind) {
+        return transceiver.sender.track == undefined &&
+            transceiver.kind === kind &&
+            !transceiver.usedForSender &&
+            !transceiver.stopping &&
+            !transceiver.stopped &&
+            !transceiver.rejected &&
+            !transceiver.pendingRejection;
+    }
+    /**
+     * Add a track: to a transceiver that may take it, else to a new one
+     * @param track
+     * @param streams
+     * @param chosen The transceiver chosen already (for a connection served in a worker thread, by the main thread): used
+     * if it may still take the track, else a new one is added, as for null
+     */
+    addTrack(track, streams = [], chosen) {
+        if (this.getSenders().find((sender) => sender.track?.uuid === track.uuid)) {
+            throw createWebRtcDomException('InvalidAccessError', 'Track already added');
+        }
+        const reusableForTrack = (t) => this.reusableForTrack(t, track.kind) &&
+            (chosen === undefined || t === chosen);
+        const emptyTrackSenderTransceiver = chosen === null ? undefined : this.transceivers.find((t) => reusableForTrack(t) && SenderDirections.includes(t.direction));
+        if (emptyTrackSenderTransceiver) {
+            this.validateTrackForTransceiver(track, emptyTrackSenderTransceiver);
+            const sender = emptyTrackSenderTransceiver.sender;
+            sender.setStreams(streams);
+            sender.registerTrack(track);
+            emptyTrackSenderTransceiver.options = {
+                ...emptyTrackSenderTransceiver.options,
+                streams
+            };
+            emptyTrackSenderTransceiver.codecs = [];
+            return emptyTrackSenderTransceiver;
+        }
+        const notSendTransceiver = chosen === null ? undefined : this.transceivers.find((t) => reusableForTrack(t) && !SenderDirections.includes(t.direction));
+        if (notSendTransceiver) {
+            const nextDirection = notSendTransceiver.direction === 'recvonly'
+                ? 'sendrecv'
+                : notSendTransceiver.direction === 'inactive'
+                    ? 'sendonly'
+                    : notSendTransceiver.direction;
+            this.validateTrackForTransceiver(track, notSendTransceiver, nextDirection);
+            const sender = notSendTransceiver.sender;
+            sender.setStreams(streams);
+            sender.registerTrack(track);
+            notSendTransceiver.options = {
+                ...notSendTransceiver.options,
+                streams
+            };
+            switch (notSendTransceiver.direction) {
+                case 'recvonly':
+                    notSendTransceiver.setDirection('sendrecv');
+                    break;
+                case 'inactive':
+                    notSendTransceiver.setDirection('sendonly');
+                    break;
+            }
+            notSendTransceiver.codecs = [];
+            return notSendTransceiver;
+        }
+        else {
+            const transceiver = this.addTransceiver(track, undefined, {
+                direction: 'sendrecv',
+                streams
+            });
+            transceiver.addedByAddTrack = true;
+            return transceiver;
+        }
+    }
+    /**
+   * sender から track を外す。
+   * @returns 交渉が必要な変更をした場合 true (呼び出し側が negotiationneeded を要求する)
+   */
+    removeTrack(sender) {
+        if (!this.getSenders().find(({ ssrc }) => sender.ssrc === ssrc)) {
+            throw createWebRtcDomException('InvalidAccessError', 'Sender does not exist');
+        }
+        const transceiver = this.transceivers.find(({ sender: { ssrc } }) => sender.ssrc === ssrc);
+        if (!transceiver)
+            throw new Error('No matching transceiver found');
+        if (transceiver.stopping || transceiver.stopped) {
+            return false;
+        }
+        if (sender.track == undefined) {
+            return false;
+        }
+        // sender 自体は止めず track だけ外し、同じ sender で送信を再開できるようにする
+        sender.detachTrack();
+        if (transceiver.direction === 'sendrecv') {
+            transceiver.setDirection('recvonly');
+        }
+        else if (transceiver.direction === 'sendonly') {
+            transceiver.setDirection('inactive');
+        }
+        return true;
+    }
+    assignTransceiverCodecs(transceiver) {
+        const configured = this.filterCodecsByDirection(transceiver.kind, transceiver.direction);
+        transceiver.codecs = assertCodecsSupported({
+            kind: transceiver.kind,
+            configured,
+            source: getTrackSourceCodecs(transceiver.sender.track),
+            preferences: transceiver.codecPreferences
+        });
+        transceiver.codecPreferencesNeedResolution = false;
+    }
+    filterCodecsByDirection(kind, direction) {
+        return this.config.codecs[kind].filter((codecCandidate) => {
+            switch (codecCandidate.direction) {
+                case 'recvonly': {
+                    if (ReceiverDirection.includes(direction))
+                        return true;
+                    return false;
+                }
+                case 'sendonly': {
+                    if (SenderDirections.includes(direction))
+                        return true;
+                    return false;
+                }
+                case 'sendrecv': {
+                    if ([Sendrecv, Recvonly, Sendonly].includes(direction))
+                        return true;
+                    return false;
+                }
+                case 'all': {
+                    return true;
+                }
+                default:
+                    return false;
+            }
+        });
+    }
+    validateTrackForTransceiver(track, transceiver, direction = transceiver.direction) {
+        captureTrackSourceCodecs(track);
+        assertCodecsSupported({
+            kind: track.kind,
+            configured: this.filterCodecsByDirection(track.kind, direction),
+            source: getTrackSourceCodecs(track),
+            preferences: transceiver.codecPreferences
+        });
+    }
+    getLocalRtpParams(transceiver) {
+        if (transceiver.mid == undefined)
+            throw new Error('mid not assigned');
+        const rtp = {
+            codecs: transceiver.codecs,
+            muxId: transceiver.mid,
+            headerExtensions: transceiver.headerExtensions,
+            rtcp: { cname: this.cname, ssrc: transceiver.sender.ssrc, mux: true }
+        };
+        return rtp;
+    }
+    getRemoteRtpParams(media, transceiver) {
+        const receiveParameters = {
+            muxId: media.rtp.muxId,
+            rtcp: media.rtp.rtcp,
+            codecs: transceiver.codecs,
+            headerExtensions: transceiver.headerExtensions,
+            encodings: Object.values(transceiver.codecs.reduce((acc, codec) => {
+                if (codec.name.toLowerCase() === 'rtx') {
+                    const params = codecParametersFromString(codec.parameters ?? '');
+                    const apt = acc[params['apt']];
+                    if (apt && media.ssrc.length === 2) {
+                        apt.rtx = new RTCRtpRtxParameters({ ssrc: media.ssrc[1].ssrc });
+                    }
+                    return acc;
+                }
+                acc[codec.payloadType] = new RTCRtpCodingParameters({
+                    ssrc: media.ssrc[0]?.ssrc,
+                    payloadType: codec.payloadType
+                });
+                return acc;
+            }, {}))
+        };
+        return receiveParameters;
+    }
+    /**
+   * remote offer と local (source constraint + preferences) から
+   * answer 用の codec を再解決し、sender/receiver の codec 状態も
+   * 新しい negotiated codec に同期する。
+   * setCodecPreferences() による無効化後に createAnswer() から呼ばれる。
+   * direction / headerExtensions / onTrack は setRemoteDescription() 時の
+   * まま変えない (track イベントの重複発火を避ける)。
+   */
+    resyncAnswerCodecs(transceiver, remoteMedia) {
+        this.refreshAnswerCodecs(transceiver, remoteMedia);
+        const localParams = this.getLocalRtpParams(transceiver);
+        transceiver.sender.prepareSend(localParams);
+        if (['recvonly', 'sendrecv'].includes(transceiver.direction)) {
+            const remoteParams = this.getRemoteRtpParams(remoteMedia, transceiver);
+            for (const param of remoteMedia.simulcastParameters) {
+                this.router.registerRtpReceiverByRid(transceiver, param, remoteParams);
+            }
+            transceiver.receiver.resyncCodecs(remoteParams);
+            this.router.registerRtpReceiverBySsrc(transceiver, remoteParams);
+        }
+    }
+    /**
+   * remote offer と local (source constraint + preferences) から
+   * answer 用の codec だけを再解決する (sender/receiver の同期なし)。
+   * setRemoteRTP() の交渉部分として使う。
+   */
+    resolveRemoteCodecSet(localCodecs, remoteMedia, order, source) {
+        // # negotiate codecs
+        const codecName = (codec) => codec.name.toLowerCase();
+        const redPayloadTypes = (codec) => (codec.parameters ?? '')
+            .split('/')
+            .map(Number)
+            .filter((payloadType) => !Number.isNaN(payloadType));
+        const remoteByLocal = new Map();
+        const usedRemote = new Set();
+        for (const localCodec of localCodecs) {
+            if (['red', 'rtx'].includes(codecName(localCodec)))
+                continue;
+            const remoteCodec = remoteMedia.rtp.codecs.find((codec) => !usedRemote.has(codec) &&
+                codec.mimeType.toLowerCase() === localCodec.mimeType.toLowerCase() &&
+                (source == undefined ||
+                    source.some((sourceCodec) => isCodecCompatible(sourceCodec, codec))));
+            if (remoteCodec) {
+                remoteByLocal.set(localCodec, remoteCodec);
+                usedRemote.add(remoteCodec);
+            }
+        }
+        const negotiated = localCodecs.flatMap((localCodec) => {
+            if (codecName(localCodec) === 'red') {
+                const remotePrimaryPayloadTypes = redPayloadTypes(localCodec).flatMap((payloadType) => {
+                    const localPrimary = localCodecs.find((codec) => codec.payloadType === payloadType);
+                    const remotePrimary = localPrimary
+                        ? remoteByLocal.get(localPrimary)
+                        : undefined;
+                    return remotePrimary ? [remotePrimary.payloadType] : [];
+                });
+                const remoteRed = remoteMedia.rtp.codecs.find((codec) => {
+                    if (codecName(codec) !== 'red' || usedRemote.has(codec))
+                        return false;
+                    const referenced = redPayloadTypes(codec);
+                    return (referenced.length === remotePrimaryPayloadTypes.length &&
+                        referenced.every((payloadType, index) => payloadType === remotePrimaryPayloadTypes[index]));
+                });
+                if (!remoteRed)
+                    return [];
+                usedRemote.add(remoteRed);
+                return [remoteRed];
+            }
+            if (codecName(localCodec) !== 'rtx') {
+                const remoteCodec = remoteByLocal.get(localCodec);
+                return remoteCodec ? [remoteCodec] : [];
+            }
+            const localApt = codecParametersFromString(localCodec.parameters ?? '').apt;
+            const localPrimary = localCodecs.find((codec) => codec.payloadType === localApt);
+            if (!localPrimary)
+                return [];
+            const remotePrimary = remoteByLocal.get(localPrimary);
+            if (!remotePrimary)
+                return [];
+            const remoteRtx = remoteMedia.rtp.codecs.find((codec) => {
+                if (codecName(codec) !== 'rtx' || usedRemote.has(codec)) {
+                    return false;
+                }
+                return (codecParametersFromString(codec.parameters ?? '').apt ===
+                    remotePrimary.payloadType);
+            });
+            if (!remoteRtx)
+                return [];
+            usedRemote.add(remoteRtx);
+            return [remoteRtx];
+        });
+        if (order === 'remote') {
+            const remoteOrder = new Map(remoteMedia.rtp.codecs.map((codec, index) => [codec, index]));
+            negotiated.sort((left, right) => remoteOrder.get(left) - remoteOrder.get(right));
+        }
+        if (negotiated.length === 0) {
+            throw createWebRtcDomException('NotSupportedError', 'No compatible codec remains after remote negotiation.');
+        }
+        return negotiated;
+    }
+    refreshAnswerCodecs(transceiver, remoteMedia) {
+        const configured = this.config.codecs[remoteMedia.kind] || [];
+        const source = getTrackSourceCodecs(transceiver.sender.track);
+        assertCodecsSupported({
+            kind: remoteMedia.kind,
+            configured,
+            source,
+            preferences: transceiver.codecPreferences
+        });
+        const localCodecs = resolveCodecs(configured, source, transceiver.codecPreferences);
+        transceiver.codecs = this.resolveRemoteCodecSet(localCodecs, remoteMedia, 'local', source);
+        transceiver.codecPreferencesNeedResolution = false;
+        log('negotiated codecs', transceiver.codecs);
+    }
+    /**
+   * remote SDP の全 audio/video m-line の codec を副作用なしで解決する。
+   * transceiver の対応付けは本適用と同じ resolver を使い、検証と適用の判定をずらさない。
+   * - port 0、停止済み / 停止中の m-line は codec 解決をしない (空)
+   * - local capability と MIME が 1 つも一致しない m-line は空とし、
+   *   offer は setRemoteRTP() で拒否 (port 0 answer)、answer/pranswer は
+   *   SDPManager が InvalidAccessError とする (Issue #705)
+   * - source constraint / preference / pending offer との不一致は NotSupportedError
+   */
+    planRemoteRtpCodecs(remoteSdp, findTransceiver) {
+        const plan = new Map();
+        const isOffer = remoteSdp.type === 'offer';
+        for (const [index, remoteMedia] of remoteSdp.media.entries()) {
+            if (!['audio', 'video'].includes(remoteMedia.kind))
+                continue;
+            const transceiver = findTransceiver(remoteMedia, index);
+            if (remoteMedia.port === 0 ||
+                transceiver?.stopped ||
+                transceiver?.stopping) {
+                plan.set(index, []);
+                continue;
+            }
+            const source = getTrackSourceCodecs(transceiver?.sender.track);
+            const configured = this.config.codecs[remoteMedia.kind] || [];
+            const localCodecs = isOffer
+                ? configured
+                : transceiver?.pendingLocalOfferCodecs || [];
+            if (!hasCommonPrimaryMimeType(localCodecs, remoteMedia.rtp.codecs)) {
+                plan.set(index, []);
+                continue;
+            }
+            if (isOffer) {
+                assertCodecsSupported({
+                    kind: remoteMedia.kind,
+                    configured,
+                    source,
+                    preferences: transceiver?.codecPreferences
+                });
+            }
+            const negotiated = this.resolveRemoteCodecSet(isOffer
+                ? resolveCodecs(configured, source, transceiver?.codecPreferences)
+                : localCodecs, remoteMedia, isOffer ? 'local' : 'remote', source);
+            if (source != undefined) {
+                assertCodecsSupported({
+                    kind: remoteMedia.kind,
+                    configured: negotiated,
+                    source,
+                    preferences: undefined
+                });
+            }
+            plan.set(index, negotiated);
+        }
+        return plan;
+    }
+    /**
+   * remote m-line を transceiver に適用する。
+   * codecs は planRemoteRtpCodecs() で検証済みの解決結果を渡す。
+   * codec が空、または remote port 0 の m-line は拒否として扱い、
+   * sender/receiver 準備・router 登録・onTrack・TWCC を行わない。
+   * @returns 受け入れた (RTP を流す) 場合 true
+   */
+    setRemoteRTP(transceiver, remoteMedia, type, mLineIndex, codecs) {
+        if (!transceiver.mid) {
+            transceiver.mid = remoteMedia.rtp.muxId ?? null;
+        }
+        transceiver.mLineIndex = mLineIndex;
+        if (type === 'answer')
+            transceiver.pendingLocalOfferCodecs = undefined;
+        if (transceiver.stopped) {
+            // 確定済みの停止 / 拒否 m-line は復活させない
+            return false;
+        }
+        if (transceiver.stopping) {
+            // app の stop() は自分の offer で交渉する。port 0 の answer で停止を確定する
+            if (type === 'answer' && remoteMedia.port === 0) {
+                transceiver.commitStopped({ rejected: false });
+            }
+            return false;
+        }
+        log('negotiated codecs', codecs);
+        if (remoteMedia.port === 0 || codecs.length === 0) {
+            if (type === 'answer') {
+                transceiver.commitStopped({ rejected: true });
+            }
+            else {
+                // answer が確定するまで既存の RTP pipeline / track は維持する
+                transceiver.pendingRejection = true;
+            }
+            return false;
+        }
+        transceiver.pendingRejection = false;
+        transceiver.codecs = codecs;
+        transceiver.headerExtensions = remoteMedia.rtp.headerExtensions.filter((extension) => (this.config.headerExtensions[remoteMedia.kind] ||
+            []).find((v) => v.uri === extension.uri));
+        // # configure direction
+        const mediaDirection = remoteMedia.direction ?? 'inactive';
+        const direction = reverseDirection(mediaDirection);
+        if (['answer', 'pranswer'].includes(type)) {
+            transceiver.setCurrentDirection(direction);
+        }
+        else {
+            transceiver.offerDirection = direction;
+        }
+        const localParams = this.getLocalRtpParams(transceiver);
+        transceiver.sender.prepareSend(localParams);
+        if (['recvonly', 'sendrecv'].includes(transceiver.direction)) {
+            const remotePrams = this.getRemoteRtpParams(remoteMedia, transceiver);
+            // register simulcast receiver
+            for (const param of remoteMedia.simulcastParameters) {
+                this.router.registerRtpReceiverByRid(transceiver, param, remotePrams);
+            }
+            // codec map / RTX を negotiated codec に合わせて再構築する
+            transceiver.receiver.resyncCodecs(remotePrams);
+            // register ssrc receiver
+            this.router.registerRtpReceiverBySsrc(transceiver, remotePrams);
+        }
+        if (['sendonly', 'sendrecv'].includes(mediaDirection)) {
+            const remoteStreamIds = [
+                ...new Set(remoteMedia.msids.map((msid) => msid.split(' ')[0]))
+            ];
+            const remoteTrackId = remoteMedia.msids[0]?.split(' ')[1];
+            transceiver.receiver.remoteStreamId = remoteStreamIds[0];
+            transceiver.receiver.remoteStreamIds = remoteStreamIds;
+            transceiver.receiver.remoteTrackId = remoteTrackId;
+            // re-offer / re-answer で同じ受信を重複通知しない
+            if (!transceiver.firedReceiving) {
+                transceiver.firedReceiving = true;
+                this.onTrack.execute({
+                    track: transceiver.receiver.track,
+                    transceiver,
+                    streams: remoteStreamIds.map((id) => new MediaStream({
+                        id,
+                        tracks: [transceiver.receiver.track]
+                    }))
+                });
+            }
+        }
+        else {
+            transceiver.firedReceiving = false;
+        }
+        return true;
+    }
+    /**
+   * The signaling state is stable: the media ids and the m-line indexes of the transceivers are kept, given back when
+   * the next local offer is rolled back
+   */
+    markStable() {
+        this.stableState = new Map(this.transceivers.map((t) => [t, { mid: t.mid, mLineIndex: t.mLineIndex }]));
+    }
+    /**
+   * A local offer is rolled back (JSEP 4.1.8.2): the transceivers it gave a media id and an m-line are associated as
+   * before it, the ones added since not at all (an offer of the other side then associates them by their own rules, not
+   * by the media id the rolled back offer gave them)
+   */
+    rollbackLocalOffer() {
+        for (const transceiver of this.transceivers) {
+            const state = this.stableState.get(transceiver);
+            transceiver.mid = state?.mid ?? null;
+            transceiver.mLineIndex = state?.mLineIndex;
+        }
+    }
+    /**
+   * remote offer 適用前の transceiver 対応を保存する。
+   * 同じ offer/answer 交換中に複数回呼ばれても最初の状態を保持する。
+   */
+    beginRemoteOffer() {
+        if (this.remoteOfferSnapshot) {
+            return;
+        }
+        this.remoteOfferSnapshot = {
+            transceivers: [...this.transceivers],
+            remoteCreated: new Set(),
+            states: new Map(this.transceivers.map((t) => [
+                t,
+                {
+                    mid: t.mid,
+                    mLineIndex: t.mLineIndex,
+                    pendingRejection: t.pendingRejection,
+                    firedReceiving: t.firedReceiving
+                }
+            ]))
+        };
+    }
+    /**
+   * local answer の確定で、拒否予定の m-line を停止・解放する。
+   * remote SDP 起因の停止なので negotiationneeded は要求しない。
+   */
+    commitRemoteOffer() {
+        this.remoteOfferSnapshot = undefined;
+        for (const transceiver of this.transceivers) {
+            if (transceiver.pendingRejection) {
+                transceiver.commitStopped({ rejected: true });
+            }
+        }
+    }
+    /**remote offer の rollback で transceiver 対応を元に戻す */
+    rollbackRemoteOffer() {
+        const snapshot = this.remoteOfferSnapshot;
+        this.remoteOfferSnapshot = undefined;
+        if (!snapshot) {
+            return;
+        }
+        for (const transceiver of this.transceivers) {
+            if (snapshot.states.has(transceiver)) {
+                continue;
+            }
+            // app が追加した transceiver と、remote offer が作ったが app が addTrack で使い始めた
+            // transceiver は残し、関連付けだけ外す (track の有無ではなく作成元で判定する)
+            if (!snapshot.remoteCreated.has(transceiver) ||
+                transceiver.sender.track) {
+                transceiver.mid = null;
+                transceiver.mLineIndex = undefined;
+                snapshot.transceivers.push(transceiver);
+                continue;
+            }
+            // remote offer が作った transceiver は破棄する
+            transceiver.forceStop();
+            this.unwatchTransceiver(transceiver);
+        }
+        this.transceivers.splice(0, this.transceivers.length, ...snapshot.transceivers);
+        snapshot.transceivers.forEach((t) => this.watchTransceiver(t));
+        for (const [transceiver, state] of snapshot.states) {
+            transceiver.mid = state.mid;
+            transceiver.mLineIndex = state.mLineIndex;
+            transceiver.pendingRejection = state.pendingRejection;
+            transceiver.firedReceiving = state.firedReceiving;
+        }
+    }
+    /**
+   * answer 確定後に、stopping のまま交渉対象になり得ない transceiver の停止を確定する。
+   * (MID が確定済み local description の非ゼロ m-line にない = offer から外れる)
+   * @param negotiatedMids 確定済み local description の非ゼロ port の MID
+   * @returns 次の自分の offer で port 0 を交渉すべき transceiver があるか
+   */
+    settleStoppingTransceivers(negotiatedMids) {
+        for (const t of this.transceivers) {
+            if (!t.stopping || t.stopped) {
+                continue;
+            }
+            if (t.mid == undefined || !negotiatedMids.has(t.mid)) {
+                t.commitStopped({ rejected: false });
+            }
+        }
+        return this.transceivers.some((t) => t.stopping && !t.stopped);
+    }
+    collectStats(timestamp) {
+        const stats = [];
+        for (const transceiver of this.transceivers) {
+            if (transceiver.sender) {
+                stats.push(...transceiver.sender.collectStats(timestamp));
+            }
+            if (transceiver.receiver) {
+                stats.push(...transceiver.receiver.collectStats(timestamp));
+            }
+            const codecStats = transceiver.collectCodecStats(timestamp);
+            if (codecStats) {
+                stats.push(...codecStats);
+            }
+        }
+        return stats;
+    }
+    getStatsRootIds(selector) {
+        if (!selector) {
+            return [];
+        }
+        const rootIds = [];
+        for (const transceiver of this.transceivers) {
+            if (transceiver.sender.track === selector) {
+                rootIds.push(...transceiver.sender.getStatsRootIds());
+            }
+            if (transceiver.receiver.tracks.includes(selector)) {
+                rootIds.push(...transceiver.receiver.getStatsRootIds(selector));
+            }
+        }
+        return rootIds;
+    }
+    /**
+   * 全トランシーバーのreceiver/senderのstopを呼ぶcloseメソッド
+   */
+    close() {
+        for (const transceiver of this.transceivers) {
+            transceiver.forceStop();
+            this.unwatchTransceiver(transceiver);
+        }
+        this.onTransceiverAdded.allUnsubscribe();
+        this.onRemoteTransceiverAdded.allUnsubscribe();
+        this.onTrack.allUnsubscribe();
+        this.onNegotiationNeeded.allUnsubscribe();
+    }
+}