mediasoup

https://mediasoup.org/documentation/v3
Admin
mediasoup is a powerful WebRTC Selective Forwarding Unit (SFU) with server-side modules (C++,...
Tokens:176,379
Snippets:1,540
Trust Score:8.9
Update:3 hours ago
Show doc for...
Tokens:
Raw
### Example installation output

Source: https://mediasoup.org/documentation/v3/libmediasoupclient/installation/

Shows the expected output when installing the library, indicating the generated static library and header files.

```text
-- Installing: /usr/local/lib/libmediasoupclient.a
-- Up-to-date: /usr/local/include/mediasoupclient/mediasoupclient.hpp
```

--------------------------------

### Install libmediasoupclient

Source: https://mediasoup.org/documentation/v3/libmediasoupclient/installation/

Optionally install the library into the system after building.

```bash
$ make install -C build/
```

--------------------------------

### Linker warning example

Source: https://mediasoup.org/documentation/v3/libmediasoupclient/installation/

Example of a linker warning that may occur due to symbol visibility mismatch between libwebrtc and libmediasoupclient.

```text
ld: warning: direct access in function 'webrtc::I010Buffer::Rotate(webrtc::I010BufferInterface const&, webrtc::VideoRotation)'
from file '/home/foo/src/webrtc-checkout/src/out/m74/obj/libwebrtc.a(i010_buffer.o)'
to global weak symbol 'void rtc::webrtc_checks_impl::LogStreamer<>::Call<>(char const*, int, char const*)::t'
from file '../libmediasoupclient.a(PeerConnection.cpp.o)' means the weak symbol cannot be overridden at runtime.
This was likely caused by different translation units being compiled with different visibility settings.
```

--------------------------------

### Install mediasoup-client v3 with npm

Source: https://mediasoup.org/documentation/v3/mediasoup-client/installation/

Install the mediasoup-client package version 3 in your client application using npm.

```bash
$ npm install mediasoup-client@3
```

--------------------------------

### Build libwebrtc common steps

Source: https://mediasoup.org/documentation/v3/libmediasoupclient/installation/

Common steps to build libwebrtc, including fetching the WebRTC source and checking out the m140 branch.

```bash
$ cd /home/foo/src
$ mkdir webrtc-checkout
$ cd webrtc-checkout
$ fetch --nohooks webrtc
$ gclient sync
$ cd src
$ git checkout -b m140 refs/remotes/branch-heads/7339
$ gclient sync
```

--------------------------------

### Build libwebrtc with ninja

Source: https://mediasoup.org/documentation/v3/libmediasoupclient/installation/

Command to build libwebrtc using ninja.

```bash
$ ninja -C out/m140
```

--------------------------------

### Build libmediasoupclient with CMake and make

Source: https://mediasoup.org/documentation/v3/libmediasoupclient/installation/

Commands to configure and build libmediasoupclient, specifying the libwebrtc include and binary paths.

```bash
$ cd /home/foo/src/libmediasoupclient

$ cmake . -Bbuild \
  -DLIBWEBRTC_INCLUDE_PATH:PATH=/home/foo/src/webrtc-checkout/src \
  -DLIBWEBRTC_BINARY_PATH:PATH=/home/foo/src/webrtc-checkout/src/out/m140/obj

$ make -C build/
```

--------------------------------

### Configure and build libmediasoupclient with cmake

Source: https://mediasoup.org/documentation/v3/libmediasoupclient/installation/

Configure the build with cmake, specifying the libwebrtc include and binary paths, then compile with make.

```bash
$ cmake . -Bbuild \
  -DLIBWEBRTC_INCLUDE_PATH:PATH=${PATH_TO_LIBWEBRTC_SOURCES} \
  -DLIBWEBRTC_BINARY_PATH:PATH=${PATH_TO_LIBWEBRTC_BINARY}

$ make -C build/
```

--------------------------------

### Skip prebuilt worker download with MEDIASOUP_SKIP_WORKER_PREBUILT_DOWNLOAD

Source: https://mediasoup.org/documentation/v3/mediasoup/installation/

Sets the MEDIASOUP_SKIP_WORKER_PREBUILT_DOWNLOAD environment variable to skip fetching a prebuilt mediasoup-worker binary and build it locally instead. This also applies when MEDIASOUP_LOCAL_DEV is set or when installing via git+ssh, unless MEDIASOUP_FORCE_WORKER_PREBUILT_DOWNLOAD is set.

```bash
MEDIASOUP_SKIP_WORKER_PREBUILT_DOWNLOAD="true" npm install mediasoup@3
```

--------------------------------

### Install mediasoup via NPM

Source: https://mediasoup.org/documentation/v3/mediasoup/installation/

Installs the mediasoup package version 3 via NPM. During installation, the package attempts to fetch a prebuilt mediasoup-worker binary for the current platform and architecture, or builds it locally if not found.

```bash
$ npm install mediasoup@3
```

--------------------------------

### Generate build files for OSX 10.14.16

Source: https://mediasoup.org/documentation/v3/libmediasoupclient/installation/

GN command to generate build files for macOS 10.14.16 with specific build arguments.

```bash
$ gn gen out/m140 --args='is_debug=false is_component_build=false is_clang=true rtc_include_tests=false rtc_use_h264=true use_rtti=true use_custom_libcxx=false'
```

--------------------------------

### Clone and checkout libmediasoupclient

Source: https://mediasoup.org/documentation/v3/libmediasoupclient/installation/

Retrieve the libmediasoupclient sources via git and check out the latest version using a git tag (e.g., 3.X.Y).

```bash
$ git clone https://github.com/versatica/libmediasoupclient.git
$ cd libmediasoupclient/
$ git checkout 3.X.Y.
```

--------------------------------

### Set PYTHON environment variable for installation

Source: https://mediasoup.org/documentation/v3/mediasoup/installation/

Sets the PYTHON environment variable to point to a Python 3 executable when neither python3 nor python commands are available. Required for building mediasoup C/C++ components when no prebuilt binary is fetched.

```bash
$ PYTHON=python3.9 npm install mediasoup@3
```

--------------------------------

### Include libmediasoupclient header

Source: https://mediasoup.org/documentation/v3/libmediasoupclient/installation/

Include the libmediasoupclient header in your C++ application.

```cpp
#include "libmediasoupclient/mediasoupclient.hpp"
```

--------------------------------

### Generate build files for Linux Debian Stretch with GCC 6.3

Source: https://mediasoup.org/documentation/v3/libmediasoupclient/installation/

GN command to generate build files for Linux Debian Stretch with GCC 6.3, including additional flags for warnings and ozone.

```bash
$ gn gen out/m140 --args='is_debug=false is_component_build=false is_clang=false rtc_include_tests=false rtc_use_h264=true use_rtti=true use_custom_libcxx=false treat_warnings_as_errors=false use_ozone=true'
```

--------------------------------

### Create device with Device.factory() and handle UnsupportedError

Source: https://mediasoup.org/documentation/v3/mediasoup-client/api/

Creates a new device using `Device.factory()`. Throws `UnsupportedError` if the current browser/device is not supported. The example catches the error and logs a warning.

```javascript
let device;

try
{
  device = await Device.factory();
}
catch (error)
{
  if (error.name === 'UnsupportedError')
    console.warn('browser not supported');
}
```

--------------------------------

### Use custom mediasoup-worker binary with MEDIASOUP_WORKER_BIN

Source: https://mediasoup.org/documentation/v3/mediasoup/installation/

Sets the MEDIASOUP_WORKER_BIN environment variable during installation to use a custom mediasoup-worker binary instead of compiling locally. The same variable must be set when running the Node.js app so mediasoup uses that binary instead of looking in the mediasoup/worker/out/Release path.

```bash
MEDIASOUP_WORKER_BIN="/home/xxx/src/foo/mediasoup-worker" npm install mediasoup@3
MEDIASOUP_WORKER_BIN="/home/xxx/src/foo/mediasoup-worker" node myapp.js
```

--------------------------------

### Create device with new Device() and handle UnsupportedError

Source: https://mediasoup.org/documentation/v3/mediasoup-client/api/

Creates a new device using the `Device` constructor (deprecated). Throws `UnsupportedError` if the current browser/device is not supported. The example catches the error and logs a warning.

```javascript
let device;

try
{
  device = new mediasoupClient.Device();
}
catch (error)
{
  if (error.name === 'UnsupportedError')
    console.warn('browser not supported');
}
```

--------------------------------

### Create Audio Level Observer with router.createAudioLevelObserver

Source: https://mediasoup.org/documentation/v3/mediasoup/api/

Asynchronously creates a new audio level observer with the given options. The example sets maxEntries to 1, threshold to -70, and interval to 2000 ms. Returns an AudioLevelObserver.

```javascript
const audioLevelObserver = await router.createAudioLevelObserver(
  {
    maxEntries : 1,
    threshold  : -70,
    interval   : 2000
  });
```

--------------------------------

### Configure with hidden visibility flags

Source: https://mediasoup.org/documentation/v3/libmediasoupclient/installation/

Provide the corresponding visibility compilation flags to avoid linker warnings, e.g., when libwebrtc was built with hidden symbol visibility.

```bash
cmake . -Bbuild \
  -DLIBWEBRTC_INCLUDE_PATH:PATH=${PATH_TO_LIBWEBRTC_SOURCES} \
  -DLIBWEBRTC_BINARY_PATH:PATH=${PATH_TO_LIBWEBRTC_BINARY} \
  -DCMAKE_CXX_FLAGS="-fvisibility=hidden"
```

--------------------------------

### Create Device with forcedRtpExtensions

Source: https://mediasoup.org/documentation/v3/mediasoup-client/api/

Creates a device with forced RTP extensions, enabling or disabling specific RTP extension URIs. The example enables the `abs-capture-time` extension.

```javascript
const device = await Device.factory({
  forcedRtpExtensions: {
    'http://www.webrtc.org/experiments/rtp-hdrext/abs-capture-time': true
  },
});
```

--------------------------------

### Create a router with worker.createRouter()

Source: https://mediasoup.org/documentation/v3/mediasoup/api/

Asynchronously creates a new router. The example defines media codecs for audio (Opus) and video (H.264) and passes them in the options.

```javascript
const mediaCodecs =
[
  {
    kind        : "audio",
    mimeType    : "audio/opus",
    clockRate   : 48000,
    channels    : 2
  },
  {
    kind       : "video",
    mimeType   : "video/H264",
    clockRate  : 90000,
    parameters :
    {
      "packetization-mode"      : 1,
      "profile-level-id"        : "42e01f",
      "level-asymmetry-allowed" : 1
    }
  }
];

const router = await worker.createRouter({ mediaCodecs });
```

--------------------------------

### Create Active Speaker Observer with router.createActiveSpeakerObserver

Source: https://mediasoup.org/documentation/v3/mediasoup/api/

Asynchronously creates a new active speaker observer with the given options. The example sets an interval of 500 ms. Returns an ActiveSpeakerObserver.

```javascript
const activeSpeakerObserver = await router.createActiveSpeakerObserver(
  {
    interval   : 500
  });
```

--------------------------------

### Create a WebRTC server with worker.createWebRtcServer()

Source: https://mediasoup.org/documentation/v3/mediasoup/api/

Asynchronously creates a new WebRTC server. The example configures listenInfos with UDP and TCP protocols on IP 9.9.9.9 port 20000.

```javascript
const webRtcServer = await worker.createWebRtcServer(
  {
    listenInfos :
    [
      {
        protocol : 'udp',
        ip       : '9.9.9.9',
        port     : 20000
      },
      {
        protocol : 'tcp',
        ip       : '9.9.9.9',
        port     : 20000
      }
    ]
  });
```

--------------------------------

### OnConnect implementation example

Source: https://mediasoup.org/documentation/v3/libmediasoupclient/api/

Called when the transport is about to establish the ICE+DTLS connection. In server side, the application should call webRtcTransport.connect(). Returns std::future<void> when the transport is created in server side mediasoup.

```cpp
std::future<void> MyTransportListener::OnConnect(
  mediasoupclient::Transport transport,
  const json& dtlsParameters
)
{
	std::promise<void> promise;

	json body =
	{
		{ "transportId",    transport->GetId() },
		{ "dtlsParameters", dtlsParameters     }
	};

	// Signal local DTLS parameters to the server side transport.
	mySignaling.send("transport-connect", body);

	// [...] Let's assume code execution continues once we get a success response
	// from the server.

	// Fulfil the promise and return its future.
	promise.set_value();

	return promise.get_future();
}
```

--------------------------------

### Get libmediasoupclient version

Source: https://mediasoup.org/documentation/v3/libmediasoupclient/api/

Call mediasoupclient::Version() to retrieve the library version as a std::string. The example shows the expected output "1.0.0".

```cpp
mediasoupclient::Version();
// "1.0.0"
```

--------------------------------

### Observer API usage example

Source: https://mediasoup.org/documentation/v3/mediasoup-client/api/

Shows how to use the observer property to monitor creation and closure of transports, producers, consumers, data producers, and data consumers. The observer is a Node.js EventEmitter intended for third-party libraries, not for direct application use.

```javascript
const mediasoupClient = require("mediasoup-client");

const mediasoupClientDevice = new mediasoupClientTypes.Device();

mediasoupClientDevice.observer.on("newtransport", (transport) =>
{
  console.log(
    "new transport created [transport.id:%s]", transport.id);

  transport.observer.on("close", () => 
  {
    console.log("transport closed [transport.id:%s]", transport.id);
  });

  transport.observer.on("newproducer", (producer) =>
  {
    console.log(
      "new producer created [transport.id:%s, producer.id:%s]",
      transport.id, producer.id);

    producer.observer.on("close", () => 
    {
      console.log("producer closed [producer.id:%s]", producer.id);
    });
  });

  transport.observer.on("newconsumer", (consumer) =>
  {
    console.log(
      "new consumer created [transport.id:%s, consumer.id:%s]",
      transport.id, consumer.id);

    consumer.observer.on("close", () => 
    {
      console.log("consumer closed [consumer.id:%s]", consumer.id);
    });
  });

  transport.observer.on("newdataproducer", (dataProducer) =>
  {
    console.log(
      "new data producer created [transport.id:%s, dataProducer.id:%s]",
      transport.id, dataProducer.id);

    dataProducer.observer.on("close", () => 
    {
      console.log("data producer closed [dataProducer.id:%s]", dataProducer.id);
    });
  });

  transport.observer.on("newdataconsumer", (dataConsumer) =>
  {
    console.log(
      "new data consumer created [transport.id:%s, dataConsumer.id:%s]",
      transport.id, dataConsumer.id);

    dataConsumer.observer.on("close", () => 
    {
      console.log("data consumer closed [dataConsumer.id:%s]", dataConsumer.id);
    });
  });
});
```

--------------------------------

### Device.factory(options)

Source: https://mediasoup.org/documentation/v3/mediasoup-client/api/

Creates a new device. This is the recommended way to instantiate a Device. It is asynchronous and throws an UnsupportedError if the current browser/device is not supported.

```APIDOC
## Device.factory(options)

### Description
Creates a new device. Currently, using `Device.factory()` instead of the `Device` constructor provides no benefit.

### Method
factory

### Parameters
#### options (DeviceOptions) - Optional - Device options.

### Returns
- Device

### Throws
- UnsupportedError, if the current browser/device is not supported.

### Example
```javascript
let device;

try
{
  device = await Device.factory();
}
catch (error)
{
  if (error.name === 'UnsupportedError')
    console.warn('browser not supported');
}
```
```

--------------------------------

### Get worker resource usage with worker.getResourceUsage()

Source: https://mediasoup.org/documentation/v3/mediasoup/api/

Asynchronously retrieves resource usage of the worker subprocess. Returns a WorkerResourceUsage object with fields like ru_idrss, ru_maxrss, ru_utime, etc. The example shows the returned object structure.

```javascript
const usage = await worker.getResourceUsage();

// =>
{
  ru_idrss: 0,
  ru_inblock: 0,
  ru_isrss: 0,
  ru_ixrss: 0,
  ru_majflt: 0,
  ru_maxrss: 46047232,
  ru_minflt: 11446,
  ru_msgrcv: 23641,
  ru_msgsnd: 40005,
  ru_nivcsw: 27926,
  ru_nsignals: 0,
  ru_nswap: 0,
  ru_nvcsw: 0,
  ru_oublock: 0,
  ru_stime: 1026,
  ru_utime: 3066
}
```

--------------------------------

### mediasoup.getSupportedRtpCapabilities usage

Source: https://mediasoup.org/documentation/v3/mediasoup/api/

Returns a cloned copy of the mediasoup supported RTP capabilities. The example logs the result, showing the structure with codecs and headerExtensions. Note: these are not the capabilities needed for mediasoup-client's device.load() or libmediasoupclient's device.Load(); use router.rtpCapabilities instead.

```javascript
const rtpCapabilities = mediasoup.getSupportedRtpCapabilities();

console.log(rtpCapabilities);
// => { codecs: [...], headerExtensions: [...] }
```

--------------------------------

### new Device(options)

Source: https://mediasoup.org/documentation/v3/mediasoup-client/api/

Creates a new device. This constructor is deprecated; use Device.factory() instead. It throws an UnsupportedError if the current browser/device is not supported.

```APIDOC
## new Device(options)

### Description
Creates a new device. This constructor is deprecated; use Device.factory() instead.

### Method
constructor

### Parameters
#### options (DeviceOptions) - Optional - Device options.

### Throws
- UnsupportedError, if the current browser/device is not supported.

### Example
```javascript
let device;

try
{
  device = new mediasoupClient.Device();
}
catch (error)
{
  if (error.name === 'UnsupportedError')
    console.warn('browser not supported');
}
```
```

--------------------------------

### Instantiate mediasoupClient.Device

Source: https://mediasoup.org/documentation/v3/mediasoup-client/api/

Creates a new Device instance, the main class for mediasoup-client.

```javascript
const device = new mediasoupClient.Device();
```

--------------------------------

### Device.factory(options)

Source: https://mediasoup.org/documentation/v3/mediasoup-client/api/

Static factory method to create a Device instance. Equivalent to `new Device(options)`.

```APIDOC
## Device.factory(options)

### Description
Static factory method to create a Device instance. Equivalent to `new Device(options)`.

### Method
Static Function

### Parameters
- **options** (DeviceOptions) - Required - Options for the Device.

### Returns
- **Device** - A new Device instance.
```

--------------------------------

### Using different video codecs per Producer with codec option

Source: https://mediasoup.org/documentation/v3/tricks/

Starting from mediasoup-client 3.6.0, the `codec` option in ProducerOptions allows selecting a specific codec for each producer. This example uses H264 for webcam and VP8 for screen sharing, assuming the Router has been provided with both codecs. The codec is found from `device.sendRtpCapabilities.codecs` by matching the MIME type.

```javascript
// Assuming that the mediasoup Router has been provided with both VP8 and H264
// video codecs, let's use H264 for webcam and VP8 for screen sharing.

const webcamProducer = await sendTransport.produce(
  {
    track: videoTrack,
    codec : device.sendRtpCapabilities.codecs
      .find((codec) => codec.mimeType.toLowerCase() === 'video/h264')
  });

const sharingProducer = await sendTransport.produce(
  {
    track: sharingTrack,
    codec : device.sendRtpCapabilities.codecs
      .find((codec) => codec.mimeType.toLowerCase() === 'video/vp8')
  });
```

--------------------------------

### mediasoup.parseScalabilityMode examples

Source: https://mediasoup.org/documentation/v3/mediasoup/api/

Parses a scalabilityMode string according to webrtc-svc rules. Returns an object with spatialLayers and temporalLayers, defaulting to 1 each. The examples show various inputs including undefined.

```javascript
mediasoup.parseScalabilityMode("L2T3");
// => { spatialLayers: 2, temporalLayers: 3 }

mediasoup.parseScalabilityMode("S3T3");
// => { spatialLayers: 3, temporalLayers: 3 }

mediasoup.parseScalabilityMode("L4T7_KEY_SHIFT");
// => { spatialLayers: 4, temporalLayers: 7 }

mediasoup.parseScalabilityMode(undefined);
// => { spatialLayers: 1, temporalLayers: 1 }
```

--------------------------------

### DirectTransport getStats() example

Source: https://mediasoup.org/documentation/v3/mediasoup/rtc-statistics/

Retrieves statistics for a DirectTransport. The returned array includes fields such as recvBitrate, sendBitrate, and transportId. The example shows a transport with no RTP or RTX bytes received or sent.

```javascript
const stats = await directTransport.getStats();

// =>
[
  {
    "probationBytesSent": 0,
    "probationSendBitrate": 0,
    "recvBitrate": 5672,
    "rtpBytesReceived": 0,
    "rtpBytesSent": 0,
    "rtpRecvBitrate": 0,
    "rtpSendBitrate": 0,
    "rtxBytesReceived": 0,
    "rtxBytesSent": 0,
    "rtxRecvBitrate": 0,
    "rtxSendBitrate": 0,
    "sendBitrate": 3204,
    "timestamp": 894308981,
    "transportId": "huif60cd-10ac-443b-8529-6474ecba2123",
    "type": "direct-transport"
  }
]
```

--------------------------------

### PipeTransport getStats() example

Source: https://mediasoup.org/documentation/v3/mediasoup/rtc-statistics/

Retrieves statistics for a PipeTransport. The returned array includes fields such as tuple and transportId. The example shows a transport with a tuple where the remote IP is the same as the local IP, indicating a local pipe.

```javascript
const stats = await pipeTransport.getStats();

// =>
[
  {
    "probationBytesSent": 0,
    "probationSendBitrate": 0,
    "recvBitrate": 1802072,
    "rtpBytesReceived": 5104571,
    "rtpBytesSent": 0,
    "rtpRecvBitrate": 1835651,
    "rtpSendBitrate": 0,
    "rtxBytesReceived": 0,
    "rtxBytesSent": 0,
    "rtxRecvBitrate": 0,
    "rtxSendBitrate": 0,
    "sendBitrate": 24,
    "timestamp": 924308980,
    "transportId": "352f60cd-10ac-443b-8529-6474ecba2e46",
    "tuple": 
    {
      "localAddress": "11.22.33.44",
      "localPort": 12455,
      "protocol": "udp",
      "remoteIp": "11.22.33.44",
      "remotePort": 42301
    },
    "type": "pipe-transport"
  }
]
```

--------------------------------

### PlainTransport getStats() example

Source: https://mediasoup.org/documentation/v3/mediasoup/rtc-statistics/

Retrieves statistics for a PlainTransport. The returned array includes fields such as comedia, rtcpMux, tuple, and transportId. The example shows a transport with comedia and rtcpMux set to true and a tuple with local and remote addresses.

```javascript
const stats = await plainTransport.getStats();

// =>
[
  {
    "bytesReceived": 467406,
    "bytesSent": 2550,
    "comedia": true,
    "rtcpMux": true,
    "probationBytesSent": 0,
    "probationSendBitrate": 0,
    "recvBitrate": 1802072,
    "rtpBytesReceived": 5104571,
    "rtpBytesSent": 0,
    "rtpRecvBitrate": 1835651,
    "rtpSendBitrate": 0,
    "rtxBytesReceived": 0,
    "rtxBytesSent": 0,
    "rtxRecvBitrate": 0,
    "rtxSendBitrate": 0,
    "sendBitrate": 24,
    "timestamp": 924308648,
    "transportId": "8e7dc219-5cb0-4cca-b1ca-0bbbc584a364",
    "tuple": 
    {
      "localAddress": "11.22.33.44",
      "localPort": 45346,
      "protocol": "udp",
      "remoteIp": "55.66.77.88",
      "remotePort": 56971
    },
    "type": "plain-rtp-transport"
  }
]
```

--------------------------------

### WebRtcTransport getStats() example

Source: https://mediasoup.org/documentation/v3/mediasoup/rtc-statistics/

Retrieves statistics for a WebRtcTransport. The returned array includes fields such as availableOutgoingBitrate, iceState, dtlsState, sctpState, and transportId. The example shows a connected transport with an iceRole of 'controlled' and an iceSelectedTuple with local and remote addresses.

```javascript
const stats = await webRtcTransport.getStats();

// =>
[
  {
    "availableOutgoingBitrate": 6750000,
    "bytesReceived": 5360091,
    "bytesSent": 20988,
    "dtlsState": "connected",
    "iceRole": "controlled",
    "iceSelectedTuple": {
      "localAddress": "11.22.33.44",
      "localPort": 56726,
      "protocol": "udp",
      "remoteIp": "55.66.77.88",
      "remotePort": 52320
    },
    "iceState": "completed",
    "maxIncomingBitrate": 5500000,
    "probationBytesSent": 0,
    "probationSendBitrate": 0,
    "recvBitrate": 1802072,
    "rtpBytesReceived": 5104571,
    "rtpBytesSent": 0,
    "rtpPacketLossSent": 0,
    "rtpRecvBitrate": 1835651,
    "rtpSendBitrate": 0,
    "rtxBytesReceived": 179934,
    "rtxBytesSent": 0,
    "rtxRecvBitrate": 0,
    "rtxSendBitrate": 0,
    "sctpState": "connected",
    "sendBitrate": 4992,
    "timestamp": 18079607138,
    "transportId": "a00746bd-0758-4dfc-9f5f-c0ad4eb326d5",
    "type": "webrtc-transport"
  }
]
```

--------------------------------

### Force a specific built-in handler with Device constructor

Source: https://mediasoup.org/documentation/v3/mediasoup-client/api/

Web applications can force a specific built-in handler by passing `handlerName` to the `Device` constructor, for example forcing `Chrome67` in Chrome >= 70 instead of auto-detecting `Chrome70`. The example uses `Chrome111`.

```javascript
const device = new mediasoupClient.Device({ handlerName: "Chrome111" });
```

--------------------------------

### new Device(options)

Source: https://mediasoup.org/documentation/v3/mediasoup-client/api/

Creates a new Device instance. The Device represents a mediasoup client device and is used to load router RTP capabilities and create transports.

```APIDOC
## new Device(options)

### Description
Creates a new Device instance. The Device represents a mediasoup client device and is used to load router RTP capabilities and create transports.

### Method
Constructor

### Parameters
- **options** (DeviceOptions) - Required - Options for the Device, including `handlerName` and `handlerFactory`.

### Returns
- **Device** - A new Device instance.
```

--------------------------------

### transport.produceData() with SCTP and direct transport

Source: https://mediasoup.org/documentation/v3/mediasoup/api/

Creates a data producer on the transport. The first example uses SCTP (DataChannel) with sctpStreamParameters, label, and ordered flag. The second example uses a direct transport with no options, allowing data messages to be sent directly from the Node.js application.

```javascript
// Using SCTP:
const dataProducer = await transport.produceData(
  {
    sctpStreamParameters :
    {
      streamId : 4,
      ordered  : true
    },
    label : 'foo'
  });
```

```javascript
// Using a direct transport:
const dataProducer = await transport.produceData();
```

--------------------------------

### worker.createWebRtcServer<WebRtcServerAppData>(options)

Source: https://mediasoup.org/documentation/v3/mediasoup/api/

Creates a new WebRTC server. Returns a WebRtcServer instance.

```APIDOC
## worker.createWebRtcServer<WebRtcServerAppData>(options)

### Description
Creates a new WebRTC server. Returns a WebRtcServer instance.

### Method
createWebRtcServer

### Endpoint
worker.createWebRtcServer<WebRtcServerAppData>(options)

### Parameters
#### Request Body
- **options** (WebRtcServerOptions) - Required - WebRTC server options.
- **WorkerAppData** (AppData) - Optional - Custom `appData` definition. Default: `{ }`.

### Request Example
```
const webRtcServer = await worker.createWebRtcServer(
  {
    listenInfos :
    [
      {
        protocol : 'udp',
        ip       : '9.9.9.9',
        port     : 20000
      },
      {
        protocol : 'tcp',
        ip       : '9.9.9.9',
        port     : 20000
      }
    ]
  });
```

### Response
#### Success Response
- **WebRtcServer** (WebRtcServer) - The created WebRTC server.
```

--------------------------------

### Create a Device instance

Source: https://mediasoup.org/documentation/v3/libmediasoupclient/api/

Instantiate a mediasoupclient::Device object, which represents an endpoint connecting to a mediasoup Router.

```cpp
auto* device = new mediasoupclient::Device();
```

--------------------------------

### mediasoupclient::Initialize()

Source: https://mediasoup.org/documentation/v3/libmediasoupclient/api/

Initializes libmediasoupclient and libwebrtc.

```APIDOC
## mediasoupclient::Initialize()

### Description
libmediasoupclient initialization. Initializes libwebrtc.

### Example
```cpp
mediasoupclient::Initialize();
```
```

--------------------------------

### Observe new router with worker.observer.on('newrouter')

Source: https://mediasoup.org/documentation/v3/mediasoup/api/

Emitted when a new router is created. The example logs the router id.

```javascript
worker.observer.on("newrouter", (router) =>
{
  console.log("new router created [id:%s]", router.id);
});
```

--------------------------------

### Log device.handlerName

Source: https://mediasoup.org/documentation/v3/mediasoup-client/api/

Logs the selected handler class name. The example output shows `"Chrome74"`.

```javascript
console.log(device.handlerName);
// => "Chrome74"
```

--------------------------------

### router.createAudioLevelObserver<AudioLevelObserverAppData>(options)

Source: https://mediasoup.org/documentation/v3/mediasoup/api/

Creates a new audio level observer. This is an asynchronous method that returns an AudioLevelObserver instance.

```APIDOC
## router.createAudioLevelObserver<AudioLevelObserverAppData>(options)

### Description
Creates a new audio level observer.

### Method
createAudioLevelObserver

### Parameters
#### Options
- **options** (AudioLevelObserverOptions) - Optional - Options.
- **AudioLevelObserverAppData** (AppData) - Optional - Custom `appData` definition. Default: `{ }`

### Request Example
```javascript
const audioLevelObserver = await router.createAudioLevelObserver(
  {
    maxEntries : 1,
    threshold  : -70,
    interval   : 2000
  });
```

### Response
#### Success Response
- **AudioLevelObserver** - The created audio level observer.
```

--------------------------------

### consumer.getStats()

Source: https://mediasoup.org/documentation/v3/mediasoup-client/api/

Gets the local RTP receiver statistics by calling `getStats()` in the underlying `RTCRtpReceiver` instance. Returns an RTCStatsReport.

```APIDOC
## consumer.getStats()

### Description
Gets the local RTP receiver statistics by calling `getStats()` in the underlying `RTCRtpReceiver` instance. Returns an RTCStatsReport.

### Method
getStats

### Parameters
None

### Response
- **RTCStatsReport** - The RTP receiver statistics.
```

--------------------------------

### new Device()

Source: https://mediasoup.org/documentation/v3/libmediasoupclient/api/

Creates a new Device instance, which represents an endpoint that connects to a mediasoup Router.

```APIDOC
## new Device()

### Description
Creates a new device.

### Returns
mediasoupclient::Device

### Example
```cpp
auto* device = new mediasoupclient::Device();
```
```

--------------------------------

### producer.getStats()

Source: https://mediasoup.org/documentation/v3/mediasoup-client/api/

Gets the local RTP sender statistics by calling `getStats()` on the underlying `RTCRtpSender` instance. Returns a `RTCStatsReport`.

```APIDOC
## producer.getStats()

### Description
Gets the local RTP sender statistics by calling `getStats()` in the underlying `RTCRtpSender` instance.

### Method
getStats

### Endpoint
producer.getStats()

### Parameters
None

### Response
#### Success Response
- **RTCStatsReport** - The RTP sender statistics.

### Notes
- This is an asynchronous method.
```

--------------------------------

### Initialize libmediasoupclient

Source: https://mediasoup.org/documentation/v3/libmediasoupclient/api/

Call mediasoupclient::Initialize() to initialize libmediasoupclient and libwebrtc.

```cpp
mediasoupclient::Initialize();
```

--------------------------------

### mediasoupclient::Initialize()

Source: https://mediasoup.org/documentation/v3/libmediasoupclient/api/

Initializes the libmediasoupclient library. Must be called before using any other functionality.

```APIDOC
## mediasoupclient::Initialize()

### Description
Initializes the libmediasoupclient library. Must be called before using any other functionality.

### Method
Function

### Signature
`void Initialize()`
```

--------------------------------

### Log all ICE and DTLS debugs/warnings and any kind of error

Source: https://mediasoup.org/documentation/v3/mediasoup/debugging/

Set DEBUG to "mediasoup* *ERROR*" and create a worker with logLevel "debug" and logTags ["ice", "dtls"] to log ICE and DTLS debug/warning messages and errors.

```bash
$ DEBUG="mediasoup* *ERROR*" node myapp.js
```

```javascript
const mediasoup = require("mediasoup");

const worker = await mediasoup.createWorker(
  {
    logLevel : "debug",
    logTags  : [ "ice", "dtls" ]
  });
```

--------------------------------

### dataConsumer.GetReadyState()

Source: https://mediasoup.org/documentation/v3/libmediasoupclient/api/

Returns the DataChannel ready state.

```APIDOC
## dataConsumer.GetReadyState()

### Description
Returns the DataChannel ready state.

### Returns
`webrtc::DataChannelInterface::DataState`
```

--------------------------------

### transport.getStats()

Source: https://mediasoup.org/documentation/v3/mediasoup-client/api/

Gets the local transport statistics by calling `getStats()` in the underlying `RTCPeerConnection` instance. This is an asynchronous method that returns an RTCStatsReport.

```APIDOC
## transport.getStats()

### Description
Gets the local transport statistics by calling `getStats()` in the underlying `RTCPeerConnection` instance. This is an asynchronous method that returns an RTCStatsReport.

### Method
getStats

### Parameters
None

### Response
- **RTCStatsReport** - The local transport statistics.
```

--------------------------------

### Log everything with DEBUG="*"

Source: https://mediasoup.org/documentation/v3/mediasoup/debugging/

Set DEBUG to "*" to log everything, including logs from other libraries using the debug module such as Express.

```bash
$ DEBUG="*" node myapp.js
```

--------------------------------

### router.createAudioLevelObserver(options)

Source: https://mediasoup.org/documentation/v3/mediasoup/api/

Creates a new AudioLevelObserver instance within the Router. This observer monitors audio levels of producers.

```APIDOC
## Method: router.createAudioLevelObserver(options)

### Description
Creates a new AudioLevelObserver instance within the Router.

### Method
Function

### Parameters
- **options** (AudioLevelObserverOptions) - Optional - Observer options.

### Request Example
```javascript
const observer = await router.createAudioLevelObserver();
```

### Response
Returns a Promise that resolves to an AudioLevelObserver instance.
```

--------------------------------

### NotFoundError

Source: https://mediasoup.org/documentation/v3/mediasoup/api/

Custom error class indicating that a referenced entity doesn't exist. Example usage when calling transport.consume() and the producer is closed.

```APIDOC
## NotFoundError

### Description
Custom error class indicating that a referenced entity doesn't exist. For example, when calling `transport.consumer()` it may happen that the associated producer is already closed. In this case, the method will reject with `NotFoundError`.

### Class Definition
```
class NotFoundError extends Error
```

### Usage Example
```javascript
import { NotFoundError } from 'mediasoup/errors';

try
{
  const consumer = await transport.consume(
    {
      producerId: 'xxxxx',
      rtpCapabilities: peerRtpCapabilities
    });
}
catch (error)
{
  if (error.instanceof(NotFoundError))
  {
    // Producer is closed, this is a legitimate scenario.
  }
  else
  {
    // Something was wrong.
  }
}
```

```

--------------------------------

### Log all RTCP warnings and any kind of error with logTags

Source: https://mediasoup.org/documentation/v3/mediasoup/debugging/

Set DEBUG to "mediasoup:WARN:* mediasoup:ERROR:*" and create a worker with logLevel "warn" and logTags ["rtcp"] to log RTCP warnings and errors.

```bash
$ DEBUG="mediasoup:WARN:* mediasoup:ERROR:*" node myapp.js
```

```javascript
const mediasoup = require("mediasoup");

const worker = await mediasoup.createWorker(
  {
    logLevel : "warn",
    logTags  : [ "rtcp" ]
  });
```

--------------------------------

### K-SVC Consumer encodings with scalabilityMode L4T5_KEY

Source: https://mediasoup.org/documentation/v3/mediasoup/rtp-parameters-and-capabilities/

Consumer rtpParameters.encodings for K-SVC with 4 spatial and 5 temporal layers. The consumer gets a single stream with the same scalabilityMode as the producer.

```plaintext
encodings :
[
  { ssrc: 222220, scalabilityMode: 'L4T5_KEY' }
]
```

--------------------------------

### producer.GetStats()

Source: https://mediasoup.org/documentation/v3/libmediasoupclient/api/

Gets local RTP sender statistics by calling getStats() on the underlying RTCRtpSender instance. This method blocks the current thread.

```APIDOC
## producer.GetStats()

### Description
Gets local RTP sender statistics by calling getStats() on the underlying RTCRtpSender instance. This method blocks the current thread.

### Method
GetStats

### Returns
- **nlohmann::json RTCStatsReport** - RTP statistics.
```

--------------------------------

### transport.GetStats()

Source: https://mediasoup.org/documentation/v3/libmediasoupclient/api/

Gets the local transport statistics by calling getStats() on the underlying RTCPeerConnection instance. This method is asynchronous and blocks the current thread.

```APIDOC
## transport.GetStats()

### Description
Gets the local transport statistics by calling `getStats()` in the underlying `RTCPeerConnection` instance. This method is asynchronous and blocks the current thread.

### Method
GetStats

### Returns
- **nlohmann::json&** - RTCStatsReport.
```

--------------------------------

### consumer.Resume()

Source: https://mediasoup.org/documentation/v3/libmediasoupclient/api/

Resumes the consumer.

```APIDOC
## consumer.Resume()

### Description
Resumes the consumer.

### Method
Method

### Signature
`void Resume()`
```

--------------------------------

### consumer.observer.on('trace', fn(trace))

Source: https://mediasoup.org/documentation/v3/mediasoup/api/

Same as the trace event.

```APIDOC
## consumer.observer.on('trace', fn(trace))

### Description
Same as the trace event.

### Event
`trace`

### Callback Arguments
- **trace** (ConsumerTraceEventData) - Trace data.
```

--------------------------------

### transport.on('trace') example

Source: https://mediasoup.org/documentation/v3/mediasoup/api/

Listens for the 'trace' event, which is emitted when trace events are enabled via enableTraceEvent(). The trace argument contains TransportTraceEventData.

```javascript
transport.on("trace", (trace) =>
{
  console.log(trace);
});
```

--------------------------------

### transport.consumeData() example

Source: https://mediasoup.org/documentation/v3/mediasoup/api/

Creates a DataConsumer on the transport to receive data messages via SCTP or directly if the transport is a DirectTransport. The dataProducerId option is required.

```javascript
const dataConsumer = await transport.consumeData(
  {
    dataProducerId : "a7a955cf-fe67-4327-bd98-bbd85d7e2ba4"
  });
```

--------------------------------

### new Device()

Source: https://mediasoup.org/documentation/v3/libmediasoupclient/api/

Creates a new Device instance. The Device represents the local client device and is used to load router capabilities and create transports.

```APIDOC
## new Device()

### Description
Creates a new Device instance. The Device represents the local client device and is used to load router capabilities and create transports.

### Method
Constructor

### Signature
`Device()`
```

--------------------------------

### Observe new WebRTC server with worker.observer.on('newwebrtcserver')

Source: https://mediasoup.org/documentation/v3/mediasoup/api/

Emitted when a new WebRTC server is created. The example logs the WebRTC server id.

```javascript
worker.observer.on("newwebrtcserver", (webRtcServer) =>
{
  console.log("new WebRTC server created [id:%s]", webRtcServer.id);
});
```

--------------------------------

### Handle worker 'died' event

Source: https://mediasoup.org/documentation/v3/mediasoup/api/

Emitted when the worker subprocess unexpectedly dies. The example logs the error. This should never happen; if it does, it's a bug.

```javascript
worker.on("died", (error) =>
{
  console.error("mediasoup worker died!: %o", error);
});
```

--------------------------------

### Update worker settings with worker.updateSettings()

Source: https://mediasoup.org/documentation/v3/mediasoup/api/

Asynchronously updates a subset of worker settings at runtime. The example sets logLevel to "warn".

```javascript
await worker.updateSettings({ logLevel: "warn" });
```

--------------------------------

### dataConsumer.GetReadyState()

Source: https://mediasoup.org/documentation/v3/libmediasoupclient/api/

Returns the ready state of the data consumer.

```APIDOC
## dataConsumer.GetReadyState()

### Description
Returns the ready state of the data consumer.

### Method
Method

### Signature
`DataConsumerReadyState GetReadyState() const`

### Returns
- **DataConsumerReadyState** - The ready state.
```

--------------------------------

### consumer.GetStats()

Source: https://mediasoup.org/documentation/v3/libmediasoupclient/api/

Gets the local RTP receiver statistics by calling `getStats()` in the underlying `RTCRtpReceiver` instance. This method is asynchronous and blocks the current thread.

```APIDOC
## consumer.GetStats()

### Description
Gets the local RTP receiver statistics by calling `getStats()` in the underlying `RTCRtpReceiver` instance. This method is asynchronous and blocks the current thread.

### Returns
nlohmann::json RTCStatsReport
```
Tokens:
Raw