Flussonic Media Server documentation

Publishing Video to the Server

Flussonic Media Server can accept video from external systems and devices that initiate broadcast. This is called publishing to Flussonic.

Publishing can be used in a situation where the external system has no static IP or where it is located behind firewall in a private IP network. In this case Flussonic Media Server has no way of sending a request for video directly.

What we call publishing:

  • Transmitting video from any mobile device to Flussonic.
  • Transmitting video from OBS (Open Broadcaster Software) or vMix software to Flussonic. Learn more
  • Transmitting video from an HTML page in the browser via WebRTC to Flussonic. Learn more

Also, Flussonic can publish video to social networks.

What we don't call publishing:

  • Receiving a multicast
  • Ingesting a stream from some source

In these situations, Flussonic connects to a source in one way or another. But the situation when Flussonic does nothing to initiate the connection is called publishing. For example, publishing is when a mobile device connects to Flussonic in order to transmit video to the server.

To be precise, publishing video to social networks does not match the Flussonic's definition of publishing.

Supported protocols

Flussonic Media Server can receive requests for video publishing via RTMP, RTSP, HTTP MPEG-TS, and WebRTC protocols.

Contents:

Publishing to a static stream Anchor Anchor x2

If you know exactly what will be the name of the stream on the server, you can create a stream and add a special source type url publish://. This would allow publishing to this stream:

stream published {
  url publish://;
}

To apply the settings, run:

/etc/init.d/flussonic reload

Important! In Flussonic 19.01, option publish_enabled was replaced with url publish://. The configuration file of version 19.01 is not compatible with the previous versions of Flussonic. The new directive url publish:// offers much more flexibility in managing publications — you can use timeout, transcoding, and WebRTC support.

Learn more about how to set up publishing

URLs for publishing via different protocols

You can publish videos to Flussonic using the following URLs:

  • rtsp://flussonic-ip/published
  • http://flussonic-ip/published/mpegts
  • rtmp://flussonic-ip/published
  • rtmp://flussonic-ip/static/published

URLs for RTMP — important points

Please, pay attention to the URL for publishing over RTMP. When the RTMP stream name is short a third-party software would not be able to recognize which part of the URL is the name of application and which is the name of the stream. Flussonic Media Server automativally cuts string "rtmp" from the application name. If the software requires to have some name of the application, you should specify name static. Here goes an example:

  • server URL: rtmp://flussonic-ip/static
  • stream name: published

If you use a composite stream name, like client15/published1, you can specify:

  • server URL: rtmp://flussonic-ip/client15
  • stream name: published1

With this configuration, you will be able to use all settings and option of the stream.

Setting up publishing to a static stream via UI Anchor Anchor x2

You can use the Flussonic administrator's web interface to add the parameter 'url publish://' as a stream's source.

To create a static stream with a published source:

  1. In the administrative interface, create a stream: Media > Stream > add.
  2. Enter Stream name.
  3. Type publish:// as a Source URL. Alternatively, save the stream and go to the Input tab and click accept under Published input.
  4. Click create to save the stream. OBS Studio

To delete a published source from stream settings:

  1. Click the stream in Media and go to the tab Input.
  2. Under Published input, click ignore. Alternatively, click remove next to the URL containing the source publish://. Media Server
  3. Click save to apply settings.

Publishing with a dynamic name Anchor Anchor x2

Why use a dynamic name and a publishing location

A static name for published streams could be impractical in the following cases:

  • A publication lasts for a limited period of time (compared to a TV channel broadcast, for example) and would never reoccur
  • You manage many publications, and it is a lot of work to create a separate stream for each of them. Also, you would need to specify the settings of each stream.
  • Stream names might not be known in advance if they are defined in external application that publish video to Flussonic. Flussonic does not know a stream name before the video transmission is started. Often a stream's name is chosen randomly on the fly. Web chat is a good example for situation like this.

Flussonic solves these problems by allowing you to create a publishing location (publication prefix) where you can specify common settings for multiple streams.

A dynamic name means that the full name of a stream is formed from a pre-configured publication prefix and the name defined in an external app.

If the name of a published stream is now known before hand; or if you expect many published streams, you should set up the publication prefix:

live chats {
}

Here, chats is the publication prefix. All streams published under the chats prefix will have settings that you specify in the live directive. Settings are described in Stream settings.

URLs for publishing via different protocols

In this case you will need to publish streams under names with the prefix, for example:

  • rtsp://flussonic-ip/chats/tempname
  • http://flussonic-ip/chats/tempname/mpegts
  • rtmp://flussonic-ip/chats/tempname

The part of the name that goes after chats is defined in the client app. Flussonic Media Server does not know the stream name in advance.

Setting up publishing with a dynamic name via UI Anchor Anchor x2

You can use the UI to create a publishing location (a prefix for publication under dynamic names).

  1. Go to the Media tab: publish-media
  2. Find the Publish locations section and click add: Publishing video to the server
  3. Enter a prefix and save the configuration. The prefix must be unique and may contain Latin characters, digits, underscore (_), and slash (/). It is strongly recommended to avoid using other characters because client applications might not allow them (Flussonic itself has no naming limitations). Publishing video to the server The publishing prefix is created.

Publishing via RTMP Anchor Anchor x2

There are several difficulties with publishing via RTMP. RTMP protocol does not support proper URLs. When connecting to a server using RTMP, the client must specify both the server name and the application name, and then specify the name of the stream to be played or published to.

Usually, the shortened version is used where the application name and the stream name are concatenated. For example, the pair rtmp://rtmp.myhosting.com/chats and chat-15 is turned into rtmp://rtmp.myhosting.com/chats/chat-15.

The standard practice when interpreting the RTMP pseudo-URL rtmp://rtmp.myhosting.com/chats/chat-15is to truncate the path after the server name at the first slash symbol and use the first part of the string as the application name.

This approach is being used only for RTMP and Flussonic Media Server does not support this concept.

Instead Flussonic uses the following logic when publishing via RTMP:

  1. The server concatenates the application name with the path being published. Thus, the pairs rtmp://rtmp.myhosting.com/chats/my, chat-15 and rtmp://rtmp.myhosting.com/chats, my/chat-15 produce the published stream name chats/my/chat-15
  2. The program searches for the first publishing prefix this name contains. In our example, that would be the prefix chats
  3. There after, all authorization interfaces and the like use the complete stream name: chats/my/chat-15.

To test publishing over RTMP you could use FFmpeg software:

ffmpeg -re -i /opt/flussonic/priv/bunny.mp4 -vcodec copy -acodec copy -f flv rtmp://localhost/chats/my/chat-15

This command will cause a new stream to appear in the web interface:

publish-stream

Publishing via RTSP Anchor Anchor x2

Some clients can publish video over RTSP.

Flussonic Media Server supports automatic selection between UDP and TCP transport and will receive the stream using the protocol selected by the client.

The stream name must be complete: chats/my/chat-15

ffmpeg -re -i /opt/flussonic/priv/bunny.mp4 -vcodec copy -acodec copy -f rtsp rtsp://localhost/chats/my/chat-15

Publishing via MPEG-TS Anchor Anchor x2

When transcoding a stream using ffmpeg, it is possible to publish video over HTTP. Video can be published with mpegts added at the end of the URL:

ffmpeg -re -i /opt/flussonic/priv/bunny.mp4 -vcodec copy -vbsf h264_mp4toannexb -acodec copy -f mpegts http://localhost:8080/chats/my/chat-15/mpegts

Authorization for stream publishing Anchor Anchor x2

Flussonic Media Server server can verify a password when publishing a stream. Enter the password in the configuration file as follows:

  live live {
    password mypass;
  }

  stream s1 {
    password secure;
    url publish://;
  }

RTMP

To publish a password-protected RTMP stream, use the following example: rtmp application rtmp://192.168.2.3/live and stream name mystream?password=mypass

HTTP MPEG-TS

To publish an HTTP MPEG-TS stream, you can enter the data as follows:

    http://192.168.2.3:8080/s1/mpegts?password=secure
    ffmpeg -re -i video.mp4 -vcodec copy -acodec copy -f flv rtmp://192.168.2.3/live/mystream?password=mypass
    ffmpeg -re -i video.mp4 -vcodec copy -bsf h264_mp4toannexb -acodec copy -f mpegts http://192.168.2.3:8080/s1?password=secure

Extended publish validation Anchor Anchor x2

Flussonic Media Server allows to configure an HTTP handler or a user script that will check extended info about the publisher before accepting or rejecting the published stream.

live chats {
  on_publish http://my-site.com/publish-check.php;
}

or

live chats {
  on_publish /etc/flussonic/publish_check.lua;
}

Flussoniс Media Server sends an HTTP POST request with a JSON body or passes the req object to the lua script.

JSON request or req has following fields:

  • name — the name of a published stream (i.e. chats/15), including publish prefix.
  • location — is the publish prefix.
  • proto — is the publishing protocol (rtmp, rtsp, mpegts)
  • args — parameters extracted from a request query string. For RTMP, a query string is extracted from the name of published stream.
  • ip — IP address of the publisher.

HTTP handler must return code 200 to start publication. It may also return x-record to tell in which file to record published stream.

lua script must return pair of true and object. This object may has record_path field with file recording path.

It is important that if handler tells where to record path, Flussonic Media Server will write endless flv path without any checks of duration, disk space and possible overwriting.

Archive and dynamic names of streams Anchor Anchor x2

You can configure the archive for a live prefix:

live recorded {
  dvr /storage 3d 500G;
}

In this case, the published video will be recorded, and will be available even if the publication is terminated.

When the client stops publishing the video, the stream will disappear after some time, and Flussonic Media Server will keep a very little information about it. Information about this stream will be stored in the index of the archive, and Flussonic Media Server will not lose the files on the disk.

If configured, the system of purging of the archive will delete published streams according to the schedule.

Re-publishing Anchor Anchor x2

When you use publication prefixes, you can't use push with UDP:

live pushed {
  udp 239.0.0.1:1234;
}

Or rather you can, but in this case all streams will be sent to the same multicast group which will lead to complications.

Instead, use push with a template (%s) for re-publishing a stream via other protocols:

live pushed {
  push rtmp://cdn-server/client43/%s;
}

With this configuration, to republish the stream pushed/mystream, Flussonic will use the URL rtmp://cdn-server/client43/pushed/mystream.