Knowledge Base

Mediasoup is a scalable and reliable Selective Forwarding Unit (SFU) library designed for WebRTC-based applications. Its primary purpose is to facilitate multi-participant video conferencing, live broadcasting, and other real-time communication applications. Mediasoup acts as a bridge between clients (e.g., web browsers or mobile applications) and the media server, enabling efficient routing and management of media streams.

Why Use Mediasoup?

• Scalability: Mediasoup is designed to support a large number of participants. By using multiple worker processes, it effectively utilizes server resources and provides high performance.
• Reliability: Mediasoup has a robust architecture and comprehensive testing. This ensures that your applications run stably and reliably.
• Flexibility: Mediasoup can be configured to suit different needs. It supports various codecs, transport protocols, and security features.
• Low Latency: Mediasoup is optimized for real-time communication. By minimizing the latency of media streams, it provides a better user experience.
• Open Source: Mediasoup is an open-source project. This allows developers to use, inspect, and modify the library for free.

What are the Requirements for Mediasoup Installation?

To install Mediasoup, you need the following requirements:

• Node.js: Mediasoup runs on Node.js. Check the Mediasoup documentation for supported Node.js versions. (LTS versions are generally recommended)
• npm or Yarn: Node.js package manager. npm usually comes with Node.js, but you can also use Yarn.
• g++ (C++ Compiler): Mediasoup has some components written in C++. Therefore, you need a C++ compiler like g++.
• Python: Python is required to compile Mediasoup.
• libuv: Mediasoup uses the libuv library. It should usually be installed on your system, but you can also install it separately if necessary.
• libsrtp: Mediasoup uses the libsrtp library for secure real-time communication.

Step-by-Step Installation Process (Ubuntu Example):

1. Node.js and npm Installation:

   
         curl -sL https://deb.nodesource.com/setup_18.x | sudo -E bash -
         sudo apt-get install -y nodejs
       

2. Installation of Required Packages:

   
         sudo apt-get update
         sudo apt-get install -y build-essential python3
       

3. Mediasoup Installation:

   
         npm install mediasoup --save
       

Important Note: If you encounter errors during installation, check for missing dependencies and install the necessary packages. The Mediasoup documentation provides detailed solutions for issues you may encounter during the installation process.

How to Start and Configure the Mediasoup Worker Process?

The Mediasoup worker process is the fundamental component that handles media streams. Each worker process can host a certain number of routers and route media streams.

Starting the Worker Process:

To start the Mediasoup worker process, you first need to create a configuration object. This configuration object defines how the worker process will operate.

const mediasoup = require('mediasoup');

(async () => {
  try {
    const worker = await mediasoup.createWorker({
      logLevel: 'warn',
      logTag: [
        'info',
        'ice',
        'dtls',
        'rtp',
        'srtp',
        'rtcp',
        'sctp',
        'simulcast',
        'svc'
      ],
      rtcMinPort: 10000,
      rtcMaxPort: 10100,
    });

    console.log(`Worker PID: ${worker.pid}`);

    worker.on('died', () => {
      console.error('Worker died, exiting...');
      process.exit(1);
    });

    // You can start using the worker.
  } catch (error) {
    console.error('Error starting worker:', error);
  }
})();

Configuration Parameters:

• logLevel: Log level (e.g., 'debug', 'warn', 'error').
• logTag: Log tags (detailed logs for different components).
• rtcMinPort/rtcMaxPort: Port range to be used for RTP/RTCP traffic.

Creating a Router:

After the worker process is started, you can create a router. The router is the main component that routes and manages media streams.

const router = await worker.createRouter({
  mediaCodecs: [
    {
      kind: 'audio',
      mimeType: 'audio/opus',
      clockRate: 48000,
      channels: 2
    },
    {
      kind: 'video',
      mimeType: 'video/VP8',
      clockRate: 90000,
      parameters: {
        'x-google-start-bitrate': 1000
      }
    },
  ]
});

Media Codecs:

In router configuration, you need to specify the supported media codecs. These codecs are used for encoding and decoding media streams.

Transports and Producer/Consumer Concepts in Mediasoup

In Mediasoup, transports are channels that enable the transfer of media streams between clients and the server. Producers are clients that produce media and send it to the transport. Consumers, on the other hand, receive and consume media from the transport.

Transport Types:

• WebRtcTransport: This is the transport type that uses the WebRTC protocol. It is used for WebRTC-compatible clients such as web browsers and mobile applications.
• PlainTransport: This is the transport type that uses RTP/RTCP protocols. It can be used for non-WebRTC compatible clients or custom media servers.

Creating a WebRtcTransport:

const webRtcTransportOptions = {
  listenIps: [
    {
      ip: '0.0.0.0',
      announcedIp: 'YOUR_PUBLIC_IP' // Your publicly accessible IP address
    }
  ],
  initialAvailableOutgoingBitrate: 1000000,
  maxSctpMessageSize: 262144,
  maxOutgoingSctpStreams: 16
};

const transport = await router.createWebRtcTransport(webRtcTransportOptions);

Creating a Producer:

const producer = await transport.produce({
  kind: 'video',
  rtpParameters: {
    codecs: [
      {
        mimeType: 'video/VP8',
        payloadType: 100,
        clockRate: 90000
      }
    ],
    encodings: [
      {
        ssrc: 12345678
      }
    ],
    rtcpFeedback: []
  }
});

Creating a Consumer:

const consumer = await transport.consume({
  producerId: producer.id,
  rtpCapabilities: router.rtpCapabilities
});

Important Note: When creating Producers and Consumers, make sure that the RTP parameters and codecs are compatible. Otherwise, the media stream may not work properly.

Scalability and Performance Optimization in Mediasoup

Mediasoup is designed to create scalable and high-performance applications. However, you can make some optimizations to further improve the performance of your application.

Using Multiple Worker Processes:

Mediasoup allows you to better utilize server resources by using multiple worker processes. Each worker process can host a certain number of routers and process media streams in parallel.

Worker Process Distribution:

By distributing worker processes to different servers, you can ensure that your application performs better for geographically distributed users.

Codec Optimization:

By selecting the codecs that best suit your application's needs, you can reduce bandwidth usage and processor load. For example, you can use more efficient codecs such as VP9 or AV1 for users with low bandwidth.

Simulcast and SVC:

By using techniques such as Simulcast and SVC (Scalable Video Coding), you can provide adaptive video streams for users with different network conditions and device capabilities. Simulcast sends multiple copies of the same video stream at different resolutions and bitrates, while SVC sends different layers of a single video stream.

Load Balancing:

If you are using multiple Mediasoup servers, you can distribute traffic between the servers using a load balancer. This prevents servers from being overloaded and improves the overall performance of the application.

Statistics Monitoring:

Mediasoup provides various statistics about worker processes, routers, and transports. By monitoring these statistics, you can identify performance issues in your application and make the necessary optimizations.

Common Mistakes and Solutions Related to Mediasoup

When using Mediasoup, you may encounter some common mistakes. Understanding the causes of these errors and knowing their solutions speeds up the development process.

1. ICE Connection Issues:
   • Why: ICE (Interactive Connectivity Establishment) is used to establish network connections between clients and the server. ICE connection issues can be caused by incorrect NAT configuration, firewall blocks, or incorrect configuration of STUN/TURN servers.
   • Solution:
     • Make sure your firewall allows UDP traffic.
     • Configure your STUN and TURN servers correctly.
     • Set the "announcedIp" parameter correctly (especially if you are behind NAT).
2. Codec Mismatch:
   • Why: If the codecs between the Producer and Consumer do not match, the media stream may not work.
   • Solution:
     • Make sure the Producer and Consumer support the same codecs.
     • Specify the correct codecs in the Router configuration.
3. RTP Parameter Errors:
   • Why: If RTP parameters (e.g., SSRC, payloadType) are configured incorrectly, the media stream may be corrupted.
   • Solution:
     • Make sure the RTP parameters are correct.
     • Allow Mediasoup to automatically generate RTP parameters (if possible).
4. Worker Process Crash:
   • Why: The Worker process may crash due to memory leaks, faulty code, or overload.
   • Solution:
     • Examine the logs of the Worker process and identify errors.
     • Optimize the code to prevent memory leaks.
     • Protect Worker processes from overload (e.g., start more worker processes).
5. Transport Issues:
   • Why: Transports may not be created or configured properly.
   • Solution:
     • Make sure the Transport configuration is correct (listenIps, etc.).
     • Ensure that Transports are properly closed and cleaned up.

Real-Life Examples and Case Studies with Mediasoup

Mediasoup is used in various real-time communication applications. Here are some examples and case studies:

• Video Conferencing Applications: Can form the basis of video conferencing applications such as Mediasoup, Zoom, Google Meet, and Microsoft Teams. It can be used to support multi-participant meetings, manage screen sharing, and provide low-latency communication.
• Live Streaming Platforms: Can be used in live streaming platforms such as Mediasoup, Twitch, and YouTube Live. It can be used to distribute live video and audio streams from broadcasters to viewers, manage chat interaction, and provide a scalable infrastructure.
• Remote Education Platforms: Mediasoup can be used in remote education platforms to enable teachers and students to conduct interactive lessons. It can support features such as video conferencing, screen sharing, and virtual whiteboards.
• Gaming Platforms: Mediasoup can be used in gaming platforms to enable players to communicate with each other and manage in-game interactions. It can support features such as voice and video chat, in-game broadcasting, and tournament management.
• Case Study - In-House Communication Application: A company developed a Mediasoup-based application to improve its employees' internal communication. This application included features such as video conferencing, instant messaging, and file sharing. Thanks to Mediasoup's scalability, the application was able to seamlessly support more users as the company grew. In addition, Mediasoup's low latency feature enabled employees to communicate more effectively.