### Install libmediasoupclient

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

Optionally install the built libmediasoupclient library to the system.

```bash
$ make install -C build/

```

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

### Install mediasoup-client v3

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

Use npm to install version 3 of the mediasoup-client library. This command should be run in your client application's directory.

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

```

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

### Install mediasoup v3 via NPM

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

Installs the mediasoup v3 package using NPM. The installation process will attempt to fetch a prebuilt mediasoup-worker binary or build it locally if not found.

```bash
$ npm install mediasoup@3

```

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

### mediasoup v3 Worker Logs Example

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

This example shows typical log output from a mediasoup worker process, including configuration details and internal events.

```text
mediasoup:worker[pid:80653] mediasoup-worker::main() | starting mediasoup-worker process [version:3.0.0-dev] +0ms
mediasoup:worker[pid:80653] mediasoup-worker::main() | little-endian CPU detected +0ms
mediasoup:worker[pid:80653] mediasoup-worker::main() | 64 bits architecture detected +1ms
mediasoup:worker[pid:80653] Settings::PrintConfiguration() | <configuration> +0ms
mediasoup:worker[pid:80653] Settings::PrintConfiguration() |   logLevel            : debug +0ms
mediasoup:worker[pid:80653] Settings::PrintConfiguration() |   logTags             : info,simulcast +0ms
mediasoup:worker[pid:80653] Settings::PrintConfiguration() |   rtcMinPort          : 40000 +0ms
mediasoup:worker[pid:80653] Settings::PrintConfiguration() |   rtcMaxPort          : 49999 +0ms
mediasoup:worker[pid:80653] Settings::PrintConfiguration() | </configuration> +0ms
mediasoup:worker[pid:80653] DepLibUV::PrintVersion() | libuv version: "1.27.0" +0ms
mediasoup:worker[pid:80653] DepOpenSSL::ClassInit() | openssl version: "OpenSSL 1.1.1b  26 Feb 2019" +0ms
mediasoup:worker[pid:80653] DepLibSRTP::ClassInit() | libsrtp version: "libsrtp 2.0.0" +0ms
mediasoup:Worker worker process running [pid:80653] +28ms
mediasoup:Worker createRouter() +1m
mediasoup:Channel[pid:80653] request() [method:worker.createRouter, id:1] +1m
mediasoup:Channel[pid:80653] request succeeded [method:worker.createRouter, id:1] +4ms
mediasoup:Router constructor() +0ms
mediasoup:Channel[pid:80653] request() [method:router.createWebRtcTransport, id:3] +360ms
mediasoup:Channel[pid:80653] request succeeded [method:router.createWebRtcTransport, id:3] +4ms
mediasoup:Transport constructor() +0ms
mediasoup:WebRtcTransport constructor() +0ms
mediasoup:Transport setMaxIncomingBitrate() [bitrate:1500000] +4ms
mediasoup:Channel[pid:80653] request() [method:transport.setMaxIncomingBitrate, id:4] +8ms
mediasoup:Channel[pid:80653] request succeeded [method:transport.setMaxIncomingBitrate, id:4] +2ms

```

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

### Connect PlainTransport

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

Examples of calling connect() on a PlainTransport with various configurations for comedia, rtcpMux, and SRTP.

```javascript
// Calling connect() on a PlainTransport created with comedia and rtcpMux set.
await plainTransport.connect(
  {
    ip   : '1.2.3.4',
    port : 9998
  });
```

```javascript
// Calling connect() on a PlainTransport created with comedia unset and rtcpMux
// also unset.
await plainTransport.connect(
  {
    ip       : '1.2.3.4',
    port     : 9998,
    rtcpPort : 9999
  });
```

```javascript
// Calling connect() on a PlainTransport created with comedia set and
// enableSrtp enabled.
await plainTransport.connect(
  {
    srtpParameters :
    {
      cryptoSuite : 'AES_CM_128_HMAC_SHA1_80',
      keyBase64   : 'ZnQ3eWJraDg0d3ZoYzM5cXN1Y2pnaHU5NWxrZTVv'
    }
  });
```

```javascript
// Calling connect() on a PlainTransport created with comedia unset, rtcpMux
// set and enableSrtp enabled.
await plainTransport.connect(
  {
    ip             : '1.2.3.4',
    port           : 9998,
    srtpParameters :
    {
      cryptoSuite : 'AEAD_AES_256_GCM',
      keyBase64   : 'YTdjcDBvY2JoMGY5YXNlNDc0eDJsdGgwaWRvNnJsamRrdG16aWVpZHphdHo='
    }
  });
```

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

### Implement Consumer Listener

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

Example implementation of the ConsumerListener interface to handle transport closure events.

```cpp
void MyConsumerListener::OnTransportClose(mediasoupclient::Consumer* consumer)
{
	std::cout << "transport closed" << std::endl;
}
```

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

### Force local build of mediasoup-worker

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

Forces the installation process to skip downloading prebuilt binaries and build the mediasoup-worker locally. This is useful when prebuilt binaries are unavailable or when developing locally.

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

```

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

### Specify Python executable for build

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

Specifies the Python executable to use during the mediasoup installation if the default 'python3' or 'python' commands are not pointing to the correct version. This is required when building the mediasoup-worker locally.

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

```

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

### Create WebRTC Transport

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

Initializes a new WebRTC transport for the router. Use the first example for standard server-based configurations and the second for manual listen information.

```javascript
const transport = await router.createWebRtcTransport(
  {
    webRtcServer : webRtcServer
    enableUdp    : true,
    enableTcp    : false
  });
```

```javascript
const transport = await router.createWebRtcTransport(
  {
    listenInfos :
    [
      {
        protocol         : "udp", 
        ip               : "192.168.0.111", 
        announcedAddress : "88.12.10.41"
      }
    ]
  });
```

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

### DataConsumerListener::OnMessage Implementation

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

Implement this method to process incoming messages on a DataChannel. This example specifically handles messages with the label 'chat'.

```cpp
void MyConsumerListener::OnMessage(DataConsumer* dataConsumer, const webrtc::DataBuffer& buffer)
{
	if (dataConsumer->GetLabel() == "chat")
	{
		std::string message = std::string(buffer.data.data<char>(), buffer.data.size());
		std::cout << "received chat message: " << message << std::endl;
	}
}
```

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

### Specify custom mediasoup-worker binary path

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

Uses a custom mediasoup-worker binary during installation and runtime. Set the MEDIASOUP_WORKER_BIN environment variable to the path of your desired binary.

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

```

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

```

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

### Implement Custom Log Handler

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

Implement the LogHandlerInterface to define a custom handler for log messages. This example shows how to print log messages to standard output.

```cpp
void MyLogHandler::OnLog(LogLevel level, char* payload, size_t len)
{
	std::cout << payload << std::endl;
}
```

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

### Enable Debug Logging in localStorage

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

Set the 'debug' key in localStorage to enable specific log levels for mediasoup-client. This example enables WARN and ERROR messages.

```html
<script>
  window.localStorage.setItem('debug', 'mediasoup-client:WARN* mediasoup-client:ERROR*');
</script>

<script src='/js/your-bundled-app.js'></script>

```

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

### Instantiating Device

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

Creates a new instance of the main Device class.

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

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

### Device.factory(options)

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

Creates a new Device instance. This is the recommended way to initialize a device for media communication.

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

### Description
Creates a new device instance. This method is asynchronous and may throw an UnsupportedError if the current environment is not supported.

### Parameters
- **options** (DeviceOptions) - Optional - Configuration object containing handlerName or handlerFactory.

### Returns
- **Device** - A new instance of the Device class.

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

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

### Create a new WebRTC server

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

Initializes a new WebRTC server with the provided listen information.

```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
      }
    ]
  });
```

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

### Create an AudioLevelObserver

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

Initializes a new audio level observer with specified threshold and interval settings.

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

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

### Get libmediasoupclient Version

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

Retrieves the current version string of the libmediasoupclient library.

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

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

### Handle NotFoundError in transport.consume

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

Example of catching a NotFoundError when a producer is closed during a consume operation.

```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.
  }
}

```

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

### Get DirectTransport Statistics

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

Retrieve statistics for a DirectTransport. This includes bitrate and packet counts.

```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"
  }
]
```

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

### Create a new device using constructor

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

Initializes a new device instance. Note that this method is deprecated in favor of Device.factory().

```javascript
let device;

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

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

### Initialize libmediasoupclient

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

Performs the necessary initialization for the libmediasoupclient library, including setting up libwebrtc.

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

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

### Create a Device Instance

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

Instantiates a new Device object. This is the primary entry point for C++ client-side applications using mediasoup.

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

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

### Create a new device using factory

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

Initializes a new device instance. This is the preferred method over the constructor.

```javascript
let device;

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

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

### producer.getStats()

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

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

```APIDOC
## producer.getStats()

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

### Returns
- **RTCStatsReport** (Object) - The statistics report.
```

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

### AudioLevelObserverOptions

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

Configuration options for initializing an AudioLevelObserver.

```APIDOC
### AudioLevelObserverOptions
- **maxEntries** (Number) - Optional - Maximum number of entries in the “volumes” event. Default: 1
- **threshold** (Number) - Optional - Minimum average volume (in dBvo from -127 to 0) for entries in the “volumes” event. Default: -80
- **interval** (Number) - Optional - Interval in ms for checking audio volumes. Default: 1000
- **appData** (AppData) - Optional - Custom application data. Default: { }
```

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

### Get DataConsumer Statistics

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

Retrieve statistics for a data consumer, including messages and bytes sent.

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

// =>
[
  {
    "type": "data-consumer",
    "label": "nnawjiwbav",
    "protocol": "app-protocol",
    "messagesSent": 3496,
    "bytesSent": 65934
  }
]
```

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

### Device.load

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

Initializes the device with router RTP capabilities.

```APIDOC
## device.load({ routerRtpCapabilities, preferLocalCodecsOrder })

### Description
Loads the device with the provided router RTP capabilities.

### Parameters
- **routerRtpCapabilities** (object) - Required
- **preferLocalCodecsOrder** (boolean) - Optional
```

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

### Get DataProducer Statistics

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

Retrieve statistics for a data producer, including messages and bytes received.

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

// =>
[
  {
    "type": "data-producer",
    "label": "nnawjiwbav",
    "protocol": "app-protocol",
    "messagesReceived": 3496,
    "bytesReceived": 65934
  }
]
```

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

### Create a new router

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

Initializes a new router instance with the specified media codecs.

```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 });
```

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

### Send direct messages via DataProducer

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

Examples of sending string and binary messages directly from the Node.js process.

```javascript
const stringMessage = "hello";
const binaryMessage = Buffer.from([ 1, 2, 3, 4 ]);

dataProducer.send(stringMessage);
dataProducer.send(binaryMessage);
```

```javascript
dataProducer.send("bye", /*ppid*/ undefined, /*subchannels*/ [ 24 ]);
```

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

### Handle transportclose event

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

Example listener for the transportclose event, which indicates the consumer has been closed due to the transport closing.

```javascript
consumer.on("transportclose", () =>
{
  console.log("transport closed so consumer closed");
});
```

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

### Load Device with Router Capabilities

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

Initializes the device using RTP capabilities retrieved from the mediasoup router.

```javascript
await device.load({ routerRtpCapabilities });
// Now the device is ready.
```

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

### Consume remote media with streamId

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

Example of using streamId to group related inbound media streams for synchronization.

```javascript
micConsumer = await transport.consume({ streamId: `${remotePeerId}-mic-webcam` });
webcamConsumer = await transport.consume({ streamId: `${remotePeerId}-mic-webcam` });
screensharingConsumer = await transport.consume({ streamId: `${remotePeerId}-screensharing` });
```

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

### Checkout and Build libwebrtc

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

Steps to fetch and sync the libwebrtc source code, and then checkout a specific version. This is a prerequisite for building libmediasoupclient.

```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
```

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

### Get PlainTransport Statistics

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

Retrieve statistics for a PlainTransport. This includes packet counts, bitrate, and transport tuple information.

```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"
  }
]
```

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

### Defining custom AppData type

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

Example of defining the AppData type to specify custom appData content for mediasoup entities.

```typescript
export type AppData =
{
  [key: string]: unknown;
};
```

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

### Importing mediasoup-client

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

Demonstrates how to import the library using ES6 modules or CommonJS, including destructuring options.

```javascript
// Using ES6 import.
import * as mediasoupClient from "mediasoup-client";

// Or using destructuring assignment:
import {
  types,
  version,
  Device,
  detectDevice,
  detectDeviceAsync,
  parseScalabilityMode,
  ortc,
  enhancedEvents,
  FakeHandler,
  testFakeParameters,
  debug
} from "mediasoup-client";

// Using CommonJS.
const mediasoupClient = require("mediasoup-client");

// Or using destructuring assignment:
const {
  types,
  version,
  Device,
  detectDevice,
  detectDeviceAsync,
  parseScalabilityMode,
  ortc,
  enhancedEvents,
  FakeHandler,
  testFakeParameters,
  debug
} = require("mediasoup-client");
```

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

### Get WebRtcTransport Statistics

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

Retrieve statistics for a WebRtcTransport. This includes ICE and DTLS states, bitrate information, and packet counts.

```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"
  }
]
```

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

### worker.createWebRtcServer(options)

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

Creates a new WebRTC server instance within the worker.

```APIDOC
## worker.createWebRtcServer(options)

### Description
Creates a new WebRTC server.

### Parameters
- **options** (WebRtcServerOptions) - Required - WebRTC server options.
- **WorkerAppData** (AppData) - Optional - Custom appData definition.
```

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

### Set Max Spatial Layer

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

Limits the highest transmitted RTP stream in a simulcast setup by specifying the encoding index.

```javascript
// Assuming `encodings` array has 3 entries, let's enable just the first and
// second streams (indexes 0 and 1).
await producer.setMaxSpatialLayer(1);
```

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

### Importing the mediasoup module

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

Demonstrates how to import the mediasoup module using ES6 syntax or CommonJS, including destructuring options.

```javascript
// Using ES6 import:
import * as mediasoup from "mediasoup";

// Or using destructuring assignment:
import {
  types,
  version,
  workerBin,
  observer,
  createWorker,
  getSupportedRtpCapabilities,
  parseScalabilityMode,
  ortc,
  extras
} from "mediasoup";

// Using CommonJS:
const mediasoup = require("mediasoup");

// Or using destructuring assignment:
const {
  types,
  version,
  workerBin,
  observer,
  createWorker,
  getSupportedRtpCapabilities,
  parseScalabilityMode,
  ortc,
  extras
} = require("mediasoup");
```

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

### Get PipeTransport Statistics

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

Retrieve statistics for a PipeTransport. This includes bitrate and packet counts, along with the transport's local and remote tuple.

```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"
  }
]
```

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

### Configure libmediasoupclient Build with CMake

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

Configure the libmediasoupclient build using CMake, specifying paths to libwebrtc sources and binaries.

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

$ make -C build/

```

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

### Build libmediasoupclient

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

Configures and builds the libmediasoupclient library using CMake and make. Requires specifying the include and binary paths for the pre-built libwebrtc.

```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/
```

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

### Observe new WebRTC server creation

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

Listens for the 'newwebrtcserver' event on the observer to track WebRTC server creation.

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

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

### Get PipeConsumer RTP Statistics

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

Retrieve statistics for a consumer created on a PipeTransport. This includes statistics for each RTP stream being forwarded, but not for the associated producer's inbound RTP streams.

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

// =>
[
  {
    "bitrate": 868184,
    "byteCount": 19478693,
    "firCount": 0,
    "fractionLost": 0,
    "kind": "video",
    "mimeType": "video/VP8",
    "nackCount": 0,
    "nackPacketCount": 0,
    "packetCount": 18696,
    "packetsDiscarded": 0,
    "packetsLost": 0,
    "packetsRepaired": 0,
    "packetsRetransmitted": 0,
    "pliCount": 0,
    "roundTripTime": 5.15,
    "score": 10,
    "ssrc": 116684231,
    "timestamp": 514442975,
    "type": "outbound-rtp"
  },
  {
    "bitrate": 350000,
    "byteCount": 8393425,
    "firCount": 0,
    "fractionLost": 0,
    "kind": "video",
    "mimeType": "video/VP8",
    "nackCount": 0,
    "nackPacketCount": 0,
    "packetCount": 9417,
    "packetsDiscarded": 0,
    "packetsLost": 0,
    "packetsRepaired": 0,
    "packetsRetransmitted": 0,
    "pliCount": 0,
    "roundTripTime": 4.43,
    "score": 10,
    "ssrc": 116684230,
    "timestamp": 514442975,
    "type": "outbound-rtp"
  },
  {
    "bitrate": 153456,
    "byteCount": 3442897,
    "firCount": 0,
    "fractionLost": 0,
    "kind": "video",
    "mimeType": "video/VP8",
    "nackCount": 0,
    "nackPacketCount": 0,
    "packetCount": 5393,
    "packetsDiscarded": 0,
    "packetsLost": 0,
    "packetsRepaired": 0,
    "packetsRetransmitted": 0,
    "pliCount": 0,
    "roundTripTime": 5.6,
    "score": 10,
    "ssrc": 116684229,
    "timestamp": 514442975,
    "type": "outbound-rtp"
  }
]
```

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

### mediasoup.getSupportedRtpCapabilities()

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

Returns a cloned copy of the mediasoup supported RTP capabilities.

```APIDOC
## mediasoup.getSupportedRtpCapabilities()

### Description
Returns a cloned copy of the mediasoup supported RTP capabilities, specifically the content of the mediasoup/node/src/supportedRtpCapabilities.ts file.
```

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

### Create a new mediasoup worker

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

Initializes a worker instance with specific settings and optional custom appData.

```javascript
const worker = await mediasoup.createWorker<{ foo: number }>(
  {
    logLevel            : "warn",
    dtlsCertificateFile : "/home/foo/dtls-cert.pem",
    dtlsPrivateKeyFile  : "/home/foo/dtls-key.pem",
    appData             : { foo: 123 }
  });
```

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

### Get Simulcast Producer Statistics

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

Retrieves statistics for a producer using Simulcast. Each entry in the returned array corresponds to a discovered RTP stream, which may include multiple temporal layers.

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

// =>
[
  {
    "bitrate": 678400,
    "bitrateByLayer": 
    {
      "0.0": 237992,
      "0.1": 145496,
      "0.2": 294912
    },
    "byteCount": 4265668,
    "firCount": 0,
    "fractionLost": 0,
    "jitter": 0,
    "kind": "video",
    "mimeType": "video/VP8",
    "nackCount": 0,
    "nackPacketCount": 0,
    "packetCount": 4150,
    "packetsDiscarded": 0,
    "packetsLost": 0,
    "packetsRepaired": 0,
    "packetsRetransmitted": 95,
    "pliCount": 5,
    "rid": "r2",
    "roundTripTime": 43.55,
    "rtxPacketsDiscarded": 0,
    "rtxSsrc": 2830213299,
    "score": 10,
    "ssrc": 689337360,
    "timestamp": 925298114,
    "type": "inbound-rtp"
  },
  {
    "bitrate": 242784,
    "bitrateByLayer": 
    {
      "0.0": 85608,
      "0.1": 52752,
      "0.2": 104424
    },
    "byteCount": 1677745,
    "firCount": 0,
    "fractionLost": 0,
    "jitter": 0,
    "kind": "video",
    "mimeType": "video/VP8",
    "nackCount": 5,
    "nackPacketCount": 31,
    "packetCount": 2045,
    "packetsDiscarded": 0,
    "packetsLost": 4294967281,
    "packetsRepaired": 15,
    "packetsRetransmitted": 563,
    "pliCount": 3,
    "rid": "r1",
    "roundTripTime": 48.1,
    "rtxPacketsDiscarded": 0,
    "rtxSsrc": 2486781276,
    "score": 10,
    "ssrc": 2995277190,
    "timestamp": 925298114,
    "type": "inbound-rtp"
  },
  {
    "bitrate": 86768,
    "bitrateByLayer": 
    {
      "0.0": 29648,
      "0.1": 19344,
      "0.2": 37776
    },
    "byteCount": 581258,
    "firCount": 0,
    "fractionLost": 0,
    "jitter": 2,
    "kind": "video",
    "mimeType": "video/VP8",
    "nackCount": 0,
    "nackPacketCount": 0,
    "packetCount": 1362,
    "packetsDiscarded": 0,
    "packetsLost": 0,
    "packetsRepaired": 0,
    "packetsRetransmitted": 10,
    "pliCount": 1,
    "rid": "r0",
    "roundTripTime": 49.77,
    "rtxPacketsDiscarded": 0,
    "rtxSsrc": 2118917939,
    "score": 10,
    "ssrc": 3060700812,
    "timestamp": 925298114,
    "type": "inbound-rtp"
  }
]

```

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

### Get Consumer RTP Statistics

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

Retrieve statistics for a consumer's outbound RTP stream and the associated producer's inbound RTP stream. This is the standard behavior for consumers on regular transports.

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

// =>
[
  {
    "bitrate": 625312,
    "byteCount": 879947,
    "firCount": 0,
    "fractionLost": 0,
    "kind": "video",
    "mimeType": "video/VP8",
    "nackCount": 0,
    "nackPacketCount": 0,
    "packetCount": 979,
    "packetsDiscarded": 0,
    "packetsLost": 0,
    "packetsRepaired": 0,
    "packetsRetransmitted": 0,
    "pliCount": 0,
    "roundTripTime": 33.02,
    "rtxSsrc": 836324070,
    "score": 10,
    "ssrc": 328066115,
    "timestamp": 925531753,
    "type": "outbound-rtp"
  },
  {
    "bitrate": 627872,
    "bitrateByLayer": 
    {
      "0.0": 238856,
      "0.1": 145872,
      "0.2": 243144
    },
    "byteCount": 883855,
    "firCount": 0,
    "fractionLost": 0,
    "jitter": 2,
    "kind": "video",
    "mimeType": "video/VP8",
    "nackCount": 0,
    "nackPacketCount": 0,
    "packetCount": 979,
    "packetsDiscarded": 0,
    "packetsLost": 0,
    "packetsRepaired": 0,
    "packetsRetransmitted": 167,
    "pliCount": 2,
    "rtxSsrc": 1976184061,
    "score": 10,
    "ssrc": 2440984788,
    "timestamp": 925531753,
    "type": "inbound-rtp"
  }
]
```

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

### device.load

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

Loads the device with the RTP capabilities of the mediasoup router to initialize media settings.

```APIDOC
## device.load({ routerRtpCapabilities, preferLocalCodecsOrder })

### Description
Loads the device with the RTP capabilities of the mediasoup router. This is how the device knows about the allowed media codecs and other settings.

### Parameters
- **routerRtpCapabilities** (RtpCapabilities) - Required - The mediasoup router RTP capabilities.
- **preferLocalCodecsOrder** (Boolean) - Optional - Whether to prefer device's local order of codecs rather than the order of codecs provided to mediasoup server.

### Request Example
await device.load({ routerRtpCapabilities });
```

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

### router.createAudioLevelObserver

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

Creates a new audio level observer for the router.

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

### Description
Creates a new audio level observer.

### Parameters
- **options** (AudioLevelObserverOptions) - Optional - Options for the observer.

### Returns
- **AudioLevelObserver** - The created audio level observer instance.

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

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

### Get SVC Producer Statistics

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

Retrieves statistics for a producer using Scalable Video Coding (SVC). This will result in a single entry in the statistics array, representing one stream with multiple spatial and temporal layers.

```javascript
[
  {
    "bitrate": 680020,
    "bitrateByLayer": {
      "0.0": 38957,
      "0.1": 48842,
      "0.2": 72589,
      "1.0": 135837,
      "1.1": 175149,
      "1.2": 260762,
      "2.0": 323139,
      "2.1": 461565,
      "2.2": 680020
    },
    "byteCount": 337978,
    "firCount": 0,
    "fractionLost": 0,
    "jitter": 4,
    "kind": "video",
    "mimeType": "video/VP9",
    "nackCount": 0,
    "nackPacketCount": 0,
    "packetCount": 347,
    "packetsDiscarded": 0,
    "packetsLost": 0,
    "packetsRepaired": 0,
    "packetsRetransmitted": 149,
    "pliCount": 0,
    "roundTripTime": 34.57,
    "rtxPacketsDiscarded": 0,
    "rtxSsrc": 4171189299,
    "score": 10,
    "ssrc": 518176773,
    "timestamp": 1205013977,
    "type": "inbound-rtp"
  }
]

```

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

### dataConsumer.resume()

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

Resumes the data consumer.

```APIDOC
## dataConsumer.resume()

### Description
Resumes the data consumer (messages are sent again to the consuming endpoint).
```

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

### transport.observer.on("newconsumer", fn(consumer))

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

Emitted when a new consumer is created.

```APIDOC
## transport.observer.on("newconsumer", fn(consumer))

### Description
Emitted when a new consumer is created.

### Parameters
- **consumer** (Consumer) - New consumer.

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

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

### Create Plain Transports for Audio and Video

Source: https://mediasoup.org/documentation/v3/communication-between-client-and-server

Initializes plain transports on the router to receive RTP streams. These transports must be configured with comedia enabled to allow the server to receive media from the external source.

```javascript
const audioTransport = await router.createPlainTransport(
  { 
    listenIp : '127.0.0.1',
    rtcpMux  : false,
    comedia  : true
  });

// Read the transport local RTP port.
const audioRtpPort = audioTransport.tuple.localPort;
// => 3301

// Read the transport local RTCP port.
const audioRtcpPort = audioTransport.rtcpTuple.localPort;
// => 4502
```

```javascript
const videoTransport = await router.createPlainTransport(
  { 
    listenIp : '127.0.0.1',
    rtcpMux  : false,
    comedia  : true
  });

// Read the transport local RTP port.
const videoRtpPort = videoTransport.tuple.localPort;
// => 3501

// Read the transport local RTCP port.
const videoRtcpPort = videoTransport.rtcpTuple.localPort;
// => 2989
```

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

### Include mediasoupclient Header

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

Include the main header file for the libmediasoupclient library.

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

```

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

### WebRtcTransportOptions

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

Configuration options for creating a WebRtcTransport. One of webRtcServer, listenInfos, or listenIps must be provided.

```APIDOC
### WebRtcTransportOptions

- **webRtcServer** (WebRtcServer) - Optional - Use a WebRTC server to handle network traffic.
- **listenInfos** (Array<TransportListenInfo>) - Optional - Listening information in order of preference.
- **listenIps** (Array<TransportListenIp|String>) - Optional - Deprecated. Listening IP address or addresses.
- **port** (Number) - Optional - Fixed port to listen on.
- **enableUdp** (Boolean) - Optional - Listen in UDP (Default: true).
- **enableTcp** (Boolean) - Optional - Listen in TCP (Default: false).
- **preferUdp** (Boolean) - Optional - Prefer UDP (Default: false).
- **preferTcp** (Boolean) - Optional - Prefer TCP (Default: false).
- **iceConsentTimeout** (Number) - Optional - ICE consent timeout in seconds (Default: 30).
- **initialAvailableOutgoingBitrate** (Number) - Optional - Initial available outgoing bitrate in bps (Default: 600000).
- **enableSctp** (Boolean) - Optional - Create a SCTP association (Default: false).
- **maxSendMessageSize** (Number) - Optional - Max size for SCTP messages sent (Default: 262144).
- **maxReceiveMessageSize** (Number) - Optional - Max size for SCTP messages received (Default: 262144).
- **sctpSendBufferSize** (Number) - Optional - Max SCTP send buffer (Default: 2000000).
- **sctpPerStreamSendQueueLimit** (Number) - Optional - Per stream send queue size limit (Default: 2000000).
- **sctpMaxReceiverWindowBufferSize** (Number) - Optional - Max received window buffer size (Default: 5242880).
- **appData** (AppData) - Optional - Custom application data.
```

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

### router.createActiveSpeakerObserver

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

Creates a new active speaker observer.

```APIDOC
## router.createActiveSpeakerObserver<ActiveSpeakerObserverAppData>(options)

### Description
Creates a new active speaker observer. This is an asynchronous operation that returns an ActiveSpeakerObserver instance.

### Parameters
- **options** (ActiveSpeakerObserverOptions) - Optional - Observer options.
- **ActiveSpeakerObserverAppData** (AppData) - Optional - Custom appData definition (default: { }).

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

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

### Configure libwebrtc Build (Linux)

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

Generates build files for libwebrtc on Linux Debian Stretch with GCC 6.3 using gn. Includes specific arguments for the Linux environment.

```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'
```

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

### ProducerOptions

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

Configuration options for creating a new Producer instance via transport.produce().

```APIDOC
## ProducerOptions

### Description
Configuration object used when creating a producer to define track behavior, encoding settings, and codec preferences.

### Parameters
- **track** (MediaStreamTrack) - Required - An audio or video track.
- **streamId** (String) - Optional - Stream id used to group tracks for synchronization.
- **encodings** (Array<RTCRtpEncodingParameters>) - Optional - Encoding settings for simulcast or SVC.
- **codecOptions** (ProducerCodecOptions) - Optional - Per codec specific options.
- **headerExtensionOptions** (ProducerHeaderExtensionOptions) - Optional - RTP header extension options.
- **codec** (RtpCodecCapability) - Optional - Specific media codec to use.
- **stopTracks** (Boolean) - Optional - Whether to call stop() on tracks when the producer is closed. Default: true.
- **disableTrackOnPause** (Boolean) - Optional - Whether to set track.enabled = false when paused. Default: true.
- **zeroRtpOnPause** (Boolean) - Optional - If true, zero RTP is sent when paused. Default: false.
- **onRtpSender** (OnRtpSenderCallback) - Optional - Callback invoked when RTCRtpSender is created.
- **appData** (Object) - Optional - Custom application data.
```

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

### Observe new router creation

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

Listens for the 'newrouter' event on the observer to track router creation.

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