MENU

問い合わせ

    お問い合わせ


    【NuxtとWebRTCで作るビデオチャット 第11回】少人数通話へ:メッシュ実装と SFU という選択肢

    (2026年10月29日 追記:記事どおりに再現できるよう、必要なコードと手順を追加しました)

    前回の第10回:切断・再接続とエラーハンドリングで、サーバーの再起動や経路の切断から自動で戻る仕組みを作りました。連載の最終回となる今回は、1対1の通話を 3〜4人の少人数通話 に広げます。あわせて、人数が増えたときに検討する SFU という選択肢と、この連載のサンプルを本番で使うまでに残っている作業を整理します。

    「1対1で動いたなら、人数の上限を増やせば10人でも使えるんじゃないの?」

    結論から言うと、今回のメッシュ構成は4人程度までが現実的です。メッシュは参加者全員と個別につながる方式で、追加のサーバーが要らない代わりに、人数が増えるほど各端末が送る映像の本数と通信量が増えていきます。実際に測ると、送信量は「人数−1」に比例して増えました。それ以上の人数や、サーバー側での録画・配信が必要なら、SFU(映像を中継するサーバー)を前提に設計と見積もりを見直すことになります。

    目次

    今回作るもの:最大4人のメッシュ通話

    • ルームの定員を2名から4名にする
    • 参加者ごとに RTCPeerConnection を持ち、全員とつながる(メッシュ構成)
    • 参加者の映像をグリッド(格子状)に並べ、各枠に名前と接続状態を表示する
    • チャット・ミュート表示・画面共有を全員向けに対応させる。録画は2人で通話中のときだけにする

    追加・変更するファイル

    ファイル役割
    app/composables/usePeerConnection.ts1対1用の処理を、相手1人分の接続を作る createPeerLink() に作り替え
    app/composables/useMeshRoom.ts参加者ごとの接続の管理(新規)
    app/components/VideoGrid.vue映像のグリッド表示(新規)
    shared/types/signaling.ts / server/routes/_ws.ts / server/utils/signaling.tsoffer/answer・ICE 候補に宛先(to)を追加し、宛先の1人にだけ送る
    server/utils/rooms.ts定員を4名に
    app/composables/useDataChannel.ts ほかチャット・状態表示・ルームページを複数の相手に対応
    app/components/ChatPanel.vue / ConnectionStatus.vue / RecordButton.vue、app/composables/useRemoteMediaState.ts、app/pages/room/[id].vue、app/pages/index.vue同上(送信者名・全体の接続状態・録画の条件の表示、定員の文言)

    仕組み:メッシュ・SFU・MCU の違い

    複数人のビデオ通話には、大きく3つの構成があります。

    構成仕組み各端末の送信サーバー向いている場面
    メッシュ全員が全員と直接つながる人数−1本シグナリング(と TURN)だけ少人数。追加のサーバーを置きたくない
    SFU各端末は1本送り、サーバーが他の参加者へ転送する1本(品質違いを複数送る方式もある)映像を中継するサーバーが必要多人数、サーバー録画、配信
    MCUサーバーが全員の映像を合成して1本にして配る1本映像の合成を行う高性能なサーバーが必要受信側の端末の負荷を下げたい場合など

    メッシュでは、4人なら1人あたり3本の接続を持ち、映像・音声を3本送って3本受け取ります。ルーム全体の接続数は「人数×(人数−1)÷2」で、4人なら6本、6人なら15本と、人数の2乗に近い形で増えます。送信は端末の上り回線とCPU(映像の圧縮)を使うため、スマホや上りの細い回線から先に苦しくなります。

    実装1:シグナリングに「宛先」を付ける

    1対1では、offer/answer と ICE 候補をルームの「自分以外」に送れば、相手に届いていました。3人以上では、Aさんが Bさん向けに作った offer が Cさんにも届いてしまうため、宛先(to)を付けてサーバーがその1人にだけ送るようにします。

    shared/types/signaling.ts に次の変更を加えます(+ が追加、- が削除)。

    --- a/shared/types/signaling.ts
    +++ b/shared/types/signaling.ts
    @@ -31,9 +31,10 @@ export type MediaState = {
     export type ClientMessage =
       | { type: 'join'; roomId: string }
       | { type: 'leave' }
    -  | { type: 'description'; description: SessionDescription }
    -  | { type: 'ice-candidate'; candidate: IceCandidate | null }
    -  | { type: 'media-state'; state: MediaState } // 第5回
    +  // 第11回: 3人以上では「誰宛てか」が必要なので to(宛先のピアID)を追加。サーバーは宛先にだけ送る
    +  | { type: 'description'; to: PeerId; description: SessionDescription }
    +  | { type: 'ice-candidate'; to: PeerId; candidate: IceCandidate | null }
    +  | { type: 'media-state'; state: MediaState } // 第5回(ルーム全員に送る)
     
     /** サーバー → ブラウザ */
     export type ServerMessage =
    @@ -49,6 +50,7 @@ export type SignalingErrorCode =
       | 'invalid-message' // 形式が正しくない
       | 'not-joined' // ルームに参加する前に通話用のメッセージを送った
       | 'room-full' // 第4回: ルームが定員に達している
    +  | 'unknown-peer' // 第11回: 宛先のピアが同じルームにいない
     
     /** ルームIDとして受け付ける文字列(英数字・ハイフン・アンダースコア、1〜64文字) */
     export const ROOM_ID_PATTERN = /^[\w-]{1,64}$/

    server/routes/_ws.ts に次の変更を加えます(+ が追加、- が削除)。

    --- a/server/routes/_ws.ts
    +++ b/server/routes/_ws.ts
    @@ -1,6 +1,7 @@
     // 第2回: シグナリングサーバー(Nitro v2 の WebSocket。nuxt.config.ts で experimental.websocket を有効化済み)
     // https://v2.nitro.build/guide/websocket
     // ルームごとに pub/sub の topic を作り、同じルームの「自分以外」へメッセージを中継する。
    +// 第11回: offer/answer・ICE 候補は宛先(to)の1人にだけ送る(3人以上のメッシュ構成のため)
     import type { ServerMessage } from '#shared/types/signaling'
     
     type SignalingPeer = {
    @@ -11,6 +12,9 @@ type SignalingPeer = {
       unsubscribe: (topic: string) => unknown
     }
     
    +/** 第11回: 宛先指定で送るため、接続中のピアを ID で引けるようにしておく */
    +const connectedPeers = new Map<string, SignalingPeer>()
    +
     /** 本人にだけ送る */
     function sendTo(peer: SignalingPeer, message: ServerMessage) {
       peer.send(JSON.stringify(message))
    @@ -31,6 +35,7 @@ function leave(peer: SignalingPeer) {
     
     export default defineWebSocketHandler({
       open(peer) {
    +    connectedPeers.set(peer.id, peer)
         // 接続しただけではどのルームにも入らない。join メッセージを待つ
         if (import.meta.dev) console.log('[ws] open', peer.id)
       },
    @@ -68,7 +73,18 @@ export default defineWebSocketHandler({
               return
             }
             // 送信者は from としてサーバーが付け直す(ブラウザが名乗った送信者は信用しない)
    -        broadcast(peer, roomId, { ...msg, from: peer.id })
    +        if (msg.type === 'media-state') {
    +          broadcast(peer, roomId, { ...msg, from: peer.id })
    +          return
    +        }
    +        // 第11回: 宛先が同じルームにいる場合だけ、その1人に送る(別のルームの人には送らせない)
    +        const target = connectedPeers.get(msg.to)
    +        if (!target || getRoomOf(msg.to) !== roomId) {
    +          sendTo(peer, { type: 'error', code: 'unknown-peer', message: '宛先の参加者が見つかりません' })
    +          return
    +        }
    +        if (msg.type === 'description') sendTo(target, { type: 'description', from: peer.id, description: msg.description })
    +        else sendTo(target, { type: 'ice-candidate', from: peer.id, candidate: msg.candidate })
             return
           }
         }
    @@ -77,6 +93,7 @@ export default defineWebSocketHandler({
       close(peer) {
         // タブを閉じた・回線が切れた場合も、ルームから外して相手に知らせる
         leave(peer)
    +    connectedPeers.delete(peer.id)
         if (import.meta.dev) console.log('[ws] close', peer.id)
       },
     

    接続中のピアを ID で引けるよう、open で Map に登録し、close で削除しています。宛先が同じルームにいるかを必ず確認するのがポイントです。確認しないと、ほかのルームの参加者の ID を知っている人が、そのルームに offer を送り込めてしまいます。定員は server/utils/rooms.ts の ROOM_CAPACITY を 4 にするだけです。

    届いたメッセージの検証(server/utils/signaling.ts)にも、宛先 to のチェックを足します。

    server/utils/signaling.ts に次の変更を加えます(+ が追加、- が削除)。

    --- a/server/utils/signaling.ts
    +++ b/server/utils/signaling.ts
    @@ -23,6 +23,11 @@ function isCandidate(v: unknown): v is IceCandidate | null {
       return isRecord(v) && (v.candidate === undefined || typeof v.candidate === 'string')
     }
     
    +/** 第11回: ピアID(サーバーが発行した ID。長さだけ確認し、実在するかは _ws.ts で確認する) */
    +function isPeerId(v: unknown): v is string {
    +  return typeof v === 'string' && v.length > 0 && v.length <= 64
    +}
    +
     function isMediaState(v: unknown): v is MediaState {
       return isRecord(v) && typeof v.audio === 'boolean' && typeof v.video === 'boolean' && typeof v.screen === 'boolean'
         && typeof v.recording === 'boolean'
    @@ -46,10 +51,15 @@ export function parseClientMessage(text: string): ClientMessage | null {
             : null
         case 'leave':
           return { type: 'leave' }
    +    // 第11回: 宛先(to)が必須
         case 'description':
    -      return isDescription(data.description) ? { type: 'description', description: data.description } : null
    +      return isPeerId(data.to) && isDescription(data.description)
    +        ? { type: 'description', to: data.to, description: data.description }
    +        : null
         case 'ice-candidate':
    -      return isCandidate(data.candidate) ? { type: 'ice-candidate', candidate: data.candidate } : null
    +      return isPeerId(data.to) && isCandidate(data.candidate)
    +        ? { type: 'ice-candidate', to: data.to, candidate: data.candidate }
    +        : null
         case 'media-state':
           // 第5回: 余計なプロパティは捨て、audio / video / screen(第7回)/ recording(第9回)だけを中継する
           return isMediaState(data.state)

    server/utils/rooms.ts に次の変更を加えます(+ が追加、- が削除)。

    --- a/server/utils/rooms.ts
    +++ b/server/utils/rooms.ts
    @@ -1,11 +1,15 @@
     // 第2回: どのピアがどのルームにいるかを覚えておく(サーバーのメモリ上。再起動で消える)
     // 第4回: 定員チェックを追加(1対1通話なので2名)
    +// 第11回: メッシュ構成の少人数通話にするため、定員を4名に
     
     const rooms = new Map<string, Set<string>>() // roomId -> peerId の集合
     const peerRooms = new Map<string, string>() // peerId -> roomId
     
    -/** 1ルームの定員。第11回(メッシュで少人数通話)で 4 に増やす */
    -export const ROOM_CAPACITY = 2
    +/**
    + * 1ルームの定員。第11回でメッシュ構成にして 4 に増やした。
    + * メッシュは参加者全員と個別につながるため、人数を増やすほど各端末の負荷と通信量が増える
    + */
    +export const ROOM_CAPACITY = 4
     
     /**
      * ルームに参加する。成功したら先にいたピアの一覧を、定員オーバーなら null を返す。

    実装2:相手1人分の接続を createPeerLink に切り出す

    第3回から育ててきた usePeerConnection は、「相手は1人」という前提で、接続を1つだけ持っていました。中身(Perfect negotiation、ICE restart、DataChannel、映像の差し替え)はそのままに、相手1人分の接続を作る関数 createPeerLink() に作り替えます。

    app/composables/usePeerConnection.ts(抜粋)

    export function createPeerLink(peerId: PeerId, polite: boolean, options: PeerLinkOptions) {
      const { send, getLocalStream, getRtcConfig, getVideoOverride } = options
      const remoteStream = shallowRef<MediaStream | null>(null)
      const connectionState = ref<RTCPeerConnectionState>('new')
      const routeType = ref<RTCIceCandidateType | null>(null)
      const chatChannel = shallowRef<RTCDataChannel | null>(null)
    
      const pc = new RTCPeerConnection(getRtcConfig())
    
      function sendDescription(description: RTCSessionDescription | null) {
        if (description) send({ type: 'description', to: peerId, description: description.toJSON() })
      }
      // …(addLocalTracks、negotiationneeded、icecandidate、ICE restart、handleSignal は第3〜10回と同じ。
      //    送信時に to: peerId を付けるところだけが変わった)
    
      return { peerId, remoteStream, connectionState, routeType, chatChannel, handleSignal, replaceVideoTrack, close }
    }

    作り替えで大部分が変わるため、app/composables/usePeerConnection.ts は差分ではなく全文を示します。ファイルの中身を次の内容に置き換えてください(ファイル名は第3回からのつながりが分かるよう、そのままにしています)。

    app/composables/usePeerConnection.ts の全文(184行)
    // app/composables/usePeerConnection.ts
    // 第3回: RTCPeerConnection による通話(Perfect negotiation パターン)
    // https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API/Perfect_negotiation
    // 第11回: 1対1専用の usePeerConnection を、「相手1人分の接続」を作る createPeerLink に作り替えた。
    // メッシュ構成では相手ごとに1つずつ作る(管理は useMeshRoom)。中身の考え方は第3〜10回のまま。
    import type { ClientMessage, PeerId, ServerMessage } from '#shared/types/signaling'
    
    export type PeerLinkOptions = {
      /** シグナリングで送る(第11回: 宛先 to は createPeerLink が付ける) */
      send: (msg: ClientMessage) => void
      getLocalStream: () => MediaStream | null
      // 第6回: STUN/TURN の設定。接続を作るたびに呼ぶ(TURN の認証情報は時間制限付きのため、固定値にしない)
      getRtcConfig: () => RTCConfiguration
      /** 第7回: カメラの代わりに送る映像(画面共有中の画面のトラック)。null ならカメラを送る */
      getVideoOverride: () => MediaStreamTrack | null
    }
    
    export type PeerLink = ReturnType<typeof createPeerLink>
    
    /**
     * 相手1人との接続を作る。polite は「offer が衝突したら自分が譲る側」かどうか(後から入った側が polite)
     */
    export function createPeerLink(peerId: PeerId, polite: boolean, options: PeerLinkOptions) {
      const { send, getLocalStream, getRtcConfig, getVideoOverride } = options
      const remoteStream = shallowRef<MediaStream | null>(null)
      const connectionState = ref<RTCPeerConnectionState>('new')
      /** 第6回: 実際に使われている経路の種類(host=直接 / srflx=STUNで分かったアドレス / relay=TURN中継 など) */
      const routeType = ref<RTCIceCandidateType | null>(null)
      /** 第8回: テキストチャット用の DataChannel */
      const chatChannel = shallowRef<RTCDataChannel | null>(null)
    
      const pc = new RTCPeerConnection(getRtcConfig())
      let closed = false
      // Perfect negotiation 用の状態
      let makingOffer = false
      let ignoreOffer = false
      let isSettingRemoteAnswerPending = false
      let localTracksAdded = false
      /** 第10回: 先にいた側(impolite)が ICE restart を代わりに行うまでの待ち時間用タイマー */
      let restartTimer: ReturnType<typeof setTimeout> | undefined
    
      function sendDescription(description: RTCSessionDescription | null) {
        if (description) send({ type: 'description', to: peerId, description: description.toJSON() })
      }
    
      /** 自分のカメラ・マイクのトラックを載せる。stable な状態で載せると negotiationneeded が発生する */
      function addLocalTracks() {
        if (localTracksAdded) return
        localTracksAdded = true
        const localStream = getLocalStream()
        const override = getVideoOverride()
        localStream?.getTracks().forEach((track) => {
          // 画面共有中に相手が入ってきた場合は、最初から画面を送る
          const sending = track.kind === 'video' && override ? override : track
          pc.addTrack(sending, localStream)
        })
        // 第8回: チャット用の DataChannel もここで作る(トラックと同じタイミングにして offer を1回にまとめる)
        chatChannel.value = pc.createDataChannel('chat', { negotiated: true, id: 0 })
      }
    
      // 第4回: 最初の offer は「後から入った側(polite)」だけが作る。先にいた側は offer を受け取ってから載せる
      if (polite) addLocalTracks()
    
      pc.addEventListener('negotiationneeded', async () => {
        try {
          makingOffer = true
          await pc.setLocalDescription() // 引数なし=状況に応じて offer か answer を自動生成
          sendDescription(pc.localDescription)
        }
        catch (e) {
          console.error('[peer] negotiationneeded', e)
        }
        finally {
          makingOffer = false
        }
      })
    
      pc.addEventListener('icecandidate', ({ candidate }) => {
        // candidate が null なのは「候補の収集が終わった」合図。相手に送る必要はない
        if (candidate) send({ type: 'ice-candidate', to: peerId, candidate: candidate.toJSON() })
      })
    
      pc.addEventListener('track', ({ streams }) => {
        if (streams[0]) remoteStream.value = streams[0]
      })
    
      // 第10回: failed になったら ICE restart。まず polite 側が行い、impolite 側は5秒後もまだ failed なら行う。
      // 検証した Chromium では connectionState だけが failed になることがあったため、両方を見る
      const isFailed = () => pc.iceConnectionState === 'failed' || pc.connectionState === 'failed'
      function restartIfFailed() {
        clearTimeout(restartTimer)
        if (closed || !isFailed()) return
        if (polite) pc.restartIce()
        else restartTimer = setTimeout(() => {
          if (!closed && isFailed()) pc.restartIce()
        }, 5000)
      }
      pc.addEventListener('iceconnectionstatechange', restartIfFailed)
    
      pc.addEventListener('connectionstatechange', () => {
        connectionState.value = pc.connectionState
        if (pc.connectionState === 'connected') void updateRouteType()
        restartIfFailed()
      })
    
      /** 第6回: getStats() で、選ばれた経路(候補ペア)の自分側の候補の種類を調べる */
      async function updateRouteType() {
        const stats = await pc.getStats()
        let pair: RTCIceCandidatePairStats | undefined
        stats.forEach((report) => {
          // 標準は transport の selectedCandidatePairId。Firefox 向けに candidate-pair の selected も見る
          if (report.type === 'transport' && report.selectedCandidatePairId) pair = stats.get(report.selectedCandidatePairId)
          if (!pair && report.type === 'candidate-pair' && report.selected) pair = report
        })
        const local = pair ? stats.get(pair.localCandidateId) : undefined
        routeType.value = local?.candidateType ?? null
      }
    
      /** この相手から届いた offer/answer・ICE 候補を処理する */
      async function handleSignal(msg: Extract<ServerMessage, { type: 'description' | 'ice-candidate' }>) {
        if (closed) return
        try {
          if (msg.type === 'description') {
            const description = msg.description
            // 自分も offer を作っている最中なら「衝突」
            const readyForOffer = !makingOffer && (pc.signalingState === 'stable' || isSettingRemoteAnswerPending)
            const offerCollision = description.type === 'offer' && !readyForOffer
            // 衝突したら impolite 側は相手の offer を無視し、polite 側は自分の offer を取り下げて相手に合わせる
            ignoreOffer = !polite && offerCollision
            if (ignoreOffer) return
    
            isSettingRemoteAnswerPending = description.type === 'answer'
            await pc.setRemoteDescription(description) // polite 側の取り下げ(rollback)はブラウザが自動で行う
            isSettingRemoteAnswerPending = false
            if (description.type === 'offer') {
              // 相手の offer を受け入れた後に載せると、offer の音声・映像の枠がそのまま使われ、answer に含まれる
              addLocalTracks()
              await pc.setLocalDescription()
              sendDescription(pc.localDescription)
            }
          }
          else if (msg.candidate) {
            try {
              await pc.addIceCandidate(msg.candidate)
            }
            catch (e) {
              // 無視した offer に対応する候補の追加は失敗してよい
              if (!ignoreOffer) throw e
            }
          }
        }
        catch (e) {
          console.error('[peer] signal', e)
        }
      }
    
      /**
       * 第7回: 送信中の映像を差し替える(画面共有の開始・終了)。再交渉なしで入れ替えられる。
       * track に null を渡すとカメラに戻す。
       */
      async function replaceVideoTrack(track: MediaStreamTrack | null) {
        if (closed || !localTracksAdded) return // まだ載せていなければ addLocalTracks で載る
        const next = track ?? getLocalStream()?.getVideoTracks()[0] ?? null
        // 映像用の送信口(sender)を、受信側のトラックの種類で探す(送信を止めている間も見つけられる)
        const sender = pc.getTransceivers().find(t => t.receiver.track.kind === 'video')?.sender
        if (!sender) return
        try {
          await sender.replaceTrack(next)
        }
        catch (e) {
          console.error('[peer] replaceTrack', e)
        }
      }
    
      function close() {
        closed = true
        clearTimeout(restartTimer)
        pc.close() // DataChannel も一緒に閉じる
        remoteStream.value = null
        connectionState.value = 'closed'
        chatChannel.value = null
      }
    
      return { peerId, remoteStream, connectionState, routeType, chatChannel, handleSignal, replaceVideoTrack, close }
    }

    実装3:useMeshRoom で全員とつながる

    useMeshRoom は、参加者ごとの接続(PeerLink)を一覧で持ち、シグナリングのメッセージを該当する接続に振り分けます。

    app/composables/useMeshRoom.ts(抜粋。全文はこの節の最後に載せます)

      signaling.onMessage((msg) => {
        switch (msg.type) {
          case 'joined':
            // 入室(再接続で入り直した場合も含む)。以前の接続は捨てて、先にいた全員とつなぐ。
            // 後から入った自分は全員に対して polite(自分から offer を送る側)
            closeAll()
            msg.peers.forEach(peerId => add(peerId, true))
            break
          case 'peer-joined':
            // 後から入ってきた人とは、先にいた自分が impolite(相手の offer を待つ側)
            add(msg.peerId, false)
            break
          case 'peer-left':
            remove(msg.peerId)
            break
          case 'description':
          case 'ice-candidate': {
            // 念のため、peer-joined より先に届いた場合も接続を用意する
            const link = find(msg.from) ?? add(msg.from, false)
            void link.handleSignal(msg)
            break
          }
        }
      })
    
      /** 第7回: 送る映像を全員分まとめて差し替える(画面共有の開始・終了) */
      async function replaceVideoTrack(track: MediaStreamTrack | null) {
        videoOverride = track
        await Promise.all(links.value.map(link => link.replaceVideoTrack(track)))
      }

    第4回で決めた「後から入った側が offer を送る」ルールを、そのまま人数分に広げています。新しく入った人は、先にいた全員に offer を送り、先にいた人たちはそれを待って応じます。これで、どの2人の組み合わせでも offer が衝突しにくくなります。

    app/composables/useMeshRoom.ts を新しく作ります。全文は次のとおりです。

    app/composables/useMeshRoom.ts の全文(83行)
    // app/composables/useMeshRoom.ts
    // 第11回: メッシュ構成の少人数通話。ルームの参加者全員と、1人ずつ RTCPeerConnection でつながる
    // 4人なら、自分から見て3本の接続を持ち、映像・音声を3本送って3本受け取る。
    import type { ClientMessage, PeerId, ServerMessage } from '#shared/types/signaling'
    import type { PeerLink } from './usePeerConnection'
    
    type SignalingChannel = {
      send: (msg: ClientMessage) => void
      onMessage: (listener: (msg: ServerMessage) => void) => unknown
    }
    
    export function useMeshRoom(
      signaling: SignalingChannel,
      getLocalStream: () => MediaStream | null,
      getRtcConfig: () => RTCConfiguration = () => ({}),
    ) {
      /** 相手ごとの接続(入室した順) */
      const links = shallowRef<PeerLink[]>([])
      /** 第7回: 画面共有中は、全員にカメラの代わりに画面を送る */
      let videoOverride: MediaStreamTrack | null = null
    
      function find(peerId: PeerId) {
        return links.value.find(link => link.peerId === peerId)
      }
    
      function add(peerId: PeerId, polite: boolean) {
        remove(peerId)
        const link = createPeerLink(peerId, polite, {
          send: signaling.send,
          getLocalStream,
          getRtcConfig,
          getVideoOverride: () => videoOverride,
        })
        links.value = [...links.value, link]
        return link
      }
    
      function remove(peerId: PeerId) {
        const link = find(peerId)
        if (!link) return
        link.close()
        links.value = links.value.filter(l => l !== link)
      }
    
      function closeAll() {
        links.value.forEach(link => link.close())
        links.value = []
      }
    
      signaling.onMessage((msg) => {
        switch (msg.type) {
          case 'joined':
            // 入室(再接続で入り直した場合も含む)。以前の接続は捨てて、先にいた全員とつなぐ。
            // 後から入った自分は全員に対して polite(自分から offer を送る側)
            closeAll()
            msg.peers.forEach(peerId => add(peerId, true))
            break
          case 'peer-joined':
            // 後から入ってきた人とは、先にいた自分が impolite(相手の offer を待つ側)
            add(msg.peerId, false)
            break
          case 'peer-left':
            remove(msg.peerId)
            break
          case 'description':
          case 'ice-candidate': {
            // 念のため、peer-joined より先に届いた場合も接続を用意する
            const link = find(msg.from) ?? add(msg.from, false)
            void link.handleSignal(msg)
            break
          }
        }
      })
    
      /** 第7回: 送る映像を全員分まとめて差し替える(画面共有の開始・終了) */
      async function replaceVideoTrack(track: MediaStreamTrack | null) {
        videoOverride = track
        await Promise.all(links.value.map(link => link.replaceVideoTrack(track)))
      }
    
      onScopeDispose(closeAll)
    
      return { links, replaceVideoTrack, closeAll }
    }

    チャット・状態表示・録画の扱い

    • チャット:相手ごとの DataChannel をまとめて扱い、全員に同じ内容を送ります。送信者名(名前入力は省略し「参加者 1a2b」のようにピアIDの先頭4文字)を表示し、参加者の出入りがあっても履歴は残すようにしました。
    • ミュート・画面共有の表示:相手の状態を、ピアIDごとの一覧で持つように変えました。
    • 録画:3人以上の映像を1ファイルにまとめるにはブラウザ内での合成が必要で、端末の負荷がさらに増えます。録画は2人で通話中のときだけ有効にし、3人目が入ったら自動で止めて保存します。

    チャットは、相手ごとのチャネルをまとめて扱う形に変えます。

    app/composables/useDataChannel.ts に次の変更を加えます(+ が追加、- が削除)。

    --- a/app/composables/useDataChannel.ts
    +++ b/app/composables/useDataChannel.ts
    @@ -1,6 +1,8 @@
     // 第8回: DataChannel でテキストチャットを送受信する
     // https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel
     // メッセージは P2P で相手に直接届き、サーバー(Nuxt)は通らない。そのため履歴はどこにも保存されない。
    +// 第11回: メッシュ構成に合わせ、相手ごとのチャネル(複数)をまとめて扱う。送信は全員に同じ内容を送る
    +import type { PeerId } from '#shared/types/signaling'
     
     /** 1メッセージの最大文字数(絵文字1つ=1文字として数える) */
     export const MAX_CHAT_LENGTH = 500
    @@ -11,6 +13,8 @@ export type ChatMessage = {
       id: number
       /** self = 自分が送った / remote = 相手から届いた */
       from: 'self' | 'remote'
    +  /** 第11回: 表示用の送信者名(「自分」「参加者 1a2b」など) */
    +  label: string
       text: string
       /** 送信時刻(ミリ秒)。相手の時計の値なので、ずれている可能性がある */
       sentAt: number
    @@ -39,53 +43,59 @@ function parseWire(data: unknown): ChatWireMessage | null {
       }
     }
     
    -export function useDataChannel(channel: Ref<RTCDataChannel | null>) {
    +/** 第11回: 相手1人分のチャネル */
    +export type PeerChannel = { peerId: PeerId; channel: RTCDataChannel }
    +
    +export function useDataChannel(
    +  channels: Ref<PeerChannel[]>,
    +  /** 第11回: ピアIDから表示名を作る */
    +  labelOf: (peerId: PeerId) => string,
    +) {
       const messages = ref<ChatMessage[]>([])
    -  const state = ref<RTCDataChannelState | 'none'>('none')
    -  const canSend = computed(() => state.value === 'open')
    +  /** open になっているチャネルの数(1つ以上あれば送信できる) */
    +  const openCount = ref(0)
    +  const canSend = computed(() => openCount.value > 0)
       let nextId = 1
     
    -  function push(from: ChatMessage['from'], text: string, sentAt: number) {
    -    messages.value = [...messages.value, { id: nextId++, from, text, sentAt }].slice(-MAX_HISTORY)
    +  function push(from: ChatMessage['from'], label: string, text: string, sentAt: number) {
    +    messages.value = [...messages.value, { id: nextId++, from, label, text, sentAt }].slice(-MAX_HISTORY)
       }
     
    -  watch(channel, (ch, _old, onCleanup) => {
    -    if (!ch) {
    -      // 相手が退出した等。やりとりした内容は画面に残しておく
    -      state.value = 'none'
    -      return
    -    }
    -    // 新しい相手とのチャネル。前の相手とのやりとりは消す
    -    messages.value = []
    -    state.value = ch.readyState
    -
    -    const update = () => { state.value = ch.readyState }
    -    const onMessage = (event: MessageEvent) => {
    -      const msg = parseWire(event.data)
    -      if (msg) push('remote', msg.text, msg.sentAt)
    -    }
    -    ch.addEventListener('open', update)
    -    ch.addEventListener('close', update)
    -    ch.addEventListener('message', onMessage)
    -    onCleanup(() => {
    -      ch.removeEventListener('open', update)
    -      ch.removeEventListener('close', update)
    -      ch.removeEventListener('message', onMessage)
    +  // 参加者が増減してチャネルの一覧が変わるたびに、全チャネルにリスナーを付け直す。
    +  // 第11回: 参加者の入れ替わりがあるので、やりとりの履歴は消さずに残す
    +  watch(channels, (list, _old, onCleanup) => {
    +    const countOpen = () => { openCount.value = list.filter(c => c.channel.readyState === 'open').length }
    +    countOpen()
    +    const cleanups = list.map(({ peerId, channel }) => {
    +      const onMessage = (event: MessageEvent) => {
    +        const msg = parseWire(event.data)
    +        if (msg) push('remote', labelOf(peerId), msg.text, msg.sentAt)
    +      }
    +      channel.addEventListener('open', countOpen)
    +      channel.addEventListener('close', countOpen)
    +      channel.addEventListener('message', onMessage)
    +      return () => {
    +        channel.removeEventListener('open', countOpen)
    +        channel.removeEventListener('close', countOpen)
    +        channel.removeEventListener('message', onMessage)
    +      }
         })
    +    onCleanup(() => cleanups.forEach(fn => fn()))
       }, { immediate: true })
     
    -  /** 送信する。送れなかった場合は理由を返す */
    +  /** 全員に送信する。送れなかった場合は理由を返す */
       function send(input: string): string | null {
         const text = input.trim()
         if (!text) return 'メッセージを入力してください'
         if (countChars(text) > MAX_CHAT_LENGTH) return `${MAX_CHAT_LENGTH}文字以内で入力してください`
    -    const ch = channel.value
    -    if (!ch || ch.readyState !== 'open') return '相手とつながっていないため送信できません'
    +    const open = channels.value.filter(c => c.channel.readyState === 'open')
    +    if (open.length === 0) return '相手とつながっていないため送信できません'
         const wire: ChatWireMessage = { type: 'chat', text, sentAt: Date.now() }
    -    ch.send(JSON.stringify(wire))
    -    push('self', text, wire.sentAt)
    +    const data = JSON.stringify(wire)
    +    open.forEach(c => c.channel.send(data))
    +    push('self', '自分', text, wire.sentAt)
         return null
       }
     
    -  return { messages, state, canSend, send }
    +  return { messages, canSend, send }
     }

    app/components/ChatPanel.vue に次の変更を加えます(+ が追加、- が削除)。

    --- a/app/components/ChatPanel.vue
    +++ b/app/components/ChatPanel.vue
    @@ -1,6 +1,7 @@
     <script setup lang="ts">
     // 第8回: テキストチャットの表示と入力欄
     // 送受信のロジックは useDataChannel が持ち、ここでは表示と入力だけを行う。
    +// 第11回: 送信者名(label)を表示(3人以上で誰の発言か分かるように)
     import type { ChatMessage } from '~/composables/useDataChannel'
     import { countChars, MAX_CHAT_LENGTH } from '~/composables/useDataChannel'
     
    @@ -49,7 +50,7 @@ function formatTime(ms: number) {
         </h2>
         <ol ref="listEl" class="chat__list" aria-live="polite">
           <li v-for="m in messages" :key="m.id" class="chat__item" :data-from="m.from">
    -        <span class="chat__meta">{{ m.from === 'self' ? '自分' : '相手' }}・{{ formatTime(m.sentAt) }}</span>
    +        <span class="chat__meta">{{ m.label }}・{{ formatTime(m.sentAt) }}</span>
             <!-- {{ }} は HTML をエスケープして表示する。相手の入力を v-html で表示しない -->
             <p class="chat__text">{{ m.text }}</p>
           </li>

    相手の状態(ミュート・画面共有など)は、ピアIDごとに持つようにします。

    app/composables/useRemoteMediaState.ts に次の変更を加えます(+ が追加、- が削除)。

    --- a/app/composables/useRemoteMediaState.ts
    +++ b/app/composables/useRemoteMediaState.ts
    @@ -1,5 +1,6 @@
     // 第5回: 自分のマイク・カメラの状態を相手に知らせ、相手の状態を受け取る
     // 映像・音声が届いていない理由(ミュート中か、回線の問題か)を相手の画面で区別できるようにする。
    +// 第11回: 3人以上に対応するため、相手の状態をピアIDごとに持つ
     import type { ClientMessage, MediaState, PeerId, ServerMessage } from '#shared/types/signaling'
     
     type SignalingChannel = {
    @@ -10,36 +11,39 @@ type SignalingChannel = {
     export function useRemoteMediaState(
       signaling: SignalingChannel,
       localState: () => MediaState,
    -  remotePeerId: Ref<PeerId | null>,
     ) {
    -  /** 相手の状態。まだ届いていなければ null(=不明。表示は「オン」扱いにしておく) */
    -  const remoteState = ref<MediaState | null>(null)
    +  /** 相手ごとの状態。まだ届いていなければ無い(=不明。表示は「オン」扱いにしておく) */
    +  const remoteStates = ref<Record<PeerId, MediaState>>({})
     
       function sendState() {
    +    // media-state はルームの全員に届く
         signaling.send({ type: 'media-state', state: localState() })
       }
     
       signaling.onMessage((msg) => {
         switch (msg.type) {
           case 'joined':
    -        // 先にいた相手に、今の自分の状態を伝える(入室前にミュートしていた場合など)
    +        // 入室(再接続を含む)したら、前の状態は捨てる。先にいた人たちに今の自分の状態を伝える
    +        remoteStates.value = {}
             if (msg.peers.length > 0) sendState()
             break
           case 'peer-joined':
    -        // 後から来た相手にも伝える
    +        // 後から来た人にも伝える
             sendState()
             break
    +      case 'peer-left': {
    +        const { [msg.peerId]: _left, ...rest } = remoteStates.value
    +        remoteStates.value = rest
    +        break
    +      }
           case 'media-state':
    -        if (msg.from === remotePeerId.value) remoteState.value = msg.state
    +        remoteStates.value = { ...remoteStates.value, [msg.from]: msg.state }
             break
         }
       })
     
    -  // 相手が変わった・いなくなったら、前の相手の状態は捨てる
    -  watch(remotePeerId, () => { remoteState.value = null })
    -
       // 自分の状態が変わったら、その都度送る(ルームに入っていなければ send は何もしない)
       watch(localState, sendState, { deep: true })
     
    -  return { remoteState }
    +  return { remoteStates }
     }

    録画ボタンには、2人のときだけ録画できることを書き添えます。

    app/components/RecordButton.vue に次の変更を加えます(+ が追加、- が削除)。

    --- a/app/components/RecordButton.vue
    +++ b/app/components/RecordButton.vue
    @@ -53,7 +53,7 @@ function confirmStart() {
           <button type="button" :disabled="!canRecord" @click="confirming = true">
             録画する
           </button>
    -      <small class="record__hint">形式: {{ mimeType || 'ブラウザの既定' }}</small>
    +      <small class="record__hint">形式: {{ mimeType || 'ブラウザの既定' }}(2人で通話中の時だけ録画できます)</small>
         </template>
       </div>
     </template>

    実装4:VideoGrid で映像を並べる

    app/components/VideoGrid.vue を新しく作ります。

    <!-- app/components/VideoGrid.vue -->
    <script setup lang="ts">
    // 第11回: 参加者の映像をグリッド(格子)状に並べる。自分+相手最大3人の4枠まで
    import type { MediaState, PeerId } from '#shared/types/signaling'
    
    export type VideoTile = {
      peerId: PeerId
      label: string
      stream: MediaStream | null
      mediaState: MediaState | null
      connectionState: RTCPeerConnectionState
      routeType: RTCIceCandidateType | null
    }
    
    const props = defineProps<{
      tiles: VideoTile[]
      /** 自分の映像(画面共有中は画面) */
      localStream: MediaStream | null
      localVideoOff: boolean
      localMirror: boolean
    }>()
    
    // 枠の数に応じて列数を変える(1枠=1列、2〜4枠=2列)
    const columns = computed(() => (props.tiles.length + 1 <= 1 ? 1 : 2))
    
    const STATE_LABELS: Partial<Record<RTCPeerConnectionState, string>> = {
      new: '接続を準備中',
      connecting: '接続中…',
      disconnected: '通信が不安定',
      failed: '接続が切れました',
    }
    const ROUTE_SHORT: Record<RTCIceCandidateType, string> = { host: '直接', srflx: '直接', prflx: '直接', relay: 'TURN経由' }
    
    function caption(tile: VideoTile) {
      if (tile.connectionState === 'connected') return tile.routeType ? `${tile.label}(${ROUTE_SHORT[tile.routeType]})` : tile.label
      return `${tile.label}・${STATE_LABELS[tile.connectionState] ?? ''}`
    }
    </script>
    
    <template>
      <div class="grid" :style="{ gridTemplateColumns: `repeat(${columns}, minmax(0, 1fr))` }">
        <div v-for="tile in tiles" :key="tile.peerId" class="grid__tile" :data-state="tile.connectionState">
          <RemoteVideo :stream="tile.stream" :media-state="tile.mediaState" />
          <span class="grid__caption">{{ caption(tile) }}</span>
        </div>
        <div class="grid__tile grid__tile--self">
          <LocalPreview :stream="localStream" :video-off="localVideoOff" :mirror="localMirror" />
          <span class="grid__caption">自分</span>
        </div>
      </div>
    </template>
    
    <style scoped>
    .grid { display: grid; gap: 8px; }
    .grid__tile { position: relative; }
    .grid__tile--self :deep(.preview) { max-width: none; }
    .grid__caption { position: absolute; right: 8px; bottom: 8px; padding: 2px 8px; background: rgb(0 0 0 / 60%); color: #fff; border-radius: 4px; font-size: 0.8em; }
    .grid__tile[data-state='failed'] .grid__caption { background: #cf222e; }
    </style>

    相手の枠は RemoteVideo、自分の枠は LocalPreview をそのまま使い、各枠に名前と接続状態を表示します。画面上部の ConnectionStatus は「接続しました(自分を含めて4人で通話中)」のように全体をまとめて表示します。

    app/components/ConnectionStatus.vue に次の変更を加えます(+ が追加、- が削除)。経路の表示は VideoGrid の各枠に移したので削除します。

    --- a/app/components/ConnectionStatus.vue
    +++ b/app/components/ConnectionStatus.vue
    @@ -1,16 +1,15 @@
     <script setup lang="ts">
     // 第10回: 接続状態の表示。サーバー(シグナリング)と相手(P2P)の2つの状態を、利用者向けの言葉にまとめる
     // 第3回・第6回でルームページに書いていた状態表示をここに移した。
    +// 第11回: 相手が複数になったので、相手ごとの状態をまとめて表示する(経路は VideoGrid の各枠に表示)
     import type { SignalingStatus } from '~/composables/useSignaling'
     
     const props = defineProps<{
       signalingStatus: SignalingStatus
       retryCount: number
       online: boolean
    -  /** 相手との接続状態(相手がいなければ null) */
    -  peerState: RTCPeerConnectionState | null
    -  /** 実際に使われている経路の種類(第6回) */
    -  routeType: RTCIceCandidateType | null
    +  /** 相手ごとの接続状態(第11回) */
    +  peerStates: RTCPeerConnectionState[]
       /** 通話中だった相手が退出した(または接続が切れた)直後か */
       peerLeft: boolean
     }>()
    @@ -18,14 +17,6 @@ const emit = defineEmits<{ retry: [] }>()
     
     type View = { level: 'ok' | 'info' | 'warn' | 'error'; text: string }
     
    -/** 経路の種類(getStats の candidateType)を利用者向けの言葉にする */
    -const ROUTE_LABELS: Record<RTCIceCandidateType, string> = {
    -  host: '直接(同じネットワーク内)',
    -  srflx: '直接(STUN で確認したアドレス)',
    -  prflx: '直接',
    -  relay: 'TURN サーバー経由',
    -}
    -
     // 優先順位: 端末のネットワーク → サーバーとの接続 → 相手との接続
     const view = computed<View>(() => {
       if (!props.online) {
    @@ -39,21 +30,20 @@ const view = computed<View>(() => {
         case 'failed':
           return { level: 'error', text: 'サーバーに接続できませんでした。ネットワークを確認して「再接続する」を押してください。' }
       }
    -  switch (props.peerState) {
    -    case null:
    -      return props.peerLeft
    -        ? { level: 'info', text: '相手が退出しました(または接続が切れました)。相手の再入室を待っています' }
    -        : { level: 'info', text: '相手を待っています' }
    -    case 'connected':
    -      return { level: 'ok', text: props.routeType ? `接続しました(経路: ${ROUTE_LABELS[props.routeType]})` : '接続しました' }
    -    case 'disconnected':
    -      return { level: 'warn', text: '通信が不安定です。回復を待っています…' }
    -    case 'failed':
    -      // usePeerConnection が自動で ICE restart を行う。回復すれば connecting → connected に戻る
    -      return { level: 'error', text: '相手との接続が切れました。経路を探し直しています。回復しない場合は、いったん退出して入り直してください。' }
    -    default:
    -      return { level: 'info', text: '接続しています…' }
    +  const states = props.peerStates
    +  if (states.length === 0) {
    +    return props.peerLeft
    +      ? { level: 'info', text: '相手が退出しました(または接続が切れました)。相手の再入室を待っています' }
    +      : { level: 'info', text: '相手を待っています' }
    +  }
    +  const connected = states.filter(s => s === 'connected').length
    +  // usePeerConnection が自動で ICE restart を行う。回復すれば connecting → connected に戻る
    +  if (states.includes('failed')) {
    +    return { level: 'error', text: '一部の参加者との接続が切れました。経路を探し直しています。回復しない場合は、いったん退出して入り直してください。' }
       }
    +  if (states.includes('disconnected')) return { level: 'warn', text: '通信が不安定です。回復を待っています…' }
    +  if (connected < states.length) return { level: 'info', text: `接続しています…(${connected} / ${states.length}人)` }
    +  return { level: 'ok', text: `接続しました(自分を含めて${states.length + 1}人で通話中)` }
     })
     </script>
     

    ルームページで、ここまでの部品を組み合わせます。

    app/pages/room/[id].vue に次の変更を加えます(+ が追加、- が削除)。

    --- a/app/pages/room/[id].vue
    +++ b/app/pages/room/[id].vue
    @@ -7,8 +7,11 @@
     // 第8回: DataChannel によるテキストチャット(useDataChannel + ChatPanel)
     // 第9回: 録画(useRecorder + RecordButton)。相手には media-state の recording で知らせる
     // 第10回: 再接続とエラー表示(ConnectionStatus)。再接続の前に STUN/TURN の設定を取り直す
    +// 第11回: メッシュ構成で最大4人に(useMeshRoom + VideoGrid)。録画は2人の時だけ
     import type { IceConfigResponse } from '#shared/types/ice'
    +import type { PeerId } from '#shared/types/signaling'
     import { ROOM_ID_PATTERN } from '#shared/types/signaling'
    +import type { VideoTile } from '~/components/VideoGrid.vue'
     
     const route = useRoute()
     const roomId = computed(() => String(route.params.id))
    @@ -21,18 +24,39 @@ const { stream: localStream, stop: stopMedia, audioEnabled, videoEnabled, setAud
     const signaling = useSignaling()
     // 第6回: STUN/TURN の設定(入室のたびに取り直す。TURN の認証情報には有効期限があるため)
     const iceConfig = shallowRef<RTCConfiguration>({})
    -const { remotePeerId, remoteStream, connectionState, routeType, chatChannel, replaceVideoTrack, close: closePeer }
    -  = usePeerConnection(signaling, () => localStream.value, () => iceConfig.value)
    -const chat = useDataChannel(chatChannel)
    +// 第11回: 参加者ごとの接続をまとめて管理する
    +const { links, replaceVideoTrack, closeAll } = useMeshRoom(signaling, () => localStream.value, () => iceConfig.value)
     const screen = useScreenShare()
    +
    +/** 表示名(本連載では名前入力を省略し、ピアIDの先頭4文字で区別する) */
    +const labelOf = (peerId: PeerId) => `参加者 ${peerId.slice(0, 4)}`
    +
    +// 第8回・第11回: チャットは全員分のチャネルをまとめて扱う
    +const chatChannels = computed(() => links.value.flatMap((link) => {
    +  const channel = link.chatChannel.value
    +  return channel ? [{ peerId: link.peerId, channel }] : []
    +}))
    +const chat = useDataChannel(chatChannels, labelOf)
    +
    +// 第9回・第11回: 録画は相手が1人(2人で通話)の時だけ。3人以上の録画は SFU 等のサーバー側で行うのが一般的
    +const soleRemoteStream = computed(() => (links.value.length === 1 ? links.value[0]!.remoteStream.value : null))
    +const recorder = useRecorder(() => ({ remote: soleRemoteStream.value, local: localStream.value }))
     const isSharing = computed(() => screen.stream.value !== null)
    -const recorder = useRecorder(() => ({ remote: remoteStream.value, local: localStream.value }))
    -const { remoteState } = useRemoteMediaState(
    +const { remoteStates } = useRemoteMediaState(
       signaling,
       () => ({ audio: audioEnabled.value, video: videoEnabled.value, screen: isSharing.value, recording: recorder.isRecording.value }),
    -  remotePeerId,
     )
     
    +// 第11回: グリッドに並べる相手の映像
    +const tiles = computed<VideoTile[]>(() => links.value.map(link => ({
    +  peerId: link.peerId,
    +  label: labelOf(link.peerId),
    +  stream: link.remoteStream.value,
    +  mediaState: remoteStates.value[link.peerId] ?? null,
    +  connectionState: link.connectionState.value,
    +  routeType: link.routeType.value,
    +})))
    +
     // --- 画面共有 ---
     // getDisplayMedia はクリック直後(ユーザー操作の中)で呼ぶ必要があるため、await の前に他の処理を挟まない
     async function toggleScreenShare() {
    @@ -64,8 +88,9 @@ onBeforeUnmount(() => {
     })
     
     // 第10回: 相手が退出した・切れたことを表示する(新しい相手とつながったら消す)
    +// 第11回: 相手が1人以上いた状態から0人になったとき
     const peerLeft = ref(false)
    -watch(remotePeerId, (id, prev) => { peerLeft.value = id === null && prev !== null })
    +watch(() => links.value.length, (n, prev) => { peerLeft.value = n === 0 && prev > 0 })
     
     // --- 招待リンク ---
     // location はブラウザにしか無いため、URL は onMounted で組み立てる
    @@ -125,17 +150,19 @@ watch(signaling.error, (err) => {
     })
     
     // 第9回: 相手が退出した(相手の映像が無くなった)ら録画を止めて、そこまでを保存する
    -watch(remoteStream, (stream) => {
    +// 第11回: 3人目が入ってきた場合も止める(録画は2人の時だけ)
    +watch(soleRemoteStream, (stream) => {
       if (!stream) recorder.stop()
     })
     
     function leave() {
       recorder.stop() // 録画中なら止めて保存する
       screen.stop()
    -  closePeer()
    +  closeAll()
       signaling.disconnect()
       stopMedia()
     }
    +
     </script>
     
     <template>
    @@ -165,19 +192,18 @@ function leave() {
               :signaling-status="signaling.status.value"
               :retry-count="signaling.retryCount.value"
               :online="online"
    -          :peer-state="remotePeerId ? connectionState : null"
    -          :route-type="routeType"
    +          :peer-states="links.map(link => link.connectionState.value)"
               :peer-left="peerLeft"
               @retry="signaling.retry()"
             />
    -        <!-- 相手の映像を大きく、自分の映像を右下に小さく重ねる -->
    -        <div class="room__videos">
    -          <RemoteVideo :stream="remoteStream" :media-state="remoteState" />
    -          <!-- 共有中は、自分が送っている画面を反転せずに表示する -->
    -          <div class="room__self">
    -            <LocalPreview :stream="screen.stream.value ?? localStream" :video-off="!isSharing && !videoEnabled" :mirror="!isSharing" />
    -          </div>
    -        </div>
    +
    +        <!-- 共有中は自分の枠に、自分が送っている画面を表示する -->
    +        <VideoGrid
    +          :tiles="tiles"
    +          :local-stream="screen.stream.value ?? localStream"
    +          :local-video-off="!isSharing && !videoEnabled"
    +          :local-mirror="!isSharing"
    +        />
     
             <p v-if="screen.error.value" class="room__error" role="alert">
               {{ screen.error.value }}
    @@ -196,7 +222,7 @@ function leave() {
     
             <RecordButton
               :is-recording="recorder.isRecording.value"
    -          :can-record="recorder.isSupported.value && remoteStream !== null"
    +          :can-record="recorder.isSupported.value && soleRemoteStream !== null"
               :elapsed="recorder.elapsed.value"
               :bytes="recorder.bytes.value"
               :mime-type="recorder.mimeType.value ?? ''"
    @@ -220,6 +246,4 @@ function leave() {
     .room__invite-row { display: flex; gap: 8px; }
     .room__invite-row input { flex: 1; min-width: 0; padding: 4px 8px; }
     .room__hint { color: #666; }
    -.room__videos { position: relative; }
    -.room__self { position: absolute; right: 12px; bottom: 12px; width: 30%; }
     </style>

    トップページの定員の案内も4名に直します。

    app/pages/index.vue に次の変更を加えます(+ が追加、- が削除)。

    --- a/app/pages/index.vue
    +++ b/app/pages/index.vue
    @@ -44,7 +44,7 @@ async function createRoom() {
         <p>連載のサンプルプロジェクト(第0回:ベースライン)です。ここに通話機能を順番に追加していきます。</p>
     
         <h2>通話を始める</h2>
    -    <p>ルームを作成すると、招待リンクが表示されます。リンクを相手に送り、同じルームに入ってもらいます(1ルーム2名まで)。</p>
    +    <p>ルームを作成すると、招待リンクが表示されます。リンクを相手に送り、同じルームに入ってもらいます(1ルーム4名まで)。</p>
         <button type="button" class="create" @click="createRoom">
           新しいルームを作成する
         </button>

    動作確認:人数による通信量と負荷の増え方

    Playwright で Chromium の独立した4つのウィンドウ(テスト用のカメラ・マイク)を同じルームに順番に入れ、次の点を確認しました。

    確認したこと結果
    2人・3人・4人での接続全員が「接続しました」になり、各自のグリッドに相手の人数分の映像が並ぶ
    5人目「このルームは定員(4名)に達しています」と表示され、入室できない
    チャット1人の送信が残り3人に届き、送信者名が表示される
    ミュート・画面共有該当する人の枠にだけ「ミュート中」「画面を共有中」が出る。画面は全員に届く
    退出・タブを閉じる残った人のグリッドから、その人の枠だけが消える
    録画ボタン2人のときだけ有効、3人以上では無効

    人数ごとに、10秒間の送受信量と、ブラウザ全体(全ウィンドウの合計)の CPU 使用率を測った結果が次の表です。CPU は1コアを100%とした値で、テスト用カメラ(640×480)の映像生成も含みます。

    人数1人あたりの送信(映像の送信本数)1人あたりの送信量ブラウザ全体の CPU
    2人1本約490kbps約89%
    3人2本約990kbps約180%
    4人3本約1,450kbps約307%

    1人あたりの送信量は「人数−1」にほぼ比例し、CPU も人数以上のペースで増えました。ただし、これは同じ PC の中で、低解像度のテスト映像を使った参考値です。実際のカメラ映像(高解像度・動きが多い)や、スマホ、インターネット越しの通信では、数値も上限の人数も大きく変わります。別々の端末・回線での実測、Firefox・Safari の混在、スマホでの発熱や電池の減り方は、この環境では確認していません。npm run build と npm run typecheck は通っています。

    SFU という選択肢:何が変わるか

    人数が増える、サーバーで録画したい、多くの人に配信したい、といった要件がある場合は、SFU を検討します。SFU は各参加者から受け取った映像を、合成せずに必要な相手へ転送するサーバーで、各端末の送信は人数によらず1本で済みます。品質の違う映像を複数送り、受け手の回線に合わせてサーバーが選ぶ仕組み(サイマルキャスト)を組み合わせることも一般的です。

    SFU の導入方法は、大きく2つに分かれます。

    方式概要主な検討事項
    OSS を自前で運用オープンソースの SFU をサーバーに構築して運用するサーバーの構築・監視・障害対応・アップデートを担う体制、帯域の確保、ライセンスの確認
    マネージドなサービスを利用事業者が運用する SFU を API で利用する利用量に応じた費用、提供地域やデータの扱い、サービスへの依存(乗り換えのしやすさ)

    OSS の例としては、mediasoup、Janus(汎用の WebRTC サーバーで、ビデオ会議用の SFU プラグインを持つ)、Jitsi Videobridge、LiveKit などがあり、いずれも公式のリポジトリで SFU(またはその機能を持つサーバー)と説明されています。これらは例として挙げたもので、順位や推奨ではありません。機能・ライセンス・サポートの状況は変わるため、採用時は必ず公式の情報で確認してください。

    どちらの方式でも、SFU を入れると次の点が変わります。

    • シグナリングの作りが変わる:全員と offer/answer を交換するのではなく、SFU と接続して「誰の映像を受け取るか」をやりとりする形になり、多くの場合 SFU 側の SDK やプロトコルに合わせます。
    • 映像がサーバーを通る:通信量に応じた費用と、映像データの扱い(どの地域のサーバーを通るか等)の検討が必要です。
    • サーバー録画や配信がしやすくなる:映像がサーバーに集まるため、サーバー側で録画・合成する設計がとりやすくなります。

    連載のまとめ:全12回の振り返り

    回記事作ったもの
    第0回Nuxt 4でビデオチャットの土台を作る:なぜHTTPSが必要なのかプロジェクトの土台、Secure Context の確認
    第1回カメラとマイクを取得してプレビューし、デバイスを選べるようにするgetUserMedia、デバイス選択、エラー表示
    第2回Nitro の WebSocket でシグナリングサーバーを作るルーム単位の中継サーバー
    第3回RTCPeerConnection で1対1通話をつなぐ(offer/answer/ICE)Perfect negotiation による1対1通話
    第4回ルーム作成と招待リンク、入室前プレビュールームID、招待リンク、定員チェック
    第5回ミュートとカメラオフtrack.enabled と状態の通知
    第6回STUN/TURN と本番デプロイ:「社外とつながらない」を解消する期限付き TURN 認証情報、HTTPS/WSS 配下へのデプロイ
    第7回画面共有getDisplayMedia と replaceTrack
    第8回DataChannel でテキストチャットP2P のテキストチャット
    第9回MediaRecorder で録画する前に考えることローカル録画、了承の確認と録画中表示
    第10回切断・再接続とエラーハンドリングWebSocket の再接続、ICE restart、状態表示
    第11回少人数通話へ:メッシュ実装と SFU という選択肢(本記事)最大4人のメッシュ通話

    本番運用までに残っている作業

    サンプルは「仕組みを理解するための最小構成」です。業務で使うには、少なくとも次の作業が残っています。

    分野残っている作業
    認証・アクセス制御ログインの仕組みと、ルームに入れる人の制限(現在は URL を知っていれば誰でも入れる)。/api/ice-servers をログイン済みの人だけに限定し、呼び出し回数を制限する(現在は誰でも TURN の認証情報を取得できる)。WebSocket の接続時(upgrade)にも同じ認証を行う
    エラー表示・再接続第10回で WebSocket の再接続と失敗時の表示は追加済み。回線断に早く気付くためのハートビート、TURN 認証情報の期限切れ後の再取得(ICE restart 時)、最初から接続できない場合の文言の改善が残っている
    監視・運用接続の成功率・切断の回数・TURN 経由の割合と通信量、サーバーの CPU・メモリ・WebSocket 接続数の監視。問い合わせ調査用のログ(IP アドレス等を含むため保存範囲と期間を決める)
    スケールルームの情報を1台のサーバーのメモリに持っているため、サーバーを複数台にするには、ルーム情報とメッセージの中継を共有する仕組み(外部のデータストアや pub/sub)か、同じルームを同じサーバーに振り分ける仕組みが必要。TURN の冗長化。人数の上限を超える場合は SFU
    品質・端末実機(スマホ・Safari・Firefox)での確認、回線の切り替えテスト、表示名の入力、アクセシビリティ
    データの扱い録画・チャットの保存要否、利用規約・プライバシーポリシーへの記載

    発注者向けメモ:人数・録画・配信の要件を最初に固める

    ビデオ通話の見積もりで一番大きく効くのは、同時に何人が参加するかと、サーバー側で録画・配信が必要かです。4人程度までならメッシュで追加のサーバーなしに作れますが、それを超える人数や、サーバー録画・配信が要件に入ると SFU が前提になり、サーバー費用、運用体制、サービスへの依存といった検討事項が加わります。後から人数を増やすと、今回のようにシグナリングや接続の作りを変える必要が出るため、最初に決めておくことをおすすめします。

    • ☐ 1つのルームの最大人数(普段の人数と、まれに起きる最大の人数)が決まっているか
    • ☐ サーバー側での録画、多人数への配信(視聴だけの参加者)が必要か
    • ☐ 参加者の端末(PC だけか、スマホが多いか)と回線(社内 Wi-Fi、モバイル回線)が想定されているか
    • ☐ SFU を使う場合、自前運用とマネージドサービスのどちらにするか、その判断材料(運用体制・費用の考え方・データの扱い)が整理されているか
    • ☐ 上の「本番運用までに残っている作業」のうち、どこまでを初期リリースに含めるか

    開発会社への質問例:

    • 「最大何人までを想定した構成ですか?その人数を超えたら何が起きますか?」
    • 「スマホの参加者が多い場合、何人まで快適に使えるかをどう確認しますか?」
    • 「将来 SFU に切り替える場合、どの部分の作り直しが必要になりますか?」
    • 「SFU を使う場合、自前運用とマネージドサービスで、運用の体制と費用の考え方はどう変わりますか?」

    まとめ

    • メッシュは全員と個別につながる構成。追加のサーバーは不要だが、送信量と端末の負荷が「人数−1」に比例して増える
    • 3人以上では offer/answer・ICE 候補に宛先を付け、サーバーは同じルームの宛先にだけ送る
    • 1対1の接続処理を「相手1人分の接続」に切り出せば、これまでの機能をほぼそのまま人数分に広げられる
    • 多人数・サーバー録画・配信が要件なら SFU を検討する。OSS の自前運用とマネージドサービスがあり、どちらもサーバー費用・運用・依存の検討が加わる
    • 本番運用には、認証・監視・スケールなどの作業が残る。人数と録画・配信の要件を最初に固めるのが、見積もりのぶれを小さくする近道

    全12回の連載をお読みいただき、ありがとうございました。サンプルコードは、1回ごとの差分で追えるようにしています。自社でビデオ通話機能を検討する際の、たたき台や開発会社との会話の材料として使っていただければ幸いです。

    この連載の記事一覧

    この記事は連載「NuxtとWebRTCで作るビデオチャット」の1回です。連載のほかの回は次のとおりです(連載の一覧ページ)。

    システム制作・運用・保守のお問い合わせはこちら

      お問い合わせ


      よかったらシェアしてね!
      • URLをコピーしました!
      • URLをコピーしました!

      この記事を書いた人

      株式会社THIRD HERO代表取締役 朝野貴朗
      Webシステム開発を中心に、toC向けサービスサイトの運営、ツール開発などを行ってまいりました。

      目次