mediasoup/app.js

import 'dotenv/config'

/**
 * integrating mediasoup server with a node.js application
 */

/* Please follow mediasoup installation requirements */
/* https://mediasoup.org/documentation/v3/mediasoup/installation/ */
import express from 'express'
const app = express()

import https from 'httpolyglot'
import fs from 'fs'
import path from 'path'
const __dirname = path.resolve()

import Server from 'socket.io'
import mediasoup from 'mediasoup'

let worker
/**
 * videoCalls
 * |-> Router
 * |-> Producer
 * |-> Consumer 
 * |-> Producer Transport
 * |-> Consumer Transport
 * 
 * '<callId>': {
 *  router: Router,
 *  producer: Producer,
 *  producerTransport: Producer Transport,
 *  consumer: Consumer,
 *  consumerTransport: Consumer Transport
 * }
 * 
 **/
let videoCalls = {}
let socketDetails = {}

app.get('/', (_req, res) => {
  res.send('Hello from mediasoup app!')
})

app.use('/sfu', express.static(path.join(__dirname, 'public')))

// SSL cert for HTTPS access
const options = {
  key: fs.readFileSync('./server/ssl/key.pem', 'utf-8'),
  cert: fs.readFileSync('./server/ssl/cert.pem', 'utf-8')
}

const httpsServer = https.createServer(options, app)

httpsServer.listen(process.env.PORT, () => {
  console.log('Listening on port:', process.env.PORT)
})

const io = new Server(httpsServer, {
  allowEIO3: true
});

// socket.io namespace (could represent a room?)
const peers = io.of('/mediasoup')

const createWorker = async () => {
  worker = await mediasoup.createWorker({
    rtcMinPort: 2000,
    rtcMaxPort: 2020,
  })
  console.log(`[createWorker] worker pid ${worker.pid}`)

  worker.on('died', error => {
    // This implies something serious happened, so kill the application
    console.error('mediasoup worker has died', error)
    setTimeout(() => process.exit(1), 2000) // exit in 2 seconds
  })

  return worker
}

// We create a Worker as soon as our application starts
worker = createWorker()

// This is an Array of RtpCapabilities
// https://mediasoup.org/documentation/v3/mediasoup/rtp-parameters-and-capabilities/#RtpCodecCapability
// list of media codecs supported by mediasoup ...
// https://github.com/versatica/mediasoup/blob/v3/src/supportedRtpCapabilities.ts
const mediaCodecs = [
  {
    kind: 'audio',
    mimeType: 'audio/opus',
    clockRate: 48000,
    channels: 2,
  },
  {
    kind: 'video',
    mimeType: 'video/VP8',
    clockRate: 90000,
    parameters: {
      'x-google-start-bitrate': 1000,
    },
  },
]

const closeCall = (callId) => {
  if (videoCalls[callId]) {
    videoCalls[callId].producer?.close();
    videoCalls[callId].consumer?.close();
    videoCalls[callId]?.consumerTransport.close();
    videoCalls[callId]?.producerTransport.close();
    videoCalls[callId].router.close();
    delete videoCalls[callId];
  }
}

const getRtpCapabilities = (callId, callback) => {
  console.log('[getRtpCapabilities] callId', callId);
  const rtpCapabilities = videoCalls[callId].router.rtpCapabilities;
  callback({ rtpCapabilities });
}

peers.on('connection', async socket => {
  console.log('[connection] socketId:', socket.id)
  socket.emit('connection-success', {
    socketId: socket.id
  })

  socket.on('disconnect', () => {
    // do some cleanup
    console.log('peer disconnected | socket.id', socket.id)
    delete socketDetails[socket.id];
  })

  socket.on('createRoom', async ({ callId }, callback) => {
    if (callId) {
      console.log(`[createRoom] socket.id ${socket.id} callId ${callId}`);
      if (!videoCalls[callId]) {
        console.log('[createRoom] callId', callId);
        videoCalls[callId] = { router: await worker.createRouter({ mediaCodecs }) }
        console.log(`[createRoom] Router ID: ${videoCalls[callId].router.id}`);
      }
      socketDetails[socket.id] = callId;
      getRtpCapabilities(callId, callback);
    } else {
      console.log(`[createRoom] missing callId ${callId}`);
    }
  })

  // Client emits a request to create server side Transport
  // We need to differentiate between the producer and consumer transports
  socket.on('createWebRtcTransport', async ({ sender, callId }, callback) => {
    console.log(`[createWebRtcTransport] Is this a sender request? ${sender} | callId ${callId}`)
    // The client indicates if it is a producer or a consumer
    // if sender is true, indicates a producer else a consumer
    if (sender)
      videoCalls[callId].producerTransport = await createWebRtcTransportLayer(callId, callback)
    else
      videoCalls[callId].consumerTransport = await createWebRtcTransportLayer(callId, callback)
  })

  // see client's socket.emit('transport-connect', ...)
  socket.on('transport-connect', async ({ dtlsParameters }) => {
    const callId = socketDetails[socket.id];
    console.log(`[transport-connect] socket.id ${socket.id} | callId ${callId} | DTLS PARAMS... ${dtlsParameters}`)
    await videoCalls[callId].producerTransport.connect({ dtlsParameters })
  })

  // see client's socket.emit('transport-produce', ...)
  socket.on('transport-produce', async ({ kind, rtpParameters, appData }) => {
    const callId = socketDetails[socket.id];
    console.log('[transport-produce] | socket.id', socket.id, '| callId', callId);
    // call produce based on the prameters from the client
    videoCalls[callId].producer = await videoCalls[callId].producerTransport.produce({
      kind,
      rtpParameters,
    })
    console.log(`[transport-produce] Producer ID: ${videoCalls[callId].producer.id} | kind: ${videoCalls[callId].producer.kind}`)

    videoCalls[callId].producer.on('transportclose', () => {
      const callId = socketDetails[socket.id];
      console.log('transport for this producer closed', callId)
      closeCall(callId);
    })
  })

  // see client's socket.emit('transport-recv-connect', ...)
  socket.on('transport-recv-connect', async ({ dtlsParameters }) => {
    const callId = socketDetails[socket.id];
    console.log(`[transport-recv-connect] socket.id ${socket.id} | callId ${callId} | DTLS PARAMS: ${dtlsParameters}`);
    await videoCalls[callId].consumerTransport.connect({ dtlsParameters })
  })

  socket.on('consume', async ({ rtpCapabilities }, callback) => {
    const callId = socketDetails[socket.id];
    console.log('[consume] callId', callId);
    try {
      // console.log('consume', rtpCapabilities, callId);
      // check if the router can consume the specified producer
      if (videoCalls[callId].router.canConsume({
        producerId: videoCalls[callId].producer.id,
        rtpCapabilities
      })) {
        console.log('[consume] Can consume', callId);
        // transport can now consume and return a consumer
        videoCalls[callId].consumer = await videoCalls[callId].consumerTransport.consume({
          producerId: videoCalls[callId].producer.id,
          rtpCapabilities,
          paused: true,
        })

        // https://mediasoup.org/documentation/v3/mediasoup/api/#consumer-on-transportclose
        videoCalls[callId].consumer.on('transportclose', () => {
          const callId = socketDetails[socket.id];
          console.log('transport close from consumer', callId);
          closeCall();
        })

        // https://mediasoup.org/documentation/v3/mediasoup/api/#consumer-on-producerclose
        videoCalls[callId].consumer.on('producerclose', () => {
          const callId = socketDetails[socket.id];
          console.log('producer of consumer closed', callId);
          closeCall();
        })

        // from the consumer extract the following params
        // to send back to the Client
        const params = {
          id: videoCalls[callId].consumer.id,
          producerId: videoCalls[callId].producer.id,
          kind: videoCalls[callId].consumer.kind,
          rtpParameters: videoCalls[callId].consumer.rtpParameters,
        }

        // send the parameters to the client
        callback({ params })
      } else {
        console.log('[canConsume] Can\'t consume')
      }
    } catch (error) {
      console.log('[consume] Error', error.message)
      callback({
        params: {
          error: error
        }
      })
    }
  })

  socket.on('consumer-resume', async () => {
    const callId = socketDetails[socket.id];
    console.log(`[consumer-resume] callId ${callId}`)
    await videoCalls[callId].consumer.resume()
  })
})

const createWebRtcTransportLayer = async (callId, callback) => {
  try {
    console.log('[createWebRtcTransportLayer] callId', callId);
    // https://mediasoup.org/documentation/v3/mediasoup/api/#WebRtcTransportOptions
    const webRtcTransport_options = {
      listenIps: [
        {
          ip: process.env.IP, // Listening IPv4 or IPv6.
          announcedIp: process.env.ANNOUNCED_IP, // Announced IPv4 or IPv6 (useful when running mediasoup behind NAT with private IP).
        }
      ],
      enableUdp: true,
      enableTcp: true,
      preferUdp: true,
    }

    // console.log('webRtcTransport_options', webRtcTransport_options);
    
    // https://mediasoup.org/documentation/v3/mediasoup/api/#router-createWebRtcTransport
    let transport = await videoCalls[callId].router.createWebRtcTransport(webRtcTransport_options)
    console.log(`callId: ${callId} | transport id: ${transport.id}`)

    transport.on('dtlsstatechange', dtlsState => {
      if (dtlsState === 'closed') {
        transport.close()
      }
    })

    transport.on('close', () => {
      console.log('transport closed')
    })

    const params = {
      id: transport.id,
      iceParameters: transport.iceParameters,
      iceCandidates: transport.iceCandidates,
      dtlsParameters: transport.dtlsParameters,
    }

    // send back to the client the following prameters
    callback({
      // https://mediasoup.org/documentation/v3/mediasoup-client/api/#TransportOptions
      params
    })

    return transport

  } catch (error) {
    console.log('[createWebRtcTransportLayer] ERROR', JSON.stringify(error));
    callback({
      params: {
        error: error
      }
    })
  }
}