Haivision Secure Reliable Transport Protocol

FFMpeg STR Transport Protocol via LIBSRT

The supported syntax for a SRT URL is:

srt://hostname:port[?options]

options contains a list of &-separated options of the form key=val.

options srt://hostname:port

options contains a list of '-key val' options.

This protocol accepts the following options.

'connect_timeout'

Connection timeout; SRT cannot connect for RTT > 1500 msec (2 handshake exchanges) with the default connect timeout of 3 seconds. This option applies to the caller and rendezvous connection modes. The connect timeout is 10 times the value set for the rendezvous mode (which can be used as a workaround for this connection problem with earlier versions).

'ffs=bytes'

Flight Flag Size (Window Size), in bytes. FFS is actually an internal parameter and you should set it to not less than 'recv_buffer_size' and 'mss'. The default value is relatively large, therefore unless you set a very large receiver buffer, you do not need to change this option. Default value is 25600.

'inputbw=bytes/seconds'

Sender nominal input rate, in bytes per seconds. Used along with 'oheadbw', when 'maxbw' is set to relative (0), to calculate maximum sending rate when recovery packets are sent along with the main media stream: 'inputbw' * (100 + 'oheadbw') / 100 if 'inputbw' is not set while 'maxbw' is set to relative (0), the actual input rate is evaluated inside the library. Default value is 0.

'iptos=tos'

IP Type of Service. Applies to sender only. Default value is 0xB8.

'ipttl=ttl'

IP Time To Live. Applies to sender only. Default value is 64.

'latency'

Timestamp-based Packet Delivery Delay. Used to absorb bursts of missed packet retransmissions. This flag sets both 'rcvlatency' and 'peerlatency' to the same value. Note that prior to version 1.3.0 this is the only flag to set the latency, however this is effectively equivalent to setting 'peerlatency', when side is sender and 'rcvlatency' when side is receiver, and the bidirectional stream sending is not supported.

'listen_timeout'

Set socket listen timeout.

'maxbw=bytes/seconds'

Maximum sending bandwidth, in bytes per seconds. -1 infinite (CSRTCC limit is 30mbps) 0 relative to input rate (see 'inputbw') >0 absolute limit value Default value is 0 (relative)

'mode=caller|listener|rendezvous'

Connection mode. 'caller' opens client connection. 'listener' starts server to listen for incoming connections. 'rendezvous' use Rendez-Vous connection mode. Default value is caller.

'mss=bytes'

Maximum Segment Size, in bytes. Used for buffer allocation and rate calculation using a packet counter assuming fully filled packets. The smallest MSS between the peers is used. This is 1500 by default in the overall internet. This is the maximum size of the UDP packet and can be only decreased, unless you have some unusual dedicated network settings. Default value is 1500.

'nakreport=1|0'

If set to 1, Receiver will send 'UMSG_LOSSREPORT' messages periodically until a lost packet is retransmitted or intentionally dropped. Default value is 1.

'oheadbw=percents'

Recovery bandwidth overhead above input rate, in percents. See 'inputbw'. Default value is 25%.

'passphrase=string'

HaiCrypt Encryption/Decryption Passphrase string, length from 10 to 79 characters. The passphrase is the shared secret between the sender and the receiver. It is used to generate the Key Encrypting Key using PBKDF2 (Password-Based Key Derivation Function). It is used only if 'pbkeylen' is non-zero. It is used on the receiver only if the received data is encrypted. The configured passphrase cannot be recovered (write-only).

'payload_size=bytes'

Sets the maximum declared size of a packet transferred during the single call to the sending function in Live mode. Use 0 if this value isn't used (which is default in file mode). Default is -1 (automatic), which typically means MPEG-TS; if you are going to use SRT to send any different kind of payload, such as, for example, wrapping a live stream in very small frames, then you can use a bigger maximum frame size, though not greater than 1456 bytes.

'pkt_size=bytes'

Alias for 'payload_size'.

'peerlatency'

The latency value (as described in 'rcvlatency') that is set by the sender side as a minimum value for the receiver.

'pbkeylen=bytes'

Sender encryption key length, in bytes. Only can be set to 0, 16, 24 and 32. Enable sender encryption if not 0. Not required on receiver (set to 0), key size obtained from sender in HaiCrypt handshake. Default value is 0.

'rcvlatency'

The time that should elapse since the moment when the packet was sent and the moment when it's delivered to the receiver application in the receiving function. This time should be a buffer time large enough to cover the time spent for sending, unexpectedly extended RTT time, and the time needed to retransmit the lost UDP packet. The effective latency value will be the maximum of this options' value and the value of 'peerlatency' set by the peer side. Before version 1.3.0 this option is only available as 'latency'.

'recv_buffer_size=bytes'

Set UDP receive buffer size, expressed in bytes.

'send_buffer_size=bytes'

Set UDP send buffer size, expressed in bytes.

'rw_timeout'

Set raise error timeout for read/write optations.

This option is only relevant in read mode: if no data arrived in more than this time interval, raise error.

'tlpktdrop=1|0'

Too-late Packet Drop. When enabled on receiver, it skips missing packets that have not been delivered in time and delivers the following packets to the application when their time-to-play has come. It also sends a fake ACK to the sender. When enabled on sender and enabled on the receiving peer, the sender drops the older packets that have no chance of being delivered in time. It was automatically enabled in the sender if the receiver supports it.

'sndbuf=bytes'

Set send buffer size, expressed in bytes.

'rcvbuf=bytes'

Set receive buffer size, expressed in bytes.

Receive buffer must not be greater than 'ffs'.

'lossmaxttl=packets'

The value up to which the Reorder Tolerance may grow. When Reorder Tolerance is > 0, then packet loss report is delayed until that number of packets come in. Reorder Tolerance increases every time a "belated" packet has come, but it wasn't due to retransmission (that is, when UDP packets tend to come out of order), with the difference between the latest sequence and this packet's sequence, and not more than the value of this option. By default it's 0, which means that this mechanism is turned off, and the loss report is always sent immediately upon experiencing a "gap" in sequences.

'minversion'

The minimum SRT version that is required from the peer. A connection to a peer that does not satisfy the minimum version requirement will be rejected.

The version format in hex is 0xXXYYZZ for x.y.z in human readable form.

'streamid=string'

A string limited to 512 characters that can be set on the socket prior to connecting. This stream ID will be able to be retrieved by the listener side from the socket that is returned from srt_accept and was connected by a socket with that set stream ID. SRT does not enforce any special interpretation of the contents of this string. This option doesn't make sense in Rendezvous connection; the result might be that simply one side will override the value from the other side and it's the matter of luck which one would win

'smoother=live|file'

The type of Smoother used for the transmission for that socket, which is responsible for the transmission and congestion control. The Smoother type must be exactly the same on both connecting parties, otherwise the connection is rejected.

'messageapi=1|0'

When set, this socket uses the Message API, otherwise it uses Buffer API. Note that in live mode (see 'transtype') there's only message API available. In File mode you can chose to use one of two modes:

Stream API (default, when this option is false). In this mode you may send as many data as you wish with one sending instruction, or even use dedicated functions that read directly from a file. The internal facility will take care of any speed and congestion control. When receiving, you can also receive as many data as desired, the data not extracted will be waiting for the next call. There is no boundary between data portions in the Stream mode.

Message API. In this mode your single sending instruction passes exactly one piece of data that has boundaries (a message). Contrary to Live mode, this message may span across multiple UDP packets and the only size limitation is that it shall fit as a whole in the sending buffer. The receiver shall use as large buffer as necessary to receive the message, otherwise the message will not be given up. When the message is not complete (not all packets received or there was a packet loss) it will not be given up.

'transtype=live|file'

Sets the transmission type for the socket, in particular, setting this option sets multiple other parameters to their default values as required for a particular transmission type.

live: Set options as for live transmission. In this mode, you should send by one sending instruction only so many data that fit in one UDP packet, and limited to the value defined first in 'payload_size' (1316 is default in this mode). There is no speed control in this mode, only the bandwidth control, if configured, in order to not exceed the bandwidth with the overhead transmission (retransmitted and control packets).

file: Set options as for non-live transmission. See 'messageapi' for further explanations

For more information see: