## srt-multiplex

# srt-test-multiplex

**srt-multiplex** (formerly called "SIPLEX") is a sample program that can send

multiple streams in one direction. This tool demonstrates two SRT features:

**srt-test-multiplex** (formerly called "SIPLEX") is a sample program that can

send multiple streams in one direction. This tool demonstrates two SRT features:

- the ability to use a single UDP link (a source and destination pair

specified by IP address and port) for multiple SRT connections

- the use of the `streamid` socket option to identify multiplexed resources

NOTE: due to changes in the common code that can't be properly handled in the

current form of srt-multiplex, this application is temporarily blocked. Instead

the `srt-test-multiplex` application was added with the same functionality,

although it's recommended for testing purposes only.

NOTE: To make this application compiled, you need the `-DENABLE_TESTING=1`

cmake option.

#### Usage

Note also that this application is intended for demonstration only. It can

simply exit with error message in case of wrong usage or broken connection.

`srt-multiplex <SRT-URI> -i <INPUT-URI1>[id] <INPUT-URI2>[id]...`

- Multiplexes data from one or more input URIs to transmit as an SRT stream.

The application reads multiple streams (INPUT URIs), each using a separate SRT

connection. All of the traffic from these connections is sent through the

same UDP link.

## Usage

`srt-multiplex <SRT-URI> -o <OUTPUT-URI1>[id] <OUTPUT-URI2>[id]...`

`srt-test-multiplex <SRT-URI> -i <INPUT-URI1>[id1] <INPUT-URI2>[id2]...`

- Reads all given input streams and sends them each one over a separate

SRT connection, all using the same remote address and source port (hence

using the same UDP link).

`srt-test-multiplex <SRT-URI> -o <OUTPUT-URI1>[id] <OUTPUT-URI2>[id]...`

- Transmits data from a multiplexed SRT stream to the specified output URI(s).

@@ -29,41 +30,41 @@ options. When `-i` is specified, the URIs provided are used as input, and will

be output over the `<SRT URI>` socket. The reverse is true for any output URIs

specified by `-o`.

Separate connections will be created for every specified URI, although all will

be using the same UDP link. When SRT is in caller mode, the SRT socket created

for transmitting data for a given URI will be set to the `streamid` socket option

from this URI's `id` parameter. When SRT is in listener mode, the `streamid`

option will already be set on the accepted socket, and will be matched with a

URI that has the same value in its `id` parameter.

This `streamid` is the SRT socket option (`SRTO_STREAMID` in the API). The idea

is that it can be set on a socket used for connecting. When a listener is

getting an accepted socket for that connection, the `streamid` socket option

can be read from it, with the result that it will be the same as was set on

the caller side.

So, in caller mode, for every stream media URI (input or output) there will be

a separate SRT socket created. This socket will have its `socketid` option

set to the value that is given by user as the `id` parameter attached to a

particular URI. In listener mode this happens in the opposite direction — the

value of the `streamid` option is extracted from the accepted socket, and then

matched against all ids specified with the stream media URIs:

If SRT-URI is caller mode, then for every declared input or output medium a

separate connection will be made, each one using the same source port (if

specified, the same will be used for all connections, otherwise the first one

will be automatically selected and then reused for all next ones) and with the

`streamid` socket option set to the value extracted from the medium's

`id` specified parameter:

```

URI1?id=a --> s1(streamid=a).connect(remhost:2000)

URI2?id=b --> s2(streamid=b).connect(remhost:2000)

URI3?id=c --> s3(streamid=c).connect(remhost:2000)

```

And on the listener side:

If SRT-URI is listener mode, then it will extract the value from `streamid`

socket option and every accepted connection will be matched against the `id`

parameter of the specified input or output medium.

```

(remhost:2000) -> accept --> s(SRT socket) --> in URI array find such that uri.id == s.streamid

```

#### Examples

Note that the rendezvous mode is not supported because you cannot make

multiple connections over the same UDP link in rendezvous mode.

This `streamid` is the SRT socket option (`SRTO_STREAMID` in the API). The idea

is that it can be set on a socket used for connecting. When a listener is

getting an accepted socket for that connection, the `streamid` socket option

can be read from it, with the result that it will be the same as was set on

the caller side.

## Examples

- **Sender:**

- `srt-multiplex srt://remhost:2000 -i udp://:5000?id=low udp://:6000?id=high`

- `srt-test-multiplex srt://remhost:2000 -i udp://:5000?id=low udp://:6000?id=high`

- **Receiver:**

- `srt-multiplex srt://:2000 -o output-high.ts?id=high output-low.ts?id=low`

- `srt-test-multiplex srt://:2000 -o output-high.ts?id=high output-low.ts?id=low`

In this example a Sender is created which will connect to `remhost` port 2000

using multiple SRT sockets, all of which will be using the same outgoing port.

@@ -72,7 +73,7 @@ sockets will reuse that port. Alternatively you can enforce the outgoing port

using the `port` parameter with the `<SRT URI>`.

- **Sender:**

- `srt-multiplex srt://remhost:2000?port=5555 ...`

- `srt-test-multiplex srt://remhost:2000?port=5555 ...`

A separate connection is made for every input resource. An appropriate resource

ID will be set to each socket assigned to that resource according to the `id`

@@ -90,9 +91,9 @@ port=5555 -| --------- ( multiplexed UDP stream ) ---------- |- port=2000

+-- --+

```

When a socket is accepted on the listener side (the Receiver in this example),

srt-multiplex will search for the resource ID among the registered resources

srt-test-multiplex will search for the resource ID among the registered resources

(input/output URIs) and set an ID that matches the one on the caller side. If

the resource is not found, the connection is closed immediately.

The srt-multiplex program works the same way for connections initiated by a

The srt-test-multiplex program works the same way for connections initiated by a

caller or a listener.