werift 0.24.3 → 0.25.0-alpha.0

package/lib/webrtc/src/transceiverManager.js

@@ -5,10 +5,23 @@ const const_1 = require("./const");
 const errors_1 = require("./errors");
 const common_1 = require("./imports/common");
 const media_1 = require("./media");
-const peerConnection_1 = require("./peerConnection");
+const codecCompatibility_1 = require("./media/codecCompatibility");
+const track_1 = require("./media/track");
 const sdp_1 = require("./sdp");
 const utils_1 = require("./utils");
 const log = (0, common_1.debug)("werift:packages/webrtc/src/media/rtpTransceiverManager.ts");
+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" }));
+}
 class TransceiverManager {
     constructor(cname, config, router) {
         Object.defineProperty(this, "cname", {
@@ -35,6 +48,18 @@ class TransceiverManager {
             writable: true,
             value: []
         });
+        Object.defineProperty(this, "watched", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new WeakSet()
+        });
+        Object.defineProperty(this, "remoteOfferSnapshot", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "onTransceiverAdded", {
             enumerable: true,
             configurable: true,
@@ -73,33 +98,121 @@ class TransceiverManager {
         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;
     }
-    addTransceiver(trackOrKind, dtlsTransport, options = {}) {
+    /**m-line から外れた transceiver の購読を解除する */
+    unwatchTransceiver(t) {
+        this.watched.delete(t);
+        t.onRelease.allUnsubscribe();
+        t.onStopRequested.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();
+            }
+        });
+    }
+    /**
+     * 拒否 / 停止の交渉が確定した 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";
-        const sender = new media_1.RTCRtpSender(trackOrKind);
+        if (typeof trackOrKind !== "string") {
+            (0, track_1.captureTrackSourceCodecs)(trackOrKind);
+            (0, codecCompatibility_1.assertCodecsSupported)({
+                kind,
+                configured: this.filterCodecsByDirection(kind, direction),
+                source: (0, track_1.getTrackSourceCodecs)(trackOrKind),
+                preferences: undefined,
+            });
+        }
+        const sender = new media_1.RTCRtpSender(trackOrKind, {
+            pendingRtp: this.config.pendingRtp,
+        });
         const receiver = new media_1.RTCRtpReceiver(this.config, kind, sender.ssrc);
         const newTransceiver = new media_1.RTCRtpTransceiver(kind, dtlsTransport, receiver, sender, direction);
-        newTransceiver.options = options;
+        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);
-        // reuse inactive
-        const inactiveTransceiverIndex = this.transceivers.findIndex((t) => t.currentDirection === "inactive" && !t.usedForSender);
-        const inactiveTransceiver = this.transceivers.find((t) => t.currentDirection === "inactive" && !t.usedForSender);
-        if (inactiveTransceiverIndex > -1 && inactiveTransceiver) {
-            this.replaceTransceiver(newTransceiver, inactiveTransceiverIndex);
-            newTransceiver.mLineIndex = inactiveTransceiver.mLineIndex;
-            newTransceiver.mid = inactiveTransceiver.mid;
-            inactiveTransceiver.setCurrentDirection(undefined);
+        // 旧 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;
     }
@@ -107,10 +220,16 @@ class TransceiverManager {
         if (this.getSenders().find((sender) => sender.track?.uuid === track.uuid)) {
             throw (0, errors_1.createWebRtcDomException)("InvalidAccessError", "Track already added");
         }
-        const emptyTrackSenderTransceiver = this.transceivers.find((t) => t.sender.track == undefined &&
+        const reusableForTrack = (t) => t.sender.track == undefined &&
             t.kind === track.kind &&
-            const_1.SenderDirections.includes(t.direction) === true);
+            !t.usedForSender &&
+            !t.stopping &&
+            !t.stopped &&
+            !t.rejected &&
+            !t.pendingRejection;
+        const emptyTrackSenderTransceiver = this.transceivers.find((t) => reusableForTrack(t) && const_1.SenderDirections.includes(t.direction));
         if (emptyTrackSenderTransceiver) {
+            this.validateTrackForTransceiver(track, emptyTrackSenderTransceiver);
             const sender = emptyTrackSenderTransceiver.sender;
             sender.setStreams(streams);
             sender.registerTrack(track);
@@ -118,13 +237,17 @@ class TransceiverManager {
                 ...emptyTrackSenderTransceiver.options,
                 streams,
             };
+            emptyTrackSenderTransceiver.codecs = [];
             return emptyTrackSenderTransceiver;
         }
-        const notSendTransceiver = this.transceivers.find((t) => t.sender.track == undefined &&
-            t.kind === track.kind &&
-            const_1.SenderDirections.includes(t.direction) === false &&
-            !t.usedForSender);
+        const notSendTransceiver = this.transceivers.find((t) => reusableForTrack(t) && !const_1.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);
@@ -140,6 +263,7 @@ class TransceiverManager {
                     notSendTransceiver.setDirection("sendonly");
                     break;
             }
+            notSendTransceiver.codecs = [];
             return notSendTransceiver;
         }
         else {
@@ -150,6 +274,10 @@ class TransceiverManager {
             return transceiver;
         }
     }
+    /**
+     * sender から track を外す。
+     * @returns 交渉が必要な変更をした場合 true (呼び出し側が negotiationneeded を要求する)
+     */
     removeTrack(sender) {
         if (!this.getSenders().find(({ ssrc }) => sender.ssrc === ssrc)) {
             throw (0, errors_1.createWebRtcDomException)("InvalidAccessError", "Sender does not exist");
@@ -158,36 +286,46 @@ class TransceiverManager {
         if (!transceiver)
             throw new Error("No matching transceiver found");
         if (transceiver.stopping || transceiver.stopped) {
-            return;
+            return false;
         }
-        sender.stop();
-        if (["recvonly", "inactive"].includes(transceiver.currentDirection ?? "")) {
-            this.onNegotiationNeeded.execute();
-            return;
+        if (sender.track == undefined) {
+            return false;
         }
+        // sender 自体は止めず track だけ外し、同じ sender で送信を再開できるようにする
+        sender.detachTrack();
         if (transceiver.direction === "sendrecv") {
             transceiver.setDirection("recvonly");
         }
-        else if (transceiver.direction === "sendonly" ||
-            transceiver.direction === "recvonly") {
+        else if (transceiver.direction === "sendonly") {
             transceiver.setDirection("inactive");
         }
+        return true;
     }
     assignTransceiverCodecs(transceiver) {
-        const codecs = this.config.codecs[transceiver.kind].filter((codecCandidate) => {
+        const configured = this.filterCodecsByDirection(transceiver.kind, transceiver.direction);
+        transceiver.codecs = (0, codecCompatibility_1.assertCodecsSupported)({
+            kind: transceiver.kind,
+            configured,
+            source: (0, track_1.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 (const_1.ReceiverDirection.includes(transceiver.direction))
+                    if (const_1.ReceiverDirection.includes(direction))
                         return true;
                     return false;
                 }
                 case "sendonly": {
-                    if (const_1.SenderDirections.includes(transceiver.direction))
+                    if (const_1.SenderDirections.includes(direction))
                         return true;
                     return false;
                 }
                 case "sendrecv": {
-                    if ([media_1.Sendrecv, media_1.Recvonly, media_1.Sendonly].includes(transceiver.direction))
+                    if ([media_1.Sendrecv, media_1.Recvonly, media_1.Sendonly].includes(direction))
                         return true;
                     return false;
                 }
@@ -198,7 +336,15 @@ class TransceiverManager {
                     return false;
             }
         });
-        transceiver.codecs = codecs;
+    }
+    validateTrackForTransceiver(track, transceiver, direction = transceiver.direction) {
+        (0, track_1.captureTrackSourceCodecs)(track);
+        (0, codecCompatibility_1.assertCodecsSupported)({
+            kind: track.kind,
+            configured: this.filterCodecsByDirection(track.kind, direction),
+            source: (0, track_1.getTrackSourceCodecs)(track),
+            preferences: transceiver.codecPreferences,
+        });
     }
     getLocalRtpParams(transceiver) {
         if (transceiver.mid == undefined)
@@ -235,33 +381,212 @@ class TransceiverManager {
         };
         return receiveParameters;
     }
-    setRemoteRTP(transceiver, remoteMedia, type, mLineIndex) {
-        if (!transceiver.mid) {
-            transceiver.mid = remoteMedia.rtp.muxId ?? null;
+    /**
+     * 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, remoteMedia.ssrc[0]?.ssrc);
+            this.router.registerRtpReceiverBySsrc(transceiver, remoteParams);
         }
-        transceiver.mLineIndex = mLineIndex;
+    }
+    /**
+     * remote offer と local (source constraint + preferences) から
+     * answer 用の codec だけを再解決する (sender/receiver の同期なし)。
+     * setRemoteRTP() の交渉部分として使う。
+     */
+    resolveRemoteCodecSet(localCodecs, remoteMedia, order, source) {
         // # negotiate codecs
-        transceiver.codecs = remoteMedia.rtp.codecs.filter((remoteCodec) => {
-            const localCodecs = this.config.codecs[remoteMedia.kind] || [];
-            const existCodec = (0, peerConnection_1.findCodecByMimeType)(localCodecs, remoteCodec);
-            if (!existCodec) {
-                return false;
+        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) => (0, codecCompatibility_1.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] : [];
             }
-            if (existCodec?.name.toLowerCase() === "rtx") {
-                const params = (0, sdp_1.codecParametersFromString)(existCodec.parameters ?? "");
-                const pt = params["apt"];
-                const origin = remoteMedia.rtp.codecs.find((c) => c.payloadType === pt);
-                if (!origin) {
+            const localApt = (0, sdp_1.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 !!(0, peerConnection_1.findCodecByMimeType)(localCodecs, origin);
-            }
-            return true;
+                return ((0, sdp_1.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 (0, errors_1.createWebRtcDomException)("NotSupportedError", "No compatible codec remains after remote negotiation.");
+        }
+        return negotiated;
+    }
+    refreshAnswerCodecs(transceiver, remoteMedia) {
+        const configured = this.config.codecs[remoteMedia.kind] || [];
+        const source = (0, track_1.getTrackSourceCodecs)(transceiver.sender.track);
+        (0, codecCompatibility_1.assertCodecsSupported)({
+            kind: remoteMedia.kind,
+            configured,
+            source,
+            preferences: transceiver.codecPreferences,
         });
+        const localCodecs = (0, codecCompatibility_1.resolveCodecs)(configured, source, transceiver.codecPreferences);
+        transceiver.codecs = this.resolveRemoteCodecSet(localCodecs, remoteMedia, "local", source);
+        transceiver.codecPreferencesNeedResolution = false;
         log("negotiated codecs", transceiver.codecs);
-        if (transceiver.codecs.length === 0) {
-            throw new Error("negotiate codecs failed.");
+    }
+    /**
+     * 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 = (0, track_1.getTrackSourceCodecs)(transceiver?.sender.track);
+            const configured = this.config.codecs[remoteMedia.kind] || [];
+            const localCodecs = isOffer
+                ? configured
+                : transceiver?.pendingLocalOfferCodecs || [];
+            if (!(0, codecCompatibility_1.hasCommonPrimaryMimeType)(localCodecs, remoteMedia.rtp.codecs)) {
+                plan.set(index, []);
+                continue;
+            }
+            if (isOffer) {
+                (0, codecCompatibility_1.assertCodecsSupported)({
+                    kind: remoteMedia.kind,
+                    configured,
+                    source,
+                    preferences: transceiver?.codecPreferences,
+                });
+            }
+            const negotiated = this.resolveRemoteCodecSet(isOffer
+                ? (0, codecCompatibility_1.resolveCodecs)(configured, source, transceiver?.codecPreferences)
+                : localCodecs, remoteMedia, isOffer ? "local" : "remote", source);
+            if (source != undefined) {
+                (0, codecCompatibility_1.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
@@ -281,12 +606,12 @@ class TransceiverManager {
             for (const param of remoteMedia.simulcastParameters) {
                 this.router.registerRtpReceiverByRid(transceiver, param, remotePrams);
             }
-            transceiver.receiver.prepareReceive(remotePrams);
+            // codec map / RTX / TWCC を negotiated codec に合わせて再構築する
+            transceiver.receiver.resyncCodecs(remotePrams, remoteMedia.ssrc[0]?.ssrc);
             // register ssrc receiver
             this.router.registerRtpReceiverBySsrc(transceiver, remotePrams);
         }
-        if (remoteMedia.port !== 0 &&
-            ["sendonly", "sendrecv"].includes(mediaDirection)) {
+        if (["sendonly", "sendrecv"].includes(mediaDirection)) {
             const remoteStreamIds = [
                 ...new Set(remoteMedia.msids.map((msid) => msid.split(" ")[0])),
             ];
@@ -294,18 +619,107 @@ class TransceiverManager {
             transceiver.receiver.remoteStreamId = remoteStreamIds[0];
             transceiver.receiver.remoteStreamIds = remoteStreamIds;
             transceiver.receiver.remoteTrackId = remoteTrackId;
-            this.onTrack.execute({
-                track: transceiver.receiver.track,
-                transceiver,
-                streams: remoteStreamIds.map((id) => new media_1.MediaStream({
-                    id,
-                    tracks: [transceiver.receiver.track],
-                })),
-            });
+            // re-offer / re-answer で同じ受信を重複通知しない
+            if (!transceiver.firedReceiving) {
+                transceiver.firedReceiving = true;
+                this.onTrack.execute({
+                    track: transceiver.receiver.track,
+                    transceiver,
+                    streams: remoteStreamIds.map((id) => new media_1.MediaStream({
+                        id,
+                        tracks: [transceiver.receiver.track],
+                    })),
+                });
+            }
+        }
+        else {
+            transceiver.firedReceiving = false;
+        }
+        return true;
+    }
+    /**
+     * 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);
         }
-        if (remoteMedia.ssrc[0]?.ssrc) {
-            transceiver.receiver.setupTWCC(remoteMedia.ssrc[0].ssrc);
+        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 = [];
@@ -344,6 +758,7 @@ class TransceiverManager {
     close() {
         for (const transceiver of this.transceivers) {
             transceiver.forceStop();
+            this.unwatchTransceiver(transceiver);
         }
         this.onTransceiverAdded.allUnsubscribe();
         this.onRemoteTransceiverAdded.allUnsubscribe();